diff --git a/CMakeLists.txt b/CMakeLists.txt
index f9a40ee43..2cb0225cb 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,777 +1,783 @@
 cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
 
 project(KWin)
 set(PROJECT_VERSION "5.18.80")
 set(PROJECT_VERSION_MAJOR 5)
 
 set(QT_MIN_VERSION "5.14.0")
 set(KF5_MIN_VERSION "5.70.0")
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 find_package(ECM 5.38 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
     Sensors
     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(KDEClangFormat)
 
 include(ECMInstallIcons)
 include(ECMOptionalAddSubdirectory)
 
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0 -DQT_USE_QSTRINGBUILDER -DQT_NO_URL_CAST_FROM_STRING)
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 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
     IconThemes
     IdleTime
     Notifications
     Package
     Plasma
     Wayland
     WidgetsAddons
     WindowSystem
 )
 # required frameworks by config modules
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Completion
     Declarative
     KCMUtils
     KIO
     NewStuff
     Service
     TextWidgets
     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(KF5Kirigami2 ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Kirigami2 PROPERTIES
     DESCRIPTION "A QtQuick based components set"
     PURPOSE "Required at runtime for Virtual desktop KCM and the virtual keyboard"
     TYPE RUNTIME
 )
 
 find_package(KDecoration2 5.18.0 CONFIG REQUIRED)
 
 find_package(KScreenLocker CONFIG REQUIRED)
 set_package_properties(KScreenLocker PROPERTIES
     TYPE REQUIRED
     PURPOSE "For screenlocker integration in kwin_wayland"
 )
 
+find_package(KWaylandServer CONFIG REQUIRED)
+set_package_properties(KWaylandServer PROPERTIES
+    TYPE REQUIRED
+    PURPOSE "For Wayland integration"
+)
+
 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 "https://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.9)
 set_package_properties(Libinput PROPERTIES TYPE REQUIRED PURPOSE "Required for input handling on Wayland.")
 
 find_package(UDev)
 set_package_properties(UDev PROPERTIES
     URL "https://www.freedesktop.org/wiki/Software/systemd/"
     DESCRIPTION "Linux device library."
     TYPE REQUIRED
     PURPOSE "Required for input handling on Wayland."
 )
 
 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)
     set(HAVE_DRM TRUE)
 endif()
 
 find_package(gbm)
 set_package_properties(gbm PROPERTIES TYPE OPTIONAL PURPOSE "Required for egl output of drm backend.")
 set(HAVE_GBM FALSE)
 if (HAVE_DRM AND gbm_FOUND)
     set(HAVE_GBM TRUE)
 endif()
 
 option(KWIN_BUILD_EGL_STREAM_BACKEND "Enable building of EGLStream based DRM backend" ON)
 if (HAVE_DRM AND KWIN_BUILD_EGL_STREAM_BACKEND)
     set(HAVE_EGL_STREAMS 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 "https://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
     COMPOSITE
     CURSOR
     DAMAGE
     GLX
     ICCCM
     IMAGE
     KEYSYMS
     RANDR
     RENDER
     SHAPE
     SHM
     SYNC
     XCB
     XFIXES
 )
 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
 find_package(Qt5FontDatabaseSupport REQUIRED)
 find_package(Qt5ThemeSupport REQUIRED)
 find_package(Qt5EventDispatcherSupport REQUIRED)
 
 find_package(Freetype REQUIRED)
 set_package_properties(Freetype PROPERTIES
     DESCRIPTION "A font rendering engine"
     URL "https://www.freetype.org"
     TYPE REQUIRED
     PURPOSE "Needed for KWin's QPA plugin."
 )
 find_package(Fontconfig REQUIRED)
 set_package_properties(Fontconfig PROPERTIES
     TYPE REQUIRED
     PURPOSE "Needed for KWin's QPA plugin."
 )
 
 find_package(Xwayland)
 set_package_properties(Xwayland PROPERTIES
     URL "https://x.org"
     DESCRIPTION "Xwayland X server"
     TYPE RUNTIME
     PURPOSE "Needed for running kwin_wayland"
 )
 
 find_package(Libcap)
 set_package_properties(Libcap PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Needed for running kwin_wayland with real-time scheduling policy"
 )
 set(HAVE_LIBCAP ${Libcap_FOUND})
 
 find_package(hwdata)
 set_package_properties(hwdata PROPERTIES
     TYPE RUNTIME
     PURPOSE "Runtime-only dependency needed for mapping monitor hardware vendor IDs to full names"
     URL "https://github.com/vcrhonek/hwdata"
 )
 
 include(ECMQMLModules)
 ecm_find_qmlmodule(QtQuick 2.3)
 ecm_find_qmlmodule(QtQuick.Controls 1.2)
 ecm_find_qmlmodule(QtQuick.Layouts 1.3)
 ecm_find_qmlmodule(QtQuick.VirtualKeyboard 2.1)
 ecm_find_qmlmodule(QtQuick.Window 2.1)
 ecm_find_qmlmodule(QtMultimedia 5.0)
 ecm_find_qmlmodule(org.kde.kquickcontrolsaddons 2.0)
 ecm_find_qmlmodule(org.kde.plasma.core 2.0)
 ecm_find_qmlmodule(org.kde.plasma.components 2.0)
 
 ########### 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")
 
 # 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)
 
 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")
 
 check_symbol_exists(SCHED_RESET_ON_FORK "sched.h" HAVE_SCHED_RESET_ON_FORK)
 add_feature_info("SCHED_RESET_ON_FORK"
                  HAVE_SCHED_RESET_ON_FORK
                  "Required for running kwin_wayland with real-time scheduling")
 
 configure_file(config-kwin.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kwin.h)
 
 ########### global ###############
 set(kwin_effects_dbus_xml ${CMAKE_CURRENT_SOURCE_DIR}/org.kde.kwin.Effects.xml)
 qt5_add_dbus_interface(effects_interface_SRCS ${kwin_effects_dbus_xml} kwineffects_interface)
 add_library(KWinEffectsInterface STATIC ${effects_interface_SRCS})
 target_link_libraries(KWinEffectsInterface Qt5::DBus)
 
 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
     ${CMAKE_CURRENT_SOURCE_DIR}/platformsupport
 )
 
 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_SRCS
     abstract_client.cpp
     abstract_opengl_context_attribute_builder.cpp
     abstract_output.cpp
     abstract_wayland_output.cpp
     activation.cpp
     appmenu.cpp
     atoms.cpp
     client_machine.cpp
     colorcorrection/clockskewnotifier.cpp
     colorcorrection/clockskewnotifierengine.cpp
     colorcorrection/colorcorrectdbusinterface.cpp
     colorcorrection/manager.cpp
     colorcorrection/suncalc.cpp
     composite.cpp
     cursor.cpp
     dbusinterface.cpp
     debug_console.cpp
     decorations/decoratedclient.cpp
     decorations/decorationbridge.cpp
     decorations/decorationpalette.cpp
     decorations/decorationrenderer.cpp
     decorations/decorations_logging.cpp
     decorations/settings.cpp
     deleted.cpp
     effectloader.cpp
     effects.cpp
     egl_context_attribute_builder.cpp
     events.cpp
     focuschain.cpp
     geometrytip.cpp
     gestures.cpp
     globalshortcuts.cpp
     group.cpp
     idle_inhibition.cpp
     input.cpp
     input_event.cpp
     input_event_spy.cpp
     internal_client.cpp
     keyboard_input.cpp
     keyboard_layout.cpp
     keyboard_layout_switching.cpp
     keyboard_repeat.cpp
     killwindow.cpp
     layers.cpp
     libinput/connection.cpp
     libinput/context.cpp
     libinput/device.cpp
     libinput/events.cpp
     libinput/libinput_logging.cpp
     linux_dmabuf.cpp
     logind.cpp
     main.cpp
     modifier_only_shortcuts.cpp
     moving_client_x11_filter.cpp
     netinfo.cpp
     onscreennotification.cpp
     options.cpp
     osd.cpp
     outline.cpp
     outputscreens.cpp
     overlaywindow.cpp
     placement.cpp
     platform.cpp
     pointer_input.cpp
     popup_input_filter.cpp
     rootinfo_filter.cpp
     rules.cpp
     rulebooksettings.cpp
     scene.cpp
     screenedge.cpp
     screenlockerwatcher.cpp
     screens.cpp
     scripting/dbuscall.cpp
     scripting/meta.cpp
     scripting/screenedgeitem.cpp
     scripting/scriptedeffect.cpp
     scripting/scripting.cpp
     scripting/scripting_logging.cpp
     scripting/scripting_model.cpp
     scripting/scriptingutils.cpp
     scripting/timer.cpp
     scripting/workspace_wrapper.cpp
     shadow.cpp
     sm.cpp
     syncalarmx11filter.cpp
     thumbnailitem.cpp
     toplevel.cpp
     touch_hide_cursor_spy.cpp
     tablet_input.cpp
     touch_input.cpp
     udev.cpp
     unmanaged.cpp
     useractions.cpp
     utils.cpp
     virtualdesktops.cpp
     virtualdesktopsdbustypes.cpp
     virtualkeyboard.cpp
     virtualkeyboard_dbus.cpp
     was_user_interaction_x11_filter.cpp
     wayland_cursor_theme.cpp
     wayland_server.cpp
     window_property_notify_x11_filter.cpp
     workspace.cpp
     x11client.cpp
     x11eventfilter.cpp
     xcbutils.cpp
     xdgshellclient.cpp
     xkb.cpp
     xwaylandclient.cpp
     xwl/xwayland_interface.cpp
 )
 
 if (CMAKE_SYSTEM_NAME MATCHES "Linux")
     set(kwin_SRCS
         ${kwin_SRCS}
         colorcorrection/clockskewnotifierengine_linux.cpp
     )
 endif()
 
 include(ECMQtDeclareLoggingCategory)
 ecm_qt_declare_logging_category(kwin_SRCS
     HEADER
         colorcorrect_logging.h
     IDENTIFIER
         KWIN_COLORCORRECTION
     CATEGORY_NAME
         kwin_colorcorrection
     DEFAULT_SEVERITY
         Critical
 )
 
 if (KWIN_BUILD_TABBOX)
     include_directories(${Qt5Gui_PRIVATE_INCLUDE_DIRS})
     set(kwin_SRCS ${kwin_SRCS}
         tabbox/clientmodel.cpp
         tabbox/desktopchain.cpp
         tabbox/desktopmodel.cpp
         tabbox/switcheritem.cpp
         tabbox/tabbox.cpp
         tabbox/tabbox_logging.cpp
         tabbox/tabboxconfig.cpp
         tabbox/tabboxhandler.cpp
         tabbox/x11_filter.cpp
     )
 endif()
 
 if (KWIN_BUILD_ACTIVITIES)
     set(kwin_SRCS ${kwin_SRCS}
         activities.cpp
     )
 endif()
 
 if (HAVE_LINUX_VT_H)
     set(kwin_SRCS ${kwin_SRCS}
         virtual_terminal.cpp
     )
 endif()
 
 kconfig_add_kcfg_files(kwin_SRCS settings.kcfgc)
 kconfig_add_kcfg_files(kwin_SRCS colorcorrection/colorcorrect_settings.kcfgc)
 kconfig_add_kcfg_files(kwin_SRCS rulesettings.kcfgc)
 kconfig_add_kcfg_files(kwin_SRCS rulebooksettingsbase.kcfgc)
 
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.xml dbusinterface.h KWin::DBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.Compositing.xml dbusinterface.h KWin::CompositorDBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.ColorCorrect.xml colorcorrection/colorcorrectdbusinterface.h KWin::ColorCorrect::ColorCorrectDBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.VirtualDesktopManager.xml dbusinterface.h KWin::VirtualDesktopManagerDBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.Session.xml sm.h KWin::SessionManager)
 
 qt5_add_dbus_interface(kwin_SRCS ${KSCREENLOCKER_DBUS_INTERFACES_DIR}/kf5_org.freedesktop.ScreenSaver.xml screenlocker_interface)
 qt5_add_dbus_interface(kwin_SRCS ${KSCREENLOCKER_DBUS_INTERFACES_DIR}/org.kde.screensaver.xml kscreenlocker_interface)
 qt5_add_dbus_interface(kwin_SRCS org.kde.kappmenu.xml appmenu_interface)
 
 ki18n_wrap_ui(kwin_SRCS
     debug_console.ui
     shortcutdialog.ui
 )
 
 ########### target link libraries ###############
 
 set(kwin_OWN_LIBS
     kwineffects
     kwin4_effect_builtins
 )
 
 set(kwin_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::Script
     Qt5::Sensors
 )
 
 set(kwin_KDE_LIBS
     KF5::ConfigCore
     KF5::ConfigWidgets
     KF5::CoreAddons
     KF5::GlobalAccel
     KF5::GlobalAccelPrivate
     KF5::I18n
     KF5::Notifications
     KF5::Package
     KF5::Plasma
     KF5::QuickAddons
     KF5::WindowSystem
 
     KDecoration2::KDecoration
     KDecoration2::KDecoration2Private
 
     PW::KScreenLocker
 )
 
 set(kwin_XLIB_LIBS
     ${X11_ICE_LIB}
     ${X11_SM_LIB}
     ${X11_X11_LIB}
 )
 
 set(kwin_XCB_LIBS
     XCB::COMPOSITE
     XCB::DAMAGE
     XCB::GLX
     XCB::ICCCM
     XCB::KEYSYMS
     XCB::RANDR
     XCB::RENDER
     XCB::SHAPE
     XCB::SHM
     XCB::SYNC
     XCB::XCB
     XCB::XFIXES
 )
 
 set(kwin_WAYLAND_LIBS
     KF5::WaylandClient
-    KF5::WaylandServer
+    Plasma::KWaylandServer
     Wayland::Cursor
     XKB::XKB
     ${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}
     ${UDEV_LIBS}
     Libinput::Libinput
 )
 
 add_library(kwin SHARED ${kwin_SRCS})
 if (Libinput_VERSION_STRING VERSION_GREATER 1.14)
     target_compile_definitions(kwin PRIVATE -DLIBINPUT_HAS_TOTEM)
 endif ()
 
 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})
 
 add_executable(kwin_x11 main_x11.cpp)
 target_link_libraries(kwin_x11 kwin KF5::Crash Qt5::X11Extras)
 
 install(TARGETS kwin ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP)
 install(TARGETS kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 set(kwin_XWAYLAND_SRCS
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/clipboard.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/databridge.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/dnd.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/drag.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/drag_wl.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/drag_x.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/selection.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/selection_source.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/transfer.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/xwayland.cpp
 )
 include(ECMQtDeclareLoggingCategory)
 ecm_qt_declare_logging_category(kwin_XWAYLAND_SRCS
     HEADER
         xwayland_logging.h
     IDENTIFIER
         KWIN_XWL
     CATEGORY_NAME
         kwin_xwl
     DEFAULT_SEVERITY
         Critical
 )
 
 set(kwin_WAYLAND_SRCS
    main_wayland.cpp
    tabletmodemanager.cpp
 )
 
 add_executable(kwin_wayland ${kwin_WAYLAND_SRCS} ${kwin_XWAYLAND_SRCS})
 target_link_libraries(kwin_wayland kwin KF5::Crash)
 if (HAVE_LIBCAP)
     target_link_libraries(kwin_wayland ${Libcap_LIBRARIES})
 endif()
 
 install(TARGETS kwin_wayland ${INSTALL_TARGETS_DEFAULT_ARGS})
 if (HAVE_LIBCAP)
     install(
     CODE "execute_process(
             COMMAND
                 ${SETCAP_EXECUTABLE}
                 CAP_SYS_NICE=+ep
                 \$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/kwin_wayland)"
     )
 endif()
 
 add_subdirectory(platformsupport)
 add_subdirectory(plugins)
 
 ########### install files ###############
 
 install(FILES kwin.kcfg DESTINATION ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}.kcfg)
 install(FILES colorcorrection/colorcorrect_settings.kcfg DESTINATION ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}_colorcorrect.kcfg)
 install(FILES kwin.notifyrc DESTINATION ${KNOTIFYRC_INSTALL_DIR} RENAME ${KWIN_NAME}.notifyrc)
 install(
     FILES
         org.kde.KWin.VirtualDesktopManager.xml
         org.kde.KWin.xml
         org.kde.kwin.ColorCorrect.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})
 
 add_subdirectory(qml)
 
 if (BUILD_TESTING)
     add_subdirectory(autotests)
     add_subdirectory(tests)
 endif()
 
 if (KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 add_subdirectory(kconf_update)
 
 # add clang-format target for all our real source files
 file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h)
 kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 include(CMakePackageConfigHelpers)
 set(CMAKECONFIG_INSTALL_DIR "${CMAKECONFIG_INSTALL_PREFIX}/KWinDBusInterface")
 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/abstract_client.cpp b/abstract_client.cpp
index 841eba711..ec9a833ad 100644
--- a/abstract_client.cpp
+++ b/abstract_client.cpp
@@ -1,3302 +1,3302 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "abstract_client.h"
 
 #include "appmenu.h"
 #include "decorations/decoratedclient.h"
 #include "decorations/decorationpalette.h"
 #include "decorations/decorationbridge.h"
 #include "cursor.h"
 #include "effects.h"
 #include "focuschain.h"
 #include "outline.h"
 #include "screens.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "screenedge.h"
 #include "useractions.h"
 #include "workspace.h"
 
 #include "wayland_server.h"
-#include <KWayland/Server/plasmawindowmanagement_interface.h>
+#include <KWaylandServer/plasmawindowmanagement_interface.h>
 
 #include <KDecoration2/Decoration>
 
 #include <KDesktopFile>
 
 #include <QMouseEvent>
 #include <QStyleHints>
 
 namespace KWin
 {
 
 static inline int sign(int v)
 {
     return (v > 0) - (v < 0);
 }
 
 QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> AbstractClient::s_palettes;
 std::shared_ptr<Decoration::DecorationPalette> AbstractClient::s_defaultPalette;
 
 AbstractClient::AbstractClient()
     : Toplevel()
 #ifdef KWIN_BUILD_TABBOX
     , m_tabBoxClient(QSharedPointer<TabBox::TabBoxClientImpl>(new TabBox::TabBoxClientImpl(this)))
 #endif
     , m_colorScheme(QStringLiteral("kdeglobals"))
 {
     connect(this, &AbstractClient::clientStartUserMovedResized,  this, &AbstractClient::moveResizedChanged);
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::moveResizedChanged);
     connect(this, &AbstractClient::clientStartUserMovedResized,  this, &AbstractClient::removeCheckScreenConnection);
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, &AbstractClient::setupCheckScreenConnection);
 
     connect(this, &AbstractClient::paletteChanged, this, &AbstractClient::triggerDecorationRepaint);
 
     connect(Decoration::DecorationBridge::self(), &QObject::destroyed, this, &AbstractClient::destroyDecoration);
 
     // If the user manually moved the window, don't restore it after the keyboard closes
     connect(this, &AbstractClient::clientFinishUserMovedResized, this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
     connect(this, qOverload<AbstractClient *, bool, bool>(&AbstractClient::clientMaximizedStateChanged), this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
     connect(this, &AbstractClient::fullScreenChanged, this, [this] () {
         m_keyboardGeometryRestore = QRect();
     });
 
     // replace on-screen-display on size changes
     connect(this, &AbstractClient::frameGeometryChanged, this,
         [this] (Toplevel *c, const QRect &old) {
             Q_UNUSED(c)
             if (isOnScreenDisplay() && !frameGeometry().isEmpty() && old.size() != frameGeometry().size() && !isInitialPositionSet()) {
                 GeometryUpdatesBlocker blocker(this);
                 const QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
                 Placement::self()->place(this, area);
                 setGeometryRestore(frameGeometry());
             }
         }
     );
 
     connect(this, &AbstractClient::paddingChanged, this, [this]() {
         m_visibleRectBeforeGeometryUpdate = visibleRect();
     });
 
     connect(ApplicationMenu::self(), &ApplicationMenu::applicationMenuEnabledChanged, this, [this] {
         emit hasApplicationMenuChanged(hasApplicationMenu());
     });
 }
 
 AbstractClient::~AbstractClient()
 {
     Q_ASSERT(m_blockGeometryUpdates == 0);
     Q_ASSERT(m_decoration.decoration == nullptr);
 }
 
 void AbstractClient::updateMouseGrab()
 {
 }
 
 bool AbstractClient::belongToSameApplication(const AbstractClient *c1, const AbstractClient *c2, SameApplicationChecks checks)
 {
     return c1->belongsToSameApplication(c2, checks);
 }
 
 bool AbstractClient::isTransient() const
 {
     return false;
 }
 
 void AbstractClient::setClientShown(bool shown)
 {
     Q_UNUSED(shown)
 }
 
 xcb_timestamp_t AbstractClient::userTime() const
 {
     return XCB_TIME_CURRENT_TIME;
 }
 
 void AbstractClient::setSkipSwitcher(bool set)
 {
     set = rules()->checkSkipSwitcher(set);
     if (set == skipSwitcher())
         return;
     m_skipSwitcher = set;
     doSetSkipSwitcher();
     updateWindowRules(Rules::SkipSwitcher);
     emit skipSwitcherChanged();
 }
 
 void AbstractClient::setSkipPager(bool b)
 {
     b = rules()->checkSkipPager(b);
     if (b == skipPager())
         return;
     m_skipPager = b;
     doSetSkipPager();
     updateWindowRules(Rules::SkipPager);
     emit skipPagerChanged();
 }
 
 void AbstractClient::doSetSkipPager()
 {
 }
 
 void AbstractClient::setSkipTaskbar(bool b)
 {
     int was_wants_tab_focus = wantsTabFocus();
     if (b == skipTaskbar())
         return;
     m_skipTaskbar = b;
     doSetSkipTaskbar();
     updateWindowRules(Rules::SkipTaskbar);
     if (was_wants_tab_focus != wantsTabFocus()) {
         FocusChain::self()->update(this, isActive() ? FocusChain::MakeFirst : FocusChain::Update);
     }
     emit skipTaskbarChanged();
 }
 
 void AbstractClient::setOriginalSkipTaskbar(bool b)
 {
     m_originalSkipTaskbar = rules()->checkSkipTaskbar(b);
     setSkipTaskbar(m_originalSkipTaskbar);
 }
 
 void AbstractClient::doSetSkipTaskbar()
 {
 
 }
 
 void AbstractClient::doSetSkipSwitcher()
 {
 
 }
 
 void AbstractClient::setIcon(const QIcon &icon)
 {
     m_icon = icon;
     emit iconChanged();
 }
 
 void AbstractClient::setActive(bool act)
 {
     if (m_active == act) {
         return;
     }
     m_active = act;
     const int ruledOpacity = m_active
                              ? rules()->checkOpacityActive(qRound(opacity() * 100.0))
                              : rules()->checkOpacityInactive(qRound(opacity() * 100.0));
     setOpacity(ruledOpacity / 100.0);
     workspace()->setActiveClient(act ? this : nullptr);
 
     if (!m_active)
         cancelAutoRaise();
 
     if (!m_active && shadeMode() == ShadeActivated)
         setShade(ShadeNormal);
 
     StackingUpdatesBlocker blocker(workspace());
     workspace()->updateClientLayer(this);   // active windows may get different layer
     auto mainclients = mainClients();
     for (auto it = mainclients.constBegin();
             it != mainclients.constEnd();
             ++it)
         if ((*it)->isFullScreen())  // fullscreens go high even if their transient is active
             workspace()->updateClientLayer(*it);
 
     doSetActive();
     emit activeChanged();
     updateMouseGrab();
 }
 
 void AbstractClient::doSetActive()
 {
 }
 
 Layer AbstractClient::layer() const
 {
     if (m_layer == UnknownLayer)
         const_cast< AbstractClient* >(this)->m_layer = belongsToLayer();
     return m_layer;
 }
 
 void AbstractClient::updateLayer()
 {
     if (layer() == belongsToLayer())
         return;
     StackingUpdatesBlocker blocker(workspace());
     invalidateLayer(); // invalidate, will be updated when doing restacking
     for (auto it = transients().constBegin(),
                                   end = transients().constEnd(); it != end; ++it)
         (*it)->updateLayer();
 }
 
 void AbstractClient::placeIn(const QRect &area)
 {
     // TODO: Get rid of this method eventually. We need to call setGeometryRestore() because
     // checkWorkspacePosition() operates on geometryRestore() and because of quick tiling.
     Placement::self()->place(this, area);
     setGeometryRestore(frameGeometry());
 }
 
 void AbstractClient::invalidateLayer()
 {
     m_layer = UnknownLayer;
 }
 
 Layer AbstractClient::belongsToLayer() const
 {
     // NOTICE while showingDesktop, desktops move to the AboveLayer
     // (interchangeable w/ eg. yakuake etc. which will at first remain visible)
     // and the docks move into the NotificationLayer (which is between Above- and
     // ActiveLayer, so that active fullscreen windows will still cover everything)
     // Since the desktop is also activated, nothing should be in the ActiveLayer, though
     if (isInternal())
         return UnmanagedLayer;
     if (isDesktop())
         return workspace()->showingDesktop() ? AboveLayer : DesktopLayer;
     if (isSplash())          // no damn annoying splashscreens
         return NormalLayer; // getting in the way of everything else
     if (isDock()) {
         if (workspace()->showingDesktop())
             return NotificationLayer;
         return layerForDock();
     }
     if (isOnScreenDisplay())
         return OnScreenDisplayLayer;
     if (isNotification())
         return NotificationLayer;
     if (isCriticalNotification())
         return CriticalNotificationLayer;
     if (workspace()->showingDesktop() && belongsToDesktop()) {
         return AboveLayer;
     }
     if (keepBelow())
         return BelowLayer;
     if (isActiveFullScreen())
         return ActiveLayer;
     if (keepAbove())
         return AboveLayer;
 
     return NormalLayer;
 }
 
 bool AbstractClient::belongsToDesktop() const
 {
     return false;
 }
 
 Layer AbstractClient::layerForDock() const
 {
     // slight hack for the 'allow window to cover panel' Kicker setting
     // don't move keepbelow docks below normal window, but only to the same
     // layer, so that both may be raised to cover the other
     if (keepBelow())
         return NormalLayer;
     if (keepAbove()) // slight hack for the autohiding panels
         return AboveLayer;
     return DockLayer;
 }
 
 void AbstractClient::setKeepAbove(bool b)
 {
     b = rules()->checkKeepAbove(b);
     if (b && !rules()->checkKeepBelow(false))
         setKeepBelow(false);
     if (b == keepAbove()) {
         return;
     }
     m_keepAbove = b;
     doSetKeepAbove();
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Above);
 
     emit keepAboveChanged(m_keepAbove);
 }
 
 void AbstractClient::doSetKeepAbove()
 {
 }
 
 void AbstractClient::setKeepBelow(bool b)
 {
     b = rules()->checkKeepBelow(b);
     if (b && !rules()->checkKeepAbove(false))
         setKeepAbove(false);
     if (b == keepBelow()) {
         return;
     }
     m_keepBelow = b;
     doSetKeepBelow();
     workspace()->updateClientLayer(this);
     updateWindowRules(Rules::Below);
 
     emit keepBelowChanged(m_keepBelow);
 }
 
 void AbstractClient::doSetKeepBelow()
 {
 }
 
 void AbstractClient::startAutoRaise()
 {
     delete m_autoRaiseTimer;
     m_autoRaiseTimer = new QTimer(this);
     connect(m_autoRaiseTimer, &QTimer::timeout, this, &AbstractClient::autoRaise);
     m_autoRaiseTimer->setSingleShot(true);
     m_autoRaiseTimer->start(options->autoRaiseInterval());
 }
 
 void AbstractClient::cancelAutoRaise()
 {
     delete m_autoRaiseTimer;
     m_autoRaiseTimer = nullptr;
 }
 
 void AbstractClient::autoRaise()
 {
     workspace()->raiseClient(this);
     cancelAutoRaise();
 }
 
 bool AbstractClient::wantsTabFocus() const
 {
     return (isNormalWindow() || isDialog()) && wantsInput();
 }
 
 bool AbstractClient::isSpecialWindow() const
 {
     // TODO
     return isDesktop() || isDock() || isSplash() || isToolbar() || isNotification() || isOnScreenDisplay() || isCriticalNotification();
 }
 
 void AbstractClient::demandAttention(bool set)
 {
     if (isActive())
         set = false;
     if (m_demandsAttention == set)
         return;
     m_demandsAttention = set;
     doSetDemandsAttention();
     workspace()->clientAttentionChanged(this, set);
     emit demandsAttentionChanged();
 }
 
 void AbstractClient::doSetDemandsAttention()
 {
 }
 
 void AbstractClient::setDesktop(int desktop)
 {
     const int numberOfDesktops = VirtualDesktopManager::self()->count();
     if (desktop != NET::OnAllDesktops)   // Do range check
         desktop = qMax(1, qMin(numberOfDesktops, desktop));
     desktop = qMin(numberOfDesktops, rules()->checkDesktop(desktop));
 
     QVector<VirtualDesktop *> desktops;
     if (desktop != NET::OnAllDesktops) {
        desktops << VirtualDesktopManager::self()->desktopForX11Id(desktop);
     }
     setDesktops(desktops);
 }
 
 void AbstractClient::setDesktops(QVector<VirtualDesktop*> desktops)
 {
     //on x11 we can have only one desktop at a time
     if (kwinApp()->operationMode() == Application::OperationModeX11 && desktops.size() > 1) {
         desktops = QVector<VirtualDesktop*>({desktops.last()});
     }
 
     if (desktops == m_desktops) {
         return;
     }
 
     int was_desk = AbstractClient::desktop();
     const bool wasOnCurrentDesktop = isOnCurrentDesktop() && was_desk >= 0;
 
     m_desktops = desktops;
 
     if (windowManagementInterface()) {
         if (m_desktops.isEmpty()) {
             windowManagementInterface()->setOnAllDesktops(true);
         } else {
             windowManagementInterface()->setOnAllDesktops(false);
             auto currentDesktops = windowManagementInterface()->plasmaVirtualDesktops();
             for (auto desktop: m_desktops) {
                 if (!currentDesktops.contains(desktop->id())) {
                     windowManagementInterface()->addPlasmaVirtualDesktop(desktop->id());
                 } else {
                     currentDesktops.removeOne(desktop->id());
                 }
             }
             for (auto desktopId: currentDesktops) {
                 windowManagementInterface()->removePlasmaVirtualDesktop(desktopId);
             }
         }
     }
     if (info) {
         info->setDesktop(desktop());
     }
 
     if ((was_desk == NET::OnAllDesktops) != (desktop() == NET::OnAllDesktops)) {
         // onAllDesktops changed
         workspace()->updateOnAllDesktopsOfTransients(this);
     }
 
     auto transients_stacking_order = workspace()->ensureStackingOrder(transients());
     for (auto it = transients_stacking_order.constBegin();
             it != transients_stacking_order.constEnd();
             ++it)
         (*it)->setDesktops(desktops);
 
     if (isModal())  // if a modal dialog is moved, move the mainwindow with it as otherwise
         // the (just moved) modal dialog will confusingly return to the mainwindow with
         // the next desktop change
     {
         foreach (AbstractClient * c2, mainClients())
         c2->setDesktops(desktops);
     }
 
     doSetDesktop();
 
     FocusChain::self()->update(this, FocusChain::MakeFirst);
     updateWindowRules(Rules::Desktop);
 
     emit desktopChanged();
     if (wasOnCurrentDesktop != isOnCurrentDesktop())
         emit desktopPresenceChanged(this, was_desk);
     emit x11DesktopIdsChanged();
 }
 
 void AbstractClient::doSetDesktop()
 {
 }
 
 void AbstractClient::enterDesktop(VirtualDesktop *virtualDesktop)
 {
     if (m_desktops.contains(virtualDesktop)) {
         return;
     }
     auto desktops = m_desktops;
     desktops.append(virtualDesktop);
     setDesktops(desktops);
 }
 
 void AbstractClient::leaveDesktop(VirtualDesktop *virtualDesktop)
 {
     QVector<VirtualDesktop*> currentDesktops;
     if (m_desktops.isEmpty()) {
         currentDesktops = VirtualDesktopManager::self()->desktops();
     } else {
         currentDesktops = m_desktops;
     }
 
     if (!currentDesktops.contains(virtualDesktop)) {
         return;
     }
     auto desktops = currentDesktops;
     desktops.removeOne(virtualDesktop);
     setDesktops(desktops);
 }
 
 void AbstractClient::setOnAllDesktops(bool b)
 {
     if ((b && isOnAllDesktops()) ||
             (!b && !isOnAllDesktops()))
         return;
     if (b)
         setDesktop(NET::OnAllDesktops);
     else
         setDesktop(VirtualDesktopManager::self()->current());
 }
 
 QVector<uint> AbstractClient::x11DesktopIds() const
 {
     const auto desks = desktops();
     QVector<uint> x11Ids;
     x11Ids.reserve(desks.count());
     std::transform(desks.constBegin(), desks.constEnd(),
         std::back_inserter(x11Ids),
         [] (const VirtualDesktop *vd) {
             return vd->x11DesktopNumber();
         }
     );
     return x11Ids;
 }
 
 bool AbstractClient::isShadeable() const
 {
     return false;
 }
 
 void AbstractClient::setShade(bool set)
 {
     set ? setShade(ShadeNormal) : setShade(ShadeNone);
 }
 
 void AbstractClient::setShade(ShadeMode mode)
 {
     Q_UNUSED(mode)
 }
 
 ShadeMode AbstractClient::shadeMode() const
 {
     return ShadeNone;
 }
 
 AbstractClient::Position AbstractClient::titlebarPosition() const
 {
     // TODO: still needed, remove?
     return PositionTop;
 }
 
 bool AbstractClient::titlebarPositionUnderMouse() const
 {
     if (!isDecorated()) {
         return false;
     }
     const auto sectionUnderMouse = decoration()->sectionUnderMouse();
     if (sectionUnderMouse == Qt::TitleBarArea) {
         return true;
     }
     // check other sections based on titlebarPosition
     switch (titlebarPosition()) {
     case AbstractClient::PositionTop:
         return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::TopSection || sectionUnderMouse == Qt::TopRightSection);
     case AbstractClient::PositionLeft:
         return (sectionUnderMouse == Qt::TopLeftSection || sectionUnderMouse == Qt::LeftSection || sectionUnderMouse == Qt::BottomLeftSection);
     case AbstractClient::PositionRight:
         return (sectionUnderMouse == Qt::BottomRightSection || sectionUnderMouse == Qt::RightSection || sectionUnderMouse == Qt::TopRightSection);
     case AbstractClient::PositionBottom:
         return (sectionUnderMouse == Qt::BottomLeftSection || sectionUnderMouse == Qt::BottomSection || sectionUnderMouse == Qt::BottomRightSection);
     default:
         // nothing
         return false;
     }
 }
 
 void AbstractClient::setMinimized(bool set)
 {
     set ? minimize() : unminimize();
 }
 
 void AbstractClient::minimize(bool avoid_animation)
 {
     if (!isMinimizable() || isMinimized())
         return;
 
     m_minimized = true;
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     FocusChain::self()->update(this, FocusChain::MakeFirstMinimized);
     // TODO: merge signal with s_minimized
     addWorkspaceRepaint(visibleRect());
     emit clientMinimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::unminimize(bool avoid_animation)
 {
     if (!isMinimized())
         return;
 
     if (rules()->checkMinimize(false)) {
         return;
     }
 
     m_minimized = false;
     doMinimize();
 
     updateWindowRules(Rules::Minimize);
     emit clientUnminimized(this, !avoid_animation);
     emit minimizedChanged();
 }
 
 void AbstractClient::doMinimize()
 {
 }
 
 QPalette AbstractClient::palette() const
 {
     if (!m_palette) {
         return QPalette();
     }
     return m_palette->palette();
 }
 
 const Decoration::DecorationPalette *AbstractClient::decorationPalette() const
 {
     return m_palette.get();
 }
 
 void AbstractClient::updateColorScheme(QString path)
 {
     if (path.isEmpty()) {
         path = QStringLiteral("kdeglobals");
     }
 
     if (!m_palette || m_colorScheme != path) {
         m_colorScheme = path;
 
         if (m_palette) {
             disconnect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
         }
 
         auto it = s_palettes.find(m_colorScheme);
 
         if (it == s_palettes.end() || it->expired()) {
             m_palette = std::make_shared<Decoration::DecorationPalette>(m_colorScheme);
             if (m_palette->isValid()) {
                 s_palettes[m_colorScheme] = m_palette;
             } else {
                 if (!s_defaultPalette) {
                     s_defaultPalette = std::make_shared<Decoration::DecorationPalette>(QStringLiteral("kdeglobals"));
                     s_palettes[QStringLiteral("kdeglobals")] = s_defaultPalette;
                 }
 
                 m_palette = s_defaultPalette;
             }
 
             if (m_colorScheme == QStringLiteral("kdeglobals")) {
                 s_defaultPalette = m_palette;
             }
         } else {
             m_palette = it->lock();
         }
 
         connect(m_palette.get(), &Decoration::DecorationPalette::changed, this, &AbstractClient::handlePaletteChange);
 
         emit paletteChanged(palette());
         emit colorSchemeChanged();
     }
 }
 
 void AbstractClient::handlePaletteChange()
 {
     emit paletteChanged(palette());
 }
 
 void AbstractClient::keepInArea(QRect area, bool partial)
 {
     if (partial) {
         // increase the area so that can have only 100 pixels in the area
         area.setLeft(qMin(area.left() - width() + 100, area.left()));
         area.setTop(qMin(area.top() - height() + 100, area.top()));
         area.setRight(qMax(area.right() + width() - 100, area.right()));
         area.setBottom(qMax(area.bottom() + height() - 100, area.bottom()));
     }
     if (!partial) {
         // resize to fit into area
         if (area.width() < width() || area.height() < height())
             resizeWithChecks(size().boundedTo(area.size()));
     }
     int tx = x(), ty = y();
     if (frameGeometry().right() > area.right() && width() <= area.width())
         tx = area.right() - width() + 1;
     if (frameGeometry().bottom() > area.bottom() && height() <= area.height())
         ty = area.bottom() - height() + 1;
     if (!area.contains(frameGeometry().topLeft())) {
         if (tx < area.x())
             tx = area.x();
         if (ty < area.y())
             ty = area.y();
     }
     if (tx != x() || ty != y())
         move(tx, ty);
 }
 
 /**
  * Returns the maximum client size, not the maximum frame size.
  */
 QSize AbstractClient::maxSize() const
 {
     return rules()->checkMaxSize(QSize(INT_MAX, INT_MAX));
 }
 
 /**
  * Returns the minimum client size, not the minimum frame size.
  */
 QSize AbstractClient::minSize() const
 {
     return rules()->checkMinSize(QSize(0, 0));
 }
 
 void AbstractClient::blockGeometryUpdates(bool block)
 {
     if (block) {
         if (m_blockGeometryUpdates == 0)
             m_pendingGeometryUpdate = PendingGeometryNone;
         ++m_blockGeometryUpdates;
     } else {
         if (--m_blockGeometryUpdates == 0) {
             if (m_pendingGeometryUpdate != PendingGeometryNone) {
                 if (isShade())
                     setFrameGeometry(QRect(pos(), adjustedSize()), NormalGeometrySet);
                 else
                     setFrameGeometry(frameGeometry(), NormalGeometrySet);
                 m_pendingGeometryUpdate = PendingGeometryNone;
             }
         }
     }
 }
 
 void AbstractClient::maximize(MaximizeMode m)
 {
     setMaximize(m & MaximizeVertical, m & MaximizeHorizontal);
 }
 
 void AbstractClient::setMaximize(bool vertically, bool horizontally)
 {
     // changeMaximize() flips the state, so change from set->flip
     const MaximizeMode oldMode = maximizeMode();
     changeMaximize(
         oldMode & MaximizeHorizontal ? !horizontally : horizontally,
         oldMode & MaximizeVertical ? !vertically : vertically,
         false);
     const MaximizeMode newMode = maximizeMode();
     if (oldMode != newMode) {
         emit clientMaximizedStateChanged(this, newMode);
         emit clientMaximizedStateChanged(this, vertically, horizontally);
     }
 }
 
 void AbstractClient::move(int x, int y, ForceGeometry_t force)
 {
     // resuming geometry updates is handled only in setGeometry()
     Q_ASSERT(pendingGeometryUpdate() == PendingGeometryNone || areGeometryUpdatesBlocked());
     QPoint p(x, y);
     if (!areGeometryUpdatesBlocked() && p != rules()->checkPosition(p)) {
         qCDebug(KWIN_CORE) << "forced position fail:" << p << ":" << rules()->checkPosition(p);
     }
     if (force == NormalGeometrySet && m_frameGeometry.topLeft() == p)
         return;
     m_frameGeometry.moveTopLeft(p);
     if (areGeometryUpdatesBlocked()) {
         if (pendingGeometryUpdate() == PendingGeometryForced)
             {} // maximum, nothing needed
         else if (force == ForceGeometrySet)
             setPendingGeometryUpdate(PendingGeometryForced);
         else
             setPendingGeometryUpdate(PendingGeometryNormal);
         return;
     }
     doMove(x, y);
     updateWindowRules(Rules::Position);
     screens()->setCurrent(this);
     workspace()->updateStackingOrder();
     // client itself is not damaged
     emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 }
 
 bool AbstractClient::startMoveResize()
 {
     Q_ASSERT(!isMoveResize());
     Q_ASSERT(QWidget::keyboardGrabber() == nullptr);
     Q_ASSERT(QWidget::mouseGrabber() == nullptr);
     stopDelayedMoveResize();
     if (QApplication::activePopupWidget() != nullptr)
         return false; // popups have grab
     if (isFullScreen() && (screens()->count() < 2 || !isMovableAcrossScreens()))
         return false;
     if (!doStartMoveResize()) {
         return false;
     }
 
     invalidateDecorationDoubleClickTimer();
 
     setMoveResize(true);
     workspace()->setMoveResizeClient(this);
 
     const Position mode = moveResizePointerMode();
     if (mode != PositionCenter) { // means "isResize()" but moveResizeMode = true is set below
         if (maximizeMode() == MaximizeFull) { // partial is cond. reset in finishMoveResize
             setGeometryRestore(frameGeometry()); // "restore" to current geometry
             setMaximize(false, false);
         }
     }
 
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && mode != PositionCenter) { // Cannot use isResize() yet
         // Exit quick tile mode when the user attempts to resize a tiled window
         updateQuickTileMode(QuickTileFlag::None); // Do so without restoring original geometry
         setGeometryRestore(frameGeometry());
         emit quickTileModeChanged();
     }
 
     updateHaveResizeEffect();
     updateInitialMoveResizeGeometry();
     checkUnrestrictedMoveResize();
     emit clientStartUserMovedResized(this);
     if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
         ScreenEdges::self()->reserveDesktopSwitching(true, Qt::Vertical|Qt::Horizontal);
     return true;
 }
 
 void AbstractClient::finishMoveResize(bool cancel)
 {
     GeometryUpdatesBlocker blocker(this);
     const bool wasResize = isResize(); // store across leaveMoveResize
     leaveMoveResize();
 
     if (cancel)
         setFrameGeometry(initialMoveResizeGeometry());
     else {
         const QRect &moveResizeGeom = moveResizeGeometry();
         if (wasResize) {
             const bool restoreH = maximizeMode() == MaximizeHorizontal &&
                                     moveResizeGeom.width() != initialMoveResizeGeometry().width();
             const bool restoreV = maximizeMode() == MaximizeVertical &&
                                     moveResizeGeom.height() != initialMoveResizeGeometry().height();
             if (restoreH || restoreV) {
                 changeMaximize(restoreH, restoreV, false);
             }
         }
         setFrameGeometry(moveResizeGeom);
     }
     checkScreen(); // needs to be done because clientFinishUserMovedResized has not yet re-activated online alignment
     if (screen() != moveResizeStartScreen()) {
         workspace()->sendClientToScreen(this, screen()); // checks rule validity
         if (maximizeMode() != MaximizeRestore)
             checkWorkspacePosition();
     }
 
     if (isElectricBorderMaximizing()) {
         setQuickTileMode(electricBorderMode());
         setElectricBorderMaximizing(false);
     } else if (!cancel) {
         QRect geom_restore = geometryRestore();
         if (!(maximizeMode() & MaximizeHorizontal)) {
             geom_restore.setX(frameGeometry().x());
             geom_restore.setWidth(frameGeometry().width());
         }
         if (!(maximizeMode() & MaximizeVertical)) {
             geom_restore.setY(frameGeometry().y());
             geom_restore.setHeight(frameGeometry().height());
         }
         setGeometryRestore(geom_restore);
     }
 // FRAME    update();
 
     emit clientFinishUserMovedResized(this);
 }
 
 // This function checks if it actually makes sense to perform a restricted move/resize.
 // If e.g. the titlebar is already outside of the workarea, there's no point in performing
 // a restricted move resize, because then e.g. resize would also move the window (#74555).
 // NOTE: Most of it is duplicated from handleMoveResize().
 void AbstractClient::checkUnrestrictedMoveResize()
 {
     if (isUnrestrictedMoveResize())
         return;
     const QRect &moveResizeGeom = moveResizeGeometry();
     QRect desktopArea = workspace()->clientArea(WorkArea, moveResizeGeom.center(), desktop());
     int left_marge, right_marge, top_marge, bottom_marge, titlebar_marge;
     // restricted move/resize - keep at least part of the titlebar always visible
     // how much must remain visible when moved away in that direction
     left_marge = qMin(100 + borderRight(), moveResizeGeom.width());
     right_marge = qMin(100 + borderLeft(), moveResizeGeom.width());
     // width/height change with opaque resizing, use the initial ones
     titlebar_marge = initialMoveResizeGeometry().height();
     top_marge = borderBottom();
     bottom_marge = borderTop();
     if (isResize()) {
         if (moveResizeGeom.bottom() < desktopArea.top() + top_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.right() < desktopArea.left() + left_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.left() > desktopArea.right() - right_marge)
             setUnrestrictedMoveResize(true);
         if (!isUnrestrictedMoveResize() && moveResizeGeom.top() < desktopArea.top())   // titlebar mustn't go out
             setUnrestrictedMoveResize(true);
     }
     if (isMove()) {
         if (moveResizeGeom.bottom() < desktopArea.top() + titlebar_marge - 1)
             setUnrestrictedMoveResize(true);
         // no need to check top_marge, titlebar_marge already handles it
         if (moveResizeGeom.top() > desktopArea.bottom() - bottom_marge + 1) // titlebar mustn't go out
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.right() < desktopArea.left() + left_marge)
             setUnrestrictedMoveResize(true);
         if (moveResizeGeom.left() > desktopArea.right() - right_marge)
             setUnrestrictedMoveResize(true);
     }
 }
 
 // When the user pressed mouse on the titlebar, don't activate move immediatelly,
 // since it may be just a click. Activate instead after a delay. Move used to be
 // activated only after moving by several pixels, but that looks bad.
 void AbstractClient::startDelayedMoveResize()
 {
     Q_ASSERT(!m_moveResize.delayedTimer);
     m_moveResize.delayedTimer = new QTimer(this);
     m_moveResize.delayedTimer->setSingleShot(true);
     connect(m_moveResize.delayedTimer, &QTimer::timeout, this,
         [this]() {
             Q_ASSERT(isMoveResizePointerButtonDown());
             if (!startMoveResize()) {
                 setMoveResizePointerButtonDown(false);
             }
             updateCursor();
             stopDelayedMoveResize();
         }
     );
     m_moveResize.delayedTimer->start(QApplication::startDragTime());
 }
 
 void AbstractClient::stopDelayedMoveResize()
 {
     delete m_moveResize.delayedTimer;
     m_moveResize.delayedTimer = nullptr;
 }
 
 void AbstractClient::updateMoveResize(const QPointF &currentGlobalCursor)
 {
     handleMoveResize(pos(), currentGlobalCursor.toPoint());
 }
 
 void AbstractClient::handleMoveResize(const QPoint &local, const QPoint &global)
 {
     const QRect oldGeo = frameGeometry();
     handleMoveResize(local.x(), local.y(), global.x(), global.y());
     if (!isFullScreen() && isMove()) {
         if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && oldGeo != frameGeometry()) {
             GeometryUpdatesBlocker blocker(this);
             setQuickTileMode(QuickTileFlag::None);
             const QRect &geom_restore = geometryRestore();
             setMoveOffset(QPoint(double(moveOffset().x()) / double(oldGeo.width()) * double(geom_restore.width()),
                                  double(moveOffset().y()) / double(oldGeo.height()) * double(geom_restore.height())));
             if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore)
                 setMoveResizeGeometry(geom_restore);
             handleMoveResize(local.x(), local.y(), global.x(), global.y()); // fix position
         } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None) && isResizable()) {
             checkQuickTilingMaximizationZones(global.x(), global.y());
         }
     }
 }
 
 void AbstractClient::handleMoveResize(int x, int y, int x_root, int y_root)
 {
     if (isWaitingForMoveResizeSync())
         return; // we're still waiting for the client or the timeout
 
     const Position mode = moveResizePointerMode();
     if ((mode == PositionCenter && !isMovableAcrossScreens())
             || (mode != PositionCenter && (isShade() || !isResizable())))
         return;
 
     if (!isMoveResize()) {
         QPoint p(QPoint(x/* - padding_left*/, y/* - padding_top*/) - moveOffset());
         if (p.manhattanLength() >= QApplication::startDragDistance()) {
             if (!startMoveResize()) {
                 setMoveResizePointerButtonDown(false);
                 updateCursor();
                 return;
             }
             updateCursor();
         } else
             return;
     }
 
     // ShadeHover or ShadeActive, ShadeNormal was already avoided above
     if (mode != PositionCenter && shadeMode() != ShadeNone)
         setShade(ShadeNone);
 
     QPoint globalPos(x_root, y_root);
     // these two points limit the geometry rectangle, i.e. if bottomleft resizing is done,
     // the bottomleft corner should be at is at (topleft.x(), bottomright().y())
     QPoint topleft = globalPos - moveOffset();
     QPoint bottomright = globalPos + invertedMoveOffset();
     QRect previousMoveResizeGeom = moveResizeGeometry();
 
     // TODO move whole group when moving its leader or when the leader is not mapped?
 
     auto titleBarRect = [this](bool &transposed, int &requiredPixels) -> QRect {
         const QRect &moveResizeGeom = moveResizeGeometry();
         QRect r(moveResizeGeom);
         r.moveTopLeft(QPoint(0,0));
         switch (titlebarPosition()) {
         default:
         case PositionTop:
             r.setHeight(borderTop());
             break;
         case PositionLeft:
             r.setWidth(borderLeft());
             transposed = true;
             break;
         case PositionBottom:
             r.setTop(r.bottom() - borderBottom());
             break;
         case PositionRight:
             r.setLeft(r.right() - borderRight());
             transposed = true;
             break;
         }
         // When doing a restricted move we must always keep 100px of the titlebar
         // visible to allow the user to be able to move it again.
         requiredPixels = qMin(100 * (transposed ? r.width() : r.height()),
                               moveResizeGeom.width() * moveResizeGeom.height());
         return r;
     };
 
     bool update = false;
     if (isResize()) {
         QRect orig = initialMoveResizeGeometry();
         SizeMode sizeMode = SizeModeAny;
         auto calculateMoveResizeGeom = [this, &topleft, &bottomright, &orig, &sizeMode, &mode]() {
             switch(mode) {
             case PositionTopLeft:
                 setMoveResizeGeometry(QRect(topleft, orig.bottomRight()));
                 break;
             case PositionBottomRight:
                 setMoveResizeGeometry(QRect(orig.topLeft(), bottomright));
                 break;
             case PositionBottomLeft:
                 setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.y()), QPoint(orig.right(), bottomright.y())));
                 break;
             case PositionTopRight:
                 setMoveResizeGeometry(QRect(QPoint(orig.x(), topleft.y()), QPoint(bottomright.x(), orig.bottom())));
                 break;
             case PositionTop:
                 setMoveResizeGeometry(QRect(QPoint(orig.left(), topleft.y()), orig.bottomRight()));
                 sizeMode = SizeModeFixedH; // try not to affect height
                 break;
             case PositionBottom:
                 setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(orig.right(), bottomright.y())));
                 sizeMode = SizeModeFixedH;
                 break;
             case PositionLeft:
                 setMoveResizeGeometry(QRect(QPoint(topleft.x(), orig.top()), orig.bottomRight()));
                 sizeMode = SizeModeFixedW;
                 break;
             case PositionRight:
                 setMoveResizeGeometry(QRect(orig.topLeft(), QPoint(bottomright.x(), orig.bottom())));
                 sizeMode = SizeModeFixedW;
                 break;
             case PositionCenter:
             default:
                 abort();
                 break;
             }
         };
 
         // first resize (without checking constrains), then snap, then check bounds, then check constrains
         calculateMoveResizeGeom();
         // adjust new size to snap to other windows/borders
         setMoveResizeGeometry(workspace()->adjustClientSize(this, moveResizeGeometry(), mode));
 
         if (!isUnrestrictedMoveResize()) {
             // Make sure the titlebar isn't behind a restricted area. We don't need to restrict
             // the other directions. If not visible enough, move the window to the closest valid
             // point. We bruteforce this by slowly moving the window back to its previous position
             QRegion availableArea(workspace()->clientArea(FullArea, -1, 0));   // On the screen
             availableArea -= workspace()->restrictedMoveArea(desktop());   // Strut areas
             bool transposed = false;
             int requiredPixels;
             QRect bTitleRect = titleBarRect(transposed, requiredPixels);
             int lastVisiblePixels = -1;
             QRect lastTry = moveResizeGeometry();
             bool titleFailed = false;
             for (;;) {
                 const QRect titleRect(bTitleRect.translated(moveResizeGeometry().topLeft()));
                 int visiblePixels = 0;
                 int realVisiblePixels = 0;
                 for (const QRect &rect : availableArea) {
                     const QRect r = rect & titleRect;
                     realVisiblePixels += r.width() * r.height();
                     if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
                         (!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
                         visiblePixels += r.width() * r.height();
                 }
 
                 if (visiblePixels >= requiredPixels)
                     break; // We have reached a valid position
 
                 if (realVisiblePixels <= lastVisiblePixels) {
                     if (titleFailed && realVisiblePixels < lastVisiblePixels)
                         break; // we won't become better
                     else {
                         if (!titleFailed)
                             setMoveResizeGeometry(lastTry);
                         titleFailed = true;
                     }
                 }
                 lastVisiblePixels = realVisiblePixels;
                 QRect moveResizeGeom = moveResizeGeometry();
                 lastTry = moveResizeGeom;
 
                 // Not visible enough, move the window to the closest valid point. We bruteforce
                 // this by slowly moving the window back to its previous position.
                 // The geometry changes at up to two edges, the one with the title (if) shall take
                 // precedence. The opposing edge has no impact on visiblePixels and only one of
                 // the adjacent can alter at a time, ie. it's enough to ignore adjacent edges
                 // if the title edge altered
                 bool leftChanged  = previousMoveResizeGeom.left()   != moveResizeGeom.left();
                 bool rightChanged = previousMoveResizeGeom.right()  != moveResizeGeom.right();
                 bool topChanged   = previousMoveResizeGeom.top()    != moveResizeGeom.top();
                 bool btmChanged   = previousMoveResizeGeom.bottom() != moveResizeGeom.bottom();
                 auto fixChangedState = [titleFailed](bool &major, bool &counter, bool &ad1, bool &ad2) {
                     counter = false;
                     if (titleFailed)
                         major = false;
                     if (major)
                         ad1 = ad2 = false;
                 };
                 switch (titlebarPosition()) {
                 default:
                 case PositionTop:
                     fixChangedState(topChanged, btmChanged, leftChanged, rightChanged);
                     break;
                 case PositionLeft:
                     fixChangedState(leftChanged, rightChanged, topChanged, btmChanged);
                     break;
                 case PositionBottom:
                     fixChangedState(btmChanged, topChanged, leftChanged, rightChanged);
                     break;
                 case PositionRight:
                     fixChangedState(rightChanged, leftChanged, topChanged, btmChanged);
                     break;
                 }
                 if (topChanged)
                     moveResizeGeom.setTop(moveResizeGeom.y() + sign(previousMoveResizeGeom.y() - moveResizeGeom.y()));
                 else if (leftChanged)
                     moveResizeGeom.setLeft(moveResizeGeom.x() + sign(previousMoveResizeGeom.x() - moveResizeGeom.x()));
                 else if (btmChanged)
                     moveResizeGeom.setBottom(moveResizeGeom.bottom() + sign(previousMoveResizeGeom.bottom() - moveResizeGeom.bottom()));
                 else if (rightChanged)
                     moveResizeGeom.setRight(moveResizeGeom.right() + sign(previousMoveResizeGeom.right() - moveResizeGeom.right()));
                 else
                     break; // no position changed - that's certainly not good
                 setMoveResizeGeometry(moveResizeGeom);
             }
         }
 
         // Always obey size hints, even when in "unrestricted" mode
         QSize size = constrainFrameSize(moveResizeGeometry().size(), sizeMode);
         // the new topleft and bottomright corners (after checking size constrains), if they'll be needed
         topleft = QPoint(moveResizeGeometry().right() - size.width() + 1, moveResizeGeometry().bottom() - size.height() + 1);
         bottomright = QPoint(moveResizeGeometry().left() + size.width() - 1, moveResizeGeometry().top() + size.height() - 1);
         orig = moveResizeGeometry();
 
         // if aspect ratios are specified, both dimensions may change.
         // Therefore grow to the right/bottom if needed.
         // TODO it should probably obey gravity rather than always using right/bottom ?
         if (sizeMode == SizeModeFixedH)
             orig.setRight(bottomright.x());
         else if (sizeMode == SizeModeFixedW)
             orig.setBottom(bottomright.y());
 
         calculateMoveResizeGeom();
 
         if (moveResizeGeometry().size() != previousMoveResizeGeom.size())
             update = true;
     } else if (isMove()) {
         Q_ASSERT(mode == PositionCenter);
         if (!isMovable()) { // isMovableAcrossScreens() must have been true to get here
             // Special moving of maximized windows on Xinerama screens
             int screen = screens()->number(globalPos);
             if (isFullScreen())
                 setMoveResizeGeometry(workspace()->clientArea(FullScreenArea, screen, 0));
             else {
                 QRect moveResizeGeom = workspace()->clientArea(MaximizeArea, screen, 0);
                 QSize adjSize = constrainFrameSize(moveResizeGeom.size(), SizeModeMax);
                 if (adjSize != moveResizeGeom.size()) {
                     QRect r(moveResizeGeom);
                     moveResizeGeom.setSize(adjSize);
                     moveResizeGeom.moveCenter(r.center());
                 }
                 setMoveResizeGeometry(moveResizeGeom);
             }
         } else {
             // first move, then snap, then check bounds
             QRect moveResizeGeom = moveResizeGeometry();
             moveResizeGeom.moveTopLeft(topleft);
             moveResizeGeom.moveTopLeft(workspace()->adjustClientPosition(this, moveResizeGeom.topLeft(),
                                        isUnrestrictedMoveResize()));
             setMoveResizeGeometry(moveResizeGeom);
 
             if (!isUnrestrictedMoveResize()) {
                 const QRegion strut = workspace()->restrictedMoveArea(desktop());   // Strut areas
                 QRegion availableArea(workspace()->clientArea(FullArea, -1, 0));   // On the screen
                 availableArea -= strut;   // Strut areas
                 bool transposed = false;
                 int requiredPixels;
                 QRect bTitleRect = titleBarRect(transposed, requiredPixels);
                 for (;;) {
                     QRect moveResizeGeom = moveResizeGeometry();
                     const QRect titleRect(bTitleRect.translated(moveResizeGeom.topLeft()));
                     int visiblePixels = 0;
                     for (const QRect &rect : availableArea) {
                         const QRect r = rect & titleRect;
                         if ((transposed && r.width() == titleRect.width()) || // Only the full size regions...
                             (!transposed && r.height() == titleRect.height())) // ...prevents long slim areas
                             visiblePixels += r.width() * r.height();
                     }
                     if (visiblePixels >= requiredPixels)
                         break; // We have reached a valid position
 
                     // (esp.) if there're more screens with different struts (panels) it the titlebar
                     // will be movable outside the movearea (covering one of the panels) until it
                     // crosses the panel "too much" (not enough visiblePixels) and then stucks because
                     // it's usually only pushed by 1px to either direction
                     // so we first check whether we intersect suc strut and move the window below it
                     // immediately (it's still possible to hit the visiblePixels >= titlebarArea break
                     // by moving the window slightly downwards, but it won't stuck)
                     // see bug #274466
                     // and bug #301805 for why we can't just match the titlearea against the screen
                     if (screens()->count() > 1) { // optimization
                         // TODO: could be useful on partial screen struts (half-width panels etc.)
                         int newTitleTop = -1;
                         for (const QRect &r : strut) {
                             if (r.top() == 0 && r.width() > r.height() && // "top panel"
                                 r.intersects(moveResizeGeom) && moveResizeGeom.top() < r.bottom()) {
                                 newTitleTop = r.bottom() + 1;
                                 break;
                             }
                         }
                         if (newTitleTop > -1) {
                             moveResizeGeom.moveTop(newTitleTop); // invalid position, possibly on screen change
                             setMoveResizeGeometry(moveResizeGeom);
                             break;
                         }
                     }
 
                     int dx = sign(previousMoveResizeGeom.x() - moveResizeGeom.x()),
                         dy = sign(previousMoveResizeGeom.y() - moveResizeGeom.y());
                     if (visiblePixels && dx) // means there's no full width cap -> favor horizontally
                         dy = 0;
                     else if (dy)
                         dx = 0;
 
                     // Move it back
                     moveResizeGeom.translate(dx, dy);
                     setMoveResizeGeometry(moveResizeGeom);
 
                     if (moveResizeGeom == previousMoveResizeGeom) {
                         break; // Prevent lockup
                     }
                 }
             }
         }
         if (moveResizeGeometry().topLeft() != previousMoveResizeGeom.topLeft())
             update = true;
     } else
         abort();
 
     if (!update)
         return;
 
     if (isResize() && !haveResizeEffect()) {
         doResizeSync();
     } else
         performMoveResize();
 
     if (isMove()) {
         ScreenEdges::self()->check(globalPos, QDateTime::fromMSecsSinceEpoch(xTime(), Qt::UTC));
     }
 }
 
 void AbstractClient::performMoveResize()
 {
     const QRect &moveResizeGeom = moveResizeGeometry();
     if (isMove() || (isResize() && !haveResizeEffect())) {
         setFrameGeometry(moveResizeGeom);
     }
     doPerformMoveResize();
     positionGeometryTip();
     emit clientStepUserMovedResized(this, moveResizeGeom);
 }
 
 bool AbstractClient::hasStrut() const
 {
     return false;
 }
 
 void AbstractClient::setupWindowManagementInterface()
 {
     if (m_windowManagementInterface) {
         // already setup
         return;
     }
     if (!waylandServer() || !surface()) {
         return;
     }
     if (!waylandServer()->windowManagement()) {
         return;
     }
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     auto w = waylandServer()->windowManagement()->createWindow(waylandServer()->windowManagement());
     w->setTitle(caption());
     w->setVirtualDesktop(isOnAllDesktops() ? 0 : desktop() - 1);
     w->setActive(isActive());
     w->setFullscreen(isFullScreen());
     w->setKeepAbove(keepAbove());
     w->setKeepBelow(keepBelow());
     w->setMaximized(maximizeMode() == KWin::MaximizeFull);
     w->setMinimized(isMinimized());
     w->setOnAllDesktops(isOnAllDesktops());
     w->setDemandsAttention(isDemandingAttention());
     w->setCloseable(isCloseable());
     w->setMaximizeable(isMaximizable());
     w->setMinimizeable(isMinimizable());
     w->setFullscreenable(isFullScreenable());
     w->setApplicationMenuPaths(applicationMenuServiceName(), applicationMenuObjectPath());
     w->setIcon(icon());
     auto updateAppId = [this, w] {
         w->setAppId(QString::fromUtf8(m_desktopFileName.isEmpty() ? resourceClass() : m_desktopFileName));
     };
     updateAppId();
     w->setSkipTaskbar(skipTaskbar());
     w->setSkipSwitcher(skipSwitcher());
     w->setPid(pid());
     w->setShadeable(isShadeable());
     w->setShaded(isShade());
     w->setResizable(isResizable());
     w->setMovable(isMovable());
     w->setVirtualDesktopChangeable(true); // FIXME Matches X11Client::actionSupported(), but both should be implemented.
     w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
     w->setGeometry(frameGeometry());
     connect(this, &AbstractClient::skipTaskbarChanged, w,
         [w, this] {
             w->setSkipTaskbar(skipTaskbar());
         }
     );
     connect(this, &AbstractClient::skipSwitcherChanged, w,
          [w, this] {
             w->setSkipSwitcher(skipSwitcher());
         }
     );
     connect(this, &AbstractClient::captionChanged, w, [w, this] { w->setTitle(caption()); });
 
     connect(this, &AbstractClient::activeChanged, w, [w, this] { w->setActive(isActive()); });
     connect(this, &AbstractClient::fullScreenChanged, w, [w, this] { w->setFullscreen(isFullScreen()); });
     connect(this, &AbstractClient::keepAboveChanged, w, &PlasmaWindowInterface::setKeepAbove);
     connect(this, &AbstractClient::keepBelowChanged, w, &PlasmaWindowInterface::setKeepBelow);
     connect(this, &AbstractClient::minimizedChanged, w, [w, this] { w->setMinimized(isMinimized()); });
     connect(this, static_cast<void (AbstractClient::*)(AbstractClient*,MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged), w,
         [w] (KWin::AbstractClient *c, MaximizeMode mode) {
             Q_UNUSED(c);
             w->setMaximized(mode == KWin::MaximizeFull);
         }
     );
     connect(this, &AbstractClient::demandsAttentionChanged, w, [w, this] { w->setDemandsAttention(isDemandingAttention()); });
     connect(this, &AbstractClient::iconChanged, w,
         [w, this] {
             w->setIcon(icon());
         }
     );
     connect(this, &AbstractClient::windowClassChanged, w, updateAppId);
     connect(this, &AbstractClient::desktopFileNameChanged, w, updateAppId);
     connect(this, &AbstractClient::shadeChanged, w, [w, this] { w->setShaded(isShade()); });
     connect(this, &AbstractClient::transientChanged, w,
         [w, this] {
             w->setParentWindow(transientFor() ? transientFor()->windowManagementInterface() : nullptr);
         }
     );
     connect(this, &AbstractClient::frameGeometryChanged, w,
         [w, this] {
             w->setGeometry(frameGeometry());
         }
     );
     connect(this, &AbstractClient::applicationMenuChanged, w,
         [w, this] {
             w->setApplicationMenuPaths(applicationMenuServiceName(), applicationMenuObjectPath());
         }
     );
     connect(w, &PlasmaWindowInterface::closeRequested, this, [this] { closeWindow(); });
     connect(w, &PlasmaWindowInterface::moveRequested, this,
         [this] {
             Cursors::self()->mouse()->setPos(frameGeometry().center());
             performMouseCommand(Options::MouseMove, Cursors::self()->mouse()->pos());
         }
     );
     connect(w, &PlasmaWindowInterface::resizeRequested, this,
         [this] {
             Cursors::self()->mouse()->setPos(frameGeometry().bottomRight());
             performMouseCommand(Options::MouseResize, Cursors::self()->mouse()->pos());
         }
     );
     connect(w, &PlasmaWindowInterface::virtualDesktopRequested, this,
         [this] (quint32 desktop) {
             workspace()->sendClientToDesktop(this, desktop + 1, true);
         }
     );
     connect(w, &PlasmaWindowInterface::fullscreenRequested, this,
         [this] (bool set) {
             setFullScreen(set, false);
         }
     );
     connect(w, &PlasmaWindowInterface::minimizedRequested, this,
         [this] (bool set) {
             if (set) {
                 minimize();
             } else {
                 unminimize();
             }
         }
     );
     connect(w, &PlasmaWindowInterface::maximizedRequested, this,
         [this] (bool set) {
             maximize(set ? MaximizeFull : MaximizeRestore);
         }
     );
     connect(w, &PlasmaWindowInterface::keepAboveRequested, this,
         [this] (bool set) {
             setKeepAbove(set);
         }
     );
     connect(w, &PlasmaWindowInterface::keepBelowRequested, this,
         [this] (bool set) {
             setKeepBelow(set);
         }
     );
     connect(w, &PlasmaWindowInterface::demandsAttentionRequested, this,
         [this] (bool set) {
             demandAttention(set);
         }
     );
     connect(w, &PlasmaWindowInterface::activeRequested, this,
         [this] (bool set) {
             if (set) {
                 workspace()->activateClient(this, true);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::shadedRequested, this,
         [this] (bool set) {
             setShade(set);
         }
     );
 
     for (const auto vd : m_desktops) {
         w->addPlasmaVirtualDesktop(vd->id());
     }
 
     //this is only for the legacy
     connect(this, &AbstractClient::desktopChanged, w,
         [w, this] {
             if (isOnAllDesktops()) {
                 w->setOnAllDesktops(true);
                 return;
             }
             w->setVirtualDesktop(desktop() - 1);
             w->setOnAllDesktops(false);
         }
     );
 
     //Plasma Virtual desktop management
     //show/hide when the window enters/exits from desktop
     connect(w, &PlasmaWindowInterface::enterPlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 enterDesktop(vd);
             }
         }
     );
     connect(w, &PlasmaWindowInterface::enterNewPlasmaVirtualDesktopRequested, this,
         [this] () {
             VirtualDesktopManager::self()->setCount(VirtualDesktopManager::self()->count() + 1);
             enterDesktop(VirtualDesktopManager::self()->desktops().last());
         }
     );
     connect(w, &PlasmaWindowInterface::leavePlasmaVirtualDesktopRequested, this,
         [this] (const QString &desktopId) {
             VirtualDesktop *vd = VirtualDesktopManager::self()->desktopForId(desktopId.toUtf8());
             if (vd) {
                 leaveDesktop(vd);
             }
         }
     );
 
     m_windowManagementInterface = w;
 }
 
 void AbstractClient::destroyWindowManagementInterface()
 {
     if (m_windowManagementInterface) {
         m_windowManagementInterface->unmap();
         m_windowManagementInterface = nullptr;
     }
 }
 
 Options::MouseCommand AbstractClient::getMouseCommand(Qt::MouseButton button, bool *handled) const
 {
     *handled = false;
     if (button == Qt::NoButton) {
         return Options::MouseNothing;
     }
     if (isActive()) {
         if (options->isClickRaise()) {
             *handled = true;
             return Options::MouseActivateRaiseAndPassClick;
         }
     } else {
         *handled = true;
         switch (button) {
         case Qt::LeftButton:
             return options->commandWindow1();
         case Qt::MiddleButton:
             return options->commandWindow2();
         case Qt::RightButton:
             return options->commandWindow3();
         default:
             // all other buttons pass Activate & Pass Client
             return Options::MouseActivateAndPassClick;
         }
     }
     return Options::MouseNothing;
 }
 
 Options::MouseCommand AbstractClient::getWheelCommand(Qt::Orientation orientation, bool *handled) const
 {
     *handled = false;
     if (orientation != Qt::Vertical) {
         return Options::MouseNothing;
     }
     if (!isActive()) {
         *handled = true;
         return options->commandWindowWheel();
     }
     return Options::MouseNothing;
 }
 
 bool AbstractClient::performMouseCommand(Options::MouseCommand cmd, const QPoint &globalPos)
 {
     bool replay = false;
     switch(cmd) {
     case Options::MouseRaise:
         workspace()->raiseClient(this);
         break;
     case Options::MouseLower: {
         workspace()->lowerClient(this);
         // used to be activateNextClient(this), then topClientOnDesktop
         // since this is a mouseOp it's however safe to use the client under the mouse instead
         if (isActive() && options->focusPolicyIsReasonable()) {
             AbstractClient *next = workspace()->clientUnderMouse(screen());
             if (next && next != this)
                 workspace()->requestFocus(next, false);
         }
         break;
     }
     case Options::MouseOperationsMenu:
         if (isActive() && options->isClickRaise())
             autoRaise();
         workspace()->showWindowMenu(QRect(globalPos, globalPos), this);
         break;
     case Options::MouseToggleRaiseAndLower:
         workspace()->raiseOrLowerClient(this);
         break;
     case Options::MouseActivateAndRaise: {
         replay = isActive(); // for clickraise mode
         bool mustReplay = !rules()->checkAcceptFocus(acceptsFocus());
         if (mustReplay) {
             auto it = workspace()->stackingOrder().constEnd(),
                                      begin = workspace()->stackingOrder().constBegin();
             while (mustReplay && --it != begin && *it != this) {
                 AbstractClient *c = qobject_cast<AbstractClient*>(*it);
                 if (!c || (c->keepAbove() && !keepAbove()) || (keepBelow() && !c->keepBelow()))
                     continue; // can never raise above "it"
                 mustReplay = !(c->isOnCurrentDesktop() && c->isOnCurrentActivity() && c->frameGeometry().intersects(frameGeometry()));
             }
         }
         workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
         screens()->setCurrent(globalPos);
         replay = replay || mustReplay;
         break;
     }
     case Options::MouseActivateAndLower:
         workspace()->requestFocus(this);
         workspace()->lowerClient(this);
         screens()->setCurrent(globalPos);
         replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
         break;
     case Options::MouseActivate:
         replay = isActive(); // for clickraise mode
         workspace()->takeActivity(this, Workspace::ActivityFocus);
         screens()->setCurrent(globalPos);
         replay = replay || !rules()->checkAcceptFocus(acceptsFocus());
         break;
     case Options::MouseActivateRaiseAndPassClick:
         workspace()->takeActivity(this, Workspace::ActivityFocus | Workspace::ActivityRaise);
         screens()->setCurrent(globalPos);
         replay = true;
         break;
     case Options::MouseActivateAndPassClick:
         workspace()->takeActivity(this, Workspace::ActivityFocus);
         screens()->setCurrent(globalPos);
         replay = true;
         break;
     case Options::MouseMaximize:
         maximize(MaximizeFull);
         break;
     case Options::MouseRestore:
         maximize(MaximizeRestore);
         break;
     case Options::MouseMinimize:
         minimize();
         break;
     case Options::MouseAbove: {
         StackingUpdatesBlocker blocker(workspace());
         if (keepBelow())
             setKeepBelow(false);
         else
             setKeepAbove(true);
         break;
     }
     case Options::MouseBelow: {
         StackingUpdatesBlocker blocker(workspace());
         if (keepAbove())
             setKeepAbove(false);
         else
             setKeepBelow(true);
         break;
     }
     case Options::MousePreviousDesktop:
         workspace()->windowToPreviousDesktop(this);
         break;
     case Options::MouseNextDesktop:
         workspace()->windowToNextDesktop(this);
         break;
     case Options::MouseOpacityMore:
         if (!isDesktop())   // No point in changing the opacity of the desktop
             setOpacity(qMin(opacity() + 0.1, 1.0));
         break;
     case Options::MouseOpacityLess:
         if (!isDesktop())   // No point in changing the opacity of the desktop
             setOpacity(qMax(opacity() - 0.1, 0.1));
         break;
     case Options::MouseClose:
         closeWindow();
         break;
     case Options::MouseActivateRaiseAndMove:
     case Options::MouseActivateRaiseAndUnrestrictedMove:
         workspace()->raiseClient(this);
         workspace()->requestFocus(this);
         screens()->setCurrent(globalPos);
         // fallthrough
     case Options::MouseMove:
     case Options::MouseUnrestrictedMove: {
         if (!isMovableAcrossScreens())
             break;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerMode(PositionCenter);
         setMoveResizePointerButtonDown(true);
         setMoveOffset(QPoint(globalPos.x() - x(), globalPos.y() - y()));  // map from global
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize((cmd == Options::MouseActivateRaiseAndUnrestrictedMove
                                   || cmd == Options::MouseUnrestrictedMove));
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     }
     case Options::MouseResize:
     case Options::MouseUnrestrictedResize: {
         if (!isResizable() || isShade())
             break;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerButtonDown(true);
         const QPoint moveOffset = QPoint(globalPos.x() - x(), globalPos.y() - y());  // map from global
         setMoveOffset(moveOffset);
         int x = moveOffset.x(), y = moveOffset.y();
         bool left = x < width() / 3;
         bool right = x >= 2 * width() / 3;
         bool top = y < height() / 3;
         bool bot = y >= 2 * height() / 3;
         Position mode;
         if (top)
             mode = left ? PositionTopLeft : (right ? PositionTopRight : PositionTop);
         else if (bot)
             mode = left ? PositionBottomLeft : (right ? PositionBottomRight : PositionBottom);
         else
             mode = (x < width() / 2) ? PositionLeft : PositionRight;
         setMoveResizePointerMode(mode);
         setInvertedMoveOffset(rect().bottomRight() - moveOffset);
         setUnrestrictedMoveResize((cmd == Options::MouseUnrestrictedResize));
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
         break;
     }
     case Options::MouseNothing:
     default:
         replay = true;
         break;
     }
     return replay;
 }
 
 void AbstractClient::setTransientFor(AbstractClient *transientFor)
 {
     if (transientFor == this) {
         // cannot be transient for one self
         return;
     }
     if (m_transientFor == transientFor) {
         return;
     }
     m_transientFor = transientFor;
     emit transientChanged();
 }
 
 const AbstractClient *AbstractClient::transientFor() const
 {
     return m_transientFor;
 }
 
 AbstractClient *AbstractClient::transientFor()
 {
     return m_transientFor;
 }
 
 bool AbstractClient::hasTransientPlacementHint() const
 {
     return false;
 }
 
 QRect AbstractClient::transientPlacement(const QRect &bounds) const
 {
     Q_UNUSED(bounds);
     Q_UNREACHABLE();
     return QRect();
 }
 
 bool AbstractClient::hasTransient(const AbstractClient *c, bool indirect) const
 {
     Q_UNUSED(indirect);
     return c->transientFor() == this;
 }
 
 QList< AbstractClient* > AbstractClient::mainClients() const
 {
     if (const AbstractClient *t = transientFor()) {
         return QList<AbstractClient*>{const_cast< AbstractClient* >(t)};
     }
     return QList<AbstractClient*>();
 }
 
 QList<AbstractClient*> AbstractClient::allMainClients() const
 {
     auto result = mainClients();
     foreach (const auto *cl, result) {
         result += cl->allMainClients();
     }
     return result;
 }
 
 void AbstractClient::setModal(bool m)
 {
     // Qt-3.2 can have even modal normal windows :(
     if (m_modal == m)
         return;
     m_modal = m;
     emit modalChanged();
     // Changing modality for a mapped window is weird (?)
     // _NET_WM_STATE_MODAL should possibly rather be _NET_WM_WINDOW_TYPE_MODAL_DIALOG
 }
 
 bool AbstractClient::isModal() const
 {
     return m_modal;
 }
 
 void AbstractClient::addTransient(AbstractClient *cl)
 {
     Q_ASSERT(!m_transients.contains(cl));
     Q_ASSERT(cl != this);
     m_transients.append(cl);
 }
 
 void AbstractClient::removeTransient(AbstractClient *cl)
 {
     m_transients.removeAll(cl);
     if (cl->transientFor() == this) {
         cl->setTransientFor(nullptr);
     }
 }
 
 void AbstractClient::removeTransientFromList(AbstractClient *cl)
 {
     m_transients.removeAll(cl);
 }
 
 bool AbstractClient::isActiveFullScreen() const
 {
     if (!isFullScreen())
         return false;
 
     const auto ac = workspace()->mostRecentlyActivatedClient(); // instead of activeClient() - avoids flicker
     // according to NETWM spec implementation notes suggests
     // "focused windows having state _NET_WM_STATE_FULLSCREEN" to be on the highest layer.
     // we'll also take the screen into account
     return ac && (ac == this || ac->screen() != screen()|| ac->allMainClients().contains(const_cast<AbstractClient*>(this)));
 }
 
 #define BORDER(which) \
     int AbstractClient::border##which() const \
     { \
         return isDecorated() ? decoration()->border##which() : 0; \
     }
 
 BORDER(Bottom)
 BORDER(Left)
 BORDER(Right)
 BORDER(Top)
 #undef BORDER
 
 void AbstractClient::addRepaintDuringGeometryUpdates()
 {
     const QRect deco_rect = visibleRect();
     addLayerRepaint(m_visibleRectBeforeGeometryUpdate);
     addLayerRepaint(deco_rect);   // trigger repaint of window's new location
     m_visibleRectBeforeGeometryUpdate = deco_rect;
 }
 
 QRect AbstractClient::bufferGeometryBeforeUpdateBlocking() const
 {
     return m_bufferGeometryBeforeUpdateBlocking;
 }
 
 QRect AbstractClient::frameGeometryBeforeUpdateBlocking() const
 {
     return m_frameGeometryBeforeUpdateBlocking;
 }
 
 void AbstractClient::updateGeometryBeforeUpdateBlocking()
 {
     m_bufferGeometryBeforeUpdateBlocking = bufferGeometry();
     m_frameGeometryBeforeUpdateBlocking = frameGeometry();
 }
 
 void AbstractClient::doMove(int, int)
 {
 }
 
 void AbstractClient::updateInitialMoveResizeGeometry()
 {
     m_moveResize.initialGeometry = frameGeometry();
     m_moveResize.geometry = m_moveResize.initialGeometry;
     m_moveResize.startScreen = screen();
 }
 
 void AbstractClient::updateCursor()
 {
     Position m = moveResizePointerMode();
     if (!isResizable() || isShade())
         m = PositionCenter;
     CursorShape c = Qt::ArrowCursor;
     switch(m) {
     case PositionTopLeft:
         c = KWin::ExtendedCursor::SizeNorthWest;
         break;
     case PositionBottomRight:
         c = KWin::ExtendedCursor::SizeSouthEast;
         break;
     case PositionBottomLeft:
         c = KWin::ExtendedCursor::SizeSouthWest;
         break;
     case PositionTopRight:
         c = KWin::ExtendedCursor::SizeNorthEast;
         break;
     case PositionTop:
         c = KWin::ExtendedCursor::SizeNorth;
         break;
     case PositionBottom:
         c = KWin::ExtendedCursor::SizeSouth;
         break;
     case PositionLeft:
         c = KWin::ExtendedCursor::SizeWest;
         break;
     case PositionRight:
         c = KWin::ExtendedCursor::SizeEast;
         break;
     default:
         if (isMoveResize())
             c = Qt::SizeAllCursor;
         else
             c = Qt::ArrowCursor;
         break;
     }
     if (c == m_moveResize.cursor)
         return;
     m_moveResize.cursor = c;
     emit moveResizeCursorChanged(c);
 }
 
 void AbstractClient::leaveMoveResize()
 {
     workspace()->setMoveResizeClient(nullptr);
     setMoveResize(false);
     if (ScreenEdges::self()->isDesktopSwitchingMovingClients())
         ScreenEdges::self()->reserveDesktopSwitching(false, Qt::Vertical|Qt::Horizontal);
     if (isElectricBorderMaximizing()) {
         outline()->hide();
         elevate(false);
     }
 }
 
 bool AbstractClient::s_haveResizeEffect = false;
 
 void AbstractClient::updateHaveResizeEffect()
 {
     s_haveResizeEffect = effects && static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::Resize);
 }
 
 bool AbstractClient::doStartMoveResize()
 {
     return true;
 }
 
 void AbstractClient::positionGeometryTip()
 {
 }
 
 void AbstractClient::doPerformMoveResize()
 {
 }
 
 bool AbstractClient::isWaitingForMoveResizeSync() const
 {
     return false;
 }
 
 void AbstractClient::doResizeSync()
 {
 }
 
 void AbstractClient::checkQuickTilingMaximizationZones(int xroot, int yroot)
 {
     QuickTileMode mode = QuickTileFlag::None;
     bool innerBorder = false;
     for (int i=0; i < screens()->count(); ++i) {
 
         if (!screens()->geometry(i).contains(QPoint(xroot, yroot)))
             continue;
 
         auto isInScreen = [i](const QPoint &pt) {
             for (int j = 0; j < screens()->count(); ++j) {
                 if (j == i)
                     continue;
                 if (screens()->geometry(j).contains(pt)) {
                     return true;
                 }
             }
             return false;
         };
 
         QRect area = workspace()->clientArea(MaximizeArea, QPoint(xroot, yroot), desktop());
         if (options->electricBorderTiling()) {
             if (xroot <= area.x() + 20) {
                 mode |= QuickTileFlag::Left;
                 innerBorder = isInScreen(QPoint(area.x() - 1, yroot));
             } else if (xroot >= area.x() + area.width() - 20) {
                 mode |= QuickTileFlag::Right;
                 innerBorder = isInScreen(QPoint(area.right() + 1, yroot));
             }
         }
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             if (yroot <= area.y() + area.height() * options->electricBorderCornerRatio())
                 mode |= QuickTileFlag::Top;
             else if (yroot >= area.y() + area.height() - area.height()  * options->electricBorderCornerRatio())
                 mode |= QuickTileFlag::Bottom;
         } else if (options->electricBorderMaximize() && yroot <= area.y() + 5 && isMaximizable()) {
             mode = QuickTileFlag::Maximize;
             innerBorder = isInScreen(QPoint(xroot, area.y() - 1));
         }
         break; // no point in checking other screens to contain this... "point"...
     }
     if (mode != electricBorderMode()) {
         setElectricBorderMode(mode);
         if (innerBorder) {
             if (!m_electricMaximizingDelay) {
                 m_electricMaximizingDelay = new QTimer(this);
                 m_electricMaximizingDelay->setInterval(250);
                 m_electricMaximizingDelay->setSingleShot(true);
                 connect(m_electricMaximizingDelay, &QTimer::timeout, [this]() {
                     if (isMove())
                         setElectricBorderMaximizing(electricBorderMode() != QuickTileMode(QuickTileFlag::None));
                 });
             }
             m_electricMaximizingDelay->start();
         } else {
             setElectricBorderMaximizing(mode != QuickTileMode(QuickTileFlag::None));
         }
     }
 }
 
 void AbstractClient::keyPressEvent(uint key_code)
 {
     if (!isMove() && !isResize())
         return;
     bool is_control = key_code & Qt::CTRL;
     bool is_alt = key_code & Qt::ALT;
     key_code = key_code & ~Qt::KeyboardModifierMask;
     int delta = is_control ? 1 : is_alt ? 32 : 8;
     QPoint pos = Cursors::self()->mouse()->pos();
     switch(key_code) {
     case Qt::Key_Left:
         pos.rx() -= delta;
         break;
     case Qt::Key_Right:
         pos.rx() += delta;
         break;
     case Qt::Key_Up:
         pos.ry() -= delta;
         break;
     case Qt::Key_Down:
         pos.ry() += delta;
         break;
     case Qt::Key_Space:
     case Qt::Key_Return:
     case Qt::Key_Enter:
         setMoveResizePointerButtonDown(false);
         finishMoveResize(false);
         updateCursor();
         break;
     case Qt::Key_Escape:
         setMoveResizePointerButtonDown(false);
         finishMoveResize(true);
         updateCursor();
         break;
     default:
         return;
     }
     Cursors::self()->mouse()->setPos(pos);
 }
 
 QSize AbstractClient::resizeIncrements() const
 {
     return QSize(1, 1);
 }
 
 void AbstractClient::dontMoveResize()
 {
     setMoveResizePointerButtonDown(false);
     stopDelayedMoveResize();
     if (isMoveResize())
         finishMoveResize(false);
 }
 
 AbstractClient::Position AbstractClient::mousePosition() const
 {
     if (isDecorated()) {
         switch (decoration()->sectionUnderMouse()) {
             case Qt::BottomLeftSection:
                 return PositionBottomLeft;
             case Qt::BottomRightSection:
                 return PositionBottomRight;
             case Qt::BottomSection:
                 return PositionBottom;
             case Qt::LeftSection:
                 return PositionLeft;
             case Qt::RightSection:
                 return PositionRight;
             case Qt::TopSection:
                 return PositionTop;
             case Qt::TopLeftSection:
                 return PositionTopLeft;
             case Qt::TopRightSection:
                 return PositionTopRight;
             default:
                 return PositionCenter;
         }
     }
     return PositionCenter;
 }
 
 void AbstractClient::endMoveResize()
 {
     setMoveResizePointerButtonDown(false);
     stopDelayedMoveResize();
     if (isMoveResize()) {
         finishMoveResize(false);
         setMoveResizePointerMode(mousePosition());
     }
     updateCursor();
 }
 
 void AbstractClient::createDecoration(const QRect &oldGeometry)
 {
     KDecoration2::Decoration *decoration = Decoration::DecorationBridge::self()->createDecoration(this);
     if (decoration) {
         QMetaObject::invokeMethod(decoration, "update", Qt::QueuedConnection);
         connect(decoration, &KDecoration2::Decoration::shadowChanged, this, &Toplevel::updateShadow);
         connect(decoration, &KDecoration2::Decoration::bordersChanged, this, [this]() {
             GeometryUpdatesBlocker blocker(this);
             const QRect oldGeometry = frameGeometry();
             if (!isShade()) {
                 checkWorkspacePosition(oldGeometry);
             }
             emit geometryShapeChanged(this, oldGeometry);
         });
     }
     setDecoration(decoration);
     setFrameGeometry(QRect(oldGeometry.topLeft(), clientSizeToFrameSize(clientSize())));
 
     emit geometryShapeChanged(this, oldGeometry);
 }
 
 void AbstractClient::destroyDecoration()
 {
     delete m_decoration.decoration;
     m_decoration.decoration = nullptr;
 }
 
 bool AbstractClient::decorationHasAlpha() const
 {
     if (!isDecorated() || decoration()->isOpaque()) {
         // either no decoration or decoration has alpha disabled
         return false;
     }
     return true;
 }
 
 void AbstractClient::triggerDecorationRepaint()
 {
     if (isDecorated()) {
         decoration()->update();
     }
 }
 
 void AbstractClient::layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const
 {
     if (!isDecorated()) {
         return;
     }
     QRect r = decoration()->rect();
 
     top = QRect(r.x(), r.y(), r.width(), borderTop());
     bottom = QRect(r.x(), r.y() + r.height() - borderBottom(),
                    r.width(), borderBottom());
     left = QRect(r.x(), r.y() + top.height(),
                  borderLeft(), r.height() - top.height() - bottom.height());
     right = QRect(r.x() + r.width() - borderRight(), r.y() + top.height(),
                   borderRight(), r.height() - top.height() - bottom.height());
 }
 
 void AbstractClient::processDecorationMove(const QPoint &localPos, const QPoint &globalPos)
 {
     if (isMoveResizePointerButtonDown()) {
         handleMoveResize(localPos.x(), localPos.y(), globalPos.x(), globalPos.y());
         return;
     }
     // TODO: handle modifiers
     Position newmode = mousePosition();
     if (newmode != moveResizePointerMode()) {
         setMoveResizePointerMode(newmode);
         updateCursor();
     }
 }
 
 bool AbstractClient::processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu)
 {
     Options::MouseCommand com = Options::MouseNothing;
     bool active = isActive();
     if (!wantsInput())    // we cannot be active, use it anyway
         active = true;
 
     // check whether it is a double click
     if (event->button() == Qt::LeftButton && titlebarPositionUnderMouse()) {
         if (m_decoration.doubleClickTimer.isValid()) {
             const qint64 interval = m_decoration.doubleClickTimer.elapsed();
             m_decoration.doubleClickTimer.invalidate();
             if (interval > QGuiApplication::styleHints()->mouseDoubleClickInterval()) {
                 m_decoration.doubleClickTimer.start(); // expired -> new first click and pot. init
             } else {
                 Workspace::self()->performWindowOperation(this, options->operationTitlebarDblClick());
                 dontMoveResize();
                 return false;
             }
         }
          else {
             m_decoration.doubleClickTimer.start(); // new first click and pot. init, could be invalidated by release - see below
         }
     }
 
     if (event->button() == Qt::LeftButton)
         com = active ? options->commandActiveTitlebar1() : options->commandInactiveTitlebar1();
     else if (event->button() == Qt::MidButton)
         com = active ? options->commandActiveTitlebar2() : options->commandInactiveTitlebar2();
     else if (event->button() == Qt::RightButton)
         com = active ? options->commandActiveTitlebar3() : options->commandInactiveTitlebar3();
     if (event->button() == Qt::LeftButton
             && com != Options::MouseOperationsMenu // actions where it's not possible to get the matching
             && com != Options::MouseMinimize)  // mouse release event
     {
         setMoveResizePointerMode(mousePosition());
         setMoveResizePointerButtonDown(true);
         setMoveOffset(event->pos());
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize(false);
         startDelayedMoveResize();
         updateCursor();
     }
     // In the new API the decoration may process the menu action to display an inactive tab's menu.
     // If the event is unhandled then the core will create one for the active window in the group.
     if (!ignoreMenu || com != Options::MouseOperationsMenu)
         performMouseCommand(com, event->globalPos());
     return !( // Return events that should be passed to the decoration in the new API
                com == Options::MouseRaise ||
                com == Options::MouseOperationsMenu ||
                com == Options::MouseActivateAndRaise ||
                com == Options::MouseActivate ||
                com == Options::MouseActivateRaiseAndPassClick ||
                com == Options::MouseActivateAndPassClick ||
                com == Options::MouseNothing);
 }
 
 void AbstractClient::processDecorationButtonRelease(QMouseEvent *event)
 {
     if (isDecorated()) {
         if (event->isAccepted() || !titlebarPositionUnderMouse()) {
             invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
         }
     }
 
     if (event->buttons() == Qt::NoButton) {
         setMoveResizePointerButtonDown(false);
         stopDelayedMoveResize();
         if (isMoveResize()) {
             finishMoveResize(false);
             setMoveResizePointerMode(mousePosition());
         }
         updateCursor();
     }
 }
 
 
 void AbstractClient::startDecorationDoubleClickTimer()
 {
     m_decoration.doubleClickTimer.start();
 }
 
 void AbstractClient::invalidateDecorationDoubleClickTimer()
 {
     m_decoration.doubleClickTimer.invalidate();
 }
 
 bool AbstractClient::providesContextHelp() const
 {
     return false;
 }
 
 void AbstractClient::showContextHelp()
 {
 }
 
 QPointer<Decoration::DecoratedClientImpl> AbstractClient::decoratedClient() const
 {
     return m_decoration.client;
 }
 
 void AbstractClient::setDecoratedClient(QPointer< Decoration::DecoratedClientImpl > client)
 {
     m_decoration.client = client;
 }
 
 void AbstractClient::enterEvent(const QPoint &globalPos)
 {
     // TODO: shade hover
     if (options->focusPolicy() == Options::ClickToFocus || workspace()->userActionsMenu()->isShown())
         return;
 
     if (options->isAutoRaise() && !isDesktop() &&
             !isDock() && workspace()->focusChangeEnabled() &&
             globalPos != workspace()->focusMousePosition() &&
             workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(),
                                             options->isSeparateScreenFocus() ? screen() : -1) != this) {
         startAutoRaise();
     }
 
     if (isDesktop() || isDock())
         return;
     // for FocusFollowsMouse, change focus only if the mouse has actually been moved, not if the focus
     // change came because of window changes (e.g. closing a window) - #92290
     if (options->focusPolicy() != Options::FocusFollowsMouse
             || globalPos != workspace()->focusMousePosition()) {
         workspace()->requestDelayFocus(this);
     }
 }
 
 void AbstractClient::leaveEvent()
 {
     cancelAutoRaise();
     workspace()->cancelDelayFocus();
     // TODO: shade hover
     // TODO: send hover leave to deco
     // TODO: handle Options::FocusStrictlyUnderMouse
 }
 
 QRect AbstractClient::iconGeometry() const
 {
     if (!windowManagementInterface() || !waylandServer()) {
         // window management interface is only available if the surface is mapped
         return QRect();
     }
 
     int minDistance = INT_MAX;
     AbstractClient *candidatePanel = nullptr;
     QRect candidateGeom;
 
     for (auto i = windowManagementInterface()->minimizedGeometries().constBegin(), end = windowManagementInterface()->minimizedGeometries().constEnd(); i != end; ++i) {
         AbstractClient *client = waylandServer()->findClient(i.key());
         if (!client) {
             continue;
         }
         const int distance = QPoint(client->pos() - pos()).manhattanLength();
         if (distance < minDistance) {
             minDistance = distance;
             candidatePanel = client;
             candidateGeom = i.value();
         }
     }
     if (!candidatePanel) {
         return QRect();
     }
     return candidateGeom.translated(candidatePanel->pos());
 }
 
 QRect AbstractClient::inputGeometry() const
 {
     if (isDecorated()) {
         return Toplevel::inputGeometry() + decoration()->resizeOnlyBorders();
     }
     return Toplevel::inputGeometry();
 }
 
 QRect AbstractClient::virtualKeyboardGeometry() const
 {
     return m_virtualKeyboardGeometry;
 }
 
 void AbstractClient::setVirtualKeyboardGeometry(const QRect &geo)
 {
     // No keyboard anymore
     if (geo.isEmpty() && !m_keyboardGeometryRestore.isEmpty()) {
         setFrameGeometry(m_keyboardGeometryRestore);
         m_keyboardGeometryRestore = QRect();
     } else if (geo.isEmpty()) {
         return;
     // The keyboard has just been opened (rather than resized) save client geometry for a restore
     } else if (m_keyboardGeometryRestore.isEmpty()) {
         m_keyboardGeometryRestore = frameGeometry();
     }
 
     m_virtualKeyboardGeometry = geo;
 
     // Don't resize Desktop and fullscreen windows
     if (isFullScreen() || isDesktop()) {
         return;
     }
 
     if (!geo.intersects(m_keyboardGeometryRestore)) {
         return;
     }
 
     const QRect availableArea = workspace()->clientArea(MaximizeArea, this);
     QRect newWindowGeometry = m_keyboardGeometryRestore;
     newWindowGeometry.moveBottom(geo.top());
     newWindowGeometry.setTop(qMax(newWindowGeometry.top(), availableArea.top()));
 
     setFrameGeometry(newWindowGeometry);
 }
 
 bool AbstractClient::dockWantsInput() const
 {
     return false;
 }
 
 void AbstractClient::setDesktopFileName(QByteArray name)
 {
     name = rules()->checkDesktopFile(name).toUtf8();
     if (name == m_desktopFileName) {
         return;
     }
     m_desktopFileName = name;
     updateWindowRules(Rules::DesktopFile);
     emit desktopFileNameChanged();
 }
 
 QString AbstractClient::iconFromDesktopFile() const
 {
     if (m_desktopFileName.isEmpty()) {
         return QString();
     }
     QString desktopFile = QString::fromUtf8(m_desktopFileName);
     if (!desktopFile.endsWith(QLatin1String(".desktop"))) {
         desktopFile.append(QLatin1String(".desktop"));
     }
     KDesktopFile df(desktopFile);
     return df.readIcon();
 }
 
 bool AbstractClient::hasApplicationMenu() const
 {
     return ApplicationMenu::self()->applicationMenuEnabled() && !m_applicationMenuServiceName.isEmpty() && !m_applicationMenuObjectPath.isEmpty();
 }
 
 void AbstractClient::updateApplicationMenuServiceName(const QString &serviceName)
 {
     const bool old_hasApplicationMenu = hasApplicationMenu();
 
     m_applicationMenuServiceName = serviceName;
 
     const bool new_hasApplicationMenu = hasApplicationMenu();
 
     emit applicationMenuChanged();
     if (old_hasApplicationMenu != new_hasApplicationMenu) {
         emit hasApplicationMenuChanged(new_hasApplicationMenu);
     }
 }
 
 void AbstractClient::updateApplicationMenuObjectPath(const QString &objectPath)
 {
     const bool old_hasApplicationMenu = hasApplicationMenu();
 
     m_applicationMenuObjectPath = objectPath;
 
     const bool new_hasApplicationMenu = hasApplicationMenu();
 
     emit applicationMenuChanged();
     if (old_hasApplicationMenu != new_hasApplicationMenu) {
         emit hasApplicationMenuChanged(new_hasApplicationMenu);
     }
 }
 
 void AbstractClient::setApplicationMenuActive(bool applicationMenuActive)
 {
     if (m_applicationMenuActive != applicationMenuActive) {
         m_applicationMenuActive = applicationMenuActive;
         emit applicationMenuActiveChanged(applicationMenuActive);
     }
 }
 
 void AbstractClient::showApplicationMenu(int actionId)
 {
     if (isDecorated()) {
         decoration()->showApplicationMenu(actionId);
     } else {
         // we don't know where the application menu button will be, show it in the top left corner instead
         Workspace::self()->showApplicationMenu(QRect(), this, actionId);
     }
 }
 
 bool AbstractClient::unresponsive() const
 {
     return m_unresponsive;
 }
 
 void AbstractClient::setUnresponsive(bool unresponsive)
 {
     if (m_unresponsive != unresponsive) {
         m_unresponsive = unresponsive;
         emit unresponsiveChanged(m_unresponsive);
         emit captionChanged();
     }
 }
 
 QString AbstractClient::shortcutCaptionSuffix() const
 {
     if (shortcut().isEmpty()) {
         return QString();
     }
     return QLatin1String(" {") + shortcut().toString() + QLatin1Char('}');
 }
 
 AbstractClient *AbstractClient::findClientWithSameCaption() const
 {
     auto fetchNameInternalPredicate = [this](const AbstractClient *cl) {
         return (!cl->isSpecialWindow() || cl->isToolbar()) && cl != this && cl->captionNormal() == captionNormal() && cl->captionSuffix() == captionSuffix();
     };
     return workspace()->findAbstractClient(fetchNameInternalPredicate);
 }
 
 QString AbstractClient::caption() const
 {
     QString cap = captionNormal() + captionSuffix();
     if (unresponsive()) {
         cap += QLatin1String(" ");
         cap += i18nc("Application is not responding, appended to window title", "(Not Responding)");
     }
     return cap;
 }
 
 void AbstractClient::removeRule(Rules* rule)
 {
     m_rules.remove(rule);
 }
 
 void AbstractClient::discardTemporaryRules()
 {
     m_rules.discardTemporary();
 }
 
 void AbstractClient::evaluateWindowRules()
 {
     setupWindowRules(true);
     applyWindowRules();
 }
 
 void AbstractClient::setOnActivities(QStringList newActivitiesList)
 {
     Q_UNUSED(newActivitiesList)
 }
 
 void AbstractClient::checkNoBorder()
 {
     setNoBorder(false);
 }
 
 bool AbstractClient::groupTransient() const
 {
     return false;
 }
 
 const Group *AbstractClient::group() const
 {
     return nullptr;
 }
 
 Group *AbstractClient::group()
 {
     return nullptr;
 }
 
 bool AbstractClient::isInternal() const
 {
     return false;
 }
 
 bool AbstractClient::supportsWindowRules() const
 {
     return true;
 }
 
 QMargins AbstractClient::frameMargins() const
 {
     return QMargins(borderLeft(), borderTop(), borderRight(), borderBottom());
 }
 
 QPoint AbstractClient::framePosToClientPos(const QPoint &point) const
 {
     return point + QPoint(borderLeft(), borderTop());
 }
 
 QPoint AbstractClient::clientPosToFramePos(const QPoint &point) const
 {
     return point - QPoint(borderLeft(), borderTop());
 }
 
 QSize AbstractClient::frameSizeToClientSize(const QSize &size) const
 {
     const int width = size.width() - borderLeft() - borderRight();
     const int height = size.height() - borderTop() - borderBottom();
     return QSize(width, height);
 }
 
 QSize AbstractClient::clientSizeToFrameSize(const QSize &size) const
 {
     const int width = size.width() + borderLeft() + borderRight();
     const int height = size.height() + borderTop() + borderBottom();
     return QSize(width, height);
 }
 
 QRect AbstractClient::frameRectToClientRect(const QRect &rect) const
 {
     const QPoint position = framePosToClientPos(rect.topLeft());
     const QSize size = frameSizeToClientSize(rect.size());
     return QRect(position, size);
 }
 
 QRect AbstractClient::clientRectToFrameRect(const QRect &rect) const
 {
     const QPoint position = clientPosToFramePos(rect.topLeft());
     const QSize size = clientSizeToFrameSize(rect.size());
     return QRect(position, size);
 }
 
 void AbstractClient::setElectricBorderMode(QuickTileMode mode)
 {
     if (mode != QuickTileMode(QuickTileFlag::Maximize)) {
         // sanitize the mode, ie. simplify "invalid" combinations
         if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
             mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
         if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
             mode &= ~QuickTileMode(QuickTileFlag::Vertical);
     }
     m_electricMode = mode;
 }
 
 void AbstractClient::setElectricBorderMaximizing(bool maximizing)
 {
     m_electricMaximizing = maximizing;
     if (maximizing)
         outline()->show(electricBorderMaximizeGeometry(Cursors::self()->mouse()->pos(), desktop()), moveResizeGeometry());
     else
         outline()->hide();
     elevate(maximizing);
 }
 
 QRect AbstractClient::electricBorderMaximizeGeometry(QPoint pos, int desktop)
 {
     if (electricBorderMode() == QuickTileMode(QuickTileFlag::Maximize)) {
         if (maximizeMode() == MaximizeFull)
             return geometryRestore();
         else
             return workspace()->clientArea(MaximizeArea, pos, desktop);
     }
 
     QRect ret = workspace()->clientArea(MaximizeArea, pos, desktop);
     if (electricBorderMode() & QuickTileFlag::Left)
         ret.setRight(ret.left()+ret.width()/2 - 1);
     else if (electricBorderMode() & QuickTileFlag::Right)
         ret.setLeft(ret.right()-(ret.width()-ret.width()/2) + 1);
     if (electricBorderMode() & QuickTileFlag::Top)
         ret.setBottom(ret.top()+ret.height()/2 - 1);
     else if (electricBorderMode() & QuickTileFlag::Bottom)
         ret.setTop(ret.bottom()-(ret.height()-ret.height()/2) + 1);
 
     return ret;
 }
 
 void AbstractClient::setQuickTileMode(QuickTileMode mode, bool keyboard)
 {
     // Only allow quick tile on a regular window.
     if (!isResizable()) {
         return;
     }
 
     workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
 
     GeometryUpdatesBlocker blocker(this);
 
     if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
         m_quickTileMode = int(QuickTileFlag::None);
         if (maximizeMode() == MaximizeFull) {
             setMaximize(false, false);
         } else {
             QRect prev_geom_restore = geometryRestore(); // setMaximize() would set moveResizeGeom as geom_restore
             m_quickTileMode = int(QuickTileFlag::Maximize);
             setMaximize(true, true);
             QRect clientArea = workspace()->clientArea(MaximizeArea, this);
             if (frameGeometry().top() != clientArea.top()) {
                 QRect r(frameGeometry());
                 r.moveTop(clientArea.top());
                 setFrameGeometry(r);
             }
             setGeometryRestore(prev_geom_restore);
         }
         emit quickTileModeChanged();
         return;
     }
 
     // sanitize the mode, ie. simplify "invalid" combinations
     if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal))
         mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
     if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical))
         mode &= ~QuickTileMode(QuickTileFlag::Vertical);
 
     setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
 
     // restore from maximized so that it is possible to tile maximized windows with one hit or by dragging
     if (maximizeMode() != MaximizeRestore) {
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             // decorations may turn off some borders when tiled
             const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
             m_quickTileMode = int(QuickTileFlag::None); // Temporary, so the maximize code doesn't get all confused
 
             setMaximize(false, false);
 
             setFrameGeometry(electricBorderMaximizeGeometry(keyboard ? frameGeometry().center() : Cursors::self()->mouse()->pos(), desktop()), geom_mode);
             // Store the mode change
             m_quickTileMode = mode;
         } else {
             m_quickTileMode = mode;
             setMaximize(false, false);
         }
 
         emit quickTileModeChanged();
 
         return;
     }
 
     if (mode != QuickTileMode(QuickTileFlag::None)) {
         QPoint whichScreen = keyboard ? frameGeometry().center() : Cursors::self()->mouse()->pos();
 
         // If trying to tile to the side that the window is already tiled to move the window to the next
         // screen if it exists, otherwise toggle the mode (set QuickTileFlag::None)
         if (quickTileMode() == mode) {
             const int numScreens = screens()->count();
             const int curScreen = screen();
             int nextScreen = curScreen;
             QVarLengthArray<QRect> screens(numScreens);
             for (int i = 0; i < numScreens; ++i)   // Cache
                 screens[i] = Screens::self()->geometry(i);
             for (int i = 0; i < numScreens; ++i) {
 
                 if (i == curScreen)
                     continue;
 
                 if (screens[i].bottom() <= screens[curScreen].top() || screens[i].top() >= screens[curScreen].bottom())
                     continue; // not in horizontal line
 
                 const int x = screens[i].center().x();
                 if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Left)) {
                     if (x >= screens[curScreen].center().x() || (curScreen != nextScreen && x <= screens[nextScreen].center().x()))
                         continue; // not left of current or more left then found next
                 } else if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Right)) {
                     if (x <= screens[curScreen].center().x() || (curScreen != nextScreen && x >= screens[nextScreen].center().x()))
                         continue; // not right of current or more right then found next
                 }
 
                 nextScreen = i;
             }
 
             if (nextScreen == curScreen) {
                 mode = QuickTileFlag::None; // No other screens, toggle tiling
             } else {
                 // Move to other screen
                 setFrameGeometry(geometryRestore().translated(screens[nextScreen].topLeft() - screens[curScreen].topLeft()));
                 whichScreen = screens[nextScreen].center();
 
                 // Swap sides
                 if (mode & QuickTileFlag::Horizontal) {
                     mode = (~mode & QuickTileFlag::Horizontal) | (mode & QuickTileFlag::Vertical);
                 }
             }
             setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.)
         } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) {
             // Not coming out of an existing tile, not shifting monitors, we're setting a brand new tile.
             // Store geometry first, so we can go out of this tile later.
             setGeometryRestore(frameGeometry());
         }
 
         if (mode != QuickTileMode(QuickTileFlag::None)) {
             m_quickTileMode = mode;
             // decorations may turn off some borders when tiled
             const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
             // Temporary, so the maximize code doesn't get all confused
             m_quickTileMode = int(QuickTileFlag::None);
             setFrameGeometry(electricBorderMaximizeGeometry(whichScreen, desktop()), geom_mode);
         }
 
         // Store the mode change
         m_quickTileMode = mode;
     }
 
     if (mode == QuickTileMode(QuickTileFlag::None)) {
         m_quickTileMode = int(QuickTileFlag::None);
         // Untiling, so just restore geometry, and we're done.
         if (!geometryRestore().isValid()) // invalid if we started maximized and wait for placement
             setGeometryRestore(frameGeometry());
         // decorations may turn off some borders when tiled
         const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet;
         setFrameGeometry(geometryRestore(), geom_mode);
         checkWorkspacePosition(); // Just in case it's a different screen
     }
     emit quickTileModeChanged();
 }
 
 void AbstractClient::sendToScreen(int newScreen)
 {
     newScreen = rules()->checkScreen(newScreen);
     if (isActive()) {
         screens()->setCurrent(newScreen);
         // might impact the layer of a fullscreen window
         foreach (AbstractClient *cc, workspace()->allClientList()) {
             if (cc->isFullScreen() && cc->screen() == newScreen) {
                 cc->updateLayer();
             }
         }
     }
     if (screen() == newScreen)   // Don't use isOnScreen(), that's true even when only partially
         return;
 
     GeometryUpdatesBlocker blocker(this);
 
     // operating on the maximized / quicktiled window would leave the old geom_restore behind,
     // so we clear the state first
     MaximizeMode maxMode = maximizeMode();
     QuickTileMode qtMode = quickTileMode();
     if (maxMode != MaximizeRestore)
         maximize(MaximizeRestore);
     if (qtMode != QuickTileMode(QuickTileFlag::None))
         setQuickTileMode(QuickTileFlag::None, true);
 
     QRect oldScreenArea = workspace()->clientArea(MaximizeArea, this);
     QRect screenArea = workspace()->clientArea(MaximizeArea, newScreen, desktop());
 
     // the window can have its center so that the position correction moves the new center onto
     // the old screen, what will tile it where it is. Ie. the screen is not changed
     // this happens esp. with electric border quicktiling
     if (qtMode != QuickTileMode(QuickTileFlag::None))
         keepInArea(oldScreenArea);
 
     QRect oldGeom = frameGeometry();
     QRect newGeom = oldGeom;
     // move the window to have the same relative position to the center of the screen
     // (i.e. one near the middle of the right edge will also end up near the middle of the right edge)
     QPoint center = newGeom.center() - oldScreenArea.center();
     center.setX(center.x() * screenArea.width() / oldScreenArea.width());
     center.setY(center.y() * screenArea.height() / oldScreenArea.height());
     center += screenArea.center();
     newGeom.moveCenter(center);
     setFrameGeometry(newGeom);
 
     // If the window was inside the old screen area, explicitly make sure its inside also the new screen area.
     // Calling checkWorkspacePosition() should ensure that, but when moving to a small screen the window could
     // be big enough to overlap outside of the new screen area, making struts from other screens come into effect,
     // which could alter the resulting geometry.
     if (oldScreenArea.contains(oldGeom)) {
         keepInArea(screenArea);
     }
 
     // align geom_restore - checkWorkspacePosition operates on it
     setGeometryRestore(frameGeometry());
 
     checkWorkspacePosition(oldGeom);
 
     // re-align geom_restore to constrained geometry
     setGeometryRestore(frameGeometry());
 
     // finally reset special states
     // NOTICE that MaximizeRestore/QuickTileFlag::None checks are required.
     // eg. setting QuickTileFlag::None would break maximization
     if (maxMode != MaximizeRestore)
         maximize(maxMode);
     if (qtMode != QuickTileMode(QuickTileFlag::None) && qtMode != quickTileMode())
         setQuickTileMode(qtMode, true);
 
     auto tso = workspace()->ensureStackingOrder(transients());
     for (auto it = tso.constBegin(), end = tso.constEnd(); it != end; ++it)
         (*it)->sendToScreen(newScreen);
 }
 
 void AbstractClient::checkWorkspacePosition(QRect oldGeometry, int oldDesktop, QRect oldClientGeometry)
 {
     enum { Left = 0, Top, Right, Bottom };
     const int border[4] = { borderLeft(), borderTop(), borderRight(), borderBottom() };
     if( !oldGeometry.isValid())
         oldGeometry = frameGeometry();
     if( oldDesktop == -2 )
         oldDesktop = desktop();
     if (!oldClientGeometry.isValid())
         oldClientGeometry = oldGeometry.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
     if (isDesktop())
         return;
     if (isFullScreen()) {
         QRect area = workspace()->clientArea(FullScreenArea, this);
         if (frameGeometry() != area)
             setFrameGeometry(area);
         return;
     }
     if (isDock())
         return;
 
     if (maximizeMode() != MaximizeRestore) {
         // TODO update geom_restore?
         changeMaximize(false, false, true);   // adjust size
         const QRect screenArea = workspace()->clientArea(ScreenArea, this);
         QRect geom = frameGeometry();
         checkOffscreenPosition(&geom, screenArea);
         setFrameGeometry(geom);
         return;
     }
 
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
         setFrameGeometry(electricBorderMaximizeGeometry(frameGeometry().center(), desktop()));
         return;
     }
 
     // this can be true only if this window was mapped before KWin
     // was started - in such case, don't adjust position to workarea,
     // because the window already had its position, and if a window
     // with a strut altering the workarea would be managed in initialization
     // after this one, this window would be moved
     if (!workspace() || workspace()->initializing())
         return;
 
     // If the window was touching an edge before but not now move it so it is again.
     // Old and new maximums have different starting values so windows on the screen
     // edge will move when a new strut is placed on the edge.
     QRect oldScreenArea;
     if( workspace()->inUpdateClientArea()) {
         // we need to find the screen area as it was before the change
         oldScreenArea = QRect( 0, 0, workspace()->oldDisplayWidth(), workspace()->oldDisplayHeight());
         int distance = INT_MAX;
         foreach(const QRect &r, workspace()->previousScreenSizes()) {
             int d = r.contains( oldGeometry.center()) ? 0 : ( r.center() - oldGeometry.center()).manhattanLength();
             if( d < distance ) {
                 distance = d;
                 oldScreenArea = r;
             }
         }
     } else {
         oldScreenArea = workspace()->clientArea(ScreenArea, oldGeometry.center(), oldDesktop);
     }
     const QRect oldGeomTall = QRect(oldGeometry.x(), oldScreenArea.y(), oldGeometry.width(), oldScreenArea.height());   // Full screen height
     const QRect oldGeomWide = QRect(oldScreenArea.x(), oldGeometry.y(), oldScreenArea.width(), oldGeometry.height());   // Full screen width
     int oldTopMax = oldScreenArea.y();
     int oldRightMax = oldScreenArea.x() + oldScreenArea.width();
     int oldBottomMax = oldScreenArea.y() + oldScreenArea.height();
     int oldLeftMax = oldScreenArea.x();
     const QRect screenArea = workspace()->clientArea(ScreenArea, geometryRestore().center(), desktop());
     int topMax = screenArea.y();
     int rightMax = screenArea.x() + screenArea.width();
     int bottomMax = screenArea.y() + screenArea.height();
     int leftMax = screenArea.x();
     QRect newGeom = geometryRestore(); // geometry();
     QRect newClientGeom = newGeom.adjusted(border[Left], border[Top], -border[Right], -border[Bottom]);
     const QRect newGeomTall = QRect(newGeom.x(), screenArea.y(), newGeom.width(), screenArea.height());   // Full screen height
     const QRect newGeomWide = QRect(screenArea.x(), newGeom.y(), screenArea.width(), newGeom.height());   // Full screen width
     // Get the max strut point for each side where the window is (E.g. Highest point for
     // the bottom struts bounded by the window's left and right sides).
 
     // These 4 compute old bounds ...
     auto moveAreaFunc = workspace()->inUpdateClientArea() ?
                                 &Workspace::previousRestrictedMoveArea : //... the restricted areas changed
                                 &Workspace::restrictedMoveArea; //... when e.g. active desktop or screen changes
 
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaTop)) {
         QRect rect = r & oldGeomTall;
         if (!rect.isEmpty())
             oldTopMax = qMax(oldTopMax, rect.y() + rect.height());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaRight)) {
         QRect rect = r & oldGeomWide;
         if (!rect.isEmpty())
             oldRightMax = qMin(oldRightMax, rect.x());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaBottom)) {
         QRect rect = r & oldGeomTall;
         if (!rect.isEmpty())
             oldBottomMax = qMin(oldBottomMax, rect.y());
     }
     for (const QRect &r : (workspace()->*moveAreaFunc)(oldDesktop, StrutAreaLeft)) {
         QRect rect = r & oldGeomWide;
         if (!rect.isEmpty())
             oldLeftMax = qMax(oldLeftMax, rect.x() + rect.width());
     }
 
     // These 4 compute new bounds
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaTop)) {
         QRect rect = r & newGeomTall;
         if (!rect.isEmpty())
             topMax = qMax(topMax, rect.y() + rect.height());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaRight)) {
         QRect rect = r & newGeomWide;
         if (!rect.isEmpty())
             rightMax = qMin(rightMax, rect.x());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaBottom)) {
         QRect rect = r & newGeomTall;
         if (!rect.isEmpty())
             bottomMax = qMin(bottomMax, rect.y());
     }
     for (const QRect &r : workspace()->restrictedMoveArea(desktop(), StrutAreaLeft)) {
         QRect rect = r & newGeomWide;
         if (!rect.isEmpty())
             leftMax = qMax(leftMax, rect.x() + rect.width());
     }
 
 
     // Check if the sides were inside or touching but are no longer
     bool keep[4] = {false, false, false, false};
     bool save[4] = {false, false, false, false};
     int padding[4] = {0, 0, 0, 0};
     if (oldGeometry.x() >= oldLeftMax)
         save[Left] = newGeom.x() < leftMax;
     if (oldGeometry.x() == oldLeftMax)
         keep[Left] = newGeom.x() != leftMax;
     else if (oldClientGeometry.x() == oldLeftMax && newClientGeom.x() != leftMax) {
         padding[0] = border[Left];
         keep[Left] = true;
     }
     if (oldGeometry.y() >= oldTopMax)
         save[Top] = newGeom.y() < topMax;
     if (oldGeometry.y() == oldTopMax)
         keep[Top] = newGeom.y() != topMax;
     else if (oldClientGeometry.y() == oldTopMax && newClientGeom.y() != topMax) {
         padding[1] = border[Left];
         keep[Top] = true;
     }
     if (oldGeometry.right() <= oldRightMax - 1)
         save[Right] = newGeom.right() > rightMax - 1;
     if (oldGeometry.right() == oldRightMax - 1)
         keep[Right] = newGeom.right() != rightMax - 1;
     else if (oldClientGeometry.right() == oldRightMax - 1 && newClientGeom.right() != rightMax - 1) {
         padding[2] = border[Right];
         keep[Right] = true;
     }
     if (oldGeometry.bottom() <= oldBottomMax - 1)
         save[Bottom] = newGeom.bottom() > bottomMax - 1;
     if (oldGeometry.bottom() == oldBottomMax - 1)
         keep[Bottom] = newGeom.bottom() != bottomMax - 1;
     else if (oldClientGeometry.bottom() == oldBottomMax - 1 && newClientGeom.bottom() != bottomMax - 1) {
         padding[3] = border[Bottom];
         keep[Bottom] = true;
     }
 
     // if randomly touches opposing edges, do not favor either
     if (keep[Left] && keep[Right]) {
         keep[Left] = keep[Right] = false;
         padding[0] = padding[2] = 0;
     }
     if (keep[Top] && keep[Bottom]) {
         keep[Top] = keep[Bottom] = false;
         padding[1] = padding[3] = 0;
     }
 
     if (save[Left] || keep[Left])
         newGeom.moveLeft(qMax(leftMax, screenArea.x()) - padding[0]);
     if (padding[0] && screens()->intersecting(newGeom) > 1)
         newGeom.moveLeft(newGeom.left() + padding[0]);
     if (save[Top] || keep[Top])
         newGeom.moveTop(qMax(topMax, screenArea.y()) - padding[1]);
     if (padding[1] && screens()->intersecting(newGeom) > 1)
         newGeom.moveTop(newGeom.top() + padding[1]);
     if (save[Right] || keep[Right])
         newGeom.moveRight(qMin(rightMax - 1, screenArea.right()) + padding[2]);
     if (padding[2] && screens()->intersecting(newGeom) > 1)
         newGeom.moveRight(newGeom.right() - padding[2]);
     if (oldGeometry.x() >= oldLeftMax && newGeom.x() < leftMax)
         newGeom.setLeft(qMax(leftMax, screenArea.x()));
     else if (oldClientGeometry.x() >= oldLeftMax && newGeom.x() + border[Left] < leftMax) {
         newGeom.setLeft(qMax(leftMax, screenArea.x()) - border[Left]);
         if (screens()->intersecting(newGeom) > 1)
             newGeom.setLeft(newGeom.left() + border[Left]);
     }
     if (save[Bottom] || keep[Bottom])
         newGeom.moveBottom(qMin(bottomMax - 1, screenArea.bottom()) + padding[3]);
     if (padding[3] && screens()->intersecting(newGeom) > 1)
         newGeom.moveBottom(newGeom.bottom() - padding[3]);
     if (oldGeometry.y() >= oldTopMax && newGeom.y() < topMax)
         newGeom.setTop(qMax(topMax, screenArea.y()));
     else if (oldClientGeometry.y() >= oldTopMax && newGeom.y() + border[Top] < topMax) {
         newGeom.setTop(qMax(topMax, screenArea.y()) - border[Top]);
         if (screens()->intersecting(newGeom) > 1)
             newGeom.setTop(newGeom.top() + border[Top]);
     }
 
     checkOffscreenPosition(&newGeom, screenArea);
     // Obey size hints. TODO: We really should make sure it stays in the right place
     if (!isShade())
         newGeom.setSize(constrainFrameSize(newGeom.size()));
 
     if (newGeom != frameGeometry())
         setFrameGeometry(newGeom);
 }
 
 void AbstractClient::checkOffscreenPosition(QRect* geom, const QRect& screenArea)
 {
     if (geom->left() > screenArea.right()) {
         geom->moveLeft(screenArea.right() - screenArea.width()/4);
     } else if (geom->right() < screenArea.left()) {
         geom->moveRight(screenArea.left() + screenArea.width()/4);
     }
     if (geom->top() > screenArea.bottom()) {
         geom->moveTop(screenArea.bottom() - screenArea.height()/4);
     } else if (geom->bottom() < screenArea.top()) {
         geom->moveBottom(screenArea.top() + screenArea.width()/4);
     }
 }
 
 /**
  * Returns the appropriate frame size for the current client size.
  *
  * This is equivalent to clientSizeToFrameSize(constrainClientSize(clientSize())).
  */
 QSize AbstractClient::adjustedSize() const
 {
     return clientSizeToFrameSize(constrainClientSize(clientSize()));
 }
 
 /**
  * Constrains the client size @p size according to a set of the window's size hints.
  *
  * Default implementation applies only minimum and maximum size constraints.
  */
 QSize AbstractClient::constrainClientSize(const QSize &size, SizeMode mode) const
 {
     Q_UNUSED(mode)
 
     int width = size.width();
     int height = size.height();
 
     // When user is resizing the window, the move resize geometry may have negative width or
     // height. In which case, we need to set negative dimensions to reasonable values.
     if (width < 1) {
         width = 1;
     }
     if (height < 1) {
         height = 1;
     }
 
     const QSize minimumSize = minSize();
     const QSize maximumSize = maxSize();
 
     width = qBound(minimumSize.width(), width, maximumSize.width());
     height = qBound(minimumSize.height(), height, maximumSize.height());
 
     return QSize(width, height);
 }
 
 /**
  * Constrains the frame size @p size according to a set of the window's size hints.
  */
 QSize AbstractClient::constrainFrameSize(const QSize &size, SizeMode mode) const
 {
     const QSize unconstrainedClientSize = frameSizeToClientSize(size);
     const QSize constrainedClientSize = constrainClientSize(unconstrainedClientSize, mode);
     return clientSizeToFrameSize(constrainedClientSize);
 }
 
 /**
  * Returns @c true if the AbstractClient can be shown in full screen mode; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isFullScreenable() const
 {
     return false;
 }
 
 /**
  * Returns @c true if the AbstractClient is currently being shown in full screen mode; otherwise @c false.
  *
  * A client in full screen mode occupies the entire screen with no window frame around it.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isFullScreen() const
 {
     return false;
 }
 
 /**
  * Returns whether requests initiated by the user to enter or leave full screen mode are honored.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::userCanSetFullScreen() const
 {
     return false;
 }
 
 /**
  * Asks the AbstractClient to enter or leave full screen mode.
  *
  * Default implementation does nothing.
  *
  * @param set @c true if the AbstractClient has to be shown in full screen mode, otherwise @c false
  * @param user @c true if the request is initiated by the user, otherwise @c false
  */
 void AbstractClient::setFullScreen(bool set, bool user)
 {
     Q_UNUSED(set)
     Q_UNUSED(user)
 }
 
 /**
  * Returns @c true if the AbstractClient can be minimized; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isMinimizable() const
 {
     return false;
 }
 
 /**
  * Returns @c true if the AbstractClient can be maximized; otherwise @c false.
  *
  * Default implementation returns @c false.
  */
 bool AbstractClient::isMaximizable() const
 {
     return false;
 }
 
 /**
  * Returns the currently applied maximize mode.
  *
  * Default implementation returns MaximizeRestore.
  */
 MaximizeMode AbstractClient::maximizeMode() const
 {
     return MaximizeRestore;
 }
 
 /**
  * Returns the last requested maximize mode.
  *
  * On X11, this method always matches maximizeMode(). On Wayland, it is asynchronous.
  *
  * Default implementation matches maximizeMode().
  */
 MaximizeMode AbstractClient::requestedMaximizeMode() const
 {
     return maximizeMode();
 }
 
 /**
  * Returns the geometry of the AbstractClient before it was maximized or quick tiled.
  */
 QRect AbstractClient::geometryRestore() const
 {
     return m_maximizeGeometryRestore;
 }
 
 /**
  * Sets the geometry of the AbstractClient before it was maximized or quick tiled to @p rect.
  */
 void AbstractClient::setGeometryRestore(const QRect &rect)
 {
     m_maximizeGeometryRestore = rect;
 }
 
 /**
  * Toggles the maximized state along specified dimensions @p horizontal and @p vertical.
  *
  * If @p adjust is @c true, only frame geometry will be updated to match requestedMaximizeMode().
  *
  * Default implementation does nothing.
  */
 void AbstractClient::changeMaximize(bool horizontal, bool vertical, bool adjust)
 {
     Q_UNUSED(horizontal)
     Q_UNUSED(vertical)
     Q_UNUSED(adjust)
 }
 
 }
diff --git a/abstract_client.h b/abstract_client.h
index 96f9dde4c..cf1ad4af0 100644
--- a/abstract_client.h
+++ b/abstract_client.h
@@ -1,1352 +1,1349 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_ABSTRACT_CLIENT_H
 #define KWIN_ABSTRACT_CLIENT_H
 
 #include "toplevel.h"
 #include "options.h"
 #include "rules.h"
 #include "cursor.h"
 
 #include <memory>
 
 #include <QElapsedTimer>
 #include <QPointer>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class PlasmaWindowInterface;
 }
-}
 
 namespace KDecoration2
 {
 class Decoration;
 }
 
 namespace KWin
 {
 class Group;
 
 namespace TabBox
 {
 class TabBoxClientImpl;
 }
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 class DecorationPalette;
 }
 
 class KWIN_EXPORT AbstractClient : public Toplevel
 {
     Q_OBJECT
 
     /**
      * Whether this Client is fullScreen. A Client might either be fullScreen due to the _NET_WM property
      * or through a legacy support hack. The fullScreen state can only be changed if the Client does not
      * use the legacy hack. To be sure whether the state changed, connect to the notify signal.
      */
     Q_PROPERTY(bool fullScreen READ isFullScreen WRITE setFullScreen NOTIFY fullScreenChanged)
 
     /**
      * Whether the Client can be set to fullScreen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool fullScreenable READ isFullScreenable)
 
     /**
      * Whether this Client is active or not. Use Workspace::activateClient() to activate a Client.
      * @see Workspace::activateClient
      */
     Q_PROPERTY(bool active READ isActive NOTIFY activeChanged)
 
     /**
      * The desktop this Client is on. If the Client is on all desktops the property has value -1.
      * This is a legacy property, use x11DesktopIds instead
      */
     Q_PROPERTY(int desktop READ desktop WRITE setDesktop NOTIFY desktopChanged)
 
     /**
      * Whether the Client is on all desktops. That is desktop is -1.
      */
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops WRITE setOnAllDesktops NOTIFY desktopChanged)
 
     /**
      * The x11 ids for all desktops this client is in. On X11 this list will always have a length of 1
      */
     Q_PROPERTY(QVector<uint> x11DesktopIds READ x11DesktopIds NOTIFY x11DesktopIdsChanged)
 
     /**
      * Indicates that the window should not be included on a taskbar.
      */
     Q_PROPERTY(bool skipTaskbar READ skipTaskbar WRITE setSkipTaskbar NOTIFY skipTaskbarChanged)
 
     /**
      * Indicates that the window should not be included on a Pager.
      */
     Q_PROPERTY(bool skipPager READ skipPager WRITE setSkipPager NOTIFY skipPagerChanged)
 
     /**
      * Whether the Client should be excluded from window switching effects.
      */
     Q_PROPERTY(bool skipSwitcher READ skipSwitcher WRITE setSkipSwitcher NOTIFY skipSwitcherChanged)
 
     /**
      * Whether the window can be closed by the user. The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool closeable READ isCloseable)
 
     Q_PROPERTY(QIcon icon READ icon NOTIFY iconChanged)
 
     /**
      * Whether the Client is set to be kept above other windows.
      */
     Q_PROPERTY(bool keepAbove READ keepAbove WRITE setKeepAbove NOTIFY keepAboveChanged)
 
     /**
      * Whether the Client is set to be kept below other windows.
      */
     Q_PROPERTY(bool keepBelow READ keepBelow WRITE setKeepBelow NOTIFY keepBelowChanged)
 
     /**
      * Whether the Client can be shaded. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool shadeable READ isShadeable)
 
     /**
      * Whether the Client is shaded.
      */
     Q_PROPERTY(bool shade READ isShade WRITE setShade NOTIFY shadeChanged)
 
     /**
      * Whether the Client can be minimized. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool minimizable READ isMinimizable)
 
     /**
      * Whether the Client is minimized.
      */
     Q_PROPERTY(bool minimized READ isMinimized WRITE setMinimized NOTIFY minimizedChanged)
 
     /**
      * The optional geometry representing the minimized Client in e.g a taskbar.
      * See _NET_WM_ICON_GEOMETRY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(QRect iconGeometry READ iconGeometry)
 
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool specialWindow READ isSpecialWindow)
 
     /**
      * Whether window state _NET_WM_STATE_DEMANDS_ATTENTION is set. This state indicates that some
      * action in or with the window happened. For example, it may be set by the Window Manager if
      * the window requested activation but the Window Manager refused it, or the application may set
      * it if it finished some work. This state may be set by both the Client and the Window Manager.
      * It should be unset by the Window Manager when it decides the window got the required attention
      * (usually, that it got activated).
      */
     Q_PROPERTY(bool demandsAttention READ isDemandingAttention WRITE demandAttention NOTIFY demandsAttentionChanged)
 
     /**
      * The Caption of the Client. Read from WM_NAME property together with a suffix for hostname and shortcut.
      * To read only the caption as provided by WM_NAME, use the getter with an additional @c false value.
      */
     Q_PROPERTY(QString caption READ caption NOTIFY captionChanged)
 
     /**
      * Minimum size as specified in WM_NORMAL_HINTS
      */
     Q_PROPERTY(QSize minSize READ minSize)
 
     /**
      * Maximum size as specified in WM_NORMAL_HINTS
      */
     Q_PROPERTY(QSize maxSize READ maxSize)
 
     /**
      * Whether the Client can accept keyboard focus.
      * The value is evaluated each time the getter is called.
      * Because of that no changed signal is provided.
      */
     Q_PROPERTY(bool wantsInput READ wantsInput)
 
     /**
      * Whether the Client is a transient Window to another Window.
      * @see transientFor
      */
     Q_PROPERTY(bool transient READ isTransient NOTIFY transientChanged)
 
     /**
      * The Client to which this Client is a transient if any.
      */
     Q_PROPERTY(KWin::AbstractClient *transientFor READ transientFor NOTIFY transientChanged)
 
     /**
      * Whether the Client represents a modal window.
      */
     Q_PROPERTY(bool modal READ isModal NOTIFY modalChanged)
 
     /**
      * The geometry of this Client. Be aware that depending on resize mode the frameGeometryChanged
      * signal might be emitted at each resize step or only at the end of the resize operation.
      */
     Q_PROPERTY(QRect geometry READ frameGeometry WRITE setFrameGeometry)
 
     /**
      * Whether the Client is currently being moved by the user.
      * Notify signal is emitted when the Client starts or ends move/resize mode.
      */
     Q_PROPERTY(bool move READ isMove NOTIFY moveResizedChanged)
 
     /**
      * Whether the Client is currently being resized by the user.
      * Notify signal is emitted when the Client starts or ends move/resize mode.
      */
     Q_PROPERTY(bool resize READ isResize NOTIFY moveResizedChanged)
 
     /**
      * Whether the decoration is currently using an alpha channel.
      */
     Q_PROPERTY(bool decorationHasAlpha READ decorationHasAlpha)
 
     /**
      * Whether the window has a decoration or not.
      * This property is not allowed to be set by applications themselves.
      * The decision whether a window has a border or not belongs to the window manager.
      * If this property gets abused by application developers, it will be removed again.
      */
     Q_PROPERTY(bool noBorder READ noBorder WRITE setNoBorder)
 
     /**
      * Whether the Client provides context help. Mostly needed by decorations to decide whether to
      * show the help button or not.
      */
     Q_PROPERTY(bool providesContextHelp READ providesContextHelp CONSTANT)
 
     /**
      * Whether the Client can be maximized both horizontally and vertically.
      * The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool maximizable READ isMaximizable)
 
     /**
      * Whether the Client is moveable. Even if it is not moveable, it might be possible to move
      * it to another screen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      * @see moveableAcrossScreens
      */
     Q_PROPERTY(bool moveable READ isMovable)
 
     /**
      * Whether the Client can be moved to another screen. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      * @see moveable
      */
     Q_PROPERTY(bool moveableAcrossScreens READ isMovableAcrossScreens)
 
     /**
      * Whether the Client can be resized. The property is evaluated each time it is invoked.
      * Because of that there is no notify signal.
      */
     Q_PROPERTY(bool resizeable READ isResizable)
 
     /**
      * The desktop file name of the application this AbstractClient belongs to.
      *
      * This is either the base name without full path and without file extension of the
      * desktop file for the window's application (e.g. "org.kde.foo").
      *
      * The application's desktop file name can also be the full path to the desktop file
      * (e.g. "/opt/kde/share/org.kde.foo.desktop") in case it's not in a standard location.
      */
     Q_PROPERTY(QByteArray desktopFileName READ desktopFileName NOTIFY desktopFileNameChanged)
 
     /**
      * Whether an application menu is available for this Client
      */
     Q_PROPERTY(bool hasApplicationMenu READ hasApplicationMenu NOTIFY hasApplicationMenuChanged)
 
     /**
      * Whether the application menu for this Client is currently opened
      */
     Q_PROPERTY(bool applicationMenuActive READ applicationMenuActive NOTIFY applicationMenuActiveChanged)
 
     /**
      * Whether this client is unresponsive.
      *
      * When an application failed to react on a ping request in time, it is
      * considered unresponsive. This usually indicates that the application froze or crashed.
      */
     Q_PROPERTY(bool unresponsive READ unresponsive NOTIFY unresponsiveChanged)
 
     /**
      * The color scheme set on this client
      * Absolute file path, or name of palette in the user's config directory following KColorSchemes format.
      * An empty string indicates the default palette from kdeglobals is used.
      * @note this indicates the colour scheme requested, which might differ from the theme applied if the colorScheme cannot be found
      */
     Q_PROPERTY(QString colorScheme READ colorScheme NOTIFY colorSchemeChanged)
 
 public:
     ~AbstractClient() override;
 
     QWeakPointer<TabBox::TabBoxClientImpl> tabBoxClient() const {
         return m_tabBoxClient.toWeakRef();
     }
     bool isFirstInTabBox() const {
         return m_firstInTabBox;
     }
     bool skipSwitcher() const {
         return m_skipSwitcher;
     }
     void setSkipSwitcher(bool set);
 
     bool skipTaskbar() const {
         return m_skipTaskbar;
     }
     void setSkipTaskbar(bool set);
     void setOriginalSkipTaskbar(bool set);
     bool originalSkipTaskbar() const {
         return m_originalSkipTaskbar;
     }
 
     bool skipPager() const {
         return m_skipPager;
     }
     void setSkipPager(bool set);
 
     const QIcon &icon() const {
         return m_icon;
     }
 
     bool isActive() const {
         return m_active;
     }
     /**
      * Sets the client's active state to \a act.
      *
      * This function does only change the visual appearance of the client,
      * it does not change the focus setting. Use
      * Workspace::activateClient() or Workspace::requestFocus() instead.
      *
      * If a client receives or looses the focus, it calls setActive() on
      * its own.
      */
     void setActive(bool);
 
     bool keepAbove() const {
         return m_keepAbove;
     }
     void setKeepAbove(bool);
     bool keepBelow() const {
         return m_keepBelow;
     }
     void setKeepBelow(bool);
 
     void demandAttention(bool set = true);
     bool isDemandingAttention() const {
         return m_demandsAttention;
     }
 
     void cancelAutoRaise();
 
     bool wantsTabFocus() const;
 
     QMargins frameMargins() const override;
     QPoint clientPos() const override {
         return QPoint(borderLeft(), borderTop());
     }
 
     virtual void updateMouseGrab();
     /**
      * @returns The caption consisting of captionNormal and captionSuffix
      * @see captionNormal
      * @see captionSuffix
      */
     QString caption() const;
     /**
      * @returns The caption as set by the AbstractClient without any suffix.
      * @see caption
      * @see captionSuffix
      */
     virtual QString captionNormal() const = 0;
     /**
      * @returns The suffix added to the caption (e.g. shortcut, machine name, etc.)
      * @see caption
      * @see captionNormal
      */
     virtual QString captionSuffix() const = 0;
     virtual bool isCloseable() const = 0;
     // TODO: remove boolean trap
     virtual bool isShown(bool shaded_is_shown) const = 0;
     virtual bool isHiddenInternal() const = 0;
     // TODO: remove boolean trap
     virtual void hideClient(bool hide) = 0;
     virtual bool isFullScreenable() const;
     virtual bool isFullScreen() const;
     // TODO: remove boolean trap
     virtual AbstractClient *findModal(bool allow_itself = false) = 0;
     virtual bool isTransient() const;
     /**
      * @returns Whether there is a hint available to place the AbstractClient on it's parent, default @c false.
      * @see transientPlacementHint
      */
     virtual bool hasTransientPlacementHint() const;
     /**
      * Only valid id hasTransientPlacementHint is true
      * @returns The position the transient wishes to position itself
      */
     virtual QRect transientPlacement(const QRect &bounds) const;
     const AbstractClient* transientFor() const;
     AbstractClient* transientFor();
     /**
      * @returns @c true if c is the transient_for window for this client,
      *  or recursively the transient_for window
      * @todo: remove boolean trap
      */
     virtual bool hasTransient(const AbstractClient* c, bool indirect) const;
     const QList<AbstractClient*>& transients() const; // Is not indirect
     virtual void addTransient(AbstractClient *client);
     virtual void removeTransient(AbstractClient* cl);
     virtual QList<AbstractClient*> mainClients() const; // Call once before loop , is not indirect
     QList<AbstractClient*> allMainClients() const; // Call once before loop , is indirect
     /**
      * Returns true for "special" windows and false for windows which are "normal"
      * (normal=window which has a border, can be moved by the user, can be closed, etc.)
      * true for Desktop, Dock, Splash, Override and TopMenu (and Toolbar??? - for now)
      * false for Normal, Dialog, Utility and Menu (and Toolbar??? - not yet) TODO
      */
     bool isSpecialWindow() const;
     void sendToScreen(int screen);
     const QKeySequence &shortcut() const {
         return _shortcut;
     }
     void setShortcut(const QString &cut);
     virtual bool performMouseCommand(Options::MouseCommand, const QPoint &globalPos);
     void setOnAllDesktops(bool set);
     void setDesktop(int);
     void enterDesktop(VirtualDesktop *desktop);
     void leaveDesktop(VirtualDesktop *desktop);
 
     /**
      * Set the window as being on the attached list of desktops
      * On X11 it will be set to the last entry
      */
     void setDesktops(QVector<VirtualDesktop *> desktops);
 
     int desktop() const override {
         return m_desktops.isEmpty() ? (int)NET::OnAllDesktops : m_desktops.last()->x11DesktopNumber();
     }
     QVector<VirtualDesktop *> desktops() const override {
         return m_desktops;
     }
     QVector<uint> x11DesktopIds() const;
 
     void setMinimized(bool set);
     /**
      * Minimizes this client plus its transients
      */
     void minimize(bool avoid_animation = false);
     void unminimize(bool avoid_animation = false);
     bool isMinimized() const {
         return m_minimized;
     }
     virtual void setFullScreen(bool set, bool user = true);
 
     virtual void setClientShown(bool shown);
 
     QRect geometryRestore() const;
     virtual MaximizeMode maximizeMode() const;
     virtual MaximizeMode requestedMaximizeMode() const;
     void maximize(MaximizeMode);
     /**
      * Sets the maximization according to @p vertically and @p horizontally.
      */
     Q_INVOKABLE void setMaximize(bool vertically, bool horizontally);
     virtual bool noBorder() const = 0;
     virtual void setNoBorder(bool set) = 0;
     virtual void blockActivityUpdates(bool b = true) = 0;
     QPalette palette() const;
     const Decoration::DecorationPalette *decorationPalette() const;
     /**
      * Returns whether the window is resizable or has a fixed size.
      */
     virtual bool isResizable() const = 0;
     /**
      * Returns whether the window is moveable or has a fixed position.
      */
     virtual bool isMovable() const = 0;
     /**
      * Returns whether the window can be moved to another screen.
      */
     virtual bool isMovableAcrossScreens() const = 0;
     /**
      * @c true only for @c ShadeNormal
      */
     bool isShade() const {
         return shadeMode() == ShadeNormal;
     }
     /**
      * Default implementation returns @c ShadeNone
      */
     virtual ShadeMode shadeMode() const; // Prefer isShade()
     void setShade(bool set);
     /**
      * Default implementation does nothing
      */
     virtual void setShade(ShadeMode mode);
     /**
      * Whether the Client can be shaded. Default implementation returns @c false.
      */
     virtual bool isShadeable() const;
     virtual bool isMaximizable() const;
     virtual bool isMinimizable() const;
     virtual QRect iconGeometry() const;
     virtual bool userCanSetFullScreen() const;
     virtual bool userCanSetNoBorder() const = 0;
     virtual void checkNoBorder();
     virtual void setOnActivities(QStringList newActivitiesList);
     virtual void setOnAllActivities(bool set) = 0;
     const WindowRules* rules() const {
         return &m_rules;
     }
     void removeRule(Rules* r);
     void setupWindowRules(bool ignore_temporary);
     void evaluateWindowRules();
     virtual void applyWindowRules();
     virtual void takeFocus() = 0;
     virtual bool wantsInput() const = 0;
     /**
      * Whether a dock window wants input.
      *
      * By default KWin doesn't pass focus to a dock window unless a force activate
      * request is provided.
      *
      * This method allows to have dock windows take focus also through flags set on
      * the window.
      *
      * The default implementation returns @c false.
      */
     virtual bool dockWantsInput() const;
     void checkWorkspacePosition(QRect oldGeometry = QRect(), int oldDesktop = -2,  QRect oldClientGeometry = QRect());
     virtual xcb_timestamp_t userTime() const;
     virtual void updateWindowRules(Rules::Types selection);
 
     void growHorizontal();
     void shrinkHorizontal();
     void growVertical();
     void shrinkVertical();
     void updateMoveResize(const QPointF &currentGlobalCursor);
     /**
      * Ends move resize when all pointer buttons are up again.
      */
     void endMoveResize();
     void keyPressEvent(uint key_code);
 
     void enterEvent(const QPoint &globalPos);
     void leaveEvent();
 
     /**
      * These values represent positions inside an area
      */
     enum Position {
         // without prefix, they'd conflict with Qt::TopLeftCorner etc. :(
         PositionCenter         = 0x00,
         PositionLeft           = 0x01,
         PositionRight          = 0x02,
         PositionTop            = 0x04,
         PositionBottom         = 0x08,
         PositionTopLeft        = PositionLeft | PositionTop,
         PositionTopRight       = PositionRight | PositionTop,
         PositionBottomLeft     = PositionLeft | PositionBottom,
         PositionBottomRight    = PositionRight | PositionBottom
     };
     Position titlebarPosition() const;
     bool titlebarPositionUnderMouse() const;
 
     // a helper for the workspace window packing. tests for screen validity and updates since in maximization case as with normal moving
     void packTo(int left, int top);
 
     /**
      * Sets the quick tile mode ("snap") of this window.
      * This will also handle preserving and restoring of window geometry as necessary.
      * @param mode The tile mode (left/right) to give this window.
      * @param keyboard Defines whether to take keyboard cursor into account.
      */
     void setQuickTileMode(QuickTileMode mode, bool keyboard = false);
     QuickTileMode quickTileMode() const {
         return QuickTileMode(m_quickTileMode);
     }
     Layer layer() const override;
     void updateLayer();
 
     void placeIn(const QRect &area);
 
     enum ForceGeometry_t { NormalGeometrySet, ForceGeometrySet };
     virtual void move(int x, int y, ForceGeometry_t force = NormalGeometrySet);
     void move(const QPoint &p, ForceGeometry_t force = NormalGeometrySet);
     virtual void resizeWithChecks(const QSize& s, ForceGeometry_t force = NormalGeometrySet) = 0;
     void keepInArea(QRect area, bool partial = false);
     virtual QSize minSize() const;
     virtual QSize maxSize() const;
     virtual void setFrameGeometry(const QRect &rect, ForceGeometry_t force = NormalGeometrySet) = 0;
 
     /**
      * How to resize the window in order to obey constraints (mainly aspect ratios).
      */
     enum SizeMode {
         SizeModeAny,
         SizeModeFixedW, ///< Try not to affect width
         SizeModeFixedH, ///< Try not to affect height
         SizeModeMax ///< Try not to make it larger in either direction
     };
 
     virtual QSize constrainClientSize(const QSize &size, SizeMode mode = SizeModeAny) const;
     QSize constrainFrameSize(const QSize &size, SizeMode mode = SizeModeAny) const;
     QSize adjustedSize() const;
 
     /**
      * Calculates the matching client position for the given frame position @p point.
      */
     virtual QPoint framePosToClientPos(const QPoint &point) const;
     /**
      * Calculates the matching frame position for the given client position @p point.
      */
     virtual QPoint clientPosToFramePos(const QPoint &point) const;
     /**
      * Calculates the matching client size for the given frame size @p size.
      *
      * Notice that size constraints won't be applied.
      *
      * Default implementation returns the frame size with frame margins being excluded.
      */
     virtual QSize frameSizeToClientSize(const QSize &size) const;
     /**
      * Calculates the matching frame size for the given client size @p size.
      *
      * Notice that size constraints won't be applied.
      *
      * Default implementation returns the client size with frame margins being included.
      */
     virtual QSize clientSizeToFrameSize(const QSize &size) const;
     /**
      * Calculates the matching client rect for the given frame rect @p rect.
      *
      * Notice that size constraints won't be applied.
      */
     QRect frameRectToClientRect(const QRect &rect) const;
     /**
      * Calculates the matching frame rect for the given client rect @p rect.
      *
      * Notice that size constraints won't be applied.
      */
     QRect clientRectToFrameRect(const QRect &rect) const;
 
     /**
      * Returns @c true if the Client is being interactively moved; otherwise @c false.
      */
     bool isMove() const {
         return isMoveResize() && moveResizePointerMode() == PositionCenter;
     }
     /**
      * Returns @c true if the Client is being interactively resized; otherwise @c false.
      */
     bool isResize() const {
         return isMoveResize() && moveResizePointerMode() != PositionCenter;
     }
     /**
      * Cursor shape for move/resize mode.
      */
     CursorShape cursor() const {
         return m_moveResize.cursor;
     }
 
     virtual bool hasStrut() const;
 
     void setModal(bool modal);
     bool isModal() const;
 
     /**
      * Determines the mouse command for the given @p button in the current state.
      *
      * The @p handled argument specifies whether the button was handled or not.
      * This value should be used to determine whether the mouse button should be
      * passed to the AbstractClient or being filtered out.
      */
     Options::MouseCommand getMouseCommand(Qt::MouseButton button, bool *handled) const;
     Options::MouseCommand getWheelCommand(Qt::Orientation orientation, bool *handled) const;
 
     // decoration related
     KDecoration2::Decoration *decoration() {
         return m_decoration.decoration;
     }
     const KDecoration2::Decoration *decoration() const {
         return m_decoration.decoration;
     }
     bool isDecorated() const {
         return m_decoration.decoration != nullptr;
     }
     QPointer<Decoration::DecoratedClientImpl> decoratedClient() const;
     void setDecoratedClient(QPointer<Decoration::DecoratedClientImpl> client);
     bool decorationHasAlpha() const;
     void triggerDecorationRepaint();
     virtual void layoutDecorationRects(QRect &left, QRect &top, QRect &right, QRect &bottom) const;
     void processDecorationMove(const QPoint &localPos, const QPoint &globalPos);
     bool processDecorationButtonPress(QMouseEvent *event, bool ignoreMenu = false);
     void processDecorationButtonRelease(QMouseEvent *event);
 
     /**
      * TODO: fix boolean traps
      */
     virtual void updateDecoration(bool check_workspace_pos, bool force = false) = 0;
 
     /**
      * Returns whether the window provides context help or not. If it does,
      * you should show a help menu item or a help button like '?' and call
      * contextHelp() if this is invoked.
      *
      * Default implementation returns @c false.
      * @see showContextHelp;
      */
     virtual bool providesContextHelp() const;
 
     /**
      * Invokes context help on the window. Only works if the window
      * actually provides context help.
      *
      * Default implementation does nothing.
      *
      * @see providesContextHelp()
      */
     virtual void showContextHelp();
 
     QRect inputGeometry() const override;
 
     /**
      * @returns the geometry of the virtual keyboard
      * This geometry is in global coordinates
      */
     QRect virtualKeyboardGeometry() const;
 
     /**
      * Sets the geometry of the virtual keyboard, The window may resize itself in order to make space for the keybaord
      * This geometry is in global coordinates
      */
     void setVirtualKeyboardGeometry(const QRect &geo);
 
     /**
      * Restores the AbstractClient after it had been hidden due to show on screen edge functionality.
      * The AbstractClient also gets raised (e.g. Panel mode windows can cover) and the AbstractClient
      * gets informed in a window specific way that it is shown and raised again.
      */
     virtual void showOnScreenEdge() = 0;
 
     QByteArray desktopFileName() const {
         return m_desktopFileName;
     }
 
     /**
      * Tries to terminate the process of this AbstractClient.
      *
      * Implementing subclasses can perform a windowing system solution for terminating.
      */
     virtual void killWindow() = 0;
     virtual void destroyClient() = 0;
 
     enum class SameApplicationCheck {
         RelaxedForActive = 1 << 0,
         AllowCrossProcesses = 1 << 1
     };
     Q_DECLARE_FLAGS(SameApplicationChecks, SameApplicationCheck)
     static bool belongToSameApplication(const AbstractClient* c1, const AbstractClient* c2, SameApplicationChecks checks = SameApplicationChecks());
 
     bool hasApplicationMenu() const;
     bool applicationMenuActive() const {
         return m_applicationMenuActive;
     }
     void setApplicationMenuActive(bool applicationMenuActive);
 
     QString applicationMenuServiceName() const {
         return m_applicationMenuServiceName;
     }
     QString applicationMenuObjectPath() const {
         return m_applicationMenuObjectPath;
     }
     QString colorScheme() const {
         return m_colorScheme;
     }
 
     /**
      * Request showing the application menu bar
      * @param actionId The DBus menu ID of the action that should be highlighted, 0 for the root menu
      */
     void showApplicationMenu(int actionId);
 
     bool unresponsive() const;
 
     virtual bool isInitialPositionSet() const {
         return false;
     }
 
     /**
      * Default implementation returns @c null.
      * Mostly intended for X11 clients, from EWMH:
      * @verbatim
      * If the WM_TRANSIENT_FOR property is set to None or Root window, the window should be
      * treated as a transient for all other windows in the same group. It has been noted that this
      * is a slight ICCCM violation, but as this behavior is pretty standard for many toolkits and
      * window managers, and is extremely unlikely to break anything, it seems reasonable to document
      * it as standard.
      * @endverbatim
      */
     virtual bool groupTransient() const;
     /**
      * Default implementation returns @c null.
      *
      * Mostly for X11 clients, holds the client group
      */
     virtual const Group *group() const;
     /**
      * Default implementation returns @c null.
      *
      * Mostly for X11 clients, holds the client group
      */
     virtual Group *group();
 
     /**
      * Returns whether this is an internal client.
      *
      * Internal clients are created by KWin and used for special purpose windows,
      * like the task switcher, etc.
      *
      * Default implementation returns @c false.
      */
     virtual bool isInternal() const;
 
     /**
      * Returns whether window rules can be applied to this client.
      *
      * Default implementation returns @c true.
      */
     virtual bool supportsWindowRules() const;
 
     /**
      * Return window management interface
      */
-    KWayland::Server::PlasmaWindowInterface *windowManagementInterface() const {
+    KWaylandServer::PlasmaWindowInterface *windowManagementInterface() const {
         return m_windowManagementInterface;
     }
 
 public Q_SLOTS:
     virtual void closeWindow() = 0;
 
 Q_SIGNALS:
     void fullScreenChanged();
     void skipTaskbarChanged();
     void skipPagerChanged();
     void skipSwitcherChanged();
     void iconChanged();
     void activeChanged();
     void keepAboveChanged(bool);
     void keepBelowChanged(bool);
     /**
      * Emitted whenever the demands attention state changes.
      */
     void demandsAttentionChanged();
     void desktopPresenceChanged(KWin::AbstractClient*, int); // to be forwarded by Workspace
     void desktopChanged();
     void x11DesktopIdsChanged();
     void shadeChanged();
     void minimizedChanged();
     void clientMinimized(KWin::AbstractClient* client, bool animate);
     void clientUnminimized(KWin::AbstractClient* client, bool animate);
     void paletteChanged(const QPalette &p);
     void colorSchemeChanged();
     void captionChanged();
     void clientMaximizedStateChanged(KWin::AbstractClient*, MaximizeMode);
     void clientMaximizedStateChanged(KWin::AbstractClient* c, bool h, bool v);
     void transientChanged();
     void modalChanged();
     void quickTileModeChanged();
     void moveResizedChanged();
     void moveResizeCursorChanged(CursorShape);
     void clientStartUserMovedResized(KWin::AbstractClient*);
     void clientStepUserMovedResized(KWin::AbstractClient *, const QRect&);
     void clientFinishUserMovedResized(KWin::AbstractClient*);
     void closeableChanged(bool);
     void minimizeableChanged(bool);
     void shadeableChanged(bool);
     void maximizeableChanged(bool);
     void desktopFileNameChanged();
     void applicationMenuChanged();
     void hasApplicationMenuChanged(bool);
     void applicationMenuActiveChanged(bool);
     void unresponsiveChanged(bool);
 
 protected:
     AbstractClient();
     void setFirstInTabBox(bool enable) {
         m_firstInTabBox = enable;
     }
     void setIcon(const QIcon &icon);
     void startAutoRaise();
     void autoRaise();
     /**
      * Whether the window accepts focus.
      * The difference to wantsInput is that the implementation should not check rules and return
      * what the window effectively supports.
      */
     virtual bool acceptsFocus() const = 0;
     /**
      * Called from setActive once the active value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetActive();
     /**
      * Called from setKeepAbove once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetKeepAbove();
     /**
      * Called from setKeepBelow once the keepBelow value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetKeepBelow();
     /**
      * Called from setDeskop once the desktop value got updated, but before the changed signal
      * is emitted.
      *
      * Default implementation does nothing.
      */
     virtual void doSetDesktop();
     /**
      * Called from @ref minimize and @ref unminimize once the minimized value got updated, but before the
      * changed signal is emitted.
      *
      * Default implementation does nothig.
      */
     virtual void doMinimize();
     virtual bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const = 0;
 
     virtual void doSetSkipTaskbar();
     virtual void doSetSkipPager();
     virtual void doSetSkipSwitcher();
     virtual void doSetDemandsAttention();
 
     void setupWindowManagementInterface();
     void destroyWindowManagementInterface();
 
     void updateColorScheme(QString path);
     virtual void updateColorScheme() = 0;
 
     void setTransientFor(AbstractClient *transientFor);
     /**
      * Just removes the @p cl from the transients without any further checks.
      */
     void removeTransientFromList(AbstractClient* cl);
 
     Layer belongsToLayer() const;
     virtual bool belongsToDesktop() const;
     void invalidateLayer();
     bool isActiveFullScreen() const;
     virtual Layer layerForDock() const;
 
     // electric border / quick tiling
     void setElectricBorderMode(QuickTileMode mode);
     QuickTileMode electricBorderMode() const {
         return m_electricMode;
     }
     void setElectricBorderMaximizing(bool maximizing);
     bool isElectricBorderMaximizing() const {
         return m_electricMaximizing;
     }
     QRect electricBorderMaximizeGeometry(QPoint pos, int desktop);
     void updateQuickTileMode(QuickTileMode newMode) {
         m_quickTileMode = newMode;
     }
 
     // geometry handling
     void checkOffscreenPosition(QRect *geom, const QRect &screenArea);
     int borderLeft() const;
     int borderRight() const;
     int borderTop() const;
     int borderBottom() const;
     virtual void changeMaximize(bool horizontal, bool vertical, bool adjust);
     void setGeometryRestore(const QRect &rect);
 
     /**
      * Called from move after updating the geometry. Can be reimplemented to perform specific tasks.
      * The base implementation does nothing.
      */
     virtual void doMove(int x, int y);
     void blockGeometryUpdates(bool block);
     void blockGeometryUpdates();
     void unblockGeometryUpdates();
     bool areGeometryUpdatesBlocked() const;
     enum PendingGeometry_t {
         PendingGeometryNone,
         PendingGeometryNormal,
         PendingGeometryForced
     };
     PendingGeometry_t pendingGeometryUpdate() const;
     void setPendingGeometryUpdate(PendingGeometry_t update);
     QRect bufferGeometryBeforeUpdateBlocking() const;
     QRect frameGeometryBeforeUpdateBlocking() const;
     void updateGeometryBeforeUpdateBlocking();
     /**
      * Schedules a repaint for the visibleRect before and after a
      * geometry update. The current visibleRect is stored for the
      * next time this method is called as the before geometry.
      */
     void addRepaintDuringGeometryUpdates();
 
     /**
      * @returns whether the Client is currently in move resize mode
      */
     bool isMoveResize() const {
         return m_moveResize.enabled;
     }
     /**
      * Sets whether the Client is in move resize mode to @p enabled.
      */
     void setMoveResize(bool enabled) {
         m_moveResize.enabled = enabled;
     }
     /**
      * @returns whether the move resize mode is unrestricted.
      */
     bool isUnrestrictedMoveResize() const {
         return m_moveResize.unrestricted;
     }
     /**
      * Sets whether move resize mode is unrestricted to @p set.
      */
     void setUnrestrictedMoveResize(bool set) {
         m_moveResize.unrestricted = set;
     }
     QPoint moveOffset() const {
         return m_moveResize.offset;
     }
     void setMoveOffset(const QPoint &offset) {
         m_moveResize.offset = offset;
     }
     QPoint invertedMoveOffset() const {
         return m_moveResize.invertedOffset;
     }
     void setInvertedMoveOffset(const QPoint &offset) {
         m_moveResize.invertedOffset = offset;
     }
     QRect initialMoveResizeGeometry() const {
         return m_moveResize.initialGeometry;
     }
     /**
      * Sets the initial move resize geometry to the current geometry.
      */
     void updateInitialMoveResizeGeometry();
     QRect moveResizeGeometry() const {
         return m_moveResize.geometry;
     }
     void setMoveResizeGeometry(const QRect &geo) {
         m_moveResize.geometry = geo;
     }
     Position moveResizePointerMode() const {
         return m_moveResize.pointer;
     }
     void setMoveResizePointerMode(Position mode) {
         m_moveResize.pointer = mode;
     }
     bool isMoveResizePointerButtonDown() const {
         return m_moveResize.buttonDown;
     }
     void setMoveResizePointerButtonDown(bool down) {
         m_moveResize.buttonDown = down;
     }
     int moveResizeStartScreen() const {
         return m_moveResize.startScreen;
     }
     void checkUnrestrictedMoveResize();
     /**
      * Sets an appropriate cursor shape for the logical mouse position.
      */
     void updateCursor();
     void startDelayedMoveResize();
     void stopDelayedMoveResize();
     bool startMoveResize();
     /**
      * Called from startMoveResize.
      *
      * Implementing classes should return @c false if starting move resize should
      * get aborted. In that case startMoveResize will also return @c false.
      *
      * Base implementation returns @c true.
      */
     virtual bool doStartMoveResize();
     void finishMoveResize(bool cancel);
     /**
      * Leaves the move resize mode.
      *
      * Inheriting classes must invoke the base implementation which
      * ensures that the internal mode is properly ended.
      */
     virtual void leaveMoveResize();
     virtual void positionGeometryTip();
     void performMoveResize();
     /**
      * Called from performMoveResize() after actually performing the change of geometry.
      * Implementing subclasses can perform windowing system specific handling here.
      *
      * Default implementation does nothing.
      */
     virtual void doPerformMoveResize();
     /*
      * Checks if the mouse cursor is near the edge of the screen and if so
      * activates quick tiling or maximization
      */
     void checkQuickTilingMaximizationZones(int xroot, int yroot);
     /**
      * Whether a sync request is still pending.
      * Default implementation returns @c false.
      */
     virtual bool isWaitingForMoveResizeSync() const;
     /**
      * Called during handling a resize. Implementing subclasses can use this
      * method to perform windowing system specific syncing.
      *
      * Default implementation does nothing.
      */
     virtual void doResizeSync();
     void handleMoveResize(int x, int y, int x_root, int y_root);
     void handleMoveResize(const QPoint &local, const QPoint &global);
     void dontMoveResize();
 
     virtual QSize resizeIncrements() const;
 
     /**
      * Returns the position depending on the Decoration's section under mouse.
      * If no decoration it returns PositionCenter.
      */
     Position mousePosition() const;
 
     static bool haveResizeEffect() {
         return s_haveResizeEffect;
     }
     static void updateHaveResizeEffect();
     static void resetHaveResizeEffect() {
         s_haveResizeEffect = false;
     }
 
     void setDecoration(KDecoration2::Decoration *decoration) {
         m_decoration.decoration = decoration;
     }
     virtual void createDecoration(const QRect &oldGeometry);
     virtual void destroyDecoration();
     void startDecorationDoubleClickTimer();
     void invalidateDecorationDoubleClickTimer();
 
     void setDesktopFileName(QByteArray name);
     QString iconFromDesktopFile() const;
 
     void updateApplicationMenuServiceName(const QString &serviceName);
     void updateApplicationMenuObjectPath(const QString &objectPath);
 
     void setUnresponsive(bool unresponsive);
 
     virtual void setShortcutInternal();
     QString shortcutCaptionSuffix() const;
     virtual void updateCaption() = 0;
 
     /**
      * Looks for another AbstractClient with same captionNormal and captionSuffix.
      * If no such AbstractClient exists @c nullptr is returned.
      */
     AbstractClient *findClientWithSameCaption() const;
 
     void finishWindowRules();
     void discardTemporaryRules();
 
     bool tabTo(AbstractClient *other, bool behind, bool activate);
 
 private:
     void handlePaletteChange();
     QSharedPointer<TabBox::TabBoxClientImpl> m_tabBoxClient;
     bool m_firstInTabBox = false;
     bool m_skipTaskbar = false;
     /**
      * Unaffected by KWin
      */
     bool m_originalSkipTaskbar = false;
     bool m_skipPager = false;
     bool m_skipSwitcher = false;
     QIcon m_icon;
     bool m_active = false;
     bool m_keepAbove = false;
     bool m_keepBelow = false;
     bool m_demandsAttention = false;
     bool m_minimized = false;
     QTimer *m_autoRaiseTimer = nullptr;
     QVector <VirtualDesktop *> m_desktops;
 
     QString m_colorScheme;
     std::shared_ptr<Decoration::DecorationPalette> m_palette;
     static QHash<QString, std::weak_ptr<Decoration::DecorationPalette>> s_palettes;
     static std::shared_ptr<Decoration::DecorationPalette> s_defaultPalette;
 
-    KWayland::Server::PlasmaWindowInterface *m_windowManagementInterface = nullptr;
+    KWaylandServer::PlasmaWindowInterface *m_windowManagementInterface = nullptr;
 
     AbstractClient *m_transientFor = nullptr;
     QList<AbstractClient*> m_transients;
     bool m_modal = false;
     Layer m_layer = UnknownLayer;
 
     // electric border/quick tiling
     QuickTileMode m_electricMode = QuickTileFlag::None;
     bool m_electricMaximizing = false;
     // The quick tile mode of this window.
     int m_quickTileMode = int(QuickTileFlag::None);
     QTimer *m_electricMaximizingDelay = nullptr;
 
     // geometry
     int m_blockGeometryUpdates = 0; // > 0 = New geometry is remembered, but not actually set
     PendingGeometry_t m_pendingGeometryUpdate = PendingGeometryNone;
     friend class GeometryUpdatesBlocker;
     QRect m_visibleRectBeforeGeometryUpdate;
     QRect m_bufferGeometryBeforeUpdateBlocking;
     QRect m_frameGeometryBeforeUpdateBlocking;
     QRect m_virtualKeyboardGeometry;
     QRect m_keyboardGeometryRestore;
     QRect m_maximizeGeometryRestore;
 
     struct {
         bool enabled = false;
         bool unrestricted = false;
         QPoint offset;
         QPoint invertedOffset;
         QRect initialGeometry;
         QRect geometry;
         Position pointer = PositionCenter;
         bool buttonDown = false;
         CursorShape cursor = Qt::ArrowCursor;
         int startScreen = 0;
         QTimer *delayedTimer = nullptr;
     } m_moveResize;
 
     struct {
         KDecoration2::Decoration *decoration = nullptr;
         QPointer<Decoration::DecoratedClientImpl> client;
         QElapsedTimer doubleClickTimer;
     } m_decoration;
     QByteArray m_desktopFileName;
 
     bool m_applicationMenuActive = false;
     QString m_applicationMenuServiceName;
     QString m_applicationMenuObjectPath;
 
     bool m_unresponsive = false;
 
     QKeySequence _shortcut;
 
     WindowRules m_rules;
 
     static bool s_haveResizeEffect;
 };
 
 /**
  * Helper for AbstractClient::blockGeometryUpdates() being called in pairs (true/false)
  */
 class GeometryUpdatesBlocker
 {
 public:
     explicit GeometryUpdatesBlocker(AbstractClient* c)
         : cl(c) {
         cl->blockGeometryUpdates(true);
     }
     ~GeometryUpdatesBlocker() {
         cl->blockGeometryUpdates(false);
     }
 
 private:
     AbstractClient* cl;
 };
 
 inline void AbstractClient::move(const QPoint& p, ForceGeometry_t force)
 {
     move(p.x(), p.y(), force);
 }
 
 inline const QList<AbstractClient*>& AbstractClient::transients() const
 {
     return m_transients;
 }
 
 inline bool AbstractClient::areGeometryUpdatesBlocked() const
 {
     return m_blockGeometryUpdates != 0;
 }
 
 inline void AbstractClient::blockGeometryUpdates()
 {
     m_blockGeometryUpdates++;
 }
 
 inline void AbstractClient::unblockGeometryUpdates()
 {
     m_blockGeometryUpdates--;
 }
 
 inline AbstractClient::PendingGeometry_t AbstractClient::pendingGeometryUpdate() const
 {
     return m_pendingGeometryUpdate;
 }
 
 inline void AbstractClient::setPendingGeometryUpdate(PendingGeometry_t update)
 {
     m_pendingGeometryUpdate = update;
 }
 
 }
 
 Q_DECLARE_METATYPE(KWin::AbstractClient*)
 Q_DECLARE_METATYPE(QList<KWin::AbstractClient*>)
 Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AbstractClient::SameApplicationChecks)
 
 #endif
diff --git a/abstract_output.cpp b/abstract_output.cpp
index 1f29302ad..3b31c5b60 100644
--- a/abstract_output.cpp
+++ b/abstract_output.cpp
@@ -1,117 +1,117 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2018 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "abstract_output.h"
 
 namespace KWin
 {
 
 GammaRamp::GammaRamp(uint32_t size)
     : m_table(3 * size)
     , m_size(size)
 {
 }
 
 uint32_t GammaRamp::size() const
 {
     return m_size;
 }
 
 uint16_t *GammaRamp::red()
 {
     return m_table.data();
 }
 
 const uint16_t *GammaRamp::red() const
 {
     return m_table.data();
 }
 
 uint16_t *GammaRamp::green()
 {
     return m_table.data() + m_size;
 }
 
 const uint16_t *GammaRamp::green() const
 {
     return m_table.data() + m_size;
 }
 
 uint16_t *GammaRamp::blue()
 {
     return m_table.data() + 2 * m_size;
 }
 
 const uint16_t *GammaRamp::blue() const
 {
     return m_table.data() + 2 * m_size;
 }
 
 AbstractOutput::AbstractOutput(QObject *parent)
     : QObject(parent)
 {
 }
 
 AbstractOutput::~AbstractOutput()
 {
 }
 
 QByteArray AbstractOutput::uuid() const
 {
     return QByteArray();
 }
 
 void AbstractOutput::setEnabled(bool enable)
 {
     Q_UNUSED(enable)
 }
 
-void AbstractOutput::applyChanges(const KWayland::Server::OutputChangeSet *changeSet)
+void AbstractOutput::applyChanges(const KWaylandServer::OutputChangeSet *changeSet)
 {
     Q_UNUSED(changeSet)
 }
 
 bool AbstractOutput::isInternal() const
 {
     return false;
 }
 
 qreal AbstractOutput::scale() const
 {
     return 1;
 }
 
 QSize AbstractOutput::physicalSize() const
 {
     return QSize();
 }
 
 int AbstractOutput::gammaRampSize() const
 {
     return 0;
 }
 
 bool AbstractOutput::setGammaRamp(const GammaRamp &gamma)
 {
     Q_UNUSED(gamma);
     return false;
 }
 
 } // namespace KWin
diff --git a/abstract_output.h b/abstract_output.h
index bf2741504..e0b5498af 100644
--- a/abstract_output.h
+++ b/abstract_output.h
@@ -1,184 +1,181 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_ABSTRACT_OUTPUT_H
 #define KWIN_ABSTRACT_OUTPUT_H
 
 #include <kwin_export.h>
 
 #include <QObject>
 #include <QRect>
 #include <QSize>
 #include <QVector>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class OutputChangeSet;
 }
-}
 
 namespace KWin
 {
 
 class KWIN_EXPORT GammaRamp
 {
 public:
     GammaRamp(uint32_t size);
 
     /**
      * Returns the size of the gamma ramp.
      */
     uint32_t size() const;
 
     /**
      * Returns pointer to the first red component in the gamma ramp.
      *
      * The returned pointer can be used for altering the red component
      * in the gamma ramp.
      */
     uint16_t *red();
 
     /**
      * Returns pointer to the first red component in the gamma ramp.
      */
     const uint16_t *red() const;
 
     /**
      * Returns pointer to the first green component in the gamma ramp.
      *
      * The returned pointer can be used for altering the green component
      * in the gamma ramp.
      */
     uint16_t *green();
 
     /**
      * Returns pointer to the first green component in the gamma ramp.
      */
     const uint16_t *green() const;
 
     /**
      * Returns pointer to the first blue component in the gamma ramp.
      *
      * The returned pointer can be used for altering the blue component
      * in the gamma ramp.
      */
     uint16_t *blue();
 
     /**
      * Returns pointer to the first blue component in the gamma ramp.
      */
     const uint16_t *blue() const;
 
 private:
     QVector<uint16_t> m_table;
     uint32_t m_size;
 };
 
 /**
  * Generic output representation.
  */
 class KWIN_EXPORT AbstractOutput : public QObject
 {
     Q_OBJECT
 
 public:
     explicit AbstractOutput(QObject *parent = nullptr);
     ~AbstractOutput() override;
 
     /**
      * Returns a short identifiable name of this output.
      */
     virtual QString name() const = 0;
 
     /**
      * Returns the identifying uuid of this output.
      *
      * Default implementation returns an empty byte array.
      */
     virtual QByteArray uuid() const;
 
     /**
      * Enable or disable the output.
      *
      * Default implementation does nothing
      */
     virtual void setEnabled(bool enable);
 
     /**
      * This sets the changes and tests them against the specific output.
      *
      * Default implementation does nothing
      */
-    virtual void applyChanges(const KWayland::Server::OutputChangeSet *changeSet);
+    virtual void applyChanges(const KWaylandServer::OutputChangeSet *changeSet);
 
     /**
      * Returns geometry of this output in device independent pixels.
      */
     virtual QRect geometry() const = 0;
 
     /**
      * Returns the approximate vertical refresh rate of this output, in mHz.
      */
     virtual int refreshRate() const = 0;
 
     /**
      * Returns whether this output is connected through an internal connector,
      * e.g. LVDS, or eDP.
      *
      * Default implementation returns @c false.
      */
     virtual bool isInternal() const;
 
     /**
      * Returns the ratio between physical pixels and logical pixels.
      *
      * Default implementation returns 1.
      */
     virtual qreal scale() const;
 
     /**
      * Returns the physical size of this output, in millimeters.
      *
      * Default implementation returns an invalid QSize.
      */
     virtual QSize physicalSize() const;
 
     /**
      * Returns the size of the gamma lookup table.
      *
      * Default implementation returns 0.
      */
     virtual int gammaRampSize() const;
 
     /**
      * Sets the gamma ramp of this output.
      *
      * Returns @c true if the gamma ramp was successfully set.
      */
     virtual bool setGammaRamp(const GammaRamp &gamma);
 
 private:
     Q_DISABLE_COPY(AbstractOutput)
 };
 
 } // namespace KWin
 
 #endif
diff --git a/abstract_wayland_output.cpp b/abstract_wayland_output.cpp
index 4426b6392..fff005d76 100644
--- a/abstract_wayland_output.cpp
+++ b/abstract_wayland_output.cpp
@@ -1,320 +1,320 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 Copyright 2020 David Edmundson <davidedmundson@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "abstract_wayland_output.h"
 
 #include "screens.h"
 #include "wayland_server.h"
 
 // KWayland
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/outputchangeset.h>
-#include <KWayland/Server/xdgoutput_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/outputchangeset.h>
+#include <KWaylandServer/xdgoutput_interface.h>
 // KF5
 #include <KLocalizedString>
 
 #include <cmath>
 
 namespace KWin
 {
 
 AbstractWaylandOutput::AbstractWaylandOutput(QObject *parent)
     : AbstractOutput(parent)
 {
     m_waylandOutput = waylandServer()->display()->createOutput(this);
     m_waylandOutputDevice = waylandServer()->display()->createOutputDevice(this);
     m_xdgOutput = waylandServer()->xdgOutputManager()->createXdgOutput(m_waylandOutput, this);
 
-    connect(m_waylandOutput, &KWayland::Server::OutputInterface::dpmsModeRequested, this,
-            [this] (KWayland::Server::OutputInterface::DpmsMode mode) {
+    connect(m_waylandOutput, &KWaylandServer::OutputInterface::dpmsModeRequested, this,
+            [this] (KWaylandServer::OutputInterface::DpmsMode mode) {
         updateDpms(mode);
     });
 }
 
 AbstractWaylandOutput::~AbstractWaylandOutput()
 {
 }
 
 QString AbstractWaylandOutput::name() const
 {
     return m_name;
 }
 
 QByteArray AbstractWaylandOutput::uuid() const
 {
     return m_waylandOutputDevice->uuid();
 }
 
 QRect AbstractWaylandOutput::geometry() const
 {
     return QRect(globalPos(), pixelSize() / scale());
 }
 
 QSize AbstractWaylandOutput::physicalSize() const
 {
     return orientateSize(m_waylandOutputDevice->physicalSize());
 }
 
 int AbstractWaylandOutput::refreshRate() const
 {
     return m_waylandOutputDevice->refreshRate();
 }
 
 QPoint AbstractWaylandOutput::globalPos() const
 {
     return m_waylandOutputDevice->globalPosition();
 }
 
 void AbstractWaylandOutput::setGlobalPos(const QPoint &pos)
 {
     m_waylandOutputDevice->setGlobalPosition(pos);
 
     m_waylandOutput->setGlobalPosition(pos);
     m_xdgOutput->setLogicalPosition(pos);
     m_xdgOutput->done();
 }
 
 QSize AbstractWaylandOutput::modeSize() const
 {
     return m_waylandOutputDevice->pixelSize();
 }
 
 QSize AbstractWaylandOutput::pixelSize() const
 {
     return orientateSize(m_waylandOutputDevice->pixelSize());
 }
 
 qreal AbstractWaylandOutput::scale() const
 {
     return m_waylandOutputDevice->scaleF();
 }
 
 void AbstractWaylandOutput::setScale(qreal scale)
 {
     m_waylandOutputDevice->setScaleF(scale);
 
     // this is the scale that clients will ideally use for their buffers
     // this has to be an int which is fine
 
     // I don't know whether we want to round or ceil
     // or maybe even set this to 3 when we're scaling to 1.5
     // don't treat this like it's chosen deliberately
     m_waylandOutput->setScale(std::ceil(scale));
     m_xdgOutput->setLogicalSize(pixelSize() / scale);
     m_xdgOutput->done();
 }
 
-using DeviceInterface = KWayland::Server::OutputDeviceInterface;
+using DeviceInterface = KWaylandServer::OutputDeviceInterface;
 
-KWayland::Server::OutputInterface::Transform toOutputTransform(DeviceInterface::Transform transform)
+KWaylandServer::OutputInterface::Transform toOutputTransform(DeviceInterface::Transform transform)
 {
     using Transform = DeviceInterface::Transform;
-    using OutputTransform = KWayland::Server::OutputInterface::Transform;
+    using OutputTransform = KWaylandServer::OutputInterface::Transform;
 
     switch (transform) {
     case Transform::Rotated90:
         return OutputTransform::Rotated90;
     case Transform::Rotated180:
         return OutputTransform::Rotated180;
     case Transform::Rotated270:
         return OutputTransform::Rotated270;
     case Transform::Flipped:
         return OutputTransform::Flipped;
     case Transform::Flipped90:
         return OutputTransform::Flipped90;
     case Transform::Flipped180:
         return OutputTransform::Flipped180;
     case Transform::Flipped270:
         return OutputTransform::Flipped270;
     default:
         return OutputTransform::Normal;
     }
 }
 
 void AbstractWaylandOutput::setTransform(DeviceInterface::Transform transform)
 {
     m_waylandOutputDevice->setTransform(transform);
 
     m_waylandOutput->setTransform(toOutputTransform(transform));
     m_xdgOutput->setLogicalSize(pixelSize() / scale());
     m_xdgOutput->done();
 }
 
 inline
 AbstractWaylandOutput::Transform toTransform(DeviceInterface::Transform deviceTransform)
 {
     return static_cast<AbstractWaylandOutput::Transform>(deviceTransform);
 }
 
 inline
 DeviceInterface::Transform toDeviceTransform(AbstractWaylandOutput::Transform transform)
 {
     return static_cast<DeviceInterface::Transform>(transform);
 }
 
-void AbstractWaylandOutput::applyChanges(const KWayland::Server::OutputChangeSet *changeSet)
+void AbstractWaylandOutput::applyChanges(const KWaylandServer::OutputChangeSet *changeSet)
 {
     qCDebug(KWIN_CORE) << "Apply changes to the Wayland output.";
     bool emitModeChanged = false;
     bool overallSizeCheckNeeded = false;
 
     // Enablement changes are handled by platform.
     if (changeSet->modeChanged()) {
         qCDebug(KWIN_CORE) << "Setting new mode:" << changeSet->mode();
         m_waylandOutputDevice->setCurrentMode(changeSet->mode());
         updateMode(changeSet->mode());
         emitModeChanged = true;
     }
     if (changeSet->transformChanged()) {
         qCDebug(KWIN_CORE) << "Server setting transform: " << (int)(changeSet->transform());
         setTransform(changeSet->transform());
         updateTransform(toTransform(changeSet->transform()));
         emitModeChanged = true;
     }
     if (changeSet->positionChanged()) {
         qCDebug(KWIN_CORE) << "Server setting position: " << changeSet->position();
         setGlobalPos(changeSet->position());
         // may just work already!
         overallSizeCheckNeeded = true;
     }
     if (changeSet->scaleChanged()) {
         qCDebug(KWIN_CORE) << "Setting scale:" << changeSet->scaleF();
         setScale(changeSet->scaleF());
         emitModeChanged = true;
     }
 
     overallSizeCheckNeeded |= emitModeChanged;
     if (overallSizeCheckNeeded) {
         emit screens()->changed();
     }
 
     if (emitModeChanged) {
         emit modeChanged();
     }
 }
 
 bool AbstractWaylandOutput::isEnabled() const
 {
     return m_waylandOutputDevice->enabled() == DeviceInterface::Enablement::Enabled;
 }
 
 void AbstractWaylandOutput::setEnabled(bool enable)
 {
     if (enable == isEnabled()) {
         return;
     }
 
     if (enable) {
         m_waylandOutputDevice->setEnabled(DeviceInterface::Enablement::Enabled);
         m_waylandOutput->create();
         updateEnablement(true);
     } else {
         m_waylandOutputDevice->setEnabled(DeviceInterface::Enablement::Disabled);
         m_waylandOutput->destroy();
         // xdg-output is destroyed in KWayland on wl_output going away.
         updateEnablement(false);
     }
 }
 
 QString AbstractWaylandOutput::description() const
 {
     return QStringLiteral("%1 %2").arg(m_waylandOutputDevice->manufacturer()).arg(
                 m_waylandOutputDevice->model());
 }
 
 void AbstractWaylandOutput::setWaylandMode(const QSize &size, int refreshRate)
 {
     m_waylandOutput->setCurrentMode(size, refreshRate);
     m_xdgOutput->setLogicalSize(pixelSize() / scale());
     m_xdgOutput->done();
 }
 
 void AbstractWaylandOutput::initInterfaces(const QString &model, const QString &manufacturer,
                                            const QByteArray &uuid, const QSize &physicalSize,
                                            const QVector<DeviceInterface::Mode> &modes)
 {
     m_waylandOutputDevice->setUuid(uuid);
 
     if (!manufacturer.isEmpty()) {
         m_waylandOutputDevice->setManufacturer(manufacturer);
     } else {
         m_waylandOutputDevice->setManufacturer(i18n("unknown"));
     }
 
     m_waylandOutputDevice->setModel(model);
     m_waylandOutputDevice->setPhysicalSize(physicalSize);
 
     m_waylandOutput->setManufacturer(m_waylandOutputDevice->manufacturer());
     m_waylandOutput->setModel(m_waylandOutputDevice->model());
     m_waylandOutput->setPhysicalSize(m_waylandOutputDevice->physicalSize());
 
     int i = 0;
     for (auto mode : modes) {
         qCDebug(KWIN_CORE).nospace() << "Adding mode " << ++i << ": " << mode.size << " [" << mode.refreshRate << "]";
         m_waylandOutputDevice->addMode(mode);
 
-        KWayland::Server::OutputInterface::ModeFlags flags;
+        KWaylandServer::OutputInterface::ModeFlags flags;
         if (mode.flags & DeviceInterface::ModeFlag::Current) {
-            flags |= KWayland::Server::OutputInterface::ModeFlag::Current;
+            flags |= KWaylandServer::OutputInterface::ModeFlag::Current;
         }
         if (mode.flags & DeviceInterface::ModeFlag::Preferred) {
-            flags |= KWayland::Server::OutputInterface::ModeFlag::Preferred;
+            flags |= KWaylandServer::OutputInterface::ModeFlag::Preferred;
         }
         m_waylandOutput->addMode(mode.size, flags, mode.refreshRate);
     }
 
     m_waylandOutputDevice->create();
 
     // start off enabled
 
     m_waylandOutput->create();
     m_xdgOutput->setName(name());
     m_xdgOutput->setDescription(description());
     m_xdgOutput->setLogicalSize(pixelSize() / scale());
     m_xdgOutput->done();
 }
 
 QSize AbstractWaylandOutput::orientateSize(const QSize &size) const
 {
     using Transform = DeviceInterface::Transform;
     const Transform transform = m_waylandOutputDevice->transform();
     if (transform == Transform::Rotated90 || transform == Transform::Rotated270 ||
             transform == Transform::Flipped90 || transform == Transform::Flipped270) {
         return size.transposed();
     }
     return size;
 }
 
 void AbstractWaylandOutput::setTransform(Transform transform)
 {
     const auto deviceTransform = toDeviceTransform(transform);
     if (deviceTransform == m_waylandOutputDevice->transform()) {
         return;
     }
     setTransform(deviceTransform);
     emit modeChanged();
 }
 
 AbstractWaylandOutput::Transform AbstractWaylandOutput::transform() const
 {
     return static_cast<Transform>(m_waylandOutputDevice->transform());
 }
 
 }
diff --git a/abstract_wayland_output.h b/abstract_wayland_output.h
index 73ef7bd71..31e101ee5 100644
--- a/abstract_wayland_output.h
+++ b/abstract_wayland_output.h
@@ -1,184 +1,181 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_ABSTRACT_WAYLAND_OUTPUT_H
 #define KWIN_ABSTRACT_WAYLAND_OUTPUT_H
 
 #include "abstract_output.h"
 #include <utils.h>
 #include <kwin_export.h>
 
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <QRect>
 #include <QSize>
 #include <QVector>
 
-#include <KWayland/Server/output_interface.h>
-#include <KWayland/Server/outputdevice_interface.h>
+#include <KWaylandServer/output_interface.h>
+#include <KWaylandServer/outputdevice_interface.h>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class OutputInterface;
 class OutputDeviceInterface;
 class OutputChangeSet;
 class OutputManagementInterface;
 class XdgOutputInterface;
 }
-}
 
 namespace KWin
 {
 
 /**
  * Generic output representation in a Wayland session
  */
 class KWIN_EXPORT AbstractWaylandOutput : public AbstractOutput
 {
     Q_OBJECT
 public:
     enum class Transform {
         Normal,
         Rotated90,
         Rotated180,
         Rotated270,
         Flipped,
         Flipped90,
         Flipped180,
         Flipped270
     };
 
     explicit AbstractWaylandOutput(QObject *parent = nullptr);
     ~AbstractWaylandOutput() override;
 
     QString name() const override;
     QByteArray uuid() const override;
 
     QSize modeSize() const;
 
     // TODO: The name is ambiguous. Rename this function.
     QSize pixelSize() const;
 
     qreal scale() const override;
 
     /**
      * The geometry of this output in global compositor co-ordinates (i.e scaled)
      */
     QRect geometry() const override;
     QSize physicalSize() const override;
 
     /**
      * Returns the orientation of this output.
      *
      * - Flipped along the vertical axis is landscape + inv. portrait.
      * - Rotated 90° and flipped along the horizontal axis is portrait + inv. landscape
      * - Rotated 180° and flipped along the vertical axis is inv. landscape + inv. portrait
      * - Rotated 270° and flipped along the horizontal axis is inv. portrait + inv. landscape +
      *   portrait
      */
     Transform transform() const;
 
     /**
      * Current refresh rate in 1/ms.
      */
     int refreshRate() const override;
 
     bool isInternal() const override {
         return m_internal;
     }
 
     void setGlobalPos(const QPoint &pos);
     void setScale(qreal scale);
 
-    void applyChanges(const KWayland::Server::OutputChangeSet *changeSet) override;
+    void applyChanges(const KWaylandServer::OutputChangeSet *changeSet) override;
 
-    QPointer<KWayland::Server::OutputInterface> waylandOutput() const {
+    QPointer<KWaylandServer::OutputInterface> waylandOutput() const {
         return m_waylandOutput;
     }
 
     bool isEnabled() const;
     /**
      * Enable or disable the output.
      *
      * This differs from updateDpms as it also removes the wl_output.
      * The default is on.
      */
     void setEnabled(bool enable) override;
 
     QString description() const;
 
 Q_SIGNALS:
     void modeChanged();
 
 protected:
     void initInterfaces(const QString &model, const QString &manufacturer,
                         const QByteArray &uuid, const QSize &physicalSize,
-                        const QVector<KWayland::Server::OutputDeviceInterface::Mode> &modes);
+                        const QVector<KWaylandServer::OutputDeviceInterface::Mode> &modes);
 
     QPoint globalPos() const;
 
     bool internal() const {
         return m_internal;
     }
     void setName(const QString &name) {
         m_name = name;
     }
     void setInternal(bool set) {
         m_internal = set;
     }
     void setDpmsSupported(bool set) {
         m_waylandOutput->setDpmsSupported(set);
     }
 
     virtual void updateEnablement(bool enable) {
         Q_UNUSED(enable);
     }
-    virtual void updateDpms(KWayland::Server::OutputInterface::DpmsMode mode) {
+    virtual void updateDpms(KWaylandServer::OutputInterface::DpmsMode mode) {
         Q_UNUSED(mode);
     }
     virtual void updateMode(int modeIndex) {
         Q_UNUSED(modeIndex);
     }
     virtual void updateTransform(Transform transform) {
         Q_UNUSED(transform);
     }
 
     void setWaylandMode(const QSize &size, int refreshRate);
     void setTransform(Transform transform);
 
     QSize orientateSize(const QSize &size) const;
 
 private:
-    void setTransform(KWayland::Server::OutputDeviceInterface::Transform transform);
+    void setTransform(KWaylandServer::OutputDeviceInterface::Transform transform);
 
-    KWayland::Server::OutputInterface *m_waylandOutput;
-    KWayland::Server::XdgOutputInterface *m_xdgOutput;
-    KWayland::Server::OutputDeviceInterface *m_waylandOutputDevice;
-    KWayland::Server::OutputInterface::DpmsMode m_dpms = KWayland::Server::OutputInterface::DpmsMode::On;
+    KWaylandServer::OutputInterface *m_waylandOutput;
+    KWaylandServer::XdgOutputInterface *m_xdgOutput;
+    KWaylandServer::OutputDeviceInterface *m_waylandOutputDevice;
+    KWaylandServer::OutputInterface::DpmsMode m_dpms = KWaylandServer::OutputInterface::DpmsMode::On;
 
     QString m_name;
     bool m_internal = false;
 };
 
 }
 
 #endif // KWIN_OUTPUT_H
diff --git a/autotests/CMakeLists.txt b/autotests/CMakeLists.txt
index 29463a6f7..d553e44cf 100644
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -1,426 +1,426 @@
 add_definitions(-DKWIN_UNIT_TEST)
 remove_definitions(-DQT_USE_QSTRINGBUILDER)
 add_subdirectory(libkwineffects)
 add_subdirectory(libxrenderutils)
 add_subdirectory(integration)
 add_subdirectory(libinput)
 if (HAVE_DRM)
     add_subdirectory(drm)
 endif()
 add_subdirectory(tabbox)
 
 ########################################################
 # Test ScreenPaintData
 ########################################################
 set(testScreenPaintData_SRCS test_screen_paint_data.cpp)
 add_executable(testScreenPaintData ${testScreenPaintData_SRCS})
 target_link_libraries(testScreenPaintData kwineffects Qt5::Test Qt5::Widgets KF5::WindowSystem)
 add_test(NAME kwin-testScreenPaintData COMMAND testScreenPaintData)
 ecm_mark_as_test(testScreenPaintData)
 
 ########################################################
 # Test WindowPaintData
 ########################################################
 set(testWindowPaintData_SRCS test_window_paint_data.cpp)
 add_executable(testWindowPaintData ${testWindowPaintData_SRCS})
 target_link_libraries(testWindowPaintData kwineffects Qt5::Widgets Qt5::Test )
 add_test(NAME kwin-testWindowPaintData COMMAND testWindowPaintData)
 ecm_mark_as_test(testWindowPaintData)
 
 ########################################################
 # Test VirtualDesktopManager
 ########################################################
 set(testVirtualDesktops_SRCS
     ../virtualdesktops.cpp
     test_virtual_desktops.cpp
 )
 add_executable(testVirtualDesktops ${testVirtualDesktops_SRCS})
 
 target_link_libraries(testVirtualDesktops
     Qt5::Test
     Qt5::Widgets
 
     KF5::ConfigCore
     KF5::GlobalAccel
     KF5::I18n
-    KF5::WaylandServer
+    Plasma::KWaylandServer
     KF5::WindowSystem
 )
 add_test(NAME kwin-testVirtualDesktops COMMAND testVirtualDesktops)
 ecm_mark_as_test(testVirtualDesktops)
 
 ########################################################
 # Test ClientMachine
 ########################################################
 set(testClientMachine_SRCS
     ../client_machine.cpp
     test_client_machine.cpp
 )
 add_executable(testClientMachine ${testClientMachine_SRCS})
 set_target_properties(testClientMachine PROPERTIES COMPILE_DEFINITIONS "NO_NONE_WINDOW")
 
 target_link_libraries(testClientMachine
     Qt5::Concurrent
     Qt5::Test
     Qt5::Widgets
     Qt5::X11Extras
 
     KF5::ConfigCore
     KF5::WindowSystem
 
     XCB::XCB
     XCB::XFIXES
 
     ${X11_X11_LIB} # to make jenkins happy
 )
 add_test(NAME kwin-testClientMachine COMMAND testClientMachine)
 ecm_mark_as_test(testClientMachine)
 
 ########################################################
 # Test XcbWrapper
 ########################################################
 set(testXcbWrapper_SRCS
     test_xcb_wrapper.cpp
 )
 add_executable(testXcbWrapper ${testXcbWrapper_SRCS})
 
 target_link_libraries(testXcbWrapper
     Qt5::Test
     Qt5::Widgets
     Qt5::X11Extras
 
     KF5::ConfigCore
     KF5::WindowSystem
 
     XCB::XCB
 )
 add_test(NAME kwin-testXcbWrapper COMMAND testXcbWrapper)
 ecm_mark_as_test(testXcbWrapper)
 
 if (XCB_ICCCM_FOUND)
     add_executable(testXcbSizeHints test_xcb_size_hints.cpp)
     set_target_properties(testXcbSizeHints PROPERTIES COMPILE_DEFINITIONS "NO_NONE_WINDOW")
     target_link_libraries(testXcbSizeHints
         Qt5::Test
         Qt5::Widgets
         Qt5::X11Extras
 
         KF5::ConfigCore
         KF5::WindowSystem
 
         XCB::ICCCM
         XCB::XCB
     )
     add_test(NAME kwin-testXcbSizeHints COMMAND testXcbSizeHints)
     ecm_mark_as_test(testXcbSizeHints)
 endif()
 
 ########################################################
 # Test XcbWindow
 ########################################################
 set(testXcbWindow_SRCS
     test_xcb_window.cpp
 )
 add_executable(testXcbWindow ${testXcbWindow_SRCS})
 
 target_link_libraries(testXcbWindow
     Qt5::Test
     Qt5::Widgets
     Qt5::X11Extras
 
     KF5::ConfigCore
     KF5::WindowSystem
 
     XCB::XCB
 )
 add_test(NAME kwin-testXcbWindow COMMAND testXcbWindow)
 ecm_mark_as_test(testXcbWindow)
 
 ########################################################
 # Test BuiltInEffectLoader
 ########################################################
 set(testBuiltInEffectLoader_SRCS
     ../effectloader.cpp
     mock_effectshandler.cpp
     test_builtin_effectloader.cpp
 )
 add_executable(testBuiltInEffectLoader ${testBuiltInEffectLoader_SRCS})
 set_target_properties(testBuiltInEffectLoader PROPERTIES COMPILE_DEFINITIONS "NO_NONE_WINDOW")
 
 target_link_libraries(testBuiltInEffectLoader
     Qt5::Concurrent
     Qt5::Test
     Qt5::X11Extras
 
     KF5::Package
 
     kwineffects
     kwin4_effect_builtins
 )
 
 add_test(NAME kwin-testBuiltInEffectLoader COMMAND testBuiltInEffectLoader)
 ecm_mark_as_test(testBuiltInEffectLoader)
 
 ########################################################
 # Test ScriptedEffectLoader
 ########################################################
 include_directories(${KWin_SOURCE_DIR})
 set(testScriptedEffectLoader_SRCS
     ../effectloader.cpp
     ../cursor.cpp
     ../screens.cpp
     ../scripting/scriptedeffect.cpp
     ../scripting/scripting_logging.cpp
     ../scripting/scriptingutils.cpp
     mock_abstract_client.cpp
     mock_effectshandler.cpp
     mock_screens.cpp
     mock_workspace.cpp
     test_scripted_effectloader.cpp
 )
 kconfig_add_kcfg_files(testScriptedEffectLoader_SRCS ../settings.kcfgc)
 add_executable(testScriptedEffectLoader ${testScriptedEffectLoader_SRCS})
 
 target_link_libraries(testScriptedEffectLoader
     Qt5::Concurrent
     Qt5::Qml
     Qt5::Script
     Qt5::Sensors
     Qt5::Test
     Qt5::X11Extras
 
     KF5::ConfigGui
     KF5::GlobalAccel
     KF5::I18n
     KF5::Notifications
     KF5::Package
 
     kwineffects
     kwin4_effect_builtins
 )
 
 add_test(NAME kwin-testScriptedEffectLoader COMMAND testScriptedEffectLoader)
 ecm_mark_as_test(testScriptedEffectLoader)
 
 ########################################################
 # Test PluginEffectLoader
 ########################################################
 set(testPluginEffectLoader_SRCS
     ../effectloader.cpp
     mock_effectshandler.cpp
     test_plugin_effectloader.cpp
 )
 add_executable(testPluginEffectLoader ${testPluginEffectLoader_SRCS})
 
 target_link_libraries(testPluginEffectLoader
     Qt5::Concurrent
     Qt5::Test
     Qt5::X11Extras
 
     KF5::Package
 
     kwineffects
     kwin4_effect_builtins
 )
 
 add_test(NAME kwin-testPluginEffectLoader COMMAND testPluginEffectLoader)
 ecm_mark_as_test(testPluginEffectLoader)
 
 ########################################################
 # FakeEffectPlugin
 ########################################################
 add_library(fakeeffectplugin MODULE fakeeffectplugin.cpp)
 set_target_properties(fakeeffectplugin PROPERTIES PREFIX "")
 target_link_libraries(fakeeffectplugin kwineffects)
 
 ########################################################
 # FakeEffectPlugin-Version
 ########################################################
 add_library(effectversionplugin MODULE fakeeffectplugin_version.cpp)
 set_target_properties(effectversionplugin PROPERTIES PREFIX "")
 target_link_libraries(effectversionplugin kwineffects)
 
 ########################################################
 # Test Screens
 ########################################################
 set(testScreens_SRCS
     ../screens.cpp
     ../cursor.cpp
     ../x11eventfilter.cpp
     mock_abstract_client.cpp
     mock_screens.cpp
     mock_workspace.cpp
     mock_x11client.cpp
     test_screens.cpp
 )
 kconfig_add_kcfg_files(testScreens_SRCS ../settings.kcfgc)
 
 add_executable(testScreens ${testScreens_SRCS})
 target_include_directories(testScreens BEFORE PRIVATE ./)
 target_link_libraries(testScreens
     Qt5::DBus
     Qt5::Sensors
     Qt5::Test
     Qt5::Widgets
     Qt5::X11Extras
 
     KF5::ConfigCore
     KF5::ConfigGui
     KF5::I18n
     KF5::Notifications
     KF5::WindowSystem
 
     XCB::XCB #for xcbutils.h
 )
 
 add_test(NAME kwin_testScreens COMMAND testScreens)
 ecm_mark_as_test(testScreens)
 
 ########################################################
 # Test ScreenEdges
 ########################################################
 set(testScreenEdges_SRCS
     ../atoms.cpp
     ../gestures.cpp
     ../plugins/platforms/x11/standalone/edge.cpp
     ../screenedge.cpp
     ../screens.cpp
     ../virtualdesktops.cpp
     ../cursor.cpp
     ../xcbutils.cpp # init of extensions
     mock_abstract_client.cpp
     mock_screens.cpp
     mock_workspace.cpp
     mock_x11client.cpp
     test_screen_edges.cpp
 )
 kconfig_add_kcfg_files(testScreenEdges_SRCS ../settings.kcfgc)
 qt5_add_dbus_interface(testScreenEdges_SRCS ${KSCREENLOCKER_DBUS_INTERFACES_DIR}/kf5_org.freedesktop.ScreenSaver.xml screenlocker_interface )
 
 add_executable(testScreenEdges ${testScreenEdges_SRCS})
 set_target_properties(testScreenEdges PROPERTIES COMPILE_DEFINITIONS "NO_NONE_WINDOW")
 target_include_directories(testScreenEdges BEFORE PRIVATE ./)
 target_link_libraries(testScreenEdges
     Qt5::DBus
     Qt5::Sensors
     Qt5::Test
     Qt5::X11Extras
 
     KF5::ConfigCore
     KF5::ConfigGui
     KF5::GlobalAccel
     KF5::I18n
     KF5::Notifications
-    KF5::WaylandServer
+    Plasma::KWaylandServer
     KF5::WindowSystem
 
     XCB::COMPOSITE
     XCB::DAMAGE
     XCB::GLX
     XCB::RANDR
     XCB::SHM
     XCB::SYNC
     XCB::XCB
     XCB::XFIXES
 )
 
 add_test(NAME kwin_testScreenEdges COMMAND testScreenEdges)
 ecm_mark_as_test(testScreenEdges)
 
 ########################################################
 # Test OnScreenNotification
 ########################################################
 set(testOnScreenNotification_SRCS
     ../input_event_spy.cpp
     ../onscreennotification.cpp
     onscreennotificationtest.cpp
 )
 add_executable(testOnScreenNotification ${testOnScreenNotification_SRCS})
 
 target_link_libraries(testOnScreenNotification
     Qt5::DBus
     Qt5::Quick
     Qt5::Test
     Qt5::Widgets # QAction include
 
     KF5::ConfigCore
 )
 
 add_test(NAME kwin-testOnScreenNotification COMMAND testOnScreenNotification)
 ecm_mark_as_test(testOnScreenNotification)
 
 ########################################################
 # Test Gestures
 ########################################################
 set(testGestures_SRCS
     ../gestures.cpp
     test_gestures.cpp
 )
 add_executable(testGestures ${testGestures_SRCS})
 
 target_link_libraries(testGestures
     Qt5::Test
 )
 
 add_test(NAME kwin-testGestures COMMAND testGestures)
 ecm_mark_as_test(testGestures)
 
 ########################################################
 # Test X11 TimestampUpdate
 ########################################################
 add_executable(testX11TimestampUpdate test_x11_timestamp_update.cpp)
 target_link_libraries(testX11TimestampUpdate
     KF5::CoreAddons
     Qt5::Test
     kwin
 )
 add_test(NAME kwin-testX11TimestampUpdate COMMAND testX11TimestampUpdate)
 ecm_mark_as_test(testX11TimestampUpdate)
 
 set(testOpenGLContextAttributeBuilder_SRCS
     ../abstract_opengl_context_attribute_builder.cpp
     ../egl_context_attribute_builder.cpp
     opengl_context_attribute_builder_test.cpp
 )
 
 if (HAVE_EPOXY_GLX)
     set(testOpenGLContextAttributeBuilder_SRCS ${testOpenGLContextAttributeBuilder_SRCS} ../plugins/platforms/x11/standalone/glx_context_attribute_builder.cpp)
 endif()
 add_executable(testOpenGLContextAttributeBuilder ${testOpenGLContextAttributeBuilder_SRCS})
 target_link_libraries(testOpenGLContextAttributeBuilder Qt5::Test)
 add_test(NAME kwin-testOpenGLContextAttributeBuilder COMMAND testOpenGLContextAttributeBuilder)
 ecm_mark_as_test(testOpenGLContextAttributeBuilder)
 
 set(testXkb_SRCS
     ../xkb.cpp
     test_xkb.cpp
 )
 add_executable(testXkb ${testXkb_SRCS})
 target_link_libraries(testXkb
     Qt5::Gui
     Qt5::Test
     Qt5::Widgets
 
     KF5::ConfigCore
-    KF5::WaylandServer
+    Plasma::KWaylandServer
     KF5::WindowSystem
 
     XKB::XKB
 )
 add_test(NAME kwin-testXkb COMMAND testXkb)
 ecm_mark_as_test(testXkb)
 
 if (HAVE_GBM)
     add_executable(testGbmSurface test_gbm_surface.cpp ../plugins/platforms/drm/gbm_surface.cpp)
     target_link_libraries(testGbmSurface Qt5::Test)
     add_test(NAME kwin-testGbmSurface COMMAND testGbmSurface)
     ecm_mark_as_test(testGbmSurface)
 endif()
 
 add_executable(testVirtualKeyboardDBus test_virtualkeyboard_dbus.cpp ../virtualkeyboard_dbus.cpp)
 target_link_libraries(testVirtualKeyboardDBus
     Qt5::DBus
     Qt5::Test
 )
 add_test(NAME kwin-testVirtualKeyboardDBus COMMAND testVirtualKeyboardDBus)
 ecm_mark_as_test(testVirtualKeyboardDBus)
diff --git a/autotests/integration/dont_crash_cursor_physical_size_empty.cpp b/autotests/integration/dont_crash_cursor_physical_size_empty.cpp
index 0b7f5dd01..bd0401729 100644
--- a/autotests/integration/dont_crash_cursor_physical_size_empty.cpp
+++ b/autotests/integration/dont_crash_cursor_physical_size_empty.cpp
@@ -1,119 +1,119 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Martin Flöser <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "effects.h"
 #include "platform.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/output_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/output_interface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_crash_cursor_physical_size_empty-0");
 
 class DontCrashCursorPhysicalSizeEmpty : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void init();
     void initTestCase();
     void cleanup();
     void testMoveCursorOverDeco_data();
     void testMoveCursorOverDeco();
 };
 
 void DontCrashCursorPhysicalSizeEmpty::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     screens()->setCurrent(0);
     KWin::Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void DontCrashCursorPhysicalSizeEmpty::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void DontCrashCursorPhysicalSizeEmpty::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("0"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
 }
 
 void DontCrashCursorPhysicalSizeEmpty::testMoveCursorOverDeco_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void DontCrashCursorPhysicalSizeEmpty::testMoveCursorOverDeco()
 {
     // This test ensures that there is no endless recursion if the cursor theme cannot be created
     // a reason for creation failure could be physical size not existing
     // see BUG: 390314
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     Test::waylandServerSideDecoration()->create(surface.data(), surface.data());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isDecorated());
 
     // destroy physical size
-    KWayland::Server::Display *display = waylandServer()->display();
+    KWaylandServer::Display *display = waylandServer()->display();
     auto output = display->outputs().first();
     output->setPhysicalSize(QSize(0, 0));
     // and fake a cursor theme change, so that the theme gets recreated
     emit KWin::Cursors::self()->mouse()->themeChanged();
 
     KWin::Cursors::self()->mouse()->setPos(QPoint(c->frameGeometry().center().x(), c->clientPos().y() / 2));
 }
 
 WAYLANDTEST_MAIN(DontCrashCursorPhysicalSizeEmpty)
 #include "dont_crash_cursor_physical_size_empty.moc"
diff --git a/autotests/integration/globalshortcuts_test.cpp b/autotests/integration/globalshortcuts_test.cpp
index c04110843..741982704 100644
--- a/autotests/integration/globalshortcuts_test.cpp
+++ b/autotests/integration/globalshortcuts_test.cpp
@@ -1,381 +1,381 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "input.h"
 #include "internal_client.h"
 #include "platform.h"
 #include "screens.h"
 #include "useractions.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <KGlobalAccel>
 #include <linux/input.h>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_globalshortcuts-0");
 
 class GlobalShortcutsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testConsumedShift();
     void testRepeatedTrigger();
     void testUserActionsMenu();
     void testMetaShiftW();
     void testComponseKey();
     void testX11ClientShortcut();
     void testWaylandClientShortcut();
     void testSetupWindowShortcut();
 };
 
 void GlobalShortcutsTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::InternalClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     qputenv("KWIN_XKB_DEFAULT_KEYMAP", "1");
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void GlobalShortcutsTest::init()
 {
     QVERIFY(Test::setupWaylandConnection());
     screens()->setCurrent(0);
     KWin::Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void GlobalShortcutsTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void GlobalShortcutsTest::testConsumedShift()
 {
     // this test verifies that a shortcut with a consumed shift modifier triggers
     // create the action
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-consumed-shift"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::Key_Percent}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::Key_Percent, action.data());
 
     // press shift+5
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_5, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     kwinApp()->platform()->keyboardKeyReleased(KEY_5, timestamp++);
 
     // release shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
 }
 
 void GlobalShortcutsTest::testRepeatedTrigger()
 {
     // this test verifies that holding a key, triggers repeated global shortcut
     // in addition pressing another key should stop triggering the shortcut
 
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-consumed-shift"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::Key_Percent}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::Key_Percent, action.data());
 
     // we need to configure the key repeat first. It is only enabled on libinput
     waylandServer()->seat()->setKeyRepeatInfo(25, 300);
 
     // press shift+5
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_WAKEUP, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_5, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     // and should repeat
     QVERIFY(triggeredSpy.wait());
     QVERIFY(triggeredSpy.wait());
     // now release the key
     kwinApp()->platform()->keyboardKeyReleased(KEY_5, timestamp++);
     QVERIFY(!triggeredSpy.wait(500));
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_WAKEUP, timestamp++);
     QVERIFY(!triggeredSpy.wait(500));
 
     // release shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
 }
 
 void GlobalShortcutsTest::testUserActionsMenu()
 {
     // this test tries to trigger the user actions menu with Alt+F3
     // the problem here is that pressing F3 consumes modifiers as it's part of the
     // Ctrl+alt+F3 keysym for vt switching. xkbcommon considers all modifiers as consumed
     // which a transformation to any keysym would cause
     // for more information see:
     // https://bugs.freedesktop.org/show_bug.cgi?id=92818
     // https://github.com/xkbcommon/libxkbcommon/issues/17
 
     // first create a window
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
 
     quint32 timestamp = 0;
     QVERIFY(!workspace()->userActionsMenu()->isShown());
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_F3, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_F3, timestamp++);
     QTRY_VERIFY(workspace()->userActionsMenu()->isShown());
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 }
 
 void GlobalShortcutsTest::testMetaShiftW()
 {
     // BUG 370341
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-test-meta-shift-w"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::META + Qt::SHIFT + Qt::Key_W}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::META + Qt::SHIFT + Qt::Key_W, action.data());
 
     // press meta+shift+w
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::MetaModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     QCOMPARE(input()->keyboardModifiers(), Qt::ShiftModifier | Qt::MetaModifier);
     kwinApp()->platform()->keyboardKeyPressed(KEY_W, timestamp++);
     QTRY_COMPARE(triggeredSpy.count(), 1);
     kwinApp()->platform()->keyboardKeyReleased(KEY_W, timestamp++);
 
     // release meta+shift
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 }
 
 void GlobalShortcutsTest::testComponseKey()
 {
     // BUG 390110
     QScopedPointer<QAction> action(new QAction(nullptr));
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName(QStringLiteral("globalshortcuts-accent"));
     QSignalSpy triggeredSpy(action.data(), &QAction::triggered);
     QVERIFY(triggeredSpy.isValid());
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::UNICODE_ACCEL}, KGlobalAccel::NoAutoloading);
     input()->registerShortcut(Qt::UNICODE_ACCEL, action.data());
 
     // press & release `
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_RESERVED, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RESERVED, timestamp++);
 
     QTRY_COMPARE(triggeredSpy.count(), 0);
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void GlobalShortcutsTest::testX11ClientShortcut()
 {
     // create an X11 window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 10, 20);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
     const QKeySequence seq(Qt::META + Qt::SHIFT + Qt::Key_Y);
     QVERIFY(workspace()->shortcutAvailable(seq));
     client->setShortcut(seq.toString());
     QCOMPARE(client->shortcut(), seq);
     QVERIFY(!workspace()->shortcutAvailable(seq));
     QCOMPARE(client->caption(), QStringLiteral(" {Meta+Shift+Y}"));
 
     // it's delayed
     QCoreApplication::processEvents();
 
     workspace()->activateClient(nullptr);
     QVERIFY(!workspace()->activeClient());
     QVERIFY(!client->isActive());
 
     // now let's trigger the shortcut
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     QTRY_COMPARE(workspace()->activeClient(), client);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void GlobalShortcutsTest::testWaylandClientShortcut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
     const QKeySequence seq(Qt::META + Qt::SHIFT + Qt::Key_Y);
     QVERIFY(workspace()->shortcutAvailable(seq));
     client->setShortcut(seq.toString());
     QCOMPARE(client->shortcut(), seq);
     QVERIFY(!workspace()->shortcutAvailable(seq));
     QCOMPARE(client->caption(), QStringLiteral(" {Meta+Shift+Y}"));
 
     workspace()->activateClient(nullptr);
     QVERIFY(!workspace()->activeClient());
     QVERIFY(!client->isActive());
 
     // now let's trigger the shortcut
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     QTRY_COMPARE(workspace()->activeClient(), client);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
     QVERIFY(workspace()->shortcutAvailable(seq));
 }
 
 void GlobalShortcutsTest::testSetupWindowShortcut()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(client->isActive());
     QCOMPARE(client->shortcut(), QKeySequence());
 
     QSignalSpy shortcutDialogAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(shortcutDialogAddedSpy.isValid());
     workspace()->slotSetupWindowShortcut();
     QTRY_COMPARE(shortcutDialogAddedSpy.count(), 1);
     auto dialog = shortcutDialogAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(dialog);
     QVERIFY(dialog->isInternal());
     auto sequenceEdit = workspace()->shortcutDialog()->findChild<QKeySequenceEdit*>();
     QVERIFY(sequenceEdit);
 
     // the QKeySequenceEdit field does not get focus, we need to pass it focus manually
     QEXPECT_FAIL("", "Edit does not have focus", Continue);
     QVERIFY(sequenceEdit->hasFocus());
     sequenceEdit->setFocus();
     QTRY_VERIFY(sequenceEdit->hasFocus());
 
     quint32 timestamp = 0;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_Y, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTSHIFT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++);
 
     // the sequence gets accepted after one second, so wait a bit longer
     QTest::qWait(2000);
     // now send in enter
     kwinApp()->platform()->keyboardKeyPressed(KEY_ENTER, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ENTER, timestamp++);
     QTRY_COMPARE(client->shortcut(), QKeySequence(Qt::META + Qt::SHIFT + Qt::Key_Y));
 }
 
 WAYLANDTEST_MAIN(GlobalShortcutsTest)
 #include "globalshortcuts_test.moc"
diff --git a/autotests/integration/idle_inhibition_test.cpp b/autotests/integration/idle_inhibition_test.cpp
index aa7282007..fe4f79ca4 100644
--- a/autotests/integration/idle_inhibition_test.cpp
+++ b/autotests/integration/idle_inhibition_test.cpp
@@ -1,359 +1,359 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "platform.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/idleinhibit.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/idle_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/idle_interface.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
-using KWayland::Server::IdleInterface;
+using KWaylandServer::IdleInterface;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_idle_inhbition_test-0");
 
 class TestIdleInhibition : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testInhibit_data();
     void testInhibit();
     void testDontInhibitWhenNotOnCurrentDesktop();
     void testDontInhibitWhenMinimized();
     void testDontInhibitWhenUnmapped();
     void testDontInhibitWhenLeftCurrentDesktop();
 };
 
 void TestIdleInhibition::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void TestIdleInhibition::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::IdleInhibition));
 
 }
 
 void TestIdleInhibition::cleanup()
 {
     Test::destroyWaylandConnection();
 
     VirtualDesktopManager::self()->setCount(1);
     QCOMPARE(VirtualDesktopManager::self()->count(), 1u);
 }
 
 void TestIdleInhibition::testInhibit_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase")  << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestIdleInhibition::testInhibit()
 {
     auto idle = waylandServer()->display()->findChild<IdleInterface*>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // now create window
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     // now create inhibition on window
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // render the client
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // this should inhibit our server object
     QVERIFY(idle->isInhibited());
 
     // deleting the object should uninhibit again
     inhibitor.reset();
     QVERIFY(inhibitedSpy.wait());
     QVERIFY(!idle->isInhibited());
 
     // inhibit again and destroy window
     Test::waylandIdleInhibitManager()->createInhibitor(surface.data(), surface.data());
     QVERIFY(inhibitedSpy.wait());
     QVERIFY(idle->isInhibited());
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenNotOnCurrentDesktop()
 {
     // This test verifies that the idle inhibitor object is not honored when
     // the associated surface is not on the current virtual desktop.
 
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
 
     // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // The test client should be only on the first virtual desktop.
     QCOMPARE(c->desktops().count(), 1);
     QCOMPARE(c->desktops().first(), VirtualDesktopManager::self()->desktops().first());
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Switch to the second virtual desktop.
     VirtualDesktopManager::self()->setCurrent(2);
 
     // The surface is no longer visible, so the compositor don't have to honor the
     // idle inhibitor object.
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // Switch back to the first virtual desktop.
     VirtualDesktopManager::self()->setCurrent(1);
 
     // The test client became visible again, so the compositor has to honor the idle
     // inhibitor object back again.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenMinimized()
 {
     // This test verifies that the idle inhibitor object is not honored when the
     // associated surface is minimized.
 
      // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Minimize the client, the idle inhibitor object should not be honored.
     c->minimize();
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // Unminimize the client, the idle inhibitor object should be honored back again.
     c->unminimize();
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenUnmapped()
 {
     // This test verifies that the idle inhibitor object is not honored by KWin
     // when the associated client is unmapped.
 
      // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Unmap the client.
     QSignalSpy hiddenSpy(c, &AbstractClient::windowHidden);
     QVERIFY(hiddenSpy.isValid());
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
 
     // The surface is no longer visible, so the compositor don't have to honor the
     // idle inhibitor object.
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // Map the client.
     QSignalSpy windowShownSpy(c, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(windowShownSpy.wait());
 
     // The test client became visible again, so the compositor has to honor the idle
     // inhibitor object back again.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 void TestIdleInhibition::testDontInhibitWhenLeftCurrentDesktop()
 {
     // This test verifies that the idle inhibitor object is not honored by KWin
     // when the associated surface leaves the current virtual desktop.
 
     VirtualDesktopManager::self()->setCount(2);
     QCOMPARE(VirtualDesktopManager::self()->count(), 2u);
 
     // Get reference to the idle interface.
     auto idle = waylandServer()->display()->findChild<IdleInterface *>();
     QVERIFY(idle);
     QVERIFY(!idle->isInhibited());
     QSignalSpy inhibitedSpy(idle, &IdleInterface::inhibitedChanged);
     QVERIFY(inhibitedSpy.isValid());
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
 
     // Create the inhibitor object.
     QScopedPointer<IdleInhibitor> inhibitor(Test::waylandIdleInhibitManager()->createInhibitor(surface.data()));
     QVERIFY(inhibitor->isValid());
 
     // Render the client.
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // The test client should be only on the first virtual desktop.
     QCOMPARE(c->desktops().count(), 1);
     QCOMPARE(c->desktops().first(), VirtualDesktopManager::self()->desktops().first());
 
     // This should inhibit our server object.
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // Let the client enter the second virtual desktop.
     c->enterDesktop(VirtualDesktopManager::self()->desktops().at(1));
     QCOMPARE(inhibitedSpy.count(), 1);
 
     // If the client leaves the first virtual desktop, then the associated idle
     // inhibitor object should not be honored.
     c->leaveDesktop(VirtualDesktopManager::self()->desktops().at(0));
     QVERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 2);
 
     // If the client enters the first desktop, then the associated idle inhibitor
     // object should be honored back again.
     c->enterDesktop(VirtualDesktopManager::self()->desktops().at(0));
     QVERIFY(idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 3);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QTRY_VERIFY(!idle->isInhibited());
     QCOMPARE(inhibitedSpy.count(), 4);
 }
 
 WAYLANDTEST_MAIN(TestIdleInhibition)
 #include "idle_inhibition_test.moc"
diff --git a/autotests/integration/input_stacking_order.cpp b/autotests/integration/input_stacking_order.cpp
index bebfb1426..b940f8647 100644
--- a/autotests/integration/input_stacking_order.cpp
+++ b/autotests/integration/input_stacking_order.cpp
@@ -1,186 +1,186 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_input_stacking_order-0");
 
 class InputStackingOrderTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testPointerFocusUpdatesOnStackingOrderChange_data();
     void testPointerFocusUpdatesOnStackingOrderChange();
 
 private:
     void render(KWayland::Client::Surface *surface);
 };
 
 void InputStackingOrderTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void InputStackingOrderTest::init()
 {
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void InputStackingOrderTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void InputStackingOrderTest::render(KWayland::Client::Surface *surface)
 {
     Test::render(surface, QSize(100, 50), Qt::blue);
     Test::flushWaylandConnection();
 }
 
 void InputStackingOrderTest::testPointerFocusUpdatesOnStackingOrderChange_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void InputStackingOrderTest::testPointerFocusUpdatesOnStackingOrderChange()
 {
     // this test creates two windows which overlap
     // the pointer is in the overlapping area which means the top most window has focus
     // as soon as the top most window gets lowered the window should lose focus and the
     // other window should gain focus without a mouse event in between
     using namespace KWayland::Client;
     // create pointer and signal spy for enter and leave signals
     auto pointer = Test::waylandSeat()->createPointer(Test::waylandSeat());
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     // now create the two windows and make them overlap
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface1);
     QFETCH(Test::XdgShellSurfaceType, type);
     XdgShellSurface *shellSurface1 = Test::createXdgShellSurface(type, surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
 
     Surface *surface2 = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellSurface(type, surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2);
     QVERIFY(clientAddedSpy.wait());
 
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
 
     // now make windows overlap
     window2->move(window1->pos());
     QCOMPARE(window1->frameGeometry(), window2->frameGeometry());
 
     // enter
     kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 1);
     // window 2 should have focus
     QCOMPARE(pointer->enteredSurface(), surface2);
     // also on the server
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window2->surface());
 
     // raise window 1 above window 2
     QVERIFY(leftSpy.isEmpty());
     workspace()->raiseClient(window1);
     // should send leave to window2
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     // and an enter to window1
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(pointer->enteredSurface(), surface1);
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window1->surface());
 
     // let's destroy window1, that should pass focus to window2 again
     QSignalSpy windowClosedSpy(window1, &Toplevel::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     surface1->deleteLater();
     QVERIFY(windowClosedSpy.wait());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 3);
     QCOMPARE(pointer->enteredSurface(), surface2);
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window2->surface());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::InputStackingOrderTest)
 #include "input_stacking_order.moc"
diff --git a/autotests/integration/internal_window.cpp b/autotests/integration/internal_window.cpp
index e4d110fec..23d039a9b 100644
--- a/autotests/integration/internal_window.cpp
+++ b/autotests/integration/internal_window.cpp
@@ -1,799 +1,799 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "cursor.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <QPainter>
 #include <QRasterWindow>
 
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/seat.h>
 #include <KWindowSystem>
 
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <linux/input.h>
 
 using namespace KWayland::Client;
 
 Q_DECLARE_METATYPE(NET::WindowType);
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_internal_window-0");
 
 class InternalWindowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testEnterLeave();
     void testPointerPressRelease();
     void testPointerAxis();
     void testKeyboard_data();
     void testKeyboard();
     void testKeyboardShowWithoutActivating();
     void testKeyboardTriggersLeave();
     void testTouch();
     void testOpacity();
     void testMove();
     void testSkipCloseAnimation_data();
     void testSkipCloseAnimation();
     void testModifierClickUnrestrictedMove();
     void testModifierScroll();
     void testPopup();
     void testScale();
     void testWindowType_data();
     void testWindowType();
     void testChangeWindowType_data();
     void testChangeWindowType();
     void testEffectWindow();
 };
 
 class HelperWindow : public QRasterWindow
 {
     Q_OBJECT
 public:
     HelperWindow();
     ~HelperWindow() override;
 
     QPoint latestGlobalMousePos() const {
         return m_latestGlobalMousePos;
     }
     Qt::MouseButtons pressedButtons() const {
         return m_pressedButtons;
     }
 
 Q_SIGNALS:
     void entered();
     void left();
     void mouseMoved(const QPoint &global);
     void mousePressed();
     void mouseReleased();
     void wheel();
     void keyPressed();
     void keyReleased();
 
 protected:
     void paintEvent(QPaintEvent *event) override;
     bool event(QEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
     void mousePressEvent(QMouseEvent *event) override;
     void mouseReleaseEvent(QMouseEvent *event) override;
     void wheelEvent(QWheelEvent *event) override;
     void keyPressEvent(QKeyEvent *event) override;
     void keyReleaseEvent(QKeyEvent *event) override;
 
 private:
     QPoint m_latestGlobalMousePos;
     Qt::MouseButtons m_pressedButtons = Qt::MouseButtons();
 };
 
 HelperWindow::HelperWindow()
     : QRasterWindow(nullptr)
 {
     setFlags(Qt::FramelessWindowHint);
 }
 
 HelperWindow::~HelperWindow() = default;
 
 void HelperWindow::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event)
     QPainter p(this);
     p.fillRect(0, 0, width(), height(), Qt::red);
 }
 
 bool HelperWindow::event(QEvent *event)
 {
     if (event->type() == QEvent::Enter) {
         emit entered();
     }
     if (event->type() == QEvent::Leave) {
         emit left();
     }
     return QRasterWindow::event(event);
 }
 
 void HelperWindow::mouseMoveEvent(QMouseEvent *event)
 {
     m_latestGlobalMousePos = event->globalPos();
     emit mouseMoved(event->globalPos());
 }
 
 void HelperWindow::mousePressEvent(QMouseEvent *event)
 {
     m_latestGlobalMousePos = event->globalPos();
     m_pressedButtons = event->buttons();
     emit mousePressed();
 }
 
 void HelperWindow::mouseReleaseEvent(QMouseEvent *event)
 {
     m_latestGlobalMousePos = event->globalPos();
     m_pressedButtons = event->buttons();
     emit mouseReleased();
 }
 
 void HelperWindow::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     emit wheel();
 }
 
 void HelperWindow::keyPressEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     emit keyPressed();
 }
 
 void HelperWindow::keyReleaseEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     emit keyReleased();
 }
 
 void InternalWindowTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient *>();
     qRegisterMetaType<KWin::InternalClient *>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void InternalWindowTest::init()
 {
     Cursors::self()->mouse()->setPos(QPoint(1280, 512));
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandKeyboard());
 }
 
 void InternalWindowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 }
 
 void InternalWindowTest::testEnterLeave()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     QVERIFY(!workspace()->findInternal(nullptr));
     QVERIFY(!workspace()->findInternal(&win));
     win.setGeometry(0, 0, 100, 100);
     win.show();
 
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     QVERIFY(!workspace()->activeClient());
     InternalClient *c = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(c);
     QVERIFY(c->isInternal());
     QVERIFY(!c->isDecorated());
     QCOMPARE(workspace()->findInternal(&win), c);
     QCOMPARE(c->frameGeometry(), QRect(0, 0, 100, 100));
     QVERIFY(c->isShown(false));
     QVERIFY(workspace()->xStackingOrder().contains(c));
 
     QSignalSpy enterSpy(&win, &HelperWindow::entered);
     QVERIFY(enterSpy.isValid());
     QSignalSpy leaveSpy(&win, &HelperWindow::left);
     QVERIFY(leaveSpy.isValid());
     QSignalSpy moveSpy(&win, &HelperWindow::mouseMoved);
     QVERIFY(moveSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
     QTRY_COMPARE(moveSpy.count(), 1);
 
     kwinApp()->platform()->pointerMotion(QPoint(60, 50), timestamp++);
     QTRY_COMPARE(moveSpy.count(), 2);
     QCOMPARE(moveSpy[1].first().toPoint(), QPoint(60, 50));
 
     kwinApp()->platform()->pointerMotion(QPoint(101, 50), timestamp++);
     QTRY_COMPARE(leaveSpy.count(), 1);
 
     // set a mask on the window
     win.setMask(QRegion(10, 20, 30, 40));
     // outside the mask we should not get an enter
     kwinApp()->platform()->pointerMotion(QPoint(5, 5), timestamp++);
     QVERIFY(!enterSpy.wait(100));
     QCOMPARE(enterSpy.count(), 1);
     // inside the mask we should still get an enter
     kwinApp()->platform()->pointerMotion(QPoint(25, 27), timestamp++);
     QTRY_COMPARE(enterSpy.count(), 2);
 }
 
 void InternalWindowTest::testPointerPressRelease()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::mousePressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::mouseReleased);
     QVERIFY(releaseSpy.isValid());
 
     QTRY_COMPARE(clientAddedSpy.count(), 1);
 
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
 
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QTRY_COMPARE(pressSpy.count(), 1);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QTRY_COMPARE(releaseSpy.count(), 1);
 }
 
 void InternalWindowTest::testPointerAxis()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy wheelSpy(&win, &HelperWindow::wheel);
     QVERIFY(wheelSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
 
     quint32 timestamp = 1;
     kwinApp()->platform()->pointerMotion(QPoint(50, 50), timestamp++);
 
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QTRY_COMPARE(wheelSpy.count(), 1);
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QTRY_COMPARE(wheelSpy.count(), 2);
 }
 
 void InternalWindowTest::testKeyboard_data()
 {
     QTest::addColumn<QPoint>("cursorPos");
 
     QTest::newRow("on Window") << QPoint(50, 50);
     QTest::newRow("outside Window") << QPoint(250, 250);
 }
 
 void InternalWindowTest::testKeyboard()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::keyPressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::keyReleased);
     QVERIFY(releaseSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QVERIFY(internalClient->readyForPainting());
 
     quint32 timestamp = 1;
     QFETCH(QPoint, cursorPos);
     kwinApp()->platform()->pointerMotion(cursorPos, timestamp++);
 
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QTRY_COMPARE(pressSpy.count(), 1);
     QCOMPARE(releaseSpy.count(), 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QTRY_COMPARE(releaseSpy.count(), 1);
     QCOMPARE(pressSpy.count(), 1);
 }
 
 void InternalWindowTest::testKeyboardShowWithoutActivating()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setProperty("_q_showWithoutActivating", true);
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::keyPressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::keyReleased);
     QVERIFY(releaseSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QVERIFY(internalClient->readyForPainting());
 
     quint32 timestamp = 1;
     const QPoint cursorPos = QPoint(50, 50);
     kwinApp()->platform()->pointerMotion(cursorPos, timestamp++);
 
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QCOMPARE(pressSpy.count(), 0);
     QVERIFY(!pressSpy.wait(100));
     QCOMPARE(releaseSpy.count(), 0);
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QCOMPARE(releaseSpy.count(), 0);
     QVERIFY(!releaseSpy.wait(100));
     QCOMPARE(pressSpy.count(), 0);
 }
 
 void InternalWindowTest::testKeyboardTriggersLeave()
 {
     // this test verifies that a leave event is sent to a client when an internal window
     // gets a key event
     QScopedPointer<Keyboard> keyboard(Test::waylandSeat()->createKeyboard());
     QVERIFY(!keyboard.isNull());
     QVERIFY(keyboard->isValid());
     QSignalSpy enteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(leftSpy.isValid());
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
 
     // now let's render
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isInternal());
 
     if (enteredSpy.isEmpty()) {
         QVERIFY(enteredSpy.wait());
     }
     QCOMPARE(enteredSpy.count(), 1);
 
     // create internal window
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QSignalSpy pressSpy(&win, &HelperWindow::keyPressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::keyReleased);
     QVERIFY(releaseSpy.isValid());
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QVERIFY(internalClient->readyForPainting());
 
     QVERIFY(leftSpy.isEmpty());
     QVERIFY(!leftSpy.wait(100));
 
     // now let's trigger a key, which should result in a leave
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QVERIFY(leftSpy.wait());
     QCOMPARE(pressSpy.count(), 1);
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
     QTRY_COMPARE(releaseSpy.count(), 1);
 
     // after hiding the internal window, next key press should trigger an enter
     win.hide();
     kwinApp()->platform()->keyboardKeyPressed(KEY_A, timestamp++);
     QVERIFY(enteredSpy.wait());
     kwinApp()->platform()->keyboardKeyReleased(KEY_A, timestamp++);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
 }
 
 void InternalWindowTest::testTouch()
 {
     // touch events for internal windows are emulated through mouse events
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
 
     QSignalSpy pressSpy(&win, &HelperWindow::mousePressed);
     QVERIFY(pressSpy.isValid());
     QSignalSpy releaseSpy(&win, &HelperWindow::mouseReleased);
     QVERIFY(releaseSpy.isValid());
     QSignalSpy moveSpy(&win, &HelperWindow::mouseMoved);
     QVERIFY(moveSpy.isValid());
 
     quint32 timestamp = 1;
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons());
     kwinApp()->platform()->touchDown(0, QPointF(50, 50), timestamp++);
     QCOMPARE(pressSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(50, 50));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // further touch down should not trigger
     kwinApp()->platform()->touchDown(1, QPointF(75, 75), timestamp++);
     QCOMPARE(pressSpy.count(), 1);
     kwinApp()->platform()->touchUp(1, timestamp++);
     QCOMPARE(releaseSpy.count(), 0);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(50, 50));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // another press
     kwinApp()->platform()->touchDown(1, QPointF(10, 10), timestamp++);
     QCOMPARE(pressSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(50, 50));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // simulate the move
     QCOMPARE(moveSpy.count(), 0);
     kwinApp()->platform()->touchMotion(0, QPointF(80, 90), timestamp++);
     QCOMPARE(moveSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // move on other ID should not do anything
     kwinApp()->platform()->touchMotion(1, QPointF(20, 30), timestamp++);
     QCOMPARE(moveSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons(Qt::LeftButton));
 
     // now up our main point
     kwinApp()->platform()->touchUp(0, timestamp++);
     QCOMPARE(releaseSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons());
 
     // and up the additional point
     kwinApp()->platform()->touchUp(1, timestamp++);
     QCOMPARE(releaseSpy.count(), 1);
     QCOMPARE(moveSpy.count(), 1);
     QCOMPARE(win.latestGlobalMousePos(), QPoint(80, 90));
     QCOMPARE(win.pressedButtons(), Qt::MouseButtons());
 }
 
 void InternalWindowTest::testOpacity()
 {
     // this test verifies that opacity is properly synced from QWindow to InternalClient
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setOpacity(0.5);
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isInternal());
     QCOMPARE(internalClient->opacity(), 0.5);
 
     QSignalSpy opacityChangedSpy(internalClient, &InternalClient::opacityChanged);
     QVERIFY(opacityChangedSpy.isValid());
     win.setOpacity(0.75);
     QCOMPARE(opacityChangedSpy.count(), 1);
     QCOMPARE(internalClient->opacity(), 0.75);
 }
 
 void InternalWindowTest::testMove()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setOpacity(0.5);
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->frameGeometry(), QRect(0, 0, 100, 100));
 
     // normal move should be synced
     internalClient->move(5, 10);
     QCOMPARE(internalClient->frameGeometry(), QRect(5, 10, 100, 100));
     QTRY_COMPARE(win.geometry(), QRect(5, 10, 100, 100));
     // another move should also be synced
     internalClient->move(10, 20);
     QCOMPARE(internalClient->frameGeometry(), QRect(10, 20, 100, 100));
     QTRY_COMPARE(win.geometry(), QRect(10, 20, 100, 100));
 
     // now move with a Geometry update blocker
     {
         GeometryUpdatesBlocker blocker(internalClient);
         internalClient->move(5, 10);
         // not synced!
         QCOMPARE(win.geometry(), QRect(10, 20, 100, 100));
     }
     // after destroying the blocker it should be synced
     QTRY_COMPARE(win.geometry(), QRect(5, 10, 100, 100));
 }
 
 void InternalWindowTest::testSkipCloseAnimation_data()
 {
     QTest::addColumn<bool>("initial");
 
     QTest::newRow("set") << true;
     QTest::newRow("not set") << false;
 }
 
 void InternalWindowTest::testSkipCloseAnimation()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setOpacity(0.5);
     win.setGeometry(0, 0, 100, 100);
     QFETCH(bool, initial);
     win.setProperty("KWIN_SKIP_CLOSE_ANIMATION", initial);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->skipsCloseAnimation(), initial);
     QSignalSpy skipCloseChangedSpy(internalClient, &Toplevel::skipCloseAnimationChanged);
     QVERIFY(skipCloseChangedSpy.isValid());
     win.setProperty("KWIN_SKIP_CLOSE_ANIMATION", !initial);
     QCOMPARE(skipCloseChangedSpy.count(), 1);
     QCOMPARE(internalClient->skipsCloseAnimation(), !initial);
     win.setProperty("KWIN_SKIP_CLOSE_ANIMATION", initial);
     QCOMPARE(skipCloseChangedSpy.count(), 2);
     QCOMPARE(internalClient->skipsCloseAnimation(), initial);
 }
 
 void InternalWindowTest::testModifierClickUnrestrictedMove()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() & ~Qt::FramelessWindowHint);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isDecorated());
 
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // move cursor on window
     Cursors::self()->mouse()->setPos(internalClient->frameGeometry().center());
 
     // simulate modifier+click
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QVERIFY(!internalClient->isMove());
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(internalClient->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QVERIFY(internalClient->isMove());
     // but releasing the key should end move/resize
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(!internalClient->isMove());
 }
 
 void InternalWindowTest::testModifierScroll()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() & ~Qt::FramelessWindowHint);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->isDecorated());
 
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     // move cursor on window
     Cursors::self()->mouse()->setPos(internalClient->frameGeometry().center());
 
     // set the opacity to 0.5
     internalClient->setOpacity(0.5);
     QCOMPARE(internalClient->opacity(), 0.5);
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(internalClient->opacity(), 0.6);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(internalClient->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 }
 
 void InternalWindowTest::testPopup()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() | Qt::Popup);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->isPopupWindow(), true);
 }
 
 void InternalWindowTest::testScale()
 {
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection,
         Q_ARG(int, 2),
         Q_ARG(QVector<QRect>, QVector<QRect>({QRect(0,0,1280, 1024), QRect(1280/2, 0, 1280, 1024)})),
         Q_ARG(QVector<int>, QVector<int>({2,2})));
 
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.setFlags(win.flags() | Qt::Popup);
     win.show();
     QCOMPARE(win.devicePixelRatio(), 2.0);
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QCOMPARE(internalClient->bufferScale(), 2);
 }
 
 void InternalWindowTest::testWindowType_data()
 {
     QTest::addColumn<NET::WindowType>("windowType");
 
     QTest::newRow("normal") << NET::Normal;
     QTest::newRow("desktop") << NET::Desktop;
     QTest::newRow("Dock") << NET::Dock;
     QTest::newRow("Toolbar") << NET::Toolbar;
     QTest::newRow("Menu") << NET::Menu;
     QTest::newRow("Dialog") << NET::Dialog;
     QTest::newRow("Utility") << NET::Utility;
     QTest::newRow("Splash") << NET::Splash;
     QTest::newRow("DropdownMenu") << NET::DropdownMenu;
     QTest::newRow("PopupMenu") << NET::PopupMenu;
     QTest::newRow("Tooltip") << NET::Tooltip;
     QTest::newRow("Notification") << NET::Notification;
     QTest::newRow("ComboBox") << NET::ComboBox;
     QTest::newRow("OnScreenDisplay") << NET::OnScreenDisplay;
     QTest::newRow("CriticalNotification") << NET::CriticalNotification;
 }
 
 void InternalWindowTest::testWindowType()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     QFETCH(NET::WindowType, windowType);
     KWindowSystem::setType(win.winId(), windowType);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->windowType(), windowType);
 }
 
 void InternalWindowTest::testChangeWindowType_data()
 {
     QTest::addColumn<NET::WindowType>("windowType");
 
     QTest::newRow("desktop") << NET::Desktop;
     QTest::newRow("Dock") << NET::Dock;
     QTest::newRow("Toolbar") << NET::Toolbar;
     QTest::newRow("Menu") << NET::Menu;
     QTest::newRow("Dialog") << NET::Dialog;
     QTest::newRow("Utility") << NET::Utility;
     QTest::newRow("Splash") << NET::Splash;
     QTest::newRow("DropdownMenu") << NET::DropdownMenu;
     QTest::newRow("PopupMenu") << NET::PopupMenu;
     QTest::newRow("Tooltip") << NET::Tooltip;
     QTest::newRow("Notification") << NET::Notification;
     QTest::newRow("ComboBox") << NET::ComboBox;
     QTest::newRow("OnScreenDisplay") << NET::OnScreenDisplay;
     QTest::newRow("CriticalNotification") << NET::CriticalNotification;
 }
 
 void InternalWindowTest::testChangeWindowType()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QCOMPARE(internalClient->windowType(), NET::Normal);
 
     QFETCH(NET::WindowType, windowType);
     KWindowSystem::setType(win.winId(), windowType);
     QTRY_COMPARE(internalClient->windowType(), windowType);
 
     KWindowSystem::setType(win.winId(), NET::Normal);
     QTRY_COMPARE(internalClient->windowType(), NET::Normal);
 }
 
 void InternalWindowTest::testEffectWindow()
 {
     QSignalSpy clientAddedSpy(workspace(), &Workspace::internalClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
     QTRY_COMPARE(clientAddedSpy.count(), 1);
     auto internalClient = clientAddedSpy.first().first().value<InternalClient *>();
     QVERIFY(internalClient);
     QVERIFY(internalClient->effectWindow());
     QCOMPARE(internalClient->effectWindow()->internalWindow(), &win);
 
     QCOMPARE(effects->findWindow(&win), internalClient->effectWindow());
     QCOMPARE(effects->findWindow(&win)->internalWindow(), &win);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::InternalWindowTest)
 #include "internal_window.moc"
diff --git a/autotests/integration/lockscreen.cpp b/autotests/integration/lockscreen.cpp
index 6058c7a7b..7fa59bb61 100644
--- a/autotests/integration/lockscreen.cpp
+++ b/autotests/integration/lockscreen.cpp
@@ -1,766 +1,766 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "scene.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <KGlobalAccel>
 
 #include <linux/input.h>
 
 Q_DECLARE_METATYPE(Qt::Orientation)
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_lock_screen-0");
 
 class LockScreenTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testPointer();
     void testPointerButton();
     void testPointerAxis();
     void testKeyboard();
     void testScreenEdge();
     void testEffects();
     void testEffectsKeyboard();
     void testEffectsKeyboardAutorepeat();
     void testMoveWindow();
     void testPointerShortcut();
     void testAxisShortcut_data();
     void testAxisShortcut();
     void testKeyboardShortcut();
     void testTouch();
 
 private:
     void unlock();
     AbstractClient *showWindow();
     KWayland::Client::ConnectionThread *m_connection = nullptr;
     KWayland::Client::Compositor *m_compositor = nullptr;
     KWayland::Client::Seat *m_seat = nullptr;
     KWayland::Client::ShmPool *m_shm = nullptr;
     KWayland::Client::Shell *m_shell = nullptr;
 };
 
 class HelperEffect : public Effect
 {
     Q_OBJECT
 public:
     HelperEffect() {}
     ~HelperEffect() override {}
 
     void windowInputMouseEvent(QEvent*) override {
         emit inputEvent();
     }
     void grabbedKeyboardEvent(QKeyEvent *e) override {
         emit keyEvent(e->text());
     }
 
 Q_SIGNALS:
     void inputEvent();
     void keyEvent(const QString&);
 };
 
 #define LOCK \
     QVERIFY(!waylandServer()->isScreenLocked()); \
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged); \
     QVERIFY(lockStateChangedSpy.isValid()); \
     ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate); \
     QCOMPARE(lockStateChangedSpy.count(), 1); \
     QVERIFY(waylandServer()->isScreenLocked());
 
 #define UNLOCK \
     int expectedLockCount = 1; \
     if (ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::Locked) { \
         expectedLockCount = 2; \
     } \
     QCOMPARE(lockStateChangedSpy.count(), expectedLockCount); \
     unlock(); \
     if (lockStateChangedSpy.count() < expectedLockCount + 1) { \
         QVERIFY(lockStateChangedSpy.wait()); \
     } \
     QCOMPARE(lockStateChangedSpy.count(), expectedLockCount + 1); \
     QVERIFY(!waylandServer()->isScreenLocked());
 
 #define MOTION(target) \
     kwinApp()->platform()->pointerMotion(target, timestamp++)
 
 #define PRESS \
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++)
 
 #define RELEASE \
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++)
 
 #define KEYPRESS( key ) \
     kwinApp()->platform()->keyboardKeyPressed(key, timestamp++)
 
 #define KEYRELEASE( key ) \
     kwinApp()->platform()->keyboardKeyReleased(key, timestamp++)
 
 void LockScreenTest::unlock()
 {
     using namespace ScreenLocker;
     const auto children = KSldApp::self()->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "requestUnlock");
         break;
     }
 }
 
 AbstractClient *LockScreenTest::showWindow()
 {
     using namespace KWayland::Client;
 #define VERIFY(statement) \
     if (!QTest::qVerify((statement), #statement, "", __FILE__, __LINE__))\
         return nullptr;
 #define COMPARE(actual, expected) \
     if (!QTest::qCompare(actual, expected, #actual, #expected, __FILE__, __LINE__))\
         return nullptr;
 
     Surface *surface = Test::createSurface(m_compositor);
     VERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     VERIFY(shellSurface);
     // let's render
     auto c = Test::renderAndWaitForShown(surface, QSize(100, 50), Qt::blue);
 
     VERIFY(c);
     COMPARE(workspace()->activeClient(), c);
 
 #undef VERIFY
 #undef COMPARE
 
     return c;
 }
 
 void LockScreenTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 }
 
 void LockScreenTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     m_connection = Test::waylandConnection();
     m_compositor = Test::waylandCompositor();
     m_shm = Test::waylandShmPool();
     m_seat = Test::waylandSeat();
 
     screens()->setCurrent(0);
     Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void LockScreenTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void LockScreenTest::testPointer()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Pointer> pointer(m_seat->createPointer());
     QVERIFY(!pointer.isNull());
     QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer.data(), &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
 
     // first move cursor into the center of the window
     quint32 timestamp = 1;
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
 
     LOCK
 
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
 
     // simulate moving out in and out again
     MOTION(c->frameGeometry().center());
     MOTION(c->frameGeometry().bottomRight() + QPoint(100, 100));
     MOTION(c->frameGeometry().bottomRight() + QPoint(100, 100));
     QVERIFY(!leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(enteredSpy.count(), 1);
 
     // go back on the window
     MOTION(c->frameGeometry().center());
     // and unlock
     UNLOCK
 
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     // move on the window
     MOTION(c->frameGeometry().center() + QPoint(100, 100));
     QVERIFY(leftSpy.wait());
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 3);
 }
 
 void LockScreenTest::testPointerButton()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Pointer> pointer(m_seat->createPointer());
     QVERIFY(!pointer.isNull());
     QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy buttonChangedSpy(pointer.data(), &Pointer::buttonStateChanged);
     QVERIFY(buttonChangedSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
 
     // first move cursor into the center of the window
     quint32 timestamp = 1;
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // and simulate a click
     PRESS;
     QVERIFY(buttonChangedSpy.wait());
     RELEASE;
     QVERIFY(buttonChangedSpy.wait());
 
     LOCK
 
     // and simulate a click
     PRESS;
     QVERIFY(!buttonChangedSpy.wait());
     RELEASE;
     QVERIFY(!buttonChangedSpy.wait());
 
     UNLOCK
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
 
     // and click again
     PRESS;
     QVERIFY(buttonChangedSpy.wait());
     RELEASE;
     QVERIFY(buttonChangedSpy.wait());
 }
 
 void LockScreenTest::testPointerAxis()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Pointer> pointer(m_seat->createPointer());
     QVERIFY(!pointer.isNull());
     QSignalSpy axisChangedSpy(pointer.data(), &Pointer::axisChanged);
     QVERIFY(axisChangedSpy.isValid());
     QSignalSpy enteredSpy(pointer.data(), &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
 
     // first move cursor into the center of the window
     quint32 timestamp = 1;
     MOTION(c->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // and simulate axis
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QVERIFY(axisChangedSpy.wait());
 
     LOCK
 
     // and simulate axis
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QVERIFY(!axisChangedSpy.wait(100));
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QVERIFY(!axisChangedSpy.wait(100));
 
     // and unlock
     UNLOCK
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
 
     // and move axis again
     kwinApp()->platform()->pointerAxisHorizontal(5.0, timestamp++);
     QVERIFY(axisChangedSpy.wait());
     kwinApp()->platform()->pointerAxisVertical(5.0, timestamp++);
     QVERIFY(axisChangedSpy.wait());
 }
 
 void LockScreenTest::testKeyboard()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Keyboard> keyboard(m_seat->createKeyboard());
     QVERIFY(!keyboard.isNull());
     QSignalSpy enteredSpy(keyboard.data(), &Keyboard::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(keyboard.data(), &Keyboard::left);
     QVERIFY(leftSpy.isValid());
     QSignalSpy keyChangedSpy(keyboard.data(), &Keyboard::keyChanged);
     QVERIFY(keyChangedSpy.isValid());
 
     AbstractClient *c = showWindow();
     QVERIFY(c);
     QVERIFY(enteredSpy.wait());
     QTRY_COMPARE(enteredSpy.count(), 1);
 
     quint32 timestamp = 1;
     KEYPRESS(KEY_A);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 1);
     QCOMPARE(keyChangedSpy.at(0).at(0).value<quint32>(), quint32(KEY_A));
     QCOMPARE(keyChangedSpy.at(0).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
     QCOMPARE(keyChangedSpy.at(0).at(2).value<quint32>(), quint32(1));
     KEYRELEASE(KEY_A);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 2);
     QCOMPARE(keyChangedSpy.at(1).at(0).value<quint32>(), quint32(KEY_A));
     QCOMPARE(keyChangedSpy.at(1).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
     QCOMPARE(keyChangedSpy.at(1).at(2).value<quint32>(), quint32(2));
 
     LOCK
     QVERIFY(leftSpy.wait());
     KEYPRESS(KEY_B);
     KEYRELEASE(KEY_B);
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(keyChangedSpy.count(), 2);
 
     UNLOCK
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     KEYPRESS(KEY_C);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 3);
     KEYRELEASE(KEY_C);
     QVERIFY(keyChangedSpy.wait());
     QCOMPARE(keyChangedSpy.count(), 4);
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(keyChangedSpy.at(2).at(0).value<quint32>(), quint32(KEY_C));
     QCOMPARE(keyChangedSpy.at(3).at(0).value<quint32>(), quint32(KEY_C));
     QCOMPARE(keyChangedSpy.at(2).at(2).value<quint32>(), quint32(5));
     QCOMPARE(keyChangedSpy.at(3).at(2).value<quint32>(), quint32(6));
     QCOMPARE(keyChangedSpy.at(2).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Pressed);
     QCOMPARE(keyChangedSpy.at(3).at(1).value<Keyboard::KeyState>(), Keyboard::KeyState::Released);
 }
 
 void LockScreenTest::testScreenEdge()
 {
     QSignalSpy screenEdgeSpy(ScreenEdges::self(), &ScreenEdges::approaching);
     QVERIFY(screenEdgeSpy.isValid());
     QCOMPARE(screenEdgeSpy.count(), 0);
 
     quint32 timestamp = 1;
     MOTION(QPoint(5, 5));
     QCOMPARE(screenEdgeSpy.count(), 1);
 
     LOCK
 
     MOTION(QPoint(4, 4));
     QCOMPARE(screenEdgeSpy.count(), 1);
 
     // and unlock
     UNLOCK
 
     MOTION(QPoint(5, 5));
     QCOMPARE(screenEdgeSpy.count(), 2);
 }
 
 void LockScreenTest::testEffects()
 {
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     QSignalSpy inputSpy(effect.data(), &HelperEffect::inputEvent);
     QVERIFY(inputSpy.isValid());
     effects->startMouseInterception(effect.data(), Qt::ArrowCursor);
 
     quint32 timestamp = 1;
     QCOMPARE(inputSpy.count(), 0);
     MOTION(QPoint(5, 5));
     QCOMPARE(inputSpy.count(), 1);
     // simlate click
     PRESS;
     QCOMPARE(inputSpy.count(), 2);
     RELEASE;
     QCOMPARE(inputSpy.count(), 3);
 
     LOCK
 
     MOTION(QPoint(6, 6));
     QCOMPARE(inputSpy.count(), 3);
     // simlate click
     PRESS;
     QCOMPARE(inputSpy.count(), 3);
     RELEASE;
     QCOMPARE(inputSpy.count(), 3);
 
     UNLOCK
 
     MOTION(QPoint(5, 5));
     QCOMPARE(inputSpy.count(), 4);
     // simlate click
     PRESS;
     QCOMPARE(inputSpy.count(), 5);
     RELEASE;
     QCOMPARE(inputSpy.count(), 6);
 
     effects->stopMouseInterception(effect.data());
 }
 
 void LockScreenTest::testEffectsKeyboard()
 {
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     QSignalSpy inputSpy(effect.data(), &HelperEffect::keyEvent);
     QVERIFY(inputSpy.isValid());
     effects->grabKeyboard(effect.data());
 
     quint32 timestamp = 1;
     KEYPRESS(KEY_A);
     QCOMPARE(inputSpy.count(), 1);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     KEYRELEASE(KEY_A);
     QCOMPARE(inputSpy.count(), 2);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
 
     LOCK
     KEYPRESS(KEY_B);
     QCOMPARE(inputSpy.count(), 2);
     KEYRELEASE(KEY_B);
     QCOMPARE(inputSpy.count(), 2);
 
     UNLOCK
     KEYPRESS(KEY_C);
     QCOMPARE(inputSpy.count(), 3);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(2).first().toString(), QStringLiteral("c"));
     KEYRELEASE(KEY_C);
     QCOMPARE(inputSpy.count(), 4);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
     QCOMPARE(inputSpy.at(2).first().toString(), QStringLiteral("c"));
     QCOMPARE(inputSpy.at(3).first().toString(), QStringLiteral("c"));
 
     effects->ungrabKeyboard();
 }
 
 void LockScreenTest::testEffectsKeyboardAutorepeat()
 {
     // this test is just like testEffectsKeyboard, but tests auto repeat key events
     // while the key is pressed the Effect should get auto repeated events
     // but the lock screen should filter them out
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     QSignalSpy inputSpy(effect.data(), &HelperEffect::keyEvent);
     QVERIFY(inputSpy.isValid());
     effects->grabKeyboard(effect.data());
 
     // we need to configure the key repeat first. It is only enabled on libinput
     waylandServer()->seat()->setKeyRepeatInfo(25, 300);
 
     quint32 timestamp = 1;
     KEYPRESS(KEY_A);
     QCOMPARE(inputSpy.count(), 1);
     QCOMPARE(inputSpy.first().first().toString(), QStringLiteral("a"));
     QVERIFY(inputSpy.wait());
     QVERIFY(inputSpy.count() > 1);
     // and still more events
     QVERIFY(inputSpy.wait());
     QCOMPARE(inputSpy.at(1).first().toString(), QStringLiteral("a"));
 
     // now release
     inputSpy.clear();
     KEYRELEASE(KEY_A);
     QCOMPARE(inputSpy.count(), 1);
 
     // while locked key repeat should not pass any events to the Effect
     LOCK
     KEYPRESS(KEY_B);
     QVERIFY(!inputSpy.wait(200));
     KEYRELEASE(KEY_B);
     QVERIFY(!inputSpy.wait(200));
 
     UNLOCK
     // don't test again, that's covered by testEffectsKeyboard
 
     effects->ungrabKeyboard();
 }
 
 void LockScreenTest::testMoveWindow()
 {
     using namespace KWayland::Client;
     AbstractClient *c = showWindow();
     QVERIFY(c);
     QSignalSpy clientStepUserMovedResizedSpy(c, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     quint32 timestamp = 1;
 
     workspace()->slotWindowMove();
     QCOMPARE(workspace()->moveResizeClient(), c);
     QVERIFY(c->isMove());
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QEXPECT_FAIL("", "First event is ignored", Continue);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     // TODO adjust once the expected fail is fixed
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     // while locking our window should continue to be in move resize
     LOCK
     QCOMPARE(workspace()->moveResizeClient(), c);
     QVERIFY(c->isMove());
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
 
     UNLOCK
     QCOMPARE(workspace()->moveResizeClient(), c);
     QVERIFY(c->isMove());
     kwinApp()->platform()->keyboardKeyPressed(KEY_RIGHT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_RIGHT, timestamp++);
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     kwinApp()->platform()->keyboardKeyPressed(KEY_ESC, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_ESC, timestamp++);
     QVERIFY(!c->isMove());
 }
 
 void LockScreenTest::testPointerShortcut()
 {
     using namespace KWayland::Client;
     QScopedPointer<QAction> action(new QAction(nullptr));
     QSignalSpy actionSpy(action.data(), &QAction::triggered);
     QVERIFY(actionSpy.isValid());
     input()->registerPointerShortcut(Qt::MetaModifier, Qt::LeftButton, action.data());
 
     // try to trigger the shortcut
     quint32 timestamp = 1;
 #define PERFORM(expectedCount) \
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
     PRESS; \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount); \
     RELEASE; \
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount);
 
     PERFORM(1)
 
     // now the same thing with a locked screen
     LOCK
     PERFORM(1)
 
     // and as unlocked
     UNLOCK
     PERFORM(2)
 #undef PERFORM
 }
 
 
 void LockScreenTest::testAxisShortcut_data()
 {
     QTest::addColumn<Qt::Orientation>("direction");
     QTest::addColumn<int>("sign");
 
     QTest::newRow("up") << Qt::Vertical << 1;
     QTest::newRow("down") << Qt::Vertical << -1;
     QTest::newRow("left") << Qt::Horizontal << 1;
     QTest::newRow("right") << Qt::Horizontal << -1;
 }
 
 void LockScreenTest::testAxisShortcut()
 {
     using namespace KWayland::Client;
     QScopedPointer<QAction> action(new QAction(nullptr));
     QSignalSpy actionSpy(action.data(), &QAction::triggered);
     QVERIFY(actionSpy.isValid());
     QFETCH(Qt::Orientation, direction);
     QFETCH(int, sign);
     PointerAxisDirection axisDirection = PointerAxisUp;
     if (direction == Qt::Vertical) {
         axisDirection = sign > 0 ? PointerAxisUp : PointerAxisDown;
     } else {
         axisDirection = sign > 0 ? PointerAxisLeft : PointerAxisRight;
     }
     input()->registerAxisShortcut(Qt::MetaModifier, axisDirection, action.data());
 
     // try to trigger the shortcut
     quint32 timestamp = 1;
 #define PERFORM(expectedCount) \
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTMETA, timestamp++); \
     if (direction == Qt::Vertical) \
         kwinApp()->platform()->pointerAxisVertical(sign * 5.0, timestamp++); \
     else \
         kwinApp()->platform()->pointerAxisHorizontal(sign * 5.0, timestamp++); \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount); \
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTMETA, timestamp++); \
     QCoreApplication::instance()->processEvents(); \
     QCOMPARE(actionSpy.count(), expectedCount);
 
     PERFORM(1)
 
     // now the same thing with a locked screen
     LOCK
     PERFORM(1)
 
     // and as unlocked
     UNLOCK
     PERFORM(2)
 #undef PERFORM
 }
 
 void LockScreenTest::testKeyboardShortcut()
 {
     using namespace KWayland::Client;
     QScopedPointer<QAction> action(new QAction(nullptr));
     QSignalSpy actionSpy(action.data(), &QAction::triggered);
     QVERIFY(actionSpy.isValid());
     action->setProperty("componentName", QStringLiteral(KWIN_NAME));
     action->setObjectName("LockScreenTest::testKeyboardShortcut");
     KGlobalAccel::self()->setDefaultShortcut(action.data(), QList<QKeySequence>{Qt::CTRL + Qt::META + Qt::ALT + Qt::Key_Space});
     KGlobalAccel::self()->setShortcut(action.data(), QList<QKeySequence>{Qt::CTRL + Qt::META + Qt::ALT + Qt::Key_Space},
                                           KGlobalAccel::NoAutoloading);
 
     // try to trigger the shortcut
     quint32 timestamp = 1;
     KEYPRESS(KEY_LEFTCTRL);
     KEYPRESS(KEY_LEFTMETA);
     KEYPRESS(KEY_LEFTALT);
     KEYPRESS(KEY_SPACE);
     QVERIFY(actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
     KEYRELEASE(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
 
     LOCK
     KEYPRESS(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
     KEYRELEASE(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 1);
 
     UNLOCK
     KEYPRESS(KEY_SPACE);
     QVERIFY(actionSpy.wait());
     QCOMPARE(actionSpy.count(), 2);
     KEYRELEASE(KEY_SPACE);
     QVERIFY(!actionSpy.wait());
     QCOMPARE(actionSpy.count(), 2);
     KEYRELEASE(KEY_LEFTCTRL);
     KEYRELEASE(KEY_LEFTMETA);
     KEYRELEASE(KEY_LEFTALT);
 }
 
 void LockScreenTest::testTouch()
 {
     using namespace KWayland::Client;
     auto touch = m_seat->createTouch(m_seat);
     QVERIFY(touch);
     QVERIFY(touch->isValid());
     AbstractClient *c = showWindow();
     QVERIFY(c);
     QSignalSpy sequenceStartedSpy(touch, &Touch::sequenceStarted);
     QVERIFY(sequenceStartedSpy.isValid());
     QSignalSpy cancelSpy(touch, &Touch::sequenceCanceled);
     QVERIFY(cancelSpy.isValid());
     QSignalSpy pointRemovedSpy(touch, &Touch::pointRemoved);
     QVERIFY(pointRemovedSpy.isValid());
 
     quint32 timestamp = 1;
     kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 1);
 
     LOCK
     QVERIFY(cancelSpy.wait());
 
     kwinApp()->platform()->touchUp(1, timestamp++);
     QVERIFY(!pointRemovedSpy.wait(100));
     kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
     kwinApp()->platform()->touchMotion(1, QPointF(26, 26), timestamp++);
     kwinApp()->platform()->touchUp(1, timestamp++);
 
     UNLOCK
     kwinApp()->platform()->touchDown(1, QPointF(25, 25), timestamp++);
     QVERIFY(sequenceStartedSpy.wait());
     QCOMPARE(sequenceStartedSpy.count(), 2);
     kwinApp()->platform()->touchUp(1, timestamp++);
     QVERIFY(pointRemovedSpy.wait());
     QCOMPARE(pointRemovedSpy.count(), 1);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::LockScreenTest)
 #include "lockscreen.moc"
diff --git a/autotests/integration/maximize_test.cpp b/autotests/integration/maximize_test.cpp
index e11e8db99..6a7a6e410 100644
--- a/autotests/integration/maximize_test.cpp
+++ b/autotests/integration/maximize_test.cpp
@@ -1,375 +1,375 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/settings.h"
 #include "platform.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Client/plasmashell.h>
 
-#include <KWayland/Server/xdgdecoration_interface.h>
+#include <KWaylandServer/xdgdecoration_interface.h>
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationSettings>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_maximized-0");
 
 class TestMaximized : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMaximizedPassedToDeco();
     void testInitiallyMaximized();
     void testBorderlessMaximizedWindow();
     void testBorderlessMaximizedWindowNoClientSideDecoration();
 };
 
 void TestMaximized::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestMaximized::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration |
                                          Test::AdditionalWaylandInterface::XdgDecoration |
                                          Test::AdditionalWaylandInterface::PlasmaShell));
 
     screens()->setCurrent(0);
     KWin::Cursors::self()->mouse()->setPos(QPoint(1280, 512));
 }
 
 void TestMaximized::cleanup()
 {
     Test::destroyWaylandConnection();
 
     // adjust config
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", false);
     group.sync();
     Workspace::self()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), false);
 }
 
 void TestMaximized::testMaximizedPassedToDeco()
 {
     // this test verifies that when a XdgShellClient gets maximized the Decoration receives the signal
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<ServerSideDecoration> ssd(Test::waylandServerSideDecoration()->create(surface.data()));
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isDecorated());
 
     auto decoration = client->decoration();
     QVERIFY(decoration);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
 
     // Wait for configure event that signals the client is active now.
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     // When there are no borders, there is no change to them when maximizing.
     // TODO: we should test both cases with fixed fake decoration for autotests.
     const bool hasBorders = Decoration::DecorationBridge::self()->settings()->borderSize() != KDecoration2::BorderSize::None;
 
     // now maximize
     QSignalSpy bordersChangedSpy(decoration, &KDecoration2::Decoration::bordersChanged);
     QVERIFY(bordersChangedSpy.isValid());
     QSignalSpy maximizedChangedSpy(decoration->client().data(), &KDecoration2::DecoratedClient::maximizedChanged);
     QVERIFY(maximizedChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024 - decoration->borderTop()));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), configureRequestedSpy.last().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     // If no borders, there is only the initial geometry shape change, but none through border resizing.
     QCOMPARE(frameGeometryChangedSpy.count(), hasBorders ? 2 : 1);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(maximizedChangedSpy.count(), 1);
     QCOMPARE(maximizedChangedSpy.last().first().toBool(), true);
     QCOMPARE(bordersChangedSpy.count(), hasBorders ? 1 : 0);
     QCOMPARE(decoration->borderLeft(), 0);
     QCOMPARE(decoration->borderBottom(), 0);
     QCOMPARE(decoration->borderRight(), 0);
     QVERIFY(decoration->borderTop() != 0);
 
     // now unmaximize again
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(100, 50));
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), hasBorders ? 4 : 2);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(maximizedChangedSpy.count(), 2);
     QCOMPARE(maximizedChangedSpy.last().first().toBool(), false);
     QCOMPARE(bordersChangedSpy.count(), hasBorders ? 2 : 0);
     QVERIFY(decoration->borderTop() != 0);
     QVERIFY(decoration->borderLeft() != !hasBorders);
     QVERIFY(decoration->borderRight() != !hasBorders);
     QVERIFY(decoration->borderBottom() != !hasBorders);
 
     // Destroy the test client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestMaximized::testInitiallyMaximized()
 {
     // This test verifies that a window created as maximized, will be maximized.
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(
         Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     shellSurface->setMaximized(true);
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     // Now let's render in an incorrect size.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 100, 50));
     QEXPECT_FAIL("", "Should go out of maximzied", Continue);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
 
     // Destroy the client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestMaximized::testBorderlessMaximizedWindow()
 {
     // This test verifies that a maximized client looses it's server-side
     // decoration when the borderless maximized option is on.
 
     // Enable the borderless maximized windows option.
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", true);
     group.sync();
     Workspace::self()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), true);
 
     // Create the test client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(
         Test::createXdgShellStableSurface(surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QScopedPointer<XdgDecoration> decoration(
         Test::xdgDecorationManager()->getToplevelDecoration(shellSurface.data()));
     QSignalSpy decorationConfiguredSpy(decoration.data(), &XdgDecoration::modeChanged);
     QVERIFY(decorationConfiguredSpy.isValid());
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     decoration->setMode(XdgDecoration::Mode::ServerSide);
     surface->commit(Surface::CommitFlag::None);
 
     // Wait for the initial configure event.
     XdgShellSurface::States states;
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(0, 0));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Map the client.
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->isDecorated(), true);
 
     // We should receive a configure event when the client becomes active.
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     // Maximize the client.
     const QRect maximizeRestoreGeometry = client->frameGeometry();
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), QRect(0, 0, 1280, 1024));
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeFull);
     QCOMPARE(client->isDecorated(), false);
 
     // Restore the client.
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(100, 50));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry(), maximizeRestoreGeometry);
     QCOMPARE(client->maximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->requestedMaximizeMode(), MaximizeMode::MaximizeRestore);
     QCOMPARE(client->isDecorated(), true);
 
     // Destroy the client.
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestMaximized::testBorderlessMaximizedWindowNoClientSideDecoration()
 {
     // test case verifies that borderless maximized windows doesn't cause
     // clients to render client-side decorations instead (BUG 405385)
 
     // adjust config
     auto group = kwinApp()->config()->group("Windows");
     group.writeEntry("BorderlessMaximizedWindows", true);
     group.sync();
     Workspace::self()->slotReconfigure();
     QCOMPARE(options->borderlessMaximizedWindows(), true);
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> xdgShellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<XdgDecoration> deco(Test::xdgDecorationManager()->getToplevelDecoration(xdgShellSurface.data()));
 
     QSignalSpy decorationConfiguredSpy(deco.data(), &XdgDecoration::modeChanged);
     QVERIFY(decorationConfiguredSpy.isValid());
 
     auto client = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy sizeChangeRequestedSpy(xdgShellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeRequestedSpy.isValid());
     QSignalSpy configureRequestedSpy(xdgShellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
 
     QVERIFY(client->isDecorated());
     QVERIFY(!client->noBorder());
     configureRequestedSpy.wait();
     QCOMPARE(decorationConfiguredSpy.count(), 1);
     QCOMPARE(deco->mode(), XdgDecoration::Mode::ServerSide);
 
     // go to maximized
     xdgShellSurface->setMaximized(true);
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 1);
 
     for (const auto &it: configureRequestedSpy) {
         xdgShellSurface->ackConfigure(it[2].toInt());
     }
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     // no deco
     QVERIFY(!client->isDecorated());
     QVERIFY(client->noBorder());
     // but still server-side
     QCOMPARE(deco->mode(), XdgDecoration::Mode::ServerSide);
 
     // go back to normal
     xdgShellSurface->setMaximized(false);
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 2);
 
     for (const auto &it: configureRequestedSpy) {
         xdgShellSurface->ackConfigure(it[2].toInt());
     }
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     QVERIFY(client->isDecorated());
     QVERIFY(!client->noBorder());
     QCOMPARE(deco->mode(), XdgDecoration::Mode::ServerSide);
 }
 
 WAYLANDTEST_MAIN(TestMaximized)
 #include "maximize_test.moc"
diff --git a/autotests/integration/plasmawindow_test.cpp b/autotests/integration/plasmawindow_test.cpp
index 22cffcfe1..a14a87c0e 100644
--- a/autotests/integration/plasmawindow_test.cpp
+++ b/autotests/integration/plasmawindow_test.cpp
@@ -1,330 +1,330 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <QPainter>
 #include <QRasterWindow>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWayland::Client;
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_plasma-window-0");
 
 class PlasmaWindowTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testCreateDestroyX11PlasmaWindow();
     void testInternalWindowNoPlasmaWindow();
     void testPopupWindowNoPlasmaWindow();
     void testLockScreenNoPlasmaWindow();
     void testDestroyedButNotUnmapped();
 
 private:
     PlasmaWindowManagement *m_windowManagement = nullptr;
     KWayland::Client::Compositor *m_compositor = nullptr;
 };
 
 void PlasmaWindowTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     setenv("QMLSCENE_DEVICE", "softwarecontext", true);
     waylandServer()->initWorkspace();
 }
 
 void PlasmaWindowTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::WindowManagement));
     m_windowManagement = Test::waylandWindowManagement();
     m_compositor = Test::waylandCompositor();
 
     screens()->setCurrent(0);
     Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void PlasmaWindowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void PlasmaWindowTest::testCreateDestroyX11PlasmaWindow()
 {
     // this test verifies that a PlasmaWindow gets unmapped on Client side when an X11 client is destroyed
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // create an xcb window
     struct XcbConnectionDeleter
     {
         static inline void cleanup(xcb_connection_t *pointer)
         {
             xcb_disconnect(pointer);
         }
     };
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, 0, nullptr);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QVERIFY(client->isDecorated());
     QVERIFY(client->isActive());
     // verify that it gets the keyboard focus
     if (!client->surface()) {
         // we don't have a surface yet, so focused keyboard surface if set is not ours
         QVERIFY(!waylandServer()->seat()->focusedKeyboardSurface());
         QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
         QVERIFY(surfaceChangedSpy.isValid());
         QVERIFY(surfaceChangedSpy.wait());
     }
     QVERIFY(client->surface());
     QCOMPARE(waylandServer()->seat()->focusedKeyboardSurface(), client->surface());
 
     // now that should also give it to us on client side
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
     QCOMPARE(m_windowManagement->windows().count(), 1);
     auto pw = m_windowManagement->windows().first();
     QCOMPARE(pw->geometry(), client->frameGeometry());
     QSignalSpy geometryChangedSpy(pw, &PlasmaWindow::geometryChanged);
     QVERIFY(geometryChangedSpy.isValid());
 
     QSignalSpy unmappedSpy(m_windowManagement->windows().first(), &PlasmaWindow::unmapped);
     QVERIFY(unmappedSpy.isValid());
     QSignalSpy destroyedSpy(m_windowManagement->windows().first(), &QObject::destroyed);
     QVERIFY(destroyedSpy.isValid());
 
     // now shade the window
     const QRect geoBeforeShade = client->frameGeometry();
     QVERIFY(geoBeforeShade.isValid());
     QVERIFY(!geoBeforeShade.isEmpty());
     workspace()->slotWindowShade();
     QVERIFY(client->isShade());
     QVERIFY(client->frameGeometry() != geoBeforeShade);
     QVERIFY(geometryChangedSpy.wait());
     QCOMPARE(pw->geometry(), client->frameGeometry());
     // and unshade again
     workspace()->slotWindowShade();
     QVERIFY(!client->isShade());
     QCOMPARE(client->frameGeometry(), geoBeforeShade);
     QVERIFY(geometryChangedSpy.wait());
     QCOMPARE(pw->geometry(), geoBeforeShade);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 
     QVERIFY(unmappedSpy.wait());
     QCOMPARE(unmappedSpy.count(), 1);
 
     QVERIFY(destroyedSpy.wait());
 }
 
 class HelperWindow : public QRasterWindow
 {
     Q_OBJECT
 public:
     HelperWindow();
     ~HelperWindow() override;
 
 protected:
     void paintEvent(QPaintEvent *event) override;
 };
 
 HelperWindow::HelperWindow()
     : QRasterWindow(nullptr)
 {
 }
 
 HelperWindow::~HelperWindow() = default;
 
 void HelperWindow::paintEvent(QPaintEvent *event)
 {
     Q_UNUSED(event)
     QPainter p(this);
     p.fillRect(0, 0, width(), height(), Qt::red);
 }
 
 void PlasmaWindowTest::testInternalWindowNoPlasmaWindow()
 {
     // this test verifies that an internal window is not added as a PlasmaWindow to the client
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
     HelperWindow win;
     win.setGeometry(0, 0, 100, 100);
     win.show();
 
     QVERIFY(!plasmaWindowCreatedSpy.wait());
 }
 
 void PlasmaWindowTest::testPopupWindowNoPlasmaWindow()
 {
     // this test verifies that for a popup window no PlasmaWindow is sent to the client
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // first create the parent window
     QScopedPointer<Surface> parentSurface(Test::createSurface());
     QScopedPointer<XdgShellSurface> parentShellSurface(Test::createXdgShellStableSurface(parentSurface.data()));
     AbstractClient *parentClient = Test::renderAndWaitForShown(parentSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(parentClient);
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
 
     // now let's create a popup window for it
     XdgPositioner positioner(QSize(10, 10), QRect(0, 0, 10, 10));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     QScopedPointer<Surface> popupSurface(Test::createSurface());
     QScopedPointer<XdgShellPopup> popupShellSurface(Test::createXdgShellStablePopup(popupSurface.data(), parentShellSurface.data(), positioner));
     AbstractClient *popupClient = Test::renderAndWaitForShown(popupSurface.data(), positioner.initialSize(), Qt::blue);
     QVERIFY(popupClient);
     QVERIFY(!plasmaWindowCreatedSpy.wait(100));
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
 
     // let's destroy the windows
     popupShellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(popupClient));
     parentShellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(parentClient));
 }
 
 void PlasmaWindowTest::testLockScreenNoPlasmaWindow()
 {
     // this test verifies that lock screen windows are not exposed to PlasmaWindow
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // this time we use a QSignalSpy on XdgShellClient as it'a a little bit more complex setup
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     // lock
     ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
     QVERIFY(clientAddedSpy.wait());
     QVERIFY(clientAddedSpy.first().first().value<AbstractClient *>()->isLockScreen());
     // should not be sent to the client
     QVERIFY(plasmaWindowCreatedSpy.isEmpty());
     QVERIFY(!plasmaWindowCreatedSpy.wait());
 
     // fake unlock
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged);
     QVERIFY(lockStateChangedSpy.isValid());
     const auto children = ScreenLocker::KSldApp::self()->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "requestUnlock");
         break;
     }
     QVERIFY(lockStateChangedSpy.wait());
     QVERIFY(!waylandServer()->isScreenLocked());
 }
 
 void PlasmaWindowTest::testDestroyedButNotUnmapped()
 {
     // this test verifies that also when a ShellSurface gets destroyed without a prior unmap
     // the PlasmaWindow gets destroyed on Client side
     QSignalSpy plasmaWindowCreatedSpy(m_windowManagement, &PlasmaWindowManagement::windowCreated);
     QVERIFY(plasmaWindowCreatedSpy.isValid());
 
     // first create the parent window
     QScopedPointer<Surface> parentSurface(Test::createSurface());
     QScopedPointer<XdgShellSurface> parentShellSurface(Test::createXdgShellStableSurface(parentSurface.data()));
     // map that window
     Test::render(parentSurface.data(), QSize(100, 50), Qt::blue);
     // this should create a plasma window
     QVERIFY(plasmaWindowCreatedSpy.wait());
     QCOMPARE(plasmaWindowCreatedSpy.count(), 1);
     auto window = plasmaWindowCreatedSpy.first().first().value<PlasmaWindow*>();
     QVERIFY(window);
     QSignalSpy destroyedSpy(window, &QObject::destroyed);
     QVERIFY(destroyedSpy.isValid());
 
     // now destroy without an unmap
     parentShellSurface.reset();
     parentSurface.reset();
     QVERIFY(destroyedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::PlasmaWindowTest)
 #include "plasmawindow_test.moc"
diff --git a/autotests/integration/pointer_constraints_test.cpp b/autotests/integration/pointer_constraints_test.cpp
index 68570275e..b2b997dbe 100644
--- a/autotests/integration/pointer_constraints_test.cpp
+++ b/autotests/integration/pointer_constraints_test.cpp
@@ -1,403 +1,403 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "keyboard_input.h"
 #include "platform.h"
 #include "pointer_input.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/pointerconstraints.h>
 #include <KWayland/Client/region.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <linux/input.h>
 
 #include <functional>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 typedef std::function<QPoint(const QRect&)> PointerFunc;
 Q_DECLARE_METATYPE(PointerFunc)
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_constraints-0");
 
 class TestPointerConstraints : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testConfinedPointer_data();
     void testConfinedPointer();
     void testLockedPointer_data();
     void testLockedPointer();
     void testCloseWindowWithLockedPointer_data();
     void testCloseWindowWithLockedPointer();
 };
 
 void TestPointerConstraints::initTestCase()
 {
     qRegisterMetaType<PointerFunc>();
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     // set custom config which disables the OnScreenNotification
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup group = config->group("OnScreenNotification");
     group.writeEntry(QStringLiteral("QmlPath"), QString("/does/not/exist.qml"));
     group.sync();
 
     kwinApp()->setConfig(config);
 
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestPointerConstraints::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::PointerConstraints));
     QVERIFY(Test::waitForWaylandPointer());
 
     screens()->setCurrent(0);
     KWin::Cursors::self()->mouse()->setPos(QPoint(1280, 512));
 }
 
 void TestPointerConstraints::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestPointerConstraints::testConfinedPointer_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<PointerFunc>("positionFunction");
     QTest::addColumn<int>("xOffset");
     QTest::addColumn<int>("yOffset");
     PointerFunc bottomLeft = &QRect::bottomLeft;
     PointerFunc bottomRight = &QRect::bottomRight;
     PointerFunc topRight = &QRect::topRight;
     PointerFunc topLeft = &QRect::topLeft;
 
     QTest::newRow("XdgWmBase - bottomLeft")   << Test::XdgShellSurfaceType::XdgShellStable << bottomLeft  << -1 << 1;
     QTest::newRow("XdgWmBase - bottomRight")  << Test::XdgShellSurfaceType::XdgShellStable << bottomRight << 1  << 1;
     QTest::newRow("XdgWmBase - topLeft")      << Test::XdgShellSurfaceType::XdgShellStable << topLeft  << -1 << -1;
     QTest::newRow("XdgWmBase - topRight")     << Test::XdgShellSurfaceType::XdgShellStable << topRight << 1  << -1;
 }
 
 void TestPointerConstraints::testConfinedPointer()
 {
     // this test sets up a Surface with a confined pointer
     // simple interaction test to verify that the pointer gets confined
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<ConfinedPointer> confinedPointer(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
     QSignalSpy confinedSpy(confinedPointer.data(), &ConfinedPointer::confined);
     QVERIFY(confinedSpy.isValid());
     QSignalSpy unconfinedSpy(confinedPointer.data(), &ConfinedPointer::unconfined);
     QVERIFY(unconfinedSpy.isValid());
 
     // now map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c);
     if (c->pos() == QPoint(0, 0)) {
         c->move(QPoint(1, 1));
     }
     QVERIFY(!c->frameGeometry().contains(KWin::Cursors::self()->mouse()->pos()));
 
     // now let's confine
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center());
     QCOMPARE(input()->pointer()->isConstrained(), true);
     QVERIFY(confinedSpy.wait());
 
     // picking a position outside the window geometry should not move pointer
     QSignalSpy pointerPositionChangedSpy(input(), &InputRedirection::globalPointerChanged);
     QVERIFY(pointerPositionChangedSpy.isValid());
     KWin::Cursors::self()->mouse()->setPos(QPoint(1280, 512));
     QVERIFY(pointerPositionChangedSpy.isEmpty());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center());
 
     // TODO: test relative motion
     QFETCH(PointerFunc, positionFunction);
     const QPoint position = positionFunction(c->frameGeometry());
     KWin::Cursors::self()->mouse()->setPos(position);
     QCOMPARE(pointerPositionChangedSpy.count(), 1);
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), position);
     // moving one to right should not be possible
     QFETCH(int, xOffset);
     KWin::Cursors::self()->mouse()->setPos(position + QPoint(xOffset, 0));
     QCOMPARE(pointerPositionChangedSpy.count(), 1);
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), position);
     // moving one to bottom should not be possible
     QFETCH(int, yOffset);
     KWin::Cursors::self()->mouse()->setPos(position + QPoint(0, yOffset));
     QCOMPARE(pointerPositionChangedSpy.count(), 1);
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), position);
 
     // modifier + click should be ignored
     // first ensure the settings are ok
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", QStringLiteral("Alt"));
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(!c->isMove());
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
 
     // set the opacity to 0.5
     c->setOpacity(0.5);
     QCOMPARE(c->opacity(), 0.5);
 
     // pointer is confined so shortcut should not work
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(c->opacity(), 0.5);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(c->opacity(), 0.5);
 
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 
     // deactivate the client, this should unconfine
     workspace()->activateClient(nullptr);
     QVERIFY(unconfinedSpy.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
 
     // reconfine pointer (this time with persistent life time)
     confinedPointer.reset(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
     QSignalSpy confinedSpy2(confinedPointer.data(), &ConfinedPointer::confined);
     QVERIFY(confinedSpy2.isValid());
     QSignalSpy unconfinedSpy2(confinedPointer.data(), &ConfinedPointer::unconfined);
     QVERIFY(unconfinedSpy2.isValid());
 
     // activate it again, this confines again
     workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
     QVERIFY(confinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // deactivate the client one more time with the persistent life time constraint, this should unconfine
     workspace()->activateClient(nullptr);
     QVERIFY(unconfinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
     // activate it again, this confines again
     workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
     QVERIFY(confinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // create a second window and move it above our constrained window
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellSurface(type, surface2.data()));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(c2);
     QVERIFY(unconfinedSpy2.wait());
     // and unmapping the second window should confine again
     shellSurface2.reset();
     surface2.reset();
     QVERIFY(confinedSpy2.wait());
 
     // let's set a region which results in unconfined
     auto r = Test::waylandCompositor()->createRegion(QRegion(2, 2, 3, 3));
     confinedPointer->setRegion(r.get());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(unconfinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
     // and set a full region again, that should confine
     confinedPointer->setRegion(nullptr);
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(confinedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // delete pointer confine
     confinedPointer.reset(nullptr);
     Test::flushWaylandConnection();
 
-    QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged);
+    QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWaylandServer::SurfaceInterface::pointerConstraintsChanged);
     QVERIFY(constraintsChangedSpy.isValid());
     QVERIFY(constraintsChangedSpy.wait());
 
     // should be unconfined
     QCOMPARE(input()->pointer()->isConstrained(), false);
 
     // confine again
     confinedPointer.reset(Test::waylandPointerConstraints()->confinePointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
     QSignalSpy confinedSpy3(confinedPointer.data(), &ConfinedPointer::confined);
     QVERIFY(confinedSpy3.isValid());
     QVERIFY(confinedSpy3.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // and now unmap
     shellSurface.reset();
     surface.reset();
     QVERIFY(Test::waitForWindowDestroyed(c));
     QCOMPARE(input()->pointer()->isConstrained(), false);
 }
 
 void TestPointerConstraints::testLockedPointer_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestPointerConstraints::testLockedPointer()
 {
     // this test sets up a Surface with a locked pointer
     // simple interaction test to verify that the pointer gets locked
     // the various ways to unlock are not tested as that's already verified by testConfinedPointer
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<LockedPointer> lockedPointer(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
     QSignalSpy lockedSpy(lockedPointer.data(), &LockedPointer::locked);
     QVERIFY(lockedSpy.isValid());
     QSignalSpy unlockedSpy(lockedPointer.data(), &LockedPointer::unlocked);
     QVERIFY(unlockedSpy.isValid());
 
     // now map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c);
     QVERIFY(!c->frameGeometry().contains(KWin::Cursors::self()->mouse()->pos()));
 
     // now let's lock
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center());
     QCOMPARE(input()->pointer()->isConstrained(), true);
     QVERIFY(lockedSpy.wait());
 
     // try to move the pointer
     // TODO: add relative pointer
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center() + QPoint(1, 1));
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center());
 
     // deactivate the client, this should unlock
     workspace()->activateClient(nullptr);
     QCOMPARE(input()->pointer()->isConstrained(), false);
     QVERIFY(unlockedSpy.wait());
 
     // moving cursor should be allowed again
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center() + QPoint(1, 1));
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center() + QPoint(1, 1));
 
     lockedPointer.reset(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::Persistent));
     QSignalSpy lockedSpy2(lockedPointer.data(), &LockedPointer::locked);
     QVERIFY(lockedSpy2.isValid());
 
     // activate the client again, this should lock again
     workspace()->activateClient(static_cast<AbstractClient*>(input()->pointer()->focus().data()));
     QVERIFY(lockedSpy2.wait());
     QCOMPARE(input()->pointer()->isConstrained(), true);
 
     // try to move the pointer
     QCOMPARE(input()->pointer()->isConstrained(), true);
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center() + QPoint(1, 1));
 
     // delete pointer lock
     lockedPointer.reset(nullptr);
     Test::flushWaylandConnection();
 
-    QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged);
+    QSignalSpy constraintsChangedSpy(input()->pointer()->focus()->surface(), &KWaylandServer::SurfaceInterface::pointerConstraintsChanged);
     QVERIFY(constraintsChangedSpy.isValid());
     QVERIFY(constraintsChangedSpy.wait());
 
     // moving cursor should be allowed again
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center());
 }
 
 void TestPointerConstraints::testCloseWindowWithLockedPointer_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("XdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestPointerConstraints::testCloseWindowWithLockedPointer()
 {
     // test case which verifies that the pointer gets unlocked when the window for it gets closed
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<Pointer> pointer(Test::waylandSeat()->createPointer());
     QScopedPointer<LockedPointer> lockedPointer(Test::waylandPointerConstraints()->lockPointer(surface.data(), pointer.data(), nullptr, PointerConstraints::LifeTime::OneShot));
     QSignalSpy lockedSpy(lockedPointer.data(), &LockedPointer::locked);
     QVERIFY(lockedSpy.isValid());
     QSignalSpy unlockedSpy(lockedPointer.data(), &LockedPointer::unlocked);
     QVERIFY(unlockedSpy.isValid());
 
     // now map the window
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 100), Qt::blue);
     QVERIFY(c);
     QVERIFY(!c->frameGeometry().contains(KWin::Cursors::self()->mouse()->pos()));
 
     // now let's lock
     QCOMPARE(input()->pointer()->isConstrained(), false);
     KWin::Cursors::self()->mouse()->setPos(c->frameGeometry().center());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), c->frameGeometry().center());
     QCOMPARE(input()->pointer()->isConstrained(), true);
     QVERIFY(lockedSpy.wait());
 
     // close the window
     shellSurface.reset();
     surface.reset();
     // this should result in unlocked
     QVERIFY(unlockedSpy.wait());
     QCOMPARE(input()->pointer()->isConstrained(), false);
 }
 
 WAYLANDTEST_MAIN(TestPointerConstraints)
 #include "pointer_constraints_test.moc"
diff --git a/autotests/integration/pointer_input.cpp b/autotests/integration/pointer_input.cpp
index e81715404..db38d8c42 100644
--- a/autotests/integration/pointer_input.cpp
+++ b/autotests/integration/pointer_input.cpp
@@ -1,1632 +1,1632 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "effects.h"
 #include "pointer_input.h"
 #include "options.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_cursor_theme.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/buffer.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/clientconnection.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/clientconnection.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <wayland-cursor.h>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 template <typename T>
 PlatformCursorImage loadReferenceThemeCursor(const T &shape)
 {
     if (!waylandServer()->internalShmPool()) {
         return PlatformCursorImage();
     }
 
     QScopedPointer<WaylandCursorTheme> cursorTheme;
     cursorTheme.reset(new WaylandCursorTheme(waylandServer()->internalShmPool()));
 
     wl_cursor_image *cursor = cursorTheme->get(shape);
     if (!cursor) {
         return PlatformCursorImage();
     }
 
     wl_buffer *b = wl_cursor_image_get_buffer(cursor);
     if (!b) {
         return PlatformCursorImage();
     }
 
     waylandServer()->internalClientConection()->flush();
     waylandServer()->dispatch();
 
-    auto buffer = KWayland::Server::BufferInterface::get(
+    auto buffer = KWaylandServer::BufferInterface::get(
         waylandServer()->internalConnection()->getResource(
             KWayland::Client::Buffer::getId(b)));
     if (!buffer) {
         return PlatformCursorImage{};
     }
 
     const qreal scale = screens()->maxScale();
     QImage image = buffer->data().copy();
     image.setDevicePixelRatio(scale);
 
     const QPoint hotSpot(
         qRound(cursor->hotspot_x / scale),
         qRound(cursor->hotspot_y / scale)
     );
 
     return PlatformCursorImage(image, hotSpot);
 }
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_pointer_input-0");
 
 class PointerInputTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testWarpingUpdatesFocus();
     void testWarpingGeneratesPointerMotion();
     void testWarpingDuringFilter();
     void testUpdateFocusAfterScreenChange();
     void testModifierClickUnrestrictedMove_data();
     void testModifierClickUnrestrictedMove();
     void testModifierClickUnrestrictedMoveGlobalShortcutsDisabled();
     void testModifierScrollOpacity_data();
     void testModifierScrollOpacity();
     void testModifierScrollOpacityGlobalShortcutsDisabled();
     void testScrollAction();
     void testFocusFollowsMouse();
     void testMouseActionInactiveWindow_data();
     void testMouseActionInactiveWindow();
     void testMouseActionActiveWindow_data();
     void testMouseActionActiveWindow();
     void testCursorImage();
     void testEffectOverrideCursorImage();
     void testPopup();
     void testDecoCancelsPopup();
     void testWindowUnderCursorWhileButtonPressed();
     void testConfineToScreenGeometry_data();
     void testConfineToScreenGeometry();
     void testResizeCursor_data();
     void testResizeCursor();
     void testMoveCursor();
     void testHideShowCursor();
 
 private:
     void render(KWayland::Client::Surface *surface, const QSize &size = QSize(100, 50));
     KWayland::Client::Compositor *m_compositor = nullptr;
     KWayland::Client::Seat *m_seat = nullptr;
 };
 
 void PointerInputTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("XKB_DEFAULT_RULES", "evdev");
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void PointerInputTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat | Test::AdditionalWaylandInterface::Decoration));
     QVERIFY(Test::waitForWaylandPointer());
     m_compositor = Test::waylandCompositor();
     m_seat = Test::waylandSeat();
 
     screens()->setCurrent(0);
     Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void PointerInputTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void PointerInputTest::render(KWayland::Client::Surface *surface, const QSize &size)
 {
     Test::render(surface, size, Qt::blue);
     Test::flushWaylandConnection();
 }
 
 void PointerInputTest::testWarpingUpdatesFocus()
 {
     // this test verifies that warping the pointer creates pointer enter and leave events
     using namespace KWayland::Client;
     // create pointer and signal spy for enter and leave signals
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // currently there should not be a focused pointer surface
     QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
     QVERIFY(!pointer->enteredSurface());
 
     // enter
     Cursors::self()->mouse()->setPos(QPoint(25, 25));
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 1);
     QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
     // window should have focus
     QCOMPARE(pointer->enteredSurface(), surface);
     // also on the server
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), window->surface());
 
     // and out again
     Cursors::self()->mouse()->setPos(QPoint(250, 250));;
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     // there should not be a focused pointer surface anymore
     QVERIFY(!waylandServer()->seat()->focusedPointerSurface());
     QVERIFY(!pointer->enteredSurface());
 }
 
 void PointerInputTest::testWarpingGeneratesPointerMotion()
 {
     // this test verifies that warping the pointer creates pointer motion events
     using namespace KWayland::Client;
     // create pointer and signal spy for enter and motion
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy movedSpy(pointer, &Pointer::motion);
     QVERIFY(movedSpy.isValid());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // enter
     kwinApp()->platform()->pointerMotion(QPointF(25, 25), 1);
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.first().at(1).toPointF(), QPointF(25, 25));
 
     // now warp
     Cursors::self()->mouse()->setPos(QPoint(26, 26));
     QVERIFY(movedSpy.wait());
     QCOMPARE(movedSpy.count(), 1);
     QCOMPARE(movedSpy.last().first().toPointF(), QPointF(26, 26));
 }
 
 void PointerInputTest::testWarpingDuringFilter()
 {
     // this test verifies that pointer motion is handled correctly if
     // the pointer gets warped during processing of input events
     using namespace KWayland::Client;
 
     // create pointer
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy movedSpy(pointer, &Pointer::motion);
     QVERIFY(movedSpy.isValid());
 
     // warp cursor into expected geometry
     Cursors::self()->mouse()->setPos(10, 10);
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     QCOMPARE(window->pos(), QPoint(0, 0));
     QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
 
     // is PresentWindows effect for top left screen edge loaded
     QVERIFY(static_cast<EffectsHandlerImpl*>(effects)->isEffectLoaded("presentwindows"));
     QVERIFY(movedSpy.isEmpty());
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerMotion(QPoint(0, 0), timestamp++);
     // screen edges push back
     QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(1, 1));
     QVERIFY(movedSpy.wait());
     QCOMPARE(movedSpy.count(), 2);
     QCOMPARE(movedSpy.at(0).first().toPoint(), QPoint(0, 0));
     QCOMPARE(movedSpy.at(1).first().toPoint(), QPoint(1, 1));
 }
 
 void PointerInputTest::testUpdateFocusAfterScreenChange()
 {
     // this test verifies that a pointer enter event is generated when the cursor changes to another
     // screen due to removal of screen
     using namespace KWayland::Client;
     // ensure cursor is on second screen
     Cursors::self()->mouse()->setPos(1500, 300);
 
     // create pointer and signal spy for enter and motion
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface, QSize(1280, 1024));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     QVERIFY(!window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
 
     QSignalSpy screensChangedSpy(screens(), &Screens::changed);
     QVERIFY(screensChangedSpy.isValid());
     // now let's remove the screen containing the cursor
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, 1),
                               Q_ARG(QVector<QRect>, QVector<QRect>{QRect(0, 0, 1280, 1024)}));
     QVERIFY(screensChangedSpy.wait());
     QCOMPARE(screens()->count(), 1);
 
     // this should have warped the cursor
     QCOMPARE(Cursors::self()->mouse()->pos(), QPoint(639, 511));
     QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
 
     // and we should get an enter event
     QTRY_COMPARE(enteredSpy.count(), 1);
 }
 
 void PointerInputTest::testModifierClickUnrestrictedMove_data()
 {
     QTest::addColumn<int>("modifierKey");
     QTest::addColumn<int>("mouseButton");
     QTest::addColumn<QString>("modKey");
     QTest::addColumn<bool>("capsLock");
 
     const QString alt = QStringLiteral("Alt");
     const QString meta = QStringLiteral("Meta");
 
     QTest::newRow("Left Alt + Left Click")    << KEY_LEFTALT  << BTN_LEFT   << alt << false;
     QTest::newRow("Left Alt + Right Click")   << KEY_LEFTALT  << BTN_RIGHT  << alt << false;
     QTest::newRow("Left Alt + Middle Click")  << KEY_LEFTALT  << BTN_MIDDLE << alt << false;
     QTest::newRow("Right Alt + Left Click")   << KEY_RIGHTALT << BTN_LEFT   << alt << false;
     QTest::newRow("Right Alt + Right Click")  << KEY_RIGHTALT << BTN_RIGHT  << alt << false;
     QTest::newRow("Right Alt + Middle Click") << KEY_RIGHTALT << BTN_MIDDLE << alt << false;
     // now everything with meta
     QTest::newRow("Left Meta + Left Click")    << KEY_LEFTMETA  << BTN_LEFT   << meta << false;
     QTest::newRow("Left Meta + Right Click")   << KEY_LEFTMETA  << BTN_RIGHT  << meta << false;
     QTest::newRow("Left Meta + Middle Click")  << KEY_LEFTMETA  << BTN_MIDDLE << meta << false;
     QTest::newRow("Right Meta + Left Click")   << KEY_RIGHTMETA << BTN_LEFT   << meta << false;
     QTest::newRow("Right Meta + Right Click")  << KEY_RIGHTMETA << BTN_RIGHT  << meta << false;
     QTest::newRow("Right Meta + Middle Click") << KEY_RIGHTMETA << BTN_MIDDLE << meta << false;
 
     // and with capslock
     QTest::newRow("Left Alt + Left Click/CapsLock")    << KEY_LEFTALT  << BTN_LEFT   << alt << true;
     QTest::newRow("Left Alt + Right Click/CapsLock")   << KEY_LEFTALT  << BTN_RIGHT  << alt << true;
     QTest::newRow("Left Alt + Middle Click/CapsLock")  << KEY_LEFTALT  << BTN_MIDDLE << alt << true;
     QTest::newRow("Right Alt + Left Click/CapsLock")   << KEY_RIGHTALT << BTN_LEFT   << alt << true;
     QTest::newRow("Right Alt + Right Click/CapsLock")  << KEY_RIGHTALT << BTN_RIGHT  << alt << true;
     QTest::newRow("Right Alt + Middle Click/CapsLock") << KEY_RIGHTALT << BTN_MIDDLE << alt << true;
     // now everything with meta
     QTest::newRow("Left Meta + Left Click/CapsLock")    << KEY_LEFTMETA  << BTN_LEFT   << meta << true;
     QTest::newRow("Left Meta + Right Click/CapsLock")   << KEY_LEFTMETA  << BTN_RIGHT  << meta << true;
     QTest::newRow("Left Meta + Middle Click/CapsLock")  << KEY_LEFTMETA  << BTN_MIDDLE << meta << true;
     QTest::newRow("Right Meta + Left Click/CapsLock")   << KEY_RIGHTMETA << BTN_LEFT   << meta << true;
     QTest::newRow("Right Meta + Right Click/CapsLock")  << KEY_RIGHTMETA << BTN_RIGHT  << meta << true;
     QTest::newRow("Right Meta + Middle Click/CapsLock") << KEY_RIGHTMETA << BTN_MIDDLE << meta << true;
 }
 
 void PointerInputTest::testModifierClickUnrestrictedMove()
 {
     // this test ensures that Alt+mouse button press triggers unrestricted move
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     // first modify the config for this run
     QFETCH(QString, modKey);
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", modKey);
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), modKey == QStringLiteral("Alt") ? Qt::AltModifier : Qt::MetaModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // move cursor on window
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
 
     // simulate modifier+click
     quint32 timestamp = 1;
     QFETCH(bool, capsLock);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     }
     QFETCH(int, modifierKey);
     QFETCH(int, mouseButton);
     kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
     QVERIFY(!window->isMove());
     kwinApp()->platform()->pointerButtonPressed(mouseButton, timestamp++);
     QVERIFY(window->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
     QVERIFY(window->isMove());
     // but releasing the key should end move/resize
     kwinApp()->platform()->pointerButtonReleased(mouseButton, timestamp++);
     QVERIFY(!window->isMove());
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     }
 
     // all of that should not have triggered button events on the surface
     QCOMPARE(buttonSpy.count(), 0);
     // also waiting shouldn't give us the event
     QVERIFY(!buttonSpy.wait(100));
 }
 
 void PointerInputTest::testModifierClickUnrestrictedMoveGlobalShortcutsDisabled()
 {
     // this test ensures that Alt+mouse button press triggers unrestricted move
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll1", "Move");
     group.writeEntry("CommandAll2", "Move");
     group.writeEntry("CommandAll3", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll2(), Options::MouseUnrestrictedMove);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedMove);
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // disable global shortcuts
     QVERIFY(!workspace()->globalShortcutsDisabled());
     workspace()->disableGlobalShortcutsForClient(true);
     QVERIFY(workspace()->globalShortcutsDisabled());
 
     // move cursor on window
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
 
     // simulate modifier+click
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     QVERIFY(!window->isMove());
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(!window->isMove());
     // release modifier should not change it
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     QVERIFY(!window->isMove());
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
 
     workspace()->disableGlobalShortcutsForClient(false);
 }
 
 void PointerInputTest::testModifierScrollOpacity_data()
 {
     QTest::addColumn<int>("modifierKey");
     QTest::addColumn<QString>("modKey");
     QTest::addColumn<bool>("capsLock");
 
     const QString alt = QStringLiteral("Alt");
     const QString meta = QStringLiteral("Meta");
 
     QTest::newRow("Left Alt")   << KEY_LEFTALT  << alt << false;
     QTest::newRow("Right Alt")  << KEY_RIGHTALT << alt << false;
     QTest::newRow("Left Meta")  << KEY_LEFTMETA  << meta << false;
     QTest::newRow("Right Meta") << KEY_RIGHTMETA << meta << false;
     QTest::newRow("Left Alt/CapsLock")   << KEY_LEFTALT  << alt << true;
     QTest::newRow("Right Alt/CapsLock")  << KEY_RIGHTALT << alt << true;
     QTest::newRow("Left Meta/CapsLock")  << KEY_LEFTMETA  << meta << true;
     QTest::newRow("Right Meta/CapsLock") << KEY_RIGHTMETA << meta << true;
 }
 
 void PointerInputTest::testModifierScrollOpacity()
 {
     // this test verifies that mod+wheel performs a window operation and does not
     // pass the wheel to the window
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
     QVERIFY(axisSpy.isValid());
 
     // first modify the config for this run
     QFETCH(QString, modKey);
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", modKey);
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     // set the opacity to 0.5
     window->setOpacity(0.5);
     QCOMPARE(window->opacity(), 0.5);
 
     // move cursor on window
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
 
     // simulate modifier+wheel
     quint32 timestamp = 1;
     QFETCH(bool, capsLock);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyPressed(KEY_CAPSLOCK, timestamp++);
     }
     QFETCH(int, modifierKey);
     kwinApp()->platform()->keyboardKeyPressed(modifierKey, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(window->opacity(), 0.6);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(window->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(modifierKey, timestamp++);
     if (capsLock) {
         kwinApp()->platform()->keyboardKeyReleased(KEY_CAPSLOCK, timestamp++);
     }
 
     // axis should have been filtered out
     QCOMPARE(axisSpy.count(), 0);
     QVERIFY(!axisSpy.wait(100));
 }
 
 void PointerInputTest::testModifierScrollOpacityGlobalShortcutsDisabled()
 {
     // this test verifies that mod+wheel performs a window operation and does not
     // pass the wheel to the window
     using namespace KWayland::Client;
     // create pointer and signal spy for button events
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
     QVERIFY(axisSpy.isValid());
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAllWheel", "change opacity");
     group.sync();
     workspace()->slotReconfigure();
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     // set the opacity to 0.5
     window->setOpacity(0.5);
     QCOMPARE(window->opacity(), 0.5);
 
     // move cursor on window
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
 
     // disable global shortcuts
     QVERIFY(!workspace()->globalShortcutsDisabled());
     workspace()->disableGlobalShortcutsForClient(true);
     QVERIFY(workspace()->globalShortcutsDisabled());
 
     // simulate modifier+wheel
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerAxisVertical(-5, timestamp++);
     QCOMPARE(window->opacity(), 0.5);
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QCOMPARE(window->opacity(), 0.5);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
 
     workspace()->disableGlobalShortcutsForClient(false);
 }
 
 void  PointerInputTest::testScrollAction()
 {
     // this test verifies that scroll on inactive window performs a mouse action
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy axisSpy(pointer, &Pointer::axisChanged);
     QVERIFY(axisSpy.isValid());
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandWindowWheel", "activate and scroll");
     group.sync();
     workspace()->slotReconfigure();
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
 
     // move cursor to the inactive window
     Cursors::self()->mouse()->setPos(window1->frameGeometry().center());
 
     quint32 timestamp = 1;
     QVERIFY(!window1->isActive());
     kwinApp()->platform()->pointerAxisVertical(5, timestamp++);
     QVERIFY(window1->isActive());
 
     // but also the wheel event should be passed to the window
     QVERIFY(axisSpy.wait());
 
     // we need to wait a little bit, otherwise the test crashes in effectshandler, needs fixing
     QTest::qWait(100);
 }
 
 void PointerInputTest::testFocusFollowsMouse()
 {
     using namespace KWayland::Client;
     // need to create a pointer, otherwise it doesn't accept focus
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     // move cursor out of the way of first window to be created
     Cursors::self()->mouse()->setPos(900, 900);
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("AutoRaise", true);
     group.writeEntry("AutoRaiseInterval", 20);
     group.writeEntry("DelayFocusInterval", 200);
     group.writeEntry("FocusPolicy", "FocusFollowsMouse");
     group.sync();
     workspace()->slotReconfigure();
     // verify the settings
     QCOMPARE(options->focusPolicy(), Options::FocusFollowsMouse);
     QVERIFY(options->isAutoRaise());
     QCOMPARE(options->autoRaiseInterval(), 20);
     QCOMPARE(options->delayFocusInterval(), 200);
 
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     // geometry of the two windows should be overlapping
     QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
 
     // signal spies for active window changed and stacking order changed
     QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
     QVERIFY(activeWindowChangedSpy.isValid());
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
 
     QVERIFY(!window1->isActive());
     QVERIFY(window2->isActive());
 
     // move on top of first window
     QVERIFY(window1->frameGeometry().contains(10, 10));
     QVERIFY(!window2->frameGeometry().contains(10, 10));
     Cursors::self()->mouse()->setPos(10, 10);
     QVERIFY(stackingOrderChangedSpy.wait());
     QCOMPARE(stackingOrderChangedSpy.count(), 1);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     QTRY_VERIFY(window1->isActive());
 
     // move on second window, but move away before active window change delay hits
     Cursors::self()->mouse()->setPos(810, 810);
     QVERIFY(stackingOrderChangedSpy.wait());
     QCOMPARE(stackingOrderChangedSpy.count(), 2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     Cursors::self()->mouse()->setPos(10, 10);
     QVERIFY(!activeWindowChangedSpy.wait(250));
     QVERIFY(window1->isActive());
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     // as we moved back on window 1 that should been raised in the mean time
     QCOMPARE(stackingOrderChangedSpy.count(), 3);
 
     // quickly move on window 2 and back on window 1 should not raise window 2
     Cursors::self()->mouse()->setPos(810, 810);
     Cursors::self()->mouse()->setPos(10, 10);
     QVERIFY(!stackingOrderChangedSpy.wait(250));
 }
 
 void PointerInputTest::testMouseActionInactiveWindow_data()
 {
     QTest::addColumn<quint32>("button");
 
     QTest::newRow("Left")   << quint32(BTN_LEFT);
     QTest::newRow("Middle") << quint32(BTN_MIDDLE);
     QTest::newRow("Right")  << quint32(BTN_RIGHT);
 }
 
 void PointerInputTest::testMouseActionInactiveWindow()
 {
     // this test performs the mouse button window action on an inactive window
     // it should activate the window and raise it
     using namespace KWayland::Client;
 
     // first modify the config for this run - disable FocusFollowsMouse
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("FocusPolicy", "ClickToFocus");
     group.sync();
     group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandWindow1", "Activate, raise and pass click");
     group.writeEntry("CommandWindow2", "Activate, raise and pass click");
     group.writeEntry("CommandWindow3", "Activate, raise and pass click");
     group.sync();
     workspace()->slotReconfigure();
 
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     // geometry of the two windows should be overlapping
     QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
 
     // signal spies for active window changed and stacking order changed
     QSignalSpy activeWindowChangedSpy(workspace(), &Workspace::clientActivated);
     QVERIFY(activeWindowChangedSpy.isValid());
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
 
     QVERIFY(!window1->isActive());
     QVERIFY(window2->isActive());
 
     // move on top of first window
     QVERIFY(window1->frameGeometry().contains(10, 10));
     QVERIFY(!window2->frameGeometry().contains(10, 10));
     Cursors::self()->mouse()->setPos(10, 10);
     // no focus follows mouse
     QVERIFY(!stackingOrderChangedSpy.wait(200));
     QVERIFY(stackingOrderChangedSpy.isEmpty());
     QVERIFY(activeWindowChangedSpy.isEmpty());
     QVERIFY(window2->isActive());
     // and click
     quint32 timestamp = 1;
     QFETCH(quint32, button);
     kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
     // should raise window1 and activate it
     QCOMPARE(stackingOrderChangedSpy.count(), 1);
     QVERIFY(!activeWindowChangedSpy.isEmpty());
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     QVERIFY(window1->isActive());
     QVERIFY(!window2->isActive());
 
     // release again
     kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
 }
 
 void PointerInputTest::testMouseActionActiveWindow_data()
 {
     QTest::addColumn<bool>("clickRaise");
     QTest::addColumn<quint32>("button");
 
     for (quint32 i=BTN_LEFT; i < BTN_JOYSTICK; i++) {
         QByteArray number = QByteArray::number(i, 16);
         QTest::newRow(QByteArrayLiteral("click raise/").append(number).constData()) << true << i;
         QTest::newRow(QByteArrayLiteral("no click raise/").append(number).constData()) << false << i;
     }
 }
 
 void PointerInputTest::testMouseActionActiveWindow()
 {
     // this test verifies the mouse action performed on an active window
     // for all buttons it should trigger a window raise depending on the
     // click raise option
     using namespace KWayland::Client;
     // create a button spy - all clicks should be passed through
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy buttonSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonSpy.isValid());
 
     // adjust config for this run
     QFETCH(bool, clickRaise);
     KConfigGroup group = kwinApp()->config()->group("Windows");
     group.writeEntry("ClickRaise", clickRaise);
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->isClickRaise(), clickRaise);
 
     // create two windows
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface1 = Test::createSurface(m_compositor);
     QVERIFY(surface1);
     XdgShellSurface *shellSurface1 = Test::createXdgShellStableSurface(surface1, surface1);
     QVERIFY(shellSurface1);
     render(surface1, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window1 = workspace()->activeClient();
     QVERIFY(window1);
     QSignalSpy window1DestroyedSpy(window1, &QObject::destroyed);
     QVERIFY(window1DestroyedSpy.isValid());
     Surface *surface2 = Test::createSurface(m_compositor);
     QVERIFY(surface2);
     XdgShellSurface *shellSurface2 = Test::createXdgShellStableSurface(surface2, surface2);
     QVERIFY(shellSurface2);
     render(surface2, QSize(800, 800));
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window2 = workspace()->activeClient();
     QVERIFY(window2);
     QVERIFY(window1 != window2);
     QSignalSpy window2DestroyedSpy(window2, &QObject::destroyed);
     QVERIFY(window2DestroyedSpy.isValid());
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window2);
     // geometry of the two windows should be overlapping
     QVERIFY(window1->frameGeometry().intersects(window2->frameGeometry()));
     // lower the currently active window
     workspace()->lowerClient(window2);
     QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
 
     // signal spy for stacking order spy
     QSignalSpy stackingOrderChangedSpy(workspace(), &Workspace::stackingOrderChanged);
     QVERIFY(stackingOrderChangedSpy.isValid());
 
     // move on top of second window
     QVERIFY(!window1->frameGeometry().contains(900, 900));
     QVERIFY(window2->frameGeometry().contains(900, 900));
     Cursors::self()->mouse()->setPos(900, 900);
 
     // and click
     quint32 timestamp = 1;
     QFETCH(quint32, button);
     kwinApp()->platform()->pointerButtonPressed(button, timestamp++);
     QVERIFY(buttonSpy.wait());
     if (clickRaise) {
         QCOMPARE(stackingOrderChangedSpy.count(), 1);
         QTRY_COMPARE_WITH_TIMEOUT(workspace()->topClientOnDesktop(1, -1), window2, 200);
     } else {
         QCOMPARE(stackingOrderChangedSpy.count(), 0);
         QVERIFY(!stackingOrderChangedSpy.wait(100));
         QCOMPARE(workspace()->topClientOnDesktop(1, -1), window1);
     }
 
     // release again
     kwinApp()->platform()->pointerButtonReleased(button, timestamp++);
 
     delete surface1;
     QVERIFY(window1DestroyedSpy.wait());
     delete surface2;
     QVERIFY(window2DestroyedSpy.wait());
 }
 
 void PointerInputTest::testCursorImage()
 {
     // this test verifies that the pointer image gets updated correctly from the client provided data
     using namespace KWayland::Client;
     // we need a pointer to get the enter event
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
 
     // move cursor somewhere the new window won't open
     auto cursor = Cursors::self()->mouse();
     cursor->setPos(800, 800);
     auto p = input()->pointer();
     // at the moment it should be the fallback cursor
     const QImage fallbackCursor = cursor->image();
     QVERIFY(!fallbackCursor.isNull());
 
     // create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // move cursor to center of window, this should first set a null pointer, so we still show old cursor
     cursor->setPos(window->frameGeometry().center());
     QCOMPARE(p->focus().data(), window);
     QCOMPARE(cursor->image(), fallbackCursor);
     QVERIFY(enteredSpy.wait());
 
     // create a cursor on the pointer
     Surface *cursorSurface = Test::createSurface(m_compositor);
     QVERIFY(cursorSurface);
     QSignalSpy cursorRenderedSpy(cursorSurface, &Surface::frameRendered);
     QVERIFY(cursorRenderedSpy.isValid());
     QImage red = QImage(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
     red.fill(Qt::red);
     cursorSurface->attachBuffer(Test::waylandShmPool()->createBuffer(red));
     cursorSurface->damage(QRect(0, 0, 10, 10));
     cursorSurface->commit();
     pointer->setCursor(cursorSurface, QPoint(5, 5));
     QVERIFY(cursorRenderedSpy.wait());
     QCOMPARE(cursor->image(), red);
     QCOMPARE(cursor->hotspot(), QPoint(5, 5));
     // change hotspot
     pointer->setCursor(cursorSurface, QPoint(6, 6));
     Test::flushWaylandConnection();
     QTRY_COMPARE(cursor->hotspot(), QPoint(6, 6));
     QCOMPARE(cursor->image(), red);
 
     // change the buffer
     QImage blue = QImage(QSize(10, 10), QImage::Format_ARGB32_Premultiplied);
     blue.fill(Qt::blue);
     auto b = Test::waylandShmPool()->createBuffer(blue);
     cursorSurface->attachBuffer(b);
     cursorSurface->damage(QRect(0, 0, 10, 10));
     cursorSurface->commit();
     QVERIFY(cursorRenderedSpy.wait());
     QTRY_COMPARE(cursor->image(), blue);
     QCOMPARE(cursor->hotspot(), QPoint(6, 6));
 
     // scaled cursor
     QImage blueScaled = QImage(QSize(20, 20), QImage::Format_ARGB32_Premultiplied);
     blueScaled.setDevicePixelRatio(2);
     blueScaled.fill(Qt::blue);
     auto bs = Test::waylandShmPool()->createBuffer(blueScaled);
     cursorSurface->attachBuffer(bs);
     cursorSurface->setScale(2);
     cursorSurface->damage(QRect(0, 0, 20, 20));
     cursorSurface->commit();
     QVERIFY(cursorRenderedSpy.wait());
     QTRY_COMPARE(cursor->image(), blueScaled);
     QCOMPARE(cursor->hotspot(), QPoint(6, 6)); //surface-local (so not changed)
 
     // hide the cursor
     pointer->setCursor(nullptr);
     Test::flushWaylandConnection();
     QTRY_VERIFY(cursor->image().isNull());
 
     // move cursor somewhere else, should reset to fallback cursor
     Cursors::self()->mouse()->setPos(window->frameGeometry().bottomLeft() + QPoint(20, 20));
     QVERIFY(p->focus().isNull());
     QVERIFY(!cursor->image().isNull());
     QCOMPARE(cursor->image(), fallbackCursor);
 }
 
 class HelperEffect : public Effect
 {
     Q_OBJECT
 public:
     HelperEffect() {}
     ~HelperEffect() override {}
 };
 
 void PointerInputTest::testEffectOverrideCursorImage()
 {
     // this test verifies the effect cursor override handling
     using namespace KWayland::Client;
     // we need a pointer to get the enter event and set a cursor
     auto pointer = m_seat->createPointer(m_seat);
     auto cursor = Cursors::self()->mouse();
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
     // move cursor somewhere the new window won't open
     cursor->setPos(800, 800);
     // here we should have the fallback cursor
     const QImage fallback = cursor->image();
     QVERIFY(!fallback.isNull());
 
     // now let's create a window
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // and move cursor to the window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     cursor->setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // cursor image should still be fallback
     QCOMPARE(cursor->image(), fallback);
 
     // now create an effect and set an override cursor
     QScopedPointer<HelperEffect> effect(new HelperEffect);
     effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
     const QImage sizeAll = cursor->image();
     QVERIFY(!sizeAll.isNull());
     QVERIFY(sizeAll != fallback);
     QVERIFY(leftSpy.wait());
 
     // let's change to arrow cursor, this should be our fallback
     effects->defineCursor(Qt::ArrowCursor);
     QCOMPARE(cursor->image(), fallback);
 
     // back to size all
     effects->defineCursor(Qt::SizeAllCursor);
     QCOMPARE(cursor->image(), sizeAll);
 
     // move cursor outside the window area
     Cursors::self()->mouse()->setPos(800, 800);
     // and end the override, which should switch to fallback
     effects->stopMouseInterception(effect.data());
     QCOMPARE(cursor->image(), fallback);
 
     // start mouse interception again
     effects->startMouseInterception(effect.data(), Qt::SizeAllCursor);
     QCOMPARE(cursor->image(), sizeAll);
 
     // move cursor to area of window
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
     // this should not result in an enter event
     QVERIFY(!enteredSpy.wait(100));
 
     // after ending the interception we should get an enter event
     effects->stopMouseInterception(effect.data());
     QVERIFY(enteredSpy.wait());
     QVERIFY(cursor->image().isNull());
 }
 
 void PointerInputTest::testPopup()
 {
     // this test validates the basic popup behavior
     // a button press outside the window should dismiss the popup
 
     // first create a parent surface
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
     QSignalSpy buttonStateChangedSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonStateChangedSpy.isValid());
     QSignalSpy motionSpy(pointer, &Pointer::motion);
     QVERIFY(motionSpy.isValid());
 
     Cursors::self()->mouse()->setPos(800, 800);
 
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     QCOMPARE(window->hasPopupGrab(), false);
     // move pointer into window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // click inside window to create serial
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(buttonStateChangedSpy.wait());
 
     // now create the popup surface
     XdgPositioner positioner(QSize(100, 50), QRect(0, 0, 80, 20));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     Surface *popupSurface = Test::createSurface(m_compositor);
     QVERIFY(popupSurface);
     XdgShellPopup *popupShellSurface = Test::createXdgShellStablePopup(popupSurface, shellSurface, positioner);
     QVERIFY(popupShellSurface);
     QSignalSpy popupDoneSpy(popupShellSurface, &XdgShellPopup::popupDone);
     QVERIFY(popupDoneSpy.isValid());
     popupShellSurface->requestGrab(Test::waylandSeat(), 0); // FIXME: Serial.
     render(popupSurface, positioner.initialSize());
     QVERIFY(clientAddedSpy.wait());
     auto popupClient = clientAddedSpy.last().first().value<AbstractClient *>();
     QVERIFY(popupClient);
     QVERIFY(popupClient != window);
     QCOMPARE(window, workspace()->activeClient());
     QCOMPARE(popupClient->transientFor(), window);
     QCOMPARE(popupClient->pos(), window->pos() + QPoint(80, 20));
     QCOMPARE(popupClient->hasPopupGrab(), true);
 
     // let's move the pointer into the center of the window
     Cursors::self()->mouse()->setPos(popupClient->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.count(), 2);
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(pointer->enteredSurface(), popupSurface);
 
     // let's move the pointer outside of the popup window
     // this should not really change anything, it gets a leave event
     Cursors::self()->mouse()->setPos(popupClient->frameGeometry().bottomRight() + QPoint(2, 2));
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 2);
     QVERIFY(popupDoneSpy.isEmpty());
     // now click, should trigger popupDone
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(popupDoneSpy.wait());
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
 }
 
 void PointerInputTest::testDecoCancelsPopup()
 {
     // this test verifies that clicking the window decoration of parent window
     // cancels the popup
 
     // first create a parent surface
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
     QSignalSpy buttonStateChangedSpy(pointer, &Pointer::buttonStateChanged);
     QVERIFY(buttonStateChangedSpy.isValid());
     QSignalSpy motionSpy(pointer, &Pointer::motion);
     QVERIFY(motionSpy.isValid());
 
     Cursors::self()->mouse()->setPos(800, 800);
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
 
     auto deco = Test::waylandServerSideDecoration()->create(surface, surface);
     QSignalSpy decoSpy(deco, &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     deco->requestMode(ServerSideDecoration::Mode::Server);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
     QCOMPARE(window->hasPopupGrab(), false);
     QVERIFY(window->isDecorated());
 
     // move pointer into window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // click inside window to create serial
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(buttonStateChangedSpy.wait());
 
     // now create the popup surface
     XdgPositioner positioner(QSize(100, 50), QRect(0, 0, 80, 20));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     Surface *popupSurface = Test::createSurface(m_compositor);
     QVERIFY(popupSurface);
     XdgShellPopup *popupShellSurface = Test::createXdgShellStablePopup(popupSurface, shellSurface, positioner);
     QVERIFY(popupShellSurface);
     QSignalSpy popupDoneSpy(popupShellSurface, &XdgShellPopup::popupDone);
     QVERIFY(popupDoneSpy.isValid());
     popupShellSurface->requestGrab(Test::waylandSeat(), 0); // FIXME: Serial.
     render(popupSurface, positioner.initialSize());
     QVERIFY(clientAddedSpy.wait());
     auto popupClient = clientAddedSpy.last().first().value<AbstractClient *>();
     QVERIFY(popupClient);
     QVERIFY(popupClient != window);
     QCOMPARE(window, workspace()->activeClient());
     QCOMPARE(popupClient->transientFor(), window);
     QCOMPARE(popupClient->pos(), window->pos() + window->clientPos() + QPoint(80, 20));
     QCOMPARE(popupClient->hasPopupGrab(), true);
 
     // let's move the pointer into the center of the deco
     Cursors::self()->mouse()->setPos(window->frameGeometry().center().x(), window->y() + (window->height() - window->clientSize().height()) / 2);
 
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     QVERIFY(popupDoneSpy.wait());
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
 }
 
 void PointerInputTest::testWindowUnderCursorWhileButtonPressed()
 {
     // this test verifies that opening a window underneath the mouse cursor does not
     // trigger a leave event if a button is pressed
     // see BUG: 372876
 
     // first create a parent surface
     using namespace KWayland::Client;
     auto pointer = m_seat->createPointer(m_seat);
     QVERIFY(pointer);
     QVERIFY(pointer->isValid());
     QSignalSpy enteredSpy(pointer, &Pointer::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(pointer, &Pointer::left);
     QVERIFY(leftSpy.isValid());
 
     Cursors::self()->mouse()->setPos(800, 800);
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     Surface *surface = Test::createSurface(m_compositor);
     QVERIFY(surface);
     XdgShellSurface *shellSurface = Test::createXdgShellStableSurface(surface, surface);
     QVERIFY(shellSurface);
     render(surface);
     QVERIFY(clientAddedSpy.wait());
     AbstractClient *window = workspace()->activeClient();
     QVERIFY(window);
 
     // move cursor over window
     QVERIFY(!window->frameGeometry().contains(QPoint(800, 800)));
     Cursors::self()->mouse()->setPos(window->frameGeometry().center());
     QVERIFY(enteredSpy.wait());
     // click inside window
     quint32 timestamp = 0;
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
 
     // now create a second window as transient
     XdgPositioner positioner(QSize(99, 49), QRect(0, 0, 1, 1));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     Surface *popupSurface = Test::createSurface(m_compositor);
     QVERIFY(popupSurface);
     XdgShellPopup *popupShellSurface = Test::createXdgShellStablePopup(popupSurface, shellSurface, positioner);
     QVERIFY(popupShellSurface);
     render(popupSurface, positioner.initialSize());
     QVERIFY(clientAddedSpy.wait());
     auto popupClient = clientAddedSpy.last().first().value<AbstractClient *>();
     QVERIFY(popupClient);
     QVERIFY(popupClient != window);
     QVERIFY(window->frameGeometry().contains(Cursors::self()->mouse()->pos()));
     QVERIFY(popupClient->frameGeometry().contains(Cursors::self()->mouse()->pos()));
     QVERIFY(!leftSpy.wait());
 
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     // now that the button is no longer pressed we should get the leave event
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.count(), 1);
     QCOMPARE(enteredSpy.count(), 2);
 }
 
 void PointerInputTest::testConfineToScreenGeometry_data()
 {
     QTest::addColumn<QPoint>("startPos");
     QTest::addColumn<QPoint>("targetPos");
     QTest::addColumn<QPoint>("expectedPos");
 
     // screen layout:
     //
     // +----------+----------+---------+
     // |   left   |    top   |  right  |
     // +----------+----------+---------+
     //            |  bottom  |
     //            +----------+
     //
 
     QTest::newRow("move top-left - left screen")       << QPoint(640, 512)   << QPoint(-100, -100) << QPoint(0, 0);
     QTest::newRow("move top - left screen")            << QPoint(640, 512)   << QPoint(640, -100)  << QPoint(640, 0);
     QTest::newRow("move top-right - left screen")      << QPoint(640, 512)   << QPoint(1380, -100) << QPoint(1380, 0);
     QTest::newRow("move right - left screen")          << QPoint(640, 512)   << QPoint(1380, 512)  << QPoint(1380, 512);
     QTest::newRow("move bottom-right - left screen")   << QPoint(640, 512)   << QPoint(1380, 1124) << QPoint(1380, 1124);
     QTest::newRow("move bottom - left screen")         << QPoint(640, 512)   << QPoint(640, 1124)  << QPoint(640, 1023);
     QTest::newRow("move bottom-left - left screen")    << QPoint(640, 512)   << QPoint(-100, 1124) << QPoint(0, 1023);
     QTest::newRow("move left - left screen")           << QPoint(640, 512)   << QPoint(-100, 512)  << QPoint(0, 512);
 
     QTest::newRow("move top-left - top screen")        << QPoint(1920, 512)  << QPoint(1180, -100) << QPoint(1180, 0);
     QTest::newRow("move top - top screen")             << QPoint(1920, 512)  << QPoint(1920, -100) << QPoint(1920, 0);
     QTest::newRow("move top-right - top screen")       << QPoint(1920, 512)  << QPoint(2660, -100) << QPoint(2660, 0);
     QTest::newRow("move right - top screen")           << QPoint(1920, 512)  << QPoint(2660, 512)  << QPoint(2660, 512);
     QTest::newRow("move bottom-right - top screen")    << QPoint(1920, 512)  << QPoint(2660, 1124) << QPoint(2559, 1023);
     QTest::newRow("move bottom - top screen")          << QPoint(1920, 512)  << QPoint(1920, 1124) << QPoint(1920, 1124);
     QTest::newRow("move bottom-left - top screen")     << QPoint(1920, 512)  << QPoint(1180, 1124) << QPoint(1280, 1023);
     QTest::newRow("move left - top screen")            << QPoint(1920, 512)  << QPoint(1180, 512)  << QPoint(1180, 512);
 
     QTest::newRow("move top-left - right screen")      << QPoint(3200, 512)  << QPoint(2460, -100) << QPoint(2460, 0);
     QTest::newRow("move top - right screen")           << QPoint(3200, 512)  << QPoint(3200, -100) << QPoint(3200, 0);
     QTest::newRow("move top-right - right screen")     << QPoint(3200, 512)  << QPoint(3940, -100) << QPoint(3839, 0);
     QTest::newRow("move right - right screen")         << QPoint(3200, 512)  << QPoint(3940, 512)  << QPoint(3839, 512);
     QTest::newRow("move bottom-right - right screen")  << QPoint(3200, 512)  << QPoint(3940, 1124) << QPoint(3839, 1023);
     QTest::newRow("move bottom - right screen")        << QPoint(3200, 512)  << QPoint(3200, 1124) << QPoint(3200, 1023);
     QTest::newRow("move bottom-left - right screen")   << QPoint(3200, 512)  << QPoint(2460, 1124) << QPoint(2460, 1124);
     QTest::newRow("move left - right screen")          << QPoint(3200, 512)  << QPoint(2460, 512)  << QPoint(2460, 512);
 
     QTest::newRow("move top-left - bottom screen")     << QPoint(1920, 1536) << QPoint(1180, 924)  << QPoint(1180, 924);
     QTest::newRow("move top - bottom screen")          << QPoint(1920, 1536) << QPoint(1920, 924)  << QPoint(1920, 924);
     QTest::newRow("move top-right - bottom screen")    << QPoint(1920, 1536) << QPoint(2660, 924)  << QPoint(2660, 924);
     QTest::newRow("move right - bottom screen")        << QPoint(1920, 1536) << QPoint(2660, 1536) << QPoint(2559, 1536);
     QTest::newRow("move bottom-right - bottom screen") << QPoint(1920, 1536) << QPoint(2660, 2148) << QPoint(2559, 2047);
     QTest::newRow("move bottom - bottom screen")       << QPoint(1920, 1536) << QPoint(1920, 2148) << QPoint(1920, 2047);
     QTest::newRow("move bottom-left - bottom screen")  << QPoint(1920, 1536) << QPoint(1180, 2148) << QPoint(1280, 2047);
     QTest::newRow("move left - bottom screen")         << QPoint(1920, 1536) << QPoint(1180, 1536) << QPoint(1280, 1536);
 }
 
 void PointerInputTest::testConfineToScreenGeometry()
 {
     // this test verifies that pointer belongs to at least one screen
     // after moving it to off-screen area
 
     // unload the Present Windows effect because it pushes back
     // pointer if it's at (0, 0)
     static_cast<EffectsHandlerImpl*>(effects)->unloadEffect(QStringLiteral("presentwindows"));
 
     // setup screen layout
     const QVector<QRect> geometries {
         QRect(0, 0, 1280, 1024),
         QRect(1280, 0, 1280, 1024),
         QRect(2560, 0, 1280, 1024),
         QRect(1280, 1024, 1280, 1024)
     };
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs",
                               Qt::DirectConnection,
                               Q_ARG(int, geometries.count()),
                               Q_ARG(QVector<QRect>, geometries));
     QCOMPARE(screens()->count(), geometries.count());
     QCOMPARE(screens()->geometry(0), geometries.at(0));
     QCOMPARE(screens()->geometry(1), geometries.at(1));
     QCOMPARE(screens()->geometry(2), geometries.at(2));
     QCOMPARE(screens()->geometry(3), geometries.at(3));
 
     // move pointer to initial position
     QFETCH(QPoint, startPos);
     Cursors::self()->mouse()->setPos(startPos);
     QCOMPARE(Cursors::self()->mouse()->pos(), startPos);
 
     // perform movement
     QFETCH(QPoint, targetPos);
     kwinApp()->platform()->pointerMotion(targetPos, 1);
 
     QFETCH(QPoint, expectedPos);
     QCOMPARE(Cursors::self()->mouse()->pos(), expectedPos);
 }
 
 void PointerInputTest::testResizeCursor_data()
 {
     QTest::addColumn<Qt::Edges>("edges");
     QTest::addColumn<KWin::CursorShape>("cursorShape");
 
     QTest::newRow("top-left")     << Qt::Edges(Qt::TopEdge | Qt::LeftEdge)     << CursorShape(ExtendedCursor::SizeNorthWest);
     QTest::newRow("top")          << Qt::Edges(Qt::TopEdge)                    << CursorShape(ExtendedCursor::SizeNorth);
     QTest::newRow("top-right")    << Qt::Edges(Qt::TopEdge | Qt::RightEdge)    << CursorShape(ExtendedCursor::SizeNorthEast);
     QTest::newRow("right")        << Qt::Edges(Qt::RightEdge)                  << CursorShape(ExtendedCursor::SizeEast);
     QTest::newRow("bottom-right") << Qt::Edges(Qt::BottomEdge | Qt::RightEdge) << CursorShape(ExtendedCursor::SizeSouthEast);
     QTest::newRow("bottom")       << Qt::Edges(Qt::BottomEdge)                 << CursorShape(ExtendedCursor::SizeSouth);
     QTest::newRow("bottom-left")  << Qt::Edges(Qt::BottomEdge | Qt::LeftEdge)  << CursorShape(ExtendedCursor::SizeSouthWest);
     QTest::newRow("left")         << Qt::Edges(Qt::LeftEdge)                   << CursorShape(ExtendedCursor::SizeWest);
 }
 
 void PointerInputTest::testResizeCursor()
 {
     // this test verifies that the cursor has correct shape during resize operation
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll3", "Resize");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll3(), Options::MouseUnrestrictedResize);
 
     // create a test client
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     AbstractClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // move the cursor to the test position
     QPoint cursorPos;
     QFETCH(Qt::Edges, edges);
 
     if (edges & Qt::LeftEdge) {
         cursorPos.setX(c->frameGeometry().left());
     } else if (edges & Qt::RightEdge) {
         cursorPos.setX(c->frameGeometry().right());
     } else {
         cursorPos.setX(c->frameGeometry().center().x());
     }
 
     if (edges & Qt::TopEdge) {
         cursorPos.setY(c->frameGeometry().top());
     } else if (edges & Qt::BottomEdge) {
         cursorPos.setY(c->frameGeometry().bottom());
     } else {
         cursorPos.setY(c->frameGeometry().center().y());
     }
 
     Cursors::self()->mouse()->setPos(cursorPos);
 
     const PlatformCursorImage arrowCursor = loadReferenceThemeCursor(Qt::ArrowCursor);
     QVERIFY(!arrowCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 
     // start resizing the client
     int timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_RIGHT, timestamp++);
     QVERIFY(c->isResize());
 
     QFETCH(KWin::CursorShape, cursorShape);
     const PlatformCursorImage resizeCursor = loadReferenceThemeCursor(cursorShape);
     QVERIFY(!resizeCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), resizeCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), resizeCursor.hotSpot());
 
     // finish resizing the client
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_RIGHT, timestamp++);
     QVERIFY(!c->isResize());
 
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 }
 
 void PointerInputTest::testMoveCursor()
 {
     // this test verifies that the cursor has correct shape during move operation
 
     // first modify the config for this run
     KConfigGroup group = kwinApp()->config()->group("MouseBindings");
     group.writeEntry("CommandAllKey", "Alt");
     group.writeEntry("CommandAll1", "Move");
     group.sync();
     workspace()->slotReconfigure();
     QCOMPARE(options->commandAllModifier(), Qt::AltModifier);
     QCOMPARE(options->commandAll1(), Options::MouseUnrestrictedMove);
 
     // create a test client
     using namespace KWayland::Client;
     QScopedPointer<Surface> surface(Test::createSurface());
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QVERIFY(!shellSurface.isNull());
     AbstractClient *c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // move cursor to the test position
     Cursors::self()->mouse()->setPos(c->frameGeometry().center());
 
     const PlatformCursorImage arrowCursor = loadReferenceThemeCursor(Qt::ArrowCursor);
     QVERIFY(!arrowCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 
     // start moving the client
     int timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonPressed(BTN_LEFT, timestamp++);
     QVERIFY(c->isMove());
 
     const PlatformCursorImage sizeAllCursor = loadReferenceThemeCursor(Qt::SizeAllCursor);
     QVERIFY(!sizeAllCursor.image().isNull());
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), sizeAllCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), sizeAllCursor.hotSpot());
 
     // finish moving the client
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->pointerButtonReleased(BTN_LEFT, timestamp++);
     QVERIFY(!c->isMove());
 
     QCOMPARE(kwinApp()->platform()->cursorImage().image(), arrowCursor.image());
     QCOMPARE(kwinApp()->platform()->cursorImage().hotSpot(), arrowCursor.hotSpot());
 }
 
 void PointerInputTest::testHideShowCursor()
 {
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
     kwinApp()->platform()->hideCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
 
     kwinApp()->platform()->hideCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->hideCursor();
     kwinApp()->platform()->hideCursor();
     kwinApp()->platform()->hideCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
 
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), true);
     kwinApp()->platform()->showCursor();
     QCOMPARE(kwinApp()->platform()->isCursorHidden(), false);
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::PointerInputTest)
 #include "pointer_input.moc"
diff --git a/autotests/integration/scene_opengl_shadow_test.cpp b/autotests/integration/scene_opengl_shadow_test.cpp
index 0e4c920a7..df075a430 100644
--- a/autotests/integration/scene_opengl_shadow_test.cpp
+++ b/autotests/integration/scene_opengl_shadow_test.cpp
@@ -1,863 +1,863 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include <algorithm>
 
 #include <QByteArray>
 #include <QDir>
 #include <QObject>
 #include <QPair>
 #include <QVector>
 
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationShadow>
 
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shadow.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/shadow_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/shadow_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "effect_builtins.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "shadow.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 Q_DECLARE_METATYPE(KWin::WindowQuadList);
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_opengl_shadow-0");
 
 class SceneOpenGLShadowTest : public QObject
 {
     Q_OBJECT
 
 public:
     SceneOpenGLShadowTest() {}
 
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
 
     void testShadowTileOverlaps_data();
     void testShadowTileOverlaps();
     void testNoCornerShadowTiles();
     void testDistributeHugeCornerTiles();
 
 };
 
 inline bool isClose(double a, double b, double eps = 1e-5)
 {
     if (a == b) {
         return true;
     }
     const double diff = std::fabs(a - b);
     if (a == 0 || b == 0) {
         return diff < eps;
     }
     return diff / std::max(a, b) < eps;
 }
 
 inline bool compareQuads(const WindowQuad &a, const WindowQuad &b)
 {
     for (int i = 0; i < 4; i++) {
         if (!isClose(a[i].x(), b[i].x())
                 || !isClose(a[i].y(), b[i].y())
                 || !isClose(a[i].u(), b[i].u())
                 || !isClose(a[i].v(), b[i].v())) {
             return false;
         }
     }
     return true;
 }
 
 inline WindowQuad makeShadowQuad(const QRectF &geo, qreal tx1, qreal ty1, qreal tx2, qreal ty2)
 {
     WindowQuad quad(WindowQuadShadow);
     quad[0] = WindowVertex(geo.left(),  geo.top(),    tx1, ty1);
     quad[1] = WindowVertex(geo.right(), geo.top(),    tx2, ty1);
     quad[2] = WindowVertex(geo.right(), geo.bottom(), tx2, ty2);
     quad[3] = WindowVertex(geo.left(),  geo.bottom(), tx1, ty2);
     return quad;
 }
 
 void SceneOpenGLShadowTest::initTestCase()
 {
     // Copied from generic_scene_opengl_test.cpp
 
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("O2"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
 
     // Add directory with fake decorations to the plugin search path.
     QCoreApplication::addLibraryPath(
         QDir(QCoreApplication::applicationDirPath()).absoluteFilePath("fakes")
     );
 
     // Change decoration theme.
     KConfigGroup group = kwinApp()->config()->group("org.kde.kdecoration2");
     group.writeEntry("library", "org.kde.test.fakedecowithshadows");
     group.sync();
     Workspace::self()->slotReconfigure();
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(scene->compositingType(), KWin::OpenGL2Compositing);
 
 }
 
 void SceneOpenGLShadowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 namespace {
     const int SHADOW_SIZE = 128;
 
     const int SHADOW_OFFSET_TOP  = 64;
     const int SHADOW_OFFSET_LEFT = 48;
 
     // NOTE: We assume deco shadows are generated with blur so that's
     //       why there is 4, 1 is the size of the inner shadow rect.
     const int SHADOW_TEXTURE_WIDTH  = 4 * SHADOW_SIZE + 1;
     const int SHADOW_TEXTURE_HEIGHT = 4 * SHADOW_SIZE + 1;
 
     const int SHADOW_PADDING_TOP    = SHADOW_SIZE - SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_RIGHT  = SHADOW_SIZE + SHADOW_OFFSET_LEFT;
     const int SHADOW_PADDING_BOTTOM = SHADOW_SIZE + SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_LEFT   = SHADOW_SIZE - SHADOW_OFFSET_LEFT;
 
     const QRectF SHADOW_INNER_RECT(2 * SHADOW_SIZE, 2 * SHADOW_SIZE, 1, 1);
 }
 
 void SceneOpenGLShadowTest::testShadowTileOverlaps_data()
 {
     QTest::addColumn<QSize>("windowSize");
     QTest::addColumn<WindowQuadList>("expectedQuads");
 
     // Precompute shadow tile geometries(in texture's space).
     const QRectF topLeftTile(
         0,
         0,
         SHADOW_INNER_RECT.x(),
         SHADOW_INNER_RECT.y());
     const QRectF topRightTile(
         SHADOW_INNER_RECT.right(),
         0,
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.y());
     const QRectF topTile(topLeftTile.topRight(), topRightTile.bottomLeft());
 
     const QRectF bottomLeftTile(
         0,
         SHADOW_INNER_RECT.bottom(),
         SHADOW_INNER_RECT.x(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomRightTile(
         SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.bottom(),
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomTile(bottomLeftTile.topRight(), bottomRightTile.bottomLeft());
 
     const QRectF leftTile(topLeftTile.bottomLeft(), bottomLeftTile.topRight());
     const QRectF rightTile(topRightTile.bottomLeft(), bottomRightTile.topRight());
 
     qreal tx1 = 0;
     qreal ty1 = 0;
     qreal tx2 = 0;
     qreal ty2 = 0;
 
     // Explanation behind numbers: (256+1 x 256+1) is the minimum window size
     // which doesn't cause overlapping of shadow tiles. For example, if a window
     // has (256 x 256+1) size, top-left and top-right or bottom-left and
     // bottom-right shadow tiles overlap.
 
     // No overlaps: In this case corner tiles are rendered as they are,
     // and top/right/bottom/left tiles are stretched.
     {
         const QSize windowSize(256 + 1, 256 + 1);
         WindowQuadList shadowQuads;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         const QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
         tx1 = topLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         const QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
         tx1 = topRightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topRightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topRightTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
         tx1 = bottomLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomLeftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         const QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
         tx1 = bottomRightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomRightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomRightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = leftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = leftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = leftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = rightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = rightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = rightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = rightTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow("no overlaps") << windowSize << shadowQuads;
     }
 
     // Top-Left & Bottom-Left/Top-Right & Bottom-Right overlap:
     // In this case overlapping parts are clipped and left/right
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> verticalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap"),
             QSize(256 + 1, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap :: pre"),
             QSize(256 + 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : verticalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - halfOverlap);
         bottomLeft.setTop(bottomLeft.top() + halfOverlap);
 
         tx1 = topLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeftTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeft.height()     / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottomLeft.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomLeftTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - halfOverlap);
         bottomRight.setTop(bottomRight.top() + halfOverlap);
 
         tx1 = topRightTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topRightTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()  / SHADOW_TEXTURE_WIDTH;
         ty2 = topRight.height()     / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomRightTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottomRight.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomRightTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left()  / SHADOW_TEXTURE_WIDTH;
         ty1 = topTile.top()   / SHADOW_TEXTURE_HEIGHT;
         tx2 = topTile.right() / SHADOW_TEXTURE_WIDTH;
         ty2 = top.height()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottom.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Top-Left & Top-Right/Bottom-Left & Bottom-Right overlap:
     // In this case overlapping parts are clipped and top/bottom
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> horizontalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap"),
             QSize(256, 256 + 1)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap :: pre"),
             QSize(256 - 1, 256 + 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : horizontalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - halfOverlap);
         topRight.setLeft(topRight.left() + halfOverlap);
 
         tx1 = topLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeft.width()      / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (topRight.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = topRightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = topRightTile.bottom()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - halfOverlap);
         bottomRight.setLeft(bottomRight.left() + halfOverlap);
 
         tx1 = bottomLeftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = bottomLeftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomLeft.width()      / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (bottomRight.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = bottomRightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = bottomRightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left()   / SHADOW_TEXTURE_WIDTH;
         ty1 = leftTile.top()    / SHADOW_TEXTURE_HEIGHT;
         tx2 = left.width()      / SHADOW_TEXTURE_WIDTH;
         ty2 = leftTile.bottom() / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = 1.0 - (right.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = rightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = rightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = rightTile.bottom()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // All shadow tiles overlap: In this case all overlapping parts
     // are clippend and top/right/bottom/left tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> allOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap"),
             QSize(256, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap :: pre"),
             QSize(256 - 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : allOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - halfOverlap);
         topRight.setLeft(topRight.left() + halfOverlap);
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - halfOverlap);
         bottomRight.setLeft(bottomRight.left() + halfOverlap);
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - halfOverlap);
         bottomLeft.setTop(bottomLeft.top() + halfOverlap);
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - halfOverlap);
         bottomRight.setTop(bottomRight.top() + halfOverlap);
 
         tx1 = topLeftTile.left() / SHADOW_TEXTURE_WIDTH;
         ty1 = topLeftTile.top()  / SHADOW_TEXTURE_HEIGHT;
         tx2 = topLeft.width()    / SHADOW_TEXTURE_WIDTH;
         ty2 = topLeft.height()   / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (topRight.width() / SHADOW_TEXTURE_WIDTH);
         ty1 = topRightTile.top()      / SHADOW_TEXTURE_HEIGHT;
         tx2 = topRightTile.right()    / SHADOW_TEXTURE_WIDTH;
         ty2 = topRight.height()       / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left()      / SHADOW_TEXTURE_WIDTH;
         ty1 = 1.0 - (bottomLeft.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomLeft.width()         / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomLeftTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = 1.0 - (bottomRight.width()  / SHADOW_TEXTURE_WIDTH);
         ty1 = 1.0 - (bottomRight.height() / SHADOW_TEXTURE_HEIGHT);
         tx2 = bottomRightTile.right()     / SHADOW_TEXTURE_WIDTH;
         ty2 = bottomRightTile.bottom()    / SHADOW_TEXTURE_HEIGHT;
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Window is too small: do not render any shadow tiles.
     {
         const QSize windowSize(1, 1);
         const WindowQuadList shadowQuads;
 
         QTest::newRow("window is too small") << windowSize << shadowQuads;
     }
 }
 
 void SceneOpenGLShadowTest::testShadowTileOverlaps()
 {
     QFETCH(QSize, windowSize);
     QFETCH(WindowQuadList, expectedQuads);
 
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     // Create a decorated client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<ServerSideDecoration> ssd(Test::waylandServerSideDecoration()->create(surface.data()));
 
     auto *client = Test::renderAndWaitForShown(surface.data(), windowSize, Qt::blue);
 
     QSignalSpy sizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangedSpy.isValid());
 
     // Check the client is decorated.
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     auto *decoration = client->decoration();
     QVERIFY(decoration);
 
     // If speciefied decoration theme is not found, KWin loads a default one
     // so we have to check whether a client has right decoration.
     auto decoShadow = decoration->shadow();
     QCOMPARE(decoShadow->shadow().size(), QSize(SHADOW_TEXTURE_WIDTH, SHADOW_TEXTURE_HEIGHT));
     QCOMPARE(decoShadow->paddingTop(),    SHADOW_PADDING_TOP);
     QCOMPARE(decoShadow->paddingRight(),  SHADOW_PADDING_RIGHT);
     QCOMPARE(decoShadow->paddingBottom(), SHADOW_PADDING_BOTTOM);
     QCOMPARE(decoShadow->paddingLeft(),   SHADOW_PADDING_LEFT);
 
     // Get shadow.
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     QVERIFY(client->effectWindow()->sceneWindow()->shadow());
     auto *shadow = client->effectWindow()->sceneWindow()->shadow();
 
     // Validate shadow quads.
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.size(), expectedQuads.size());
 
     QVector<bool> mask(expectedQuads.size(), false);
     for (const auto &q : quads) {
         for (int i = 0; i < expectedQuads.size(); i++) {
             if (!compareQuads(q, expectedQuads[i])) {
                 continue;
             }
             if (!mask[i]) {
                 mask[i] = true;
                 break;
             } else {
                 QFAIL("got a duplicate shadow quad");
             }
         }
     }
 
     for (const auto &v : qAsConst(mask)) {
         if (!v) {
             QFAIL("missed a shadow quad");
         }
     }
 }
 
 void SceneOpenGLShadowTest::testNoCornerShadowTiles()
 {
     // this test verifies that top/right/bottom/left shadow tiles are
     // still drawn even when corner tiles are missing
 
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::ShadowManager));
 
     // Create a surface.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto *client = Test::renderAndWaitForShown(surface.data(), QSize(512, 512), Qt::blue);
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
 
     // Render reference shadow texture with the following params:
     //  - shadow size: 128
     //  - inner rect size: 1
     //  - padding: 128
     QImage referenceShadowTexture(256 + 1, 256 + 1, QImage::Format_ARGB32_Premultiplied);
     referenceShadowTexture.fill(Qt::transparent);
 
     // We don't care about content of the shadow.
 
     // Submit the shadow to KWin.
     QScopedPointer<KWayland::Client::Shadow> clientShadow(Test::waylandShadowManager()->createShadow(surface.data()));
     QVERIFY(clientShadow->isValid());
 
     auto *shmPool = Test::waylandShmPool();
 
     Buffer::Ptr bufferTop = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 0, 1, 128)));
     clientShadow->attachTop(bufferTop);
 
     Buffer::Ptr bufferRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 128, 128, 1)));
     clientShadow->attachRight(bufferRight);
 
     Buffer::Ptr bufferBottom = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 128 + 1, 1, 128)));
     clientShadow->attachBottom(bufferBottom);
 
     Buffer::Ptr bufferLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 128, 128, 1)));
     clientShadow->attachLeft(bufferLeft);
 
     clientShadow->setOffsets(QMarginsF(128, 128, 128, 128));
 
-    QSignalSpy shadowChangedSpy(client->surface(), &KWayland::Server::SurfaceInterface::shadowChanged);
+    QSignalSpy shadowChangedSpy(client->surface(), &KWaylandServer::SurfaceInterface::shadowChanged);
     QVERIFY(shadowChangedSpy.isValid());
     clientShadow->commit();
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(shadowChangedSpy.wait());
 
     // Check that we got right shadow from the client.
-    QPointer<KWayland::Server::ShadowInterface> shadowIface = client->surface()->shadow();
+    QPointer<KWaylandServer::ShadowInterface> shadowIface = client->surface()->shadow();
     QVERIFY(!shadowIface.isNull());
     QCOMPARE(shadowIface->offset().left(),   128.0);
     QCOMPARE(shadowIface->offset().top(),    128.0);
     QCOMPARE(shadowIface->offset().right(),  128.0);
     QCOMPARE(shadowIface->offset().bottom(), 128.0);
 
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     KWin::Shadow *shadow = client->effectWindow()->sceneWindow()->shadow();
     QVERIFY(shadow != nullptr);
 
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.count(), 4);
 
     // Shadow size: 128
     // Padding: QMargins(128, 128, 128, 128)
     // Inner rect: QRect(128, 128, 1, 1)
     // Texture size: QSize(257, 257)
     // Window size: QSize(512, 512)
     WindowQuadList expectedQuads;
     expectedQuads << makeShadowQuad(QRectF(   0, -128, 512, 128), 128.0 / 257.0,           0.0, 129.0 / 257.0, 128.0 / 257.0); // top
     expectedQuads << makeShadowQuad(QRectF( 512,    0, 128, 512), 129.0 / 257.0, 128.0 / 257.0,           1.0, 129.0 / 257.0); // right
     expectedQuads << makeShadowQuad(QRectF(   0,  512, 512, 128), 128.0 / 257.0, 129.0 / 257.0, 129.0 / 257.0, 1.0);           // bottom
     expectedQuads << makeShadowQuad(QRectF(-128,    0, 128, 512),           0.0, 128.0 / 257.0, 128.0 / 257.0, 129.0 / 257.0); // left
 
     for (const WindowQuad &expectedQuad : expectedQuads) {
         auto it = std::find_if(quads.constBegin(), quads.constEnd(),
             [&expectedQuad](const WindowQuad &quad) {
                 return compareQuads(quad, expectedQuad);
             });
         if (it == quads.constEnd()) {
             const QString message = QStringLiteral("Missing shadow quad (left: %1, top: %2, right: %3, bottom: %4)")
                 .arg(expectedQuad.left())
                 .arg(expectedQuad.top())
                 .arg(expectedQuad.right())
                 .arg(expectedQuad.bottom());
             const QByteArray rawMessage = message.toLocal8Bit().data();
             QFAIL(rawMessage.data());
         }
     }
 }
 
 void SceneOpenGLShadowTest::testDistributeHugeCornerTiles()
 {
     // this test verifies that huge corner tiles are distributed correctly
 
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::ShadowManager));
 
     // Create a surface.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto *client = Test::renderAndWaitForShown(surface.data(), QSize(64, 64), Qt::blue);
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
 
     // Submit the shadow to KWin.
     QScopedPointer<KWayland::Client::Shadow> clientShadow(Test::waylandShadowManager()->createShadow(surface.data()));
     QVERIFY(clientShadow->isValid());
 
     QImage referenceTileTexture(512, 512, QImage::Format_ARGB32_Premultiplied);
     referenceTileTexture.fill(Qt::transparent);
 
     auto *shmPool = Test::waylandShmPool();
 
     Buffer::Ptr bufferTopLeft = shmPool->createBuffer(referenceTileTexture);
     clientShadow->attachTopLeft(bufferTopLeft);
 
     Buffer::Ptr bufferTopRight = shmPool->createBuffer(referenceTileTexture);
     clientShadow->attachTopRight(bufferTopRight);
 
     clientShadow->setOffsets(QMarginsF(256, 256, 256, 0));
 
-    QSignalSpy shadowChangedSpy(client->surface(), &KWayland::Server::SurfaceInterface::shadowChanged);
+    QSignalSpy shadowChangedSpy(client->surface(), &KWaylandServer::SurfaceInterface::shadowChanged);
     QVERIFY(shadowChangedSpy.isValid());
     clientShadow->commit();
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(shadowChangedSpy.wait());
 
     // Check that we got right shadow from the client.
-    QPointer<KWayland::Server::ShadowInterface> shadowIface = client->surface()->shadow();
+    QPointer<KWaylandServer::ShadowInterface> shadowIface = client->surface()->shadow();
     QVERIFY(!shadowIface.isNull());
     QCOMPARE(shadowIface->offset().left(),   256.0);
     QCOMPARE(shadowIface->offset().top(),    256.0);
     QCOMPARE(shadowIface->offset().right(),  256.0);
     QCOMPARE(shadowIface->offset().bottom(), 0.0);
 
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     KWin::Shadow *shadow = client->effectWindow()->sceneWindow()->shadow();
     QVERIFY(shadow != nullptr);
 
     WindowQuadList expectedQuads;
 
     // Top-left quad
     expectedQuads << makeShadowQuad(
         QRectF(-256, -256, 256 + 32, 256 + 64),
         0.0, 0.0, (256.0 + 32.0) / 1024.0, (256.0 + 64.0) / 512.0);
 
     // Top-right quad
     expectedQuads << makeShadowQuad(
         QRectF(32, -256, 256 + 32, 256 + 64),
         1.0 - (256.0 + 32.0) / 1024.0, 0.0, 1.0, (256.0 + 64.0) / 512.0);
 
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.count(), expectedQuads.count());
 
     for (const WindowQuad &expectedQuad : expectedQuads) {
         auto it = std::find_if(quads.constBegin(), quads.constEnd(),
             [&expectedQuad](const WindowQuad &quad) {
                 return compareQuads(quad, expectedQuad);
             });
         if (it == quads.constEnd()) {
             const QString message = QStringLiteral("Missing shadow quad (left: %1, top: %2, right: %3, bottom: %4)")
                 .arg(expectedQuad.left())
                 .arg(expectedQuad.top())
                 .arg(expectedQuad.right())
                 .arg(expectedQuad.bottom());
             const QByteArray rawMessage = message.toLocal8Bit().data();
             QFAIL(rawMessage.data());
         }
     }
 }
 
 WAYLANDTEST_MAIN(SceneOpenGLShadowTest)
 #include "scene_opengl_shadow_test.moc"
diff --git a/autotests/integration/scene_qpainter_shadow_test.cpp b/autotests/integration/scene_qpainter_shadow_test.cpp
index b45d7a13d..cba443788 100644
--- a/autotests/integration/scene_qpainter_shadow_test.cpp
+++ b/autotests/integration/scene_qpainter_shadow_test.cpp
@@ -1,780 +1,780 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include <algorithm>
 #include <cmath>
 
 #include <QByteArray>
 #include <QDir>
 #include <QImage>
 #include <QMarginsF>
 #include <QObject>
 #include <QPainter>
 #include <QPair>
 #include <QVector>
 
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationShadow>
 
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shadow.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/shadow_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/shadow_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include "kwin_wayland_test.h"
 
 #include "abstract_client.h"
 #include "composite.h"
 #include "effect_builtins.h"
 #include "effectloader.h"
 #include "effects.h"
 #include "platform.h"
 #include "plugins/scenes/qpainter/scene_qpainter.h"
 #include "shadow.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 Q_DECLARE_METATYPE(KWin::WindowQuadList)
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_qpainter_shadow-0");
 
 class SceneQPainterShadowTest : public QObject
 {
     Q_OBJECT
 
 public:
     SceneQPainterShadowTest() {}
 
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
 
     void testShadowTileOverlaps_data();
     void testShadowTileOverlaps();
     void testShadowTextureReconstruction();
 
 };
 
 inline bool isClose(double a, double b, double eps = 1e-5)
 {
     if (a == b) {
         return true;
     }
     const double diff = std::fabs(a - b);
     if (a == 0 || b == 0) {
         return diff < eps;
     }
     return diff / std::max(a, b) < eps;
 }
 
 inline bool compareQuads(const WindowQuad &a, const WindowQuad &b)
 {
     for (int i = 0; i < 4; i++) {
         if (!isClose(a[i].x(), b[i].x())
                 || !isClose(a[i].y(), b[i].y())
                 || !isClose(a[i].textureX(), b[i].textureX())
                 || !isClose(a[i].textureY(), b[i].textureY())) {
             return false;
         }
     }
     return true;
 }
 
 inline WindowQuad makeShadowQuad(const QRectF &geo, qreal tx1, qreal ty1, qreal tx2, qreal ty2)
 {
     WindowQuad quad(WindowQuadShadow);
     quad[0] = WindowVertex(geo.left(),  geo.top(),    tx1, ty1);
     quad[1] = WindowVertex(geo.right(), geo.top(),    tx2, ty1);
     quad[2] = WindowVertex(geo.right(), geo.bottom(), tx2, ty2);
     quad[3] = WindowVertex(geo.left(),  geo.bottom(), tx1, ty2);
     return quad;
 }
 
 void SceneQPainterShadowTest::initTestCase()
 {
     // Copied from scene_qpainter_test.cpp
 
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("Q"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(KWin::Compositor::self());
 
     // Add directory with fake decorations to the plugin search path.
     QCoreApplication::addLibraryPath(
         QDir(QCoreApplication::applicationDirPath()).absoluteFilePath("fakes")
     );
 
     // Change decoration theme.
     KConfigGroup group = kwinApp()->config()->group("org.kde.kdecoration2");
     group.writeEntry("library", "org.kde.test.fakedecowithshadows");
     group.sync();
     Workspace::self()->slotReconfigure();
 }
 
 void SceneQPainterShadowTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 namespace {
     const int SHADOW_SIZE = 128;
 
     const int SHADOW_OFFSET_TOP  = 64;
     const int SHADOW_OFFSET_LEFT = 48;
 
     // NOTE: We assume deco shadows are generated with blur so that's
     //       why there is 4, 1 is the size of the inner shadow rect.
     const int SHADOW_TEXTURE_WIDTH  = 4 * SHADOW_SIZE + 1;
     const int SHADOW_TEXTURE_HEIGHT = 4 * SHADOW_SIZE + 1;
 
     const int SHADOW_PADDING_TOP    = SHADOW_SIZE - SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_RIGHT  = SHADOW_SIZE + SHADOW_OFFSET_LEFT;
     const int SHADOW_PADDING_BOTTOM = SHADOW_SIZE + SHADOW_OFFSET_TOP;
     const int SHADOW_PADDING_LEFT   = SHADOW_SIZE - SHADOW_OFFSET_LEFT;
 
     const QRectF SHADOW_INNER_RECT(2 * SHADOW_SIZE, 2 * SHADOW_SIZE, 1, 1);
 }
 
 void SceneQPainterShadowTest::testShadowTileOverlaps_data()
 {
     QTest::addColumn<QSize>("windowSize");
     QTest::addColumn<WindowQuadList>("expectedQuads");
 
     // Precompute shadow tile geometries(in texture's space).
     const QRectF topLeftTile(
         0,
         0,
         SHADOW_INNER_RECT.x(),
         SHADOW_INNER_RECT.y());
     const QRectF topRightTile(
         SHADOW_INNER_RECT.right(),
         0,
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.y());
     const QRectF topTile(topLeftTile.topRight(), topRightTile.bottomLeft());
 
     const QRectF bottomLeftTile(
         0,
         SHADOW_INNER_RECT.bottom(),
         SHADOW_INNER_RECT.x(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomRightTile(
         SHADOW_INNER_RECT.right(),
         SHADOW_INNER_RECT.bottom(),
         SHADOW_TEXTURE_WIDTH - SHADOW_INNER_RECT.right(),
         SHADOW_TEXTURE_HEIGHT - SHADOW_INNER_RECT.bottom());
     const QRectF bottomTile(bottomLeftTile.topRight(), bottomRightTile.bottomLeft());
 
     const QRectF leftTile(topLeftTile.bottomLeft(), bottomLeftTile.topRight());
     const QRectF rightTile(topRightTile.bottomLeft(), bottomRightTile.topRight());
 
     qreal tx1 = 0;
     qreal ty1 = 0;
     qreal tx2 = 0;
     qreal ty2 = 0;
 
     // Explanation behind numbers: (256+1 x 256+1) is the minimum window size
     // which doesn't cause overlapping of shadow tiles. For example, if a window
     // has (256 x 256+1) size, top-left and top-right or bottom-left and
     // bottom-right shadow tiles overlap.
 
     // No overlaps: In this case corner tiles are rendered as they are,
     // and top/right/bottom/left tiles are stretched.
     {
         const QSize windowSize(256 + 1, 256 + 1);
         WindowQuadList shadowQuads;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         const QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeftTile.right();
         ty2 = topLeftTile.bottom();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         const QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
         tx1 = topRightTile.left();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRightTile.bottom();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left();
         ty1 = topTile.top();
         tx2 = topTile.right();
         ty2 = topTile.bottom();
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
         tx1 = bottomLeftTile.left();
         ty1 = bottomLeftTile.top();
         tx2 = bottomLeftTile.right();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         const QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
         tx1 = bottomRightTile.left();
         ty1 = bottomRightTile.top();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left();
         ty1 = bottomTile.top();
         tx2 = bottomTile.right();
         ty2 = bottomTile.bottom();
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left();
         ty1 = leftTile.top();
         tx2 = leftTile.right();
         ty2 = leftTile.bottom();
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = rightTile.left();
         ty1 = rightTile.top();
         tx2 = rightTile.right();
         ty2 = rightTile.bottom();
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow("no overlaps") << windowSize << shadowQuads;
     }
 
     // Top-Left & Bottom-Left/Top-Right & Bottom-Right overlap:
     // In this case overlapping parts are clipped and left/right
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> verticalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap"),
             QSize(256 + 1, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & bottom-left/top-right & bottom-right overlap :: pre"),
             QSize(256 + 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : verticalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - std::floor(halfOverlap));
         bottomLeft.setTop(bottomLeft.top() + std::ceil(halfOverlap));
 
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeftTile.right();
         ty2 = topLeft.height();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomLeft.height();
         tx2 = bottomLeftTile.right();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - std::floor(halfOverlap));
         bottomRight.setTop(bottomRight.top() + std::ceil(halfOverlap));
 
         tx1 = topRightTile.left();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRight.height();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomRightTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomRight.height();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF top(topLeft.topRight(), topRight.bottomLeft());
         tx1 = topTile.left();
         ty1 = topTile.top();
         tx2 = topTile.right();
         ty2 = top.height();
         shadowQuads << makeShadowQuad(top, tx1, ty1, tx2, ty2);
 
         const QRectF bottom(bottomLeft.topRight(), bottomRight.bottomLeft());
         tx1 = bottomTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottom.height();
         tx2 = bottomTile.right();
         ty2 = bottomTile.bottom();
         shadowQuads << makeShadowQuad(bottom, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Top-Left & Top-Right/Bottom-Left & Bottom-Right overlap:
     // In this case overlapping parts are clipped and top/bottom
     // tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> horizontalOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap"),
             QSize(256, 256 + 1)
         },
         QPair<QByteArray, QSize> {
             QByteArray("top-left & top-right/bottom-left & bottom-right overlap :: pre"),
             QSize(256 - 1, 256 + 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : horizontalOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - std::floor(halfOverlap));
         topRight.setLeft(topRight.left() + std::ceil(halfOverlap));
 
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeft.width();
         ty2 = topLeftTile.bottom();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - topRight.width();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRightTile.bottom();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - std::floor(halfOverlap));
         bottomRight.setLeft(bottomRight.left() + std::ceil(halfOverlap));
 
         tx1 = bottomLeftTile.left();
         ty1 = bottomLeftTile.top();
         tx2 = bottomLeft.width();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - bottomRight.width();
         ty1 = bottomRightTile.top();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         const QRectF left(topLeft.bottomLeft(), bottomLeft.topRight());
         tx1 = leftTile.left();
         ty1 = leftTile.top();
         tx2 = left.width();
         ty2 = leftTile.bottom();
         shadowQuads << makeShadowQuad(left, tx1, ty1, tx2, ty2);
 
         const QRectF right(topRight.bottomLeft(), bottomRight.topRight());
         tx1 = SHADOW_TEXTURE_WIDTH - right.width();
         ty1 = rightTile.top();
         tx2 = rightTile.right();
         ty2 = rightTile.bottom();
         shadowQuads << makeShadowQuad(right, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // All shadow tiles overlap: In this case all overlapping parts
     // are clippend and top/right/bottom/left tiles aren't rendered.
     const QVector<QPair<QByteArray, QSize>> allOverlapTestTable {
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap"),
             QSize(256, 256)
         },
         QPair<QByteArray, QSize> {
             QByteArray("all corner tiles overlap :: pre"),
             QSize(256 - 1, 256 - 1)
         }
         // No need to test the case when window size is QSize(256 + 1, 256 + 1).
         // It has been tested already (no overlaps test case).
     };
 
     for (auto const &tt : allOverlapTestTable) {
         const char *testName = tt.first.constData();
         const QSize windowSize = tt.second;
 
         WindowQuadList shadowQuads;
         qreal halfOverlap = 0.0;
 
         const QRectF outerRect(
             -SHADOW_PADDING_LEFT,
             -SHADOW_PADDING_TOP,
             windowSize.width() + SHADOW_PADDING_LEFT + SHADOW_PADDING_RIGHT,
             windowSize.height() + SHADOW_PADDING_TOP + SHADOW_PADDING_BOTTOM);
 
         QRectF topLeft(
             outerRect.left(),
             outerRect.top(),
             topLeftTile.width(),
             topLeftTile.height());
 
         QRectF topRight(
             outerRect.right() - topRightTile.width(),
             outerRect.top(),
             topRightTile.width(),
             topRightTile.height());
 
         QRectF bottomLeft(
             outerRect.left(),
             outerRect.bottom() - bottomLeftTile.height(),
             bottomLeftTile.width(),
             bottomLeftTile.height());
 
         QRectF bottomRight(
             outerRect.right() - bottomRightTile.width(),
             outerRect.bottom() - bottomRightTile.height(),
             bottomRightTile.width(),
             bottomRightTile.height());
 
         halfOverlap = qAbs(topLeft.right() - topRight.left()) / 2;
         topLeft.setRight(topLeft.right() - std::floor(halfOverlap));
         topRight.setLeft(topRight.left() + std::ceil(halfOverlap));
 
         halfOverlap = qAbs(bottomLeft.right() - bottomRight.left()) / 2;
         bottomLeft.setRight(bottomLeft.right() - std::floor(halfOverlap));
         bottomRight.setLeft(bottomRight.left() + std::ceil(halfOverlap));
 
         halfOverlap = qAbs(topLeft.bottom() - bottomLeft.top()) / 2;
         topLeft.setBottom(topLeft.bottom() - std::floor(halfOverlap));
         bottomLeft.setTop(bottomLeft.top() + std::ceil(halfOverlap));
 
         halfOverlap = qAbs(topRight.bottom() - bottomRight.top()) / 2;
         topRight.setBottom(topRight.bottom() - std::floor(halfOverlap));
         bottomRight.setTop(bottomRight.top() + std::ceil(halfOverlap));
 
         tx1 = topLeftTile.left();
         ty1 = topLeftTile.top();
         tx2 = topLeft.width();
         ty2 = topLeft.height();
         shadowQuads << makeShadowQuad(topLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - topRight.width();
         ty1 = topRightTile.top();
         tx2 = topRightTile.right();
         ty2 = topRight.height();
         shadowQuads << makeShadowQuad(topRight, tx1, ty1, tx2, ty2);
 
         tx1 = bottomLeftTile.left();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomLeft.height();
         tx2 = bottomLeft.width();
         ty2 = bottomLeftTile.bottom();
         shadowQuads << makeShadowQuad(bottomLeft, tx1, ty1, tx2, ty2);
 
         tx1 = SHADOW_TEXTURE_WIDTH - bottomRight.width();
         ty1 = SHADOW_TEXTURE_HEIGHT - bottomRight.height();
         tx2 = bottomRightTile.right();
         ty2 = bottomRightTile.bottom();
         shadowQuads << makeShadowQuad(bottomRight, tx1, ty1, tx2, ty2);
 
         QTest::newRow(testName) << windowSize << shadowQuads;
     }
 
     // Window is too small: do not render any shadow tiles.
     {
         const QSize windowSize(1, 1);
         const WindowQuadList shadowQuads;
 
         QTest::newRow("window is too small") << windowSize << shadowQuads;
     }
 }
 
 void SceneQPainterShadowTest::testShadowTileOverlaps()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration));
 
     QFETCH(QSize, windowSize);
     QFETCH(WindowQuadList, expectedQuads);
 
     // Create a decorated client.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<ServerSideDecoration> ssd(Test::waylandServerSideDecoration()->create(surface.data()));
 
     auto *client = Test::renderAndWaitForShown(surface.data(), windowSize, Qt::blue);
 
     QSignalSpy sizeChangedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangedSpy.isValid());
 
     // Check the client is decorated.
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     auto *decoration = client->decoration();
     QVERIFY(decoration);
 
     // If speciefied decoration theme is not found, KWin loads a default one
     // so we have to check whether a client has right decoration.
     auto decoShadow = decoration->shadow();
     QCOMPARE(decoShadow->shadow().size(), QSize(SHADOW_TEXTURE_WIDTH, SHADOW_TEXTURE_HEIGHT));
     QCOMPARE(decoShadow->paddingTop(),    SHADOW_PADDING_TOP);
     QCOMPARE(decoShadow->paddingRight(),  SHADOW_PADDING_RIGHT);
     QCOMPARE(decoShadow->paddingBottom(), SHADOW_PADDING_BOTTOM);
     QCOMPARE(decoShadow->paddingLeft(),   SHADOW_PADDING_LEFT);
 
     // Get shadow.
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     QVERIFY(client->effectWindow()->sceneWindow()->shadow());
     auto *shadow = client->effectWindow()->sceneWindow()->shadow();
 
     // Validate shadow quads.
     const WindowQuadList &quads = shadow->shadowQuads();
     QCOMPARE(quads.size(), expectedQuads.size());
 
     QVector<bool> mask(expectedQuads.size(), false);
     for (const auto &q : quads) {
         for (int i = 0; i < expectedQuads.size(); i++) {
             if (!compareQuads(q, expectedQuads[i])) {
                 continue;
             }
             if (!mask[i]) {
                 mask[i] = true;
                 break;
             } else {
                 QFAIL("got a duplicate shadow quad");
             }
         }
     }
 
     for (const auto &v : qAsConst(mask)) {
         if (!v) {
             QFAIL("missed a shadow quad");
         }
     }
 }
 
 void SceneQPainterShadowTest::testShadowTextureReconstruction()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::ShadowManager));
 
     // Create a surface.
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto *client = Test::renderAndWaitForShown(surface.data(), QSize(512, 512), Qt::blue);
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
 
     // Render reference shadow texture with the following params:
     //  - shadow size: 128
     //  - inner rect size: 1
     //  - padding: 128
     QImage referenceShadowTexture(QSize(256 + 1, 256 + 1), QImage::Format_ARGB32_Premultiplied);
     referenceShadowTexture.fill(Qt::transparent);
 
     QPainter painter(&referenceShadowTexture);
     painter.fillRect(QRect(10, 10, 192, 200), QColor(255, 0, 0, 128));
     painter.fillRect(QRect(128, 30, 10, 180), QColor(0, 0, 0, 30));
     painter.fillRect(QRect(20, 140, 160, 10), QColor(0, 255, 0, 128));
 
     painter.setCompositionMode(QPainter::CompositionMode_DestinationOut);
     painter.fillRect(QRect(128, 128, 1, 1), Qt::black);
     painter.end();
 
     // Create shadow.
     QScopedPointer<KWayland::Client::Shadow> clientShadow(Test::waylandShadowManager()->createShadow(surface.data()));
     QVERIFY(clientShadow->isValid());
 
     auto *shmPool = Test::waylandShmPool();
 
     Buffer::Ptr bufferTopLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 0, 128, 128)));
     clientShadow->attachTopLeft(bufferTopLeft);
 
     Buffer::Ptr bufferTop = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 0, 1, 128)));
     clientShadow->attachTop(bufferTop);
 
     Buffer::Ptr bufferTopRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 0, 128, 128)));
     clientShadow->attachTopRight(bufferTopRight);
 
     Buffer::Ptr bufferRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 128, 128, 1)));
     clientShadow->attachRight(bufferRight);
 
     Buffer::Ptr bufferBottomRight = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128 + 1, 128 + 1, 128, 128)));
     clientShadow->attachBottomRight(bufferBottomRight);
 
     Buffer::Ptr bufferBottom = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(128, 128 + 1, 1, 128)));
     clientShadow->attachBottom(bufferBottom);
 
     Buffer::Ptr bufferBottomLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 128 + 1, 128, 128)));
     clientShadow->attachBottomLeft(bufferBottomLeft);
 
     Buffer::Ptr bufferLeft = shmPool->createBuffer(
         referenceShadowTexture.copy(QRect(0, 128, 128, 1)));
     clientShadow->attachLeft(bufferLeft);
 
     clientShadow->setOffsets(QMarginsF(128, 128, 128, 128));
 
     // Commit shadow.
-    QSignalSpy shadowChangedSpy(client->surface(), &KWayland::Server::SurfaceInterface::shadowChanged);
+    QSignalSpy shadowChangedSpy(client->surface(), &KWaylandServer::SurfaceInterface::shadowChanged);
     QVERIFY(shadowChangedSpy.isValid());
     clientShadow->commit();
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(shadowChangedSpy.wait());
 
     // Check whether we've got right shadow.
     auto shadowIface = client->surface()->shadow();
     QVERIFY(!shadowIface.isNull());
     QCOMPARE(shadowIface->offset().left(),   128.0);
     QCOMPARE(shadowIface->offset().top(),    128.0);
     QCOMPARE(shadowIface->offset().right(),  128.0);
     QCOMPARE(shadowIface->offset().bottom(), 128.0);
 
     // Get SceneQPainterShadow's texture.
     QVERIFY(client->effectWindow());
     QVERIFY(client->effectWindow()->sceneWindow());
     QVERIFY(client->effectWindow()->sceneWindow()->shadow());
     auto &shadowTexture = static_cast<SceneQPainterShadow *>(client->effectWindow()->sceneWindow()->shadow())->shadowTexture();
 
     QCOMPARE(shadowTexture, referenceShadowTexture);
 }
 
 WAYLANDTEST_MAIN(SceneQPainterShadowTest)
 #include "scene_qpainter_shadow_test.moc"
diff --git a/autotests/integration/scene_qpainter_test.cpp b/autotests/integration/scene_qpainter_test.cpp
index cdbd61b70..e972d762f 100644
--- a/autotests/integration/scene_qpainter_test.cpp
+++ b/autotests/integration/scene_qpainter_test.cpp
@@ -1,395 +1,395 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "composite.h"
 #include "effectloader.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "effects.h"
 #include "platform.h"
 #include "wayland_server.h"
 #include "effect_builtins.h"
 #include "workspace.h"
 
 #include <KConfigGroup>
 
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/pointer.h>
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <QPainter>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 using namespace KWin;
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_scene_qpainter-0");
 
 class SceneQPainterTest : public QObject
 {
 Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
     void testStartFrame();
     void testCursorMoving();
     void testWindow_data();
     void testWindow();
     void testWindowScaled();
     void testCompositorRestart_data();
     void testCompositorRestart();
     void testX11Window();
 };
 
 void SceneQPainterTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void SceneQPainterTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     // disable all effects - we don't want to have it interact with the rendering
     auto config = KSharedConfig::openConfig(QString(), KConfig::SimpleConfig);
     KConfigGroup plugins(config, QStringLiteral("Plugins"));
     ScriptedEffectLoader loader;
     const auto builtinNames = BuiltInEffects::availableEffectNames() << loader.listOfKnownEffects();
     for (QString name : builtinNames) {
         plugins.writeEntry(name + QStringLiteral("Enabled"), false);
     }
 
     config->sync();
     kwinApp()->setConfig(config);
 
     if (!QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("icons/DMZ-White/index.theme")).isEmpty()) {
         qputenv("XCURSOR_THEME", QByteArrayLiteral("DMZ-White"));
     } else {
         // might be vanilla-dmz (e.g. Arch, FreeBSD)
         qputenv("XCURSOR_THEME", QByteArrayLiteral("Vanilla-DMZ"));
     }
     qputenv("XCURSOR_SIZE", QByteArrayLiteral("24"));
     qputenv("KWIN_COMPOSE", QByteArrayLiteral("Q"));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QVERIFY(Compositor::self());
 }
 
 void SceneQPainterTest::testStartFrame()
 {
     // this test verifies that the initial rendering is correct
     Compositor::self()->addRepaintFull();
     auto scene = Compositor::self()->scene();
     QVERIFY(scene);
     QCOMPARE(kwinApp()->platform()->selectedCompositor(), QPainterCompositing);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     QVERIFY(frameRenderedSpy.wait());
     // now let's render a reference image for comparison
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter p(&referenceImage);
 
     auto cursor = KWin::Cursors::self()->mouse();
     const QImage cursorImage = cursor->image();
     QVERIFY(!cursorImage.isNull());
     p.drawImage(cursor->pos() - cursor->hotspot(), cursorImage);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testCursorMoving()
 {
     // this test verifies that rendering is correct also after moving the cursor a few times
     auto scene = Compositor::self()->scene();
     QVERIFY(scene);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     KWin::Cursors::self()->mouse()->setPos(0, 0);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursors::self()->mouse()->setPos(10, 0);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursors::self()->mouse()->setPos(10, 12);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursors::self()->mouse()->setPos(12, 14);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursors::self()->mouse()->setPos(50, 60);
     QVERIFY(frameRenderedSpy.wait());
     KWin::Cursors::self()->mouse()->setPos(45, 45);
     QVERIFY(frameRenderedSpy.wait());
     // now let's render a reference image for comparison
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter p(&referenceImage);
 
     auto cursor = Cursors::self()->currentCursor();
     const QImage cursorImage = cursor->image();
     QVERIFY(!cursorImage.isNull());
     p.drawImage(QPoint(45, 45) - cursor->hotspot(), cursorImage);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void SceneQPainterTest::testWindow()
 {
     KWin::Cursors::self()->mouse()->setPos(45, 45);
     // this test verifies that a window is rendered correctly
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     QScopedPointer<Surface> s(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> ss(Test::createXdgShellSurface(type, s.data()));
     QScopedPointer<Pointer> p(Test::waylandSeat()->createPointer());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
 
     // now let's map the window
     QVERIFY(Test::renderAndWaitForShown(s.data(), QSize(200, 300), Qt::blue));
     // which should trigger a frame
     if (frameRenderedSpy.isEmpty()) {
         QVERIFY(frameRenderedSpy.wait());
     }
     // we didn't set a cursor image on the surface yet, so it should be just black + window and previous cursor
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter painter(&referenceImage);
     painter.fillRect(0, 0, 200, 300, Qt::blue);
 
     // now let's set a cursor image
     QScopedPointer<Surface> cs(Test::createSurface());
     QVERIFY(!cs.isNull());
     Test::render(cs.data(), QSize(10, 10), Qt::red);
     p->setCursor(cs.data(), QPoint(5, 5));
     QVERIFY(frameRenderedSpy.wait());
     painter.fillRect(KWin::Cursors::self()->mouse()->pos().x() - 5, KWin::Cursors::self()->mouse()->pos().y() - 5, 10, 10, Qt::red);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
     // let's move the cursor again
     KWin::Cursors::self()->mouse()->setPos(10, 10);
     QVERIFY(frameRenderedSpy.wait());
     painter.fillRect(0, 0, 200, 300, Qt::blue);
     painter.fillRect(5, 5, 10, 10, Qt::red);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testWindowScaled()
 {
     KWin::Cursors::self()->mouse()->setPos(10, 10);
     // this test verifies that a window is rendered correctly
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Seat));
     QVERIFY(Test::waitForWaylandPointer());
     QScopedPointer<Surface> s(Test::createSurface());
     QScopedPointer<XdgShellSurface> ss(Test::createXdgShellStableSurface(s.data()));
     QScopedPointer<Pointer> p(Test::waylandSeat()->createPointer());
     QSignalSpy pointerEnteredSpy(p.data(), &Pointer::entered);
     QVERIFY(pointerEnteredSpy.isValid());
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
 
     // now let's set a cursor image
     QScopedPointer<Surface> cs(Test::createSurface());
     QVERIFY(!cs.isNull());
     Test::render(cs.data(), QSize(10, 10), Qt::red);
 
     // now let's map the window
     s->setScale(2);
 
     //draw a blue square@400x600 with red rectangle@200x200 in the middle
     const QSize size(400,600);
     QImage img(size, QImage::Format_ARGB32_Premultiplied);
     img.fill(Qt::blue);
     QPainter surfacePainter(&img);
     surfacePainter.fillRect(200,300,200,200, Qt::red);
 
     //add buffer
     Test::render(s.data(), img);
     QVERIFY(pointerEnteredSpy.wait());
     p->setCursor(cs.data(), QPoint(5, 5));
 
     // which should trigger a frame
     QVERIFY(frameRenderedSpy.wait());
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter painter(&referenceImage);
     painter.fillRect(0, 0, 200, 300, Qt::blue);
     painter.fillRect(100, 150, 100, 100, Qt::red);
     painter.fillRect(5, 5, 10, 10, Qt::red); //cursor
 
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 void SceneQPainterTest::testCompositorRestart_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void SceneQPainterTest::testCompositorRestart()
 {
     // this test verifies that the compositor/SceneQPainter survive a restart of the compositor and still render correctly
     KWin::Cursors::self()->mouse()->setPos(400, 400);
 
     // first create a window
     using namespace KWayland::Client;
     QVERIFY(Test::setupWaylandConnection());
     QScopedPointer<Surface> s(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> ss(Test::createXdgShellSurface(type, s.data()));
     QVERIFY(Test::renderAndWaitForShown(s.data(), QSize(200, 300), Qt::blue));
 
     // now let's try to reinitialize the compositing scene
     auto oldScene = KWin::Compositor::self()->scene();
     QVERIFY(oldScene);
     QSignalSpy sceneCreatedSpy(KWin::Compositor::self(), &KWin::Compositor::sceneCreated);
     QVERIFY(sceneCreatedSpy.isValid());
     KWin::Compositor::self()->reinitialize();
     if (sceneCreatedSpy.isEmpty()) {
         QVERIFY(sceneCreatedSpy.wait());
     }
     QCOMPARE(sceneCreatedSpy.count(), 1);
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
 
     // this should directly trigger a frame
     KWin::Compositor::self()->addRepaintFull();
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     QVERIFY(frameRenderedSpy.wait());
 
     // render reference image
     QImage referenceImage(QSize(1280, 1024), QImage::Format_RGB32);
     referenceImage.fill(Qt::black);
     QPainter painter(&referenceImage);
     painter.fillRect(0, 0, 200, 300, Qt::blue);
 
     auto cursor = Cursors::self()->mouse();
     const QImage cursorImage = cursor->image();
     QVERIFY(!cursorImage.isNull());
     painter.drawImage(QPoint(400, 400) - cursor->hotspot(), cursorImage);
     QCOMPARE(referenceImage, *scene->qpainterRenderBuffer());
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 void SceneQPainterTest::testX11Window()
 {
     // this test verifies the condition of BUG: 382748
 
     // create X11 window
     QSignalSpy windowAddedSpy(effects, &EffectsHandler::windowAdded);
     QVERIFY(windowAddedSpy.isValid());
 
     // create an xcb window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     const QRect windowGeometry(0, 0, 100, 200);
     xcb_window_t w = xcb_generate_id(c.data());
     uint32_t value = defaultScreen()->white_pixel;
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_BACK_PIXEL, &value);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
 
     // we should get a client for it
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.first().first().value<X11Client *>();
     QVERIFY(client);
     QCOMPARE(client->window(), w);
     QCOMPARE(client->clientSize(), QSize(100, 200));
     if (!client->surface()) {
         // wait for surface
         QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
         QVERIFY(surfaceChangedSpy.isValid());
         QVERIFY(surfaceChangedSpy.wait());
     }
     QVERIFY(client->surface());
     QTRY_VERIFY(client->surface()->buffer());
     QTRY_COMPARE(client->surface()->buffer()->data().size(), client->size());
     QImage compareImage(client->clientSize(), QImage::Format_RGB32);
     compareImage.fill(Qt::white);
     QCOMPARE(client->surface()->buffer()->data().copy(QRect(client->clientPos(), client->clientSize())), compareImage);
 
     // enough time for rendering the window
     QTest::qWait(100);
 
     auto scene = KWin::Compositor::self()->scene();
     QVERIFY(scene);
 
     // this should directly trigger a frame
     KWin::Compositor::self()->addRepaintFull();
     QSignalSpy frameRenderedSpy(scene, &Scene::frameRendered);
     QVERIFY(frameRenderedSpy.isValid());
     QVERIFY(frameRenderedSpy.wait());
 
     const QPoint startPos = client->pos() + client->clientPos();
     auto image = scene->qpainterRenderBuffer();
     QCOMPARE(image->copy(QRect(startPos, client->clientSize())), compareImage);
 
     // and destroy the window again
     xcb_unmap_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     QVERIFY(windowClosedSpy.wait());
     xcb_destroy_window(c.data(), w);
     c.reset();
 }
 
 WAYLANDTEST_MAIN(SceneQPainterTest)
 #include "scene_qpainter_test.moc"
diff --git a/autotests/integration/test_helpers.cpp b/autotests/integration/test_helpers.cpp
index bb7cf43ba..7b82a627e 100644
--- a/autotests/integration/test_helpers.cpp
+++ b/autotests/integration/test_helpers.cpp
@@ -1,586 +1,586 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "screenlockerwatcher.h"
 #include "wayland_server.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/idleinhibit.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 #include <KWayland/Client/pointerconstraints.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shadow.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/output.h>
 #include <KWayland/Client/subcompositor.h>
 #include <KWayland/Client/subsurface.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/appmenu.h>
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Client/xdgdecoration.h>
-#include <KWayland/Server/display.h>
+#include <KWaylandServer/display.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <QThread>
 
 // system
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 using namespace KWayland::Client;
 
 namespace KWin
 {
 namespace Test
 {
 
 static struct {
     ConnectionThread *connection = nullptr;
     EventQueue *queue = nullptr;
     Compositor *compositor = nullptr;
     SubCompositor *subCompositor = nullptr;
     ServerSideDecorationManager *decoration = nullptr;
     ShadowManager *shadowManager = nullptr;
     XdgShell *xdgShellStable = nullptr;
     ShmPool *shm = nullptr;
     Seat *seat = nullptr;
     PlasmaShell *plasmaShell = nullptr;
     PlasmaWindowManagement *windowManagement = nullptr;
     PointerConstraints *pointerConstraints = nullptr;
     Registry *registry = nullptr;
     QThread *thread = nullptr;
     QVector<Output*> outputs;
     IdleInhibitManager *idleInhibit = nullptr;
     AppMenuManager *appMenu = nullptr;
     XdgDecorationManager *xdgDecoration = nullptr;
 } s_waylandConnection;
 
 bool setupWaylandConnection(AdditionalWaylandInterfaces flags)
 {
     if (s_waylandConnection.connection) {
         return false;
     }
 
     int sx[2];
     if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) < 0) {
         return false;
     }
     KWin::waylandServer()->display()->createClient(sx[0]);
     // setup connection
     s_waylandConnection.connection = new ConnectionThread;
     QSignalSpy connectedSpy(s_waylandConnection.connection, &ConnectionThread::connected);
     if (!connectedSpy.isValid()) {
         return false;
     }
     s_waylandConnection.connection->setSocketFd(sx[1]);
 
     s_waylandConnection.thread = new QThread(kwinApp());
     s_waylandConnection.connection->moveToThread(s_waylandConnection.thread);
     s_waylandConnection.thread->start();
 
     s_waylandConnection.connection->initConnection();
     if (!connectedSpy.wait()) {
         return false;
     }
 
     s_waylandConnection.queue = new EventQueue;
     s_waylandConnection.queue->setup(s_waylandConnection.connection);
     if (!s_waylandConnection.queue->isValid()) {
         return false;
     }
 
     Registry *registry = new Registry;
     s_waylandConnection.registry = registry;
     registry->setEventQueue(s_waylandConnection.queue);
 
     QObject::connect(registry, &Registry::outputAnnounced, [=](quint32 name, quint32 version) {
         auto output = registry->createOutput(name, version, s_waylandConnection.registry);
         s_waylandConnection.outputs << output;
         QObject::connect(output, &Output::removed, [=]() {
             output->deleteLater();
             s_waylandConnection.outputs.removeOne(output);
         });
     });
 
     QSignalSpy allAnnounced(registry, &Registry::interfacesAnnounced);
     if (!allAnnounced.isValid()) {
         return false;
     }
     registry->create(s_waylandConnection.connection);
     if (!registry->isValid()) {
         return false;
     }
     registry->setup();
     if (!allAnnounced.wait()) {
         return false;
     }
 
     s_waylandConnection.compositor = registry->createCompositor(registry->interface(Registry::Interface::Compositor).name, registry->interface(Registry::Interface::Compositor).version);
     if (!s_waylandConnection.compositor->isValid()) {
         return false;
     }
     s_waylandConnection.subCompositor = registry->createSubCompositor(registry->interface(Registry::Interface::SubCompositor).name, registry->interface(Registry::Interface::SubCompositor).version);
     if (!s_waylandConnection.subCompositor->isValid()) {
         return false;
     }
     s_waylandConnection.shm = registry->createShmPool(registry->interface(Registry::Interface::Shm).name, registry->interface(Registry::Interface::Shm).version);
     if (!s_waylandConnection.shm->isValid()) {
         return false;
     }
     s_waylandConnection.xdgShellStable = registry->createXdgShell(registry->interface(Registry::Interface::XdgShellStable).name, registry->interface(Registry::Interface::XdgShellStable).version);
     if (!s_waylandConnection.xdgShellStable->isValid()) {
         return false;
     }
     if (flags.testFlag(AdditionalWaylandInterface::Seat)) {
         s_waylandConnection.seat = registry->createSeat(registry->interface(Registry::Interface::Seat).name, registry->interface(Registry::Interface::Seat).version);
         if (!s_waylandConnection.seat->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::ShadowManager)) {
         s_waylandConnection.shadowManager = registry->createShadowManager(registry->interface(Registry::Interface::Shadow).name,
                                                                           registry->interface(Registry::Interface::Shadow).version);
         if (!s_waylandConnection.shadowManager->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::Decoration)) {
         s_waylandConnection.decoration = registry->createServerSideDecorationManager(registry->interface(Registry::Interface::ServerSideDecorationManager).name,
                                                                                     registry->interface(Registry::Interface::ServerSideDecorationManager).version);
         if (!s_waylandConnection.decoration->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::PlasmaShell)) {
         s_waylandConnection.plasmaShell = registry->createPlasmaShell(registry->interface(Registry::Interface::PlasmaShell).name,
                                                                      registry->interface(Registry::Interface::PlasmaShell).version);
         if (!s_waylandConnection.plasmaShell->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::WindowManagement)) {
         s_waylandConnection.windowManagement = registry->createPlasmaWindowManagement(registry->interface(Registry::Interface::PlasmaWindowManagement).name,
                                                                                      registry->interface(Registry::Interface::PlasmaWindowManagement).version);
         if (!s_waylandConnection.windowManagement->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::PointerConstraints)) {
         s_waylandConnection.pointerConstraints = registry->createPointerConstraints(registry->interface(Registry::Interface::PointerConstraintsUnstableV1).name,
                                                                                    registry->interface(Registry::Interface::PointerConstraintsUnstableV1).version);
         if (!s_waylandConnection.pointerConstraints->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::IdleInhibition)) {
         s_waylandConnection.idleInhibit = registry->createIdleInhibitManager(registry->interface(Registry::Interface::IdleInhibitManagerUnstableV1).name,
                                                                             registry->interface(Registry::Interface::IdleInhibitManagerUnstableV1).version);
         if (!s_waylandConnection.idleInhibit->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::AppMenu)) {
         s_waylandConnection.appMenu = registry->createAppMenuManager(registry->interface(Registry::Interface::AppMenu).name, registry->interface(Registry::Interface::AppMenu).version);
         if (!s_waylandConnection.appMenu->isValid()) {
             return false;
         }
     }
     if (flags.testFlag(AdditionalWaylandInterface::XdgDecoration)) {
         s_waylandConnection.xdgDecoration = registry->createXdgDecorationManager(registry->interface(Registry::Interface::XdgDecorationUnstableV1).name, registry->interface(Registry::Interface::XdgDecorationUnstableV1).version);
         if (!s_waylandConnection.xdgDecoration->isValid()) {
             return false;
         }
     }
 
     return true;
 }
 
 void destroyWaylandConnection()
 {
     delete s_waylandConnection.compositor;
     s_waylandConnection.compositor = nullptr;
     delete s_waylandConnection.subCompositor;
     s_waylandConnection.subCompositor = nullptr;
     delete s_waylandConnection.windowManagement;
     s_waylandConnection.windowManagement = nullptr;
     delete s_waylandConnection.plasmaShell;
     s_waylandConnection.plasmaShell = nullptr;
     delete s_waylandConnection.decoration;
     s_waylandConnection.decoration = nullptr;
     delete s_waylandConnection.decoration;
     s_waylandConnection.decoration = nullptr;
     delete s_waylandConnection.seat;
     s_waylandConnection.seat = nullptr;
     delete s_waylandConnection.pointerConstraints;
     s_waylandConnection.pointerConstraints = nullptr;
     delete s_waylandConnection.xdgShellStable;
     s_waylandConnection.xdgShellStable = nullptr;
     delete s_waylandConnection.shadowManager;
     s_waylandConnection.shadowManager = nullptr;
     delete s_waylandConnection.idleInhibit;
     s_waylandConnection.idleInhibit = nullptr;
     delete s_waylandConnection.shm;
     s_waylandConnection.shm = nullptr;
     delete s_waylandConnection.queue;
     s_waylandConnection.queue = nullptr;
     delete s_waylandConnection.registry;
     s_waylandConnection.registry = nullptr;
     delete s_waylandConnection.appMenu;
     s_waylandConnection.appMenu = nullptr;
     delete s_waylandConnection.xdgDecoration;
     s_waylandConnection.xdgDecoration = nullptr;
     if (s_waylandConnection.thread) {
         QSignalSpy spy(s_waylandConnection.connection, &QObject::destroyed);
         s_waylandConnection.connection->deleteLater();
         if (spy.isEmpty()) {
             QVERIFY(spy.wait());
         }
         s_waylandConnection.thread->quit();
         s_waylandConnection.thread->wait();
         delete s_waylandConnection.thread;
         s_waylandConnection.thread = nullptr;
         s_waylandConnection.connection = nullptr;
     }
 }
 
 ConnectionThread *waylandConnection()
 {
     return s_waylandConnection.connection;
 }
 
 Compositor *waylandCompositor()
 {
     return s_waylandConnection.compositor;
 }
 
 SubCompositor *waylandSubCompositor()
 {
     return s_waylandConnection.subCompositor;
 }
 
 ShadowManager *waylandShadowManager()
 {
     return s_waylandConnection.shadowManager;
 }
 
 ShmPool *waylandShmPool()
 {
     return s_waylandConnection.shm;
 }
 
 Seat *waylandSeat()
 {
     return s_waylandConnection.seat;
 }
 
 ServerSideDecorationManager *waylandServerSideDecoration()
 {
     return s_waylandConnection.decoration;
 }
 
 PlasmaShell *waylandPlasmaShell()
 {
     return s_waylandConnection.plasmaShell;
 }
 
 PlasmaWindowManagement *waylandWindowManagement()
 {
     return s_waylandConnection.windowManagement;
 }
 
 PointerConstraints *waylandPointerConstraints()
 {
     return s_waylandConnection.pointerConstraints;
 }
 
 IdleInhibitManager *waylandIdleInhibitManager()
 {
     return s_waylandConnection.idleInhibit;
 }
 
 AppMenuManager* waylandAppMenuManager()
 {
     return s_waylandConnection.appMenu;
 }
 
 XdgDecorationManager *xdgDecorationManager()
 {
     return s_waylandConnection.xdgDecoration;
 }
 
 
 bool waitForWaylandPointer()
 {
     if (!s_waylandConnection.seat) {
         return false;
     }
     QSignalSpy hasPointerSpy(s_waylandConnection.seat, &Seat::hasPointerChanged);
     if (!hasPointerSpy.isValid()) {
         return false;
     }
     return hasPointerSpy.wait();
 }
 
 bool waitForWaylandTouch()
 {
     if (!s_waylandConnection.seat) {
         return false;
     }
     QSignalSpy hasTouchSpy(s_waylandConnection.seat, &Seat::hasTouchChanged);
     if (!hasTouchSpy.isValid()) {
         return false;
     }
     return hasTouchSpy.wait();
 }
 
 bool waitForWaylandKeyboard()
 {
     if (!s_waylandConnection.seat) {
         return false;
     }
     QSignalSpy hasKeyboardSpy(s_waylandConnection.seat, &Seat::hasKeyboardChanged);
     if (!hasKeyboardSpy.isValid()) {
         return false;
     }
     return hasKeyboardSpy.wait();
 }
 
 void render(Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format)
 {
     QImage img(size, format);
     img.fill(color);
     render(surface, img);
 }
 
 void render(Surface *surface, const QImage &img)
 {
     surface->attachBuffer(s_waylandConnection.shm->createBuffer(img));
     surface->damage(QRect(QPoint(0, 0), img.size()));
     surface->commit(Surface::CommitFlag::None);
 }
 
 AbstractClient *waitForWaylandWindowShown(int timeout)
 {
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     if (!clientAddedSpy.isValid()) {
         return nullptr;
     }
     if (!clientAddedSpy.wait(timeout)) {
         return nullptr;
     }
     return clientAddedSpy.first().first().value<AbstractClient *>();
 }
 
 AbstractClient *renderAndWaitForShown(Surface *surface, const QSize &size, const QColor &color, const QImage::Format &format, int timeout)
 {
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     if (!clientAddedSpy.isValid()) {
         return nullptr;
     }
     render(surface, size, color, format);
     flushWaylandConnection();
     if (!clientAddedSpy.wait(timeout)) {
         return nullptr;
     }
     return clientAddedSpy.first().first().value<AbstractClient *>();
 }
 
 void flushWaylandConnection()
 {
     if (s_waylandConnection.connection) {
         s_waylandConnection.connection->flush();
     }
 }
 
 Surface *createSurface(QObject *parent)
 {
     if (!s_waylandConnection.compositor) {
         return nullptr;
     }
     auto s = s_waylandConnection.compositor->createSurface(parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     return s;
 }
 
 SubSurface *createSubSurface(Surface *surface, Surface *parentSurface, QObject *parent)
 {
     if (!s_waylandConnection.subCompositor) {
         return nullptr;
     }
     auto s = s_waylandConnection.subCompositor->createSubSurface(surface, parentSurface, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     return s;
 }
 
 XdgShellSurface *createXdgShellStableSurface(Surface *surface, QObject *parent, CreationSetup creationSetup)
 {
     if (!s_waylandConnection.xdgShellStable) {
         return nullptr;
     }
     auto s = s_waylandConnection.xdgShellStable->createSurface(surface, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     if (creationSetup == CreationSetup::CreateAndConfigure) {
         initXdgShellSurface(surface, s);
     }
     return s;
 }
 
 XdgShellPopup *createXdgShellStablePopup(Surface *surface, XdgShellSurface *parentSurface, const XdgPositioner &positioner, QObject *parent, CreationSetup creationSetup)
 {
     if (!s_waylandConnection.xdgShellStable) {
         return nullptr;
     }
     auto s = s_waylandConnection.xdgShellStable->createPopup(surface, parentSurface, positioner, parent);
     if (!s->isValid()) {
         delete s;
         return nullptr;
     }
     if (creationSetup == CreationSetup::CreateAndConfigure) {
         initXdgShellPopup(surface, s);
     }
     return s;
 }
 
 void initXdgShellSurface(KWayland::Client::Surface *surface, KWayland::Client::XdgShellSurface *shellSurface)
 {
     //wait for configure
     QSignalSpy configureRequestedSpy(shellSurface, &KWayland::Client::XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
 }
 
 void initXdgShellPopup(KWayland::Client::Surface *surface, KWayland::Client::XdgShellPopup *shellPopup)
 {
     //wait for configure
     QSignalSpy configureRequestedSpy(shellPopup, &KWayland::Client::XdgShellPopup::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     shellPopup->ackConfigure(configureRequestedSpy.last()[1].toInt());
 }
 
 KWayland::Client::XdgShellSurface *createXdgShellSurface(XdgShellSurfaceType type, KWayland::Client::Surface *surface, QObject *parent, CreationSetup creationSetup)
 {
     switch (type) {
     case XdgShellSurfaceType::XdgShellStable:
         return createXdgShellStableSurface(surface, parent, creationSetup);
     default:
         return nullptr;
     }
 }
 
 bool waitForWindowDestroyed(AbstractClient *client)
 {
     QSignalSpy destroyedSpy(client, &QObject::destroyed);
     if (!destroyedSpy.isValid()) {
         return false;
     }
     return destroyedSpy.wait();
 }
 
 bool lockScreen()
 {
     if (waylandServer()->isScreenLocked()) {
         return false;
     }
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged);
     if (!lockStateChangedSpy.isValid()) {
         return false;
     }
     ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
     if (lockStateChangedSpy.count() != 1) {
         return false;
     }
     if (!waylandServer()->isScreenLocked()) {
         return false;
     }
     if (!ScreenLockerWatcher::self()->isLocked()) {
         QSignalSpy lockedSpy(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked);
         if (!lockedSpy.isValid()) {
             return false;
         }
         if (!lockedSpy.wait()) {
             return false;
         }
         if (!ScreenLockerWatcher::self()->isLocked()) {
             return false;
         }
     }
     return true;
 }
 
 bool unlockScreen()
 {
     QSignalSpy lockStateChangedSpy(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged);
     if (!lockStateChangedSpy.isValid()) {
         return false;
     }
     using namespace ScreenLocker;
     const auto children = KSldApp::self()->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         if (qstrcmp((*it)->metaObject()->className(), "LogindIntegration") != 0) {
             continue;
         }
         QMetaObject::invokeMethod(*it, "requestUnlock");
         break;
     }
     if (waylandServer()->isScreenLocked()) {
         lockStateChangedSpy.wait();
     }
     if (waylandServer()->isScreenLocked()) {
         return true;
     }
     if (ScreenLockerWatcher::self()->isLocked()) {
         QSignalSpy lockedSpy(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked);
         if (!lockedSpy.isValid()) {
             return false;
         }
         if (!lockedSpy.wait()) {
             return false;
         }
         if (ScreenLockerWatcher::self()->isLocked()) {
             return false;
         }
     }
     return true;
 }
 
 }
 }
diff --git a/autotests/integration/transient_placement.cpp b/autotests/integration/transient_placement.cpp
index 3c0f4b3fc..e45a28049 100644
--- a/autotests/integration/transient_placement.cpp
+++ b/autotests/integration/transient_placement.cpp
@@ -1,366 +1,366 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <kwineffects.h>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 #include <KWayland/Client/xdgshell.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_transient_placement-0");
 
 class TransientPlacementTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
     void testXdgPopup_data();
     void testXdgPopup();
     void testXdgPopupWithPanel();
 };
 
 void TransientPlacementTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void TransientPlacementTest::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration | Test::AdditionalWaylandInterface::PlasmaShell));
 
     screens()->setCurrent(0);
     Cursors::self()->mouse()->setPos(QPoint(640, 512));
 }
 
 void TransientPlacementTest::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TransientPlacementTest::testXdgPopup_data()
 {
     using namespace KWayland::Client;
 
     QTest::addColumn<QSize>("parentSize");
     QTest::addColumn<QPoint>("parentPosition");
     QTest::addColumn<XdgPositioner>("positioner");
     QTest::addColumn<QRect>("expectedGeometry");
 
     // window in the middle, plenty of room either side: Changing anchor
 
     // parent window is 500,500, starting at 300,300, anchorRect is therefore between 350->750 in both dirs
     XdgPositioner positioner(QSize(200,200), QRect(50,50, 400,400));
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
 
     positioner.setAnchorEdge(Qt::Edges());
     QTest::newRow("anchorCentre") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(550, 550, 200, 200);
     positioner.setAnchorEdge(Qt::TopEdge | Qt::LeftEdge);
     QTest::newRow("anchorTopLeft") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(350,350, 200, 200);
     positioner.setAnchorEdge(Qt::TopEdge);
     QTest::newRow("anchorTop") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(550, 350, 200, 200);
     positioner.setAnchorEdge(Qt::TopEdge | Qt::RightEdge);
     QTest::newRow("anchorTopRight") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(750, 350, 200, 200);
     positioner.setAnchorEdge(Qt::RightEdge);
     QTest::newRow("anchorRight") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(750, 550, 200, 200);
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     QTest::newRow("anchorBottomRight") << QSize(500,500) << QPoint(300,300) << positioner << QRect(750, 750, 200, 200);
     positioner.setAnchorEdge(Qt::BottomEdge);
     QTest::newRow("anchorBottom") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(550, 750, 200, 200);
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::LeftEdge);
     QTest::newRow("anchorBottomLeft") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(350, 750, 200, 200);
     positioner.setAnchorEdge(Qt::LeftEdge);
     QTest::newRow("anchorLeft") << QSize(500, 500) << QPoint(300,300) << positioner << QRect(350, 550, 200, 200);
 
     // ----------------------------------------------------------------
     // window in the middle, plenty of room either side: Changing gravity around the bottom right anchor
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::Edges());
     QTest::newRow("gravityCentre") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(650, 650, 200, 200);
     positioner.setGravity(Qt::TopEdge | Qt::LeftEdge);
     QTest::newRow("gravityTopLeft") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(550, 550, 200, 200);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("gravityTop") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(650, 550, 200, 200);
     positioner.setGravity(Qt::TopEdge | Qt::RightEdge);
     QTest::newRow("gravityTopRight") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(750, 550, 200, 200);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("gravityRight") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(750, 650, 200, 200);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     QTest::newRow("gravityBottomRight") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(750, 750, 200, 200);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("gravityBottom") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(650, 750, 200, 200);
     positioner.setGravity(Qt::BottomEdge | Qt::LeftEdge);
     QTest::newRow("gravityBottomLeft") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(550, 750, 200, 200);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("gravityLeft") << QSize(500, 500) << QPoint(300, 300) << positioner << QRect(550, 650, 200, 200);
 
     // ----------------------------------------------------------------
     //constrain and slide
     //popup is still 200,200. window moved near edge of screen, popup always comes out towards the screen edge
     positioner.setConstraints(XdgPositioner::Constraint::SlideX | XdgPositioner::Constraint::SlideY);
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("constraintSlideTop") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(80 + 250 - 100, 0, 200, 200);
 
     positioner.setAnchorEdge(Qt::LeftEdge);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("constraintSlideLeft") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(0, 80 + 250 - 100, 200, 200);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("constraintSlideRight") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(1280 - 200, 80 + 250 - 100, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("constraintSlideBottom") << QSize(500, 500) << QPoint(80, 500) << positioner << QRect(80 + 250 - 100, 1024 - 200, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge| Qt::RightEdge);
     QTest::newRow("constraintSlideBottomRight") << QSize(500, 500) << QPoint(700, 1000) << positioner << QRect(1280 - 200, 1024 - 200, 200, 200);
 
 
     // ----------------------------------------------------------------
     // constrain and flip
     positioner.setConstraints(XdgPositioner::Constraint::FlipX | XdgPositioner::Constraint::FlipY);
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("constraintFlipTop") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(230, 80 + 500 - 50, 200, 200);
 
     positioner.setAnchorEdge(Qt::LeftEdge);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("constraintFlipLeft") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(80 + 500 - 50, 230, 200, 200);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("constraintFlipRight") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 50 - 200, 230, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("constraintFlipBottom") << QSize(500, 500) << QPoint(80, 500) << positioner << QRect(230, 500 + 50 - 200, 200, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge| Qt::RightEdge);
     QTest::newRow("constraintFlipBottomRight") << QSize(500, 500) << QPoint(700, 500) << positioner << QRect(700 + 50 - 200, 500 + 50 - 200, 200, 200);
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::RightEdge);
     //as popup is positioned in the middle of the parent we need a massive popup to be able to overflow
     positioner.setInitialSize(QSize(400, 400));
     QTest::newRow("constraintFlipRightNoAnchor") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 250 - 400, 330, 400, 400);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::TopEdge);
     positioner.setInitialSize(QSize(300, 200));
     QTest::newRow("constraintFlipRightNoGravity") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 50 - 150, 130, 300, 200);
 
     // ----------------------------------------------------------------
     // resize
     positioner.setConstraints(XdgPositioner::Constraint::ResizeX | XdgPositioner::Constraint::ResizeY);
     positioner.setInitialSize(QSize(200, 200));
 
     positioner.setAnchorEdge(Qt::TopEdge);
     positioner.setGravity(Qt::TopEdge);
     QTest::newRow("resizeTop") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(80 + 250 - 100, 0, 200, 130);
 
     positioner.setAnchorEdge(Qt::LeftEdge);
     positioner.setGravity(Qt::LeftEdge);
     QTest::newRow("resizeLeft") << QSize(500, 500) << QPoint(80, 80) << positioner << QRect(0, 80 + 250 - 100, 130, 200);
 
     positioner.setAnchorEdge(Qt::RightEdge);
     positioner.setGravity(Qt::RightEdge);
     QTest::newRow("resizeRight") << QSize(500, 500) << QPoint(700, 80) << positioner << QRect(700 + 50 + 400, 80 + 250 - 100, 130, 200);
 
     positioner.setAnchorEdge(Qt::BottomEdge);
     positioner.setGravity(Qt::BottomEdge);
     QTest::newRow("resizeBottom") << QSize(500, 500) << QPoint(80, 500) << positioner << QRect(80 + 250 - 100, 500 + 50 + 400, 200, 74);
 }
 
 void TransientPlacementTest::testXdgPopup()
 {
     using namespace KWayland::Client;
 
     // this test verifies that the position of a transient window is taken from the passed position
     // there are no further constraints like window too large to fit screen, cascading transients, etc
     // some test cases also verify that the transient fits on the screen
     QFETCH(QSize, parentSize);
     QFETCH(QPoint, parentPosition);
     QFETCH(QRect, expectedGeometry);
     const QRect expectedRelativeGeometry = expectedGeometry.translated(-parentPosition);
 
     Surface *surface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(surface);
     auto parentShellSurface = Test::createXdgShellStableSurface(surface, Test::waylandCompositor());
     QVERIFY(parentShellSurface);
     auto parent = Test::renderAndWaitForShown(surface, parentSize, Qt::blue);
     QVERIFY(parent);
 
     QVERIFY(!parent->isDecorated());
     parent->move(parentPosition);
     QCOMPARE(parent->frameGeometry(), QRect(parentPosition, parentSize));
 
     //create popup
     QFETCH(XdgPositioner, positioner);
 
     Surface *transientSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
 
     auto popup = Test::createXdgShellStablePopup(transientSurface, parentShellSurface, positioner, Test::waylandCompositor(), Test::CreationSetup::CreateOnly);
     QSignalSpy configureRequestedSpy(popup, &XdgShellPopup::configureRequested);
     transientSurface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.first()[0].value<QRect>(), expectedRelativeGeometry);
     popup->ackConfigure(configureRequestedSpy.first()[1].toUInt());
 
     auto transient = Test::renderAndWaitForShown(transientSurface, expectedRelativeGeometry.size(), Qt::red);
     QVERIFY(transient);
 
     QVERIFY(!transient->isDecorated());
     QVERIFY(transient->hasTransientPlacementHint());
     QCOMPARE(transient->frameGeometry(), expectedGeometry);
 
     QCOMPARE(configureRequestedSpy.count(), 1); // check that we did not get reconfigured
 }
 
 void TransientPlacementTest::testXdgPopupWithPanel()
 {
     using namespace KWayland::Client;
 
     QScopedPointer<Surface> surface{Test::createSurface()};
     QVERIFY(!surface.isNull());
     QScopedPointer<XdgShellSurface> dockShellSurface{Test::createXdgShellStableSurface(surface.data(), surface.data())};
     QVERIFY(!dockShellSurface.isNull());
     QScopedPointer<PlasmaShellSurface> plasmaSurface(Test::waylandPlasmaShell()->createSurface(surface.data()));
     QVERIFY(!plasmaSurface.isNull());
     plasmaSurface->setRole(PlasmaShellSurface::Role::Panel);
     plasmaSurface->setPosition(QPoint(0, screens()->geometry(0).height() - 50));
     plasmaSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AlwaysVisible);
 
     // now render and map the window
     QVERIFY(workspace()->clientArea(PlacementArea, 0, 1) == workspace()->clientArea(FullScreenArea, 0, 1));
     auto dock = Test::renderAndWaitForShown(surface.data(), QSize(1280, 50), Qt::blue);
     QVERIFY(dock);
     QCOMPARE(dock->windowType(), NET::Dock);
     QVERIFY(dock->isDock());
     QCOMPARE(dock->frameGeometry(), QRect(0, screens()->geometry(0).height() - 50, 1280, 50));
     QCOMPARE(dock->hasStrut(), true);
     QVERIFY(workspace()->clientArea(PlacementArea, 0, 1) != workspace()->clientArea(FullScreenArea, 0, 1));
 
     //create parent
     Surface *parentSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(parentSurface);
     auto parentShellSurface = Test::createXdgShellStableSurface(parentSurface, Test::waylandCompositor());
     QVERIFY(parentShellSurface);
     auto parent = Test::renderAndWaitForShown(parentSurface, {800, 600}, Qt::blue);
     QVERIFY(parent);
 
     QVERIFY(!parent->isDecorated());
     parent->move({0, screens()->geometry(0).height() - 600});
     parent->keepInArea(workspace()->clientArea(PlacementArea, parent));
     QCOMPARE(parent->frameGeometry(), QRect(0, screens()->geometry(0).height() - 600 - 50, 800, 600));
 
     Surface *transientSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
     XdgPositioner positioner(QSize(200,200), QRect(50,500, 200,200));
 
     auto transientShellSurface = Test::createXdgShellStablePopup(transientSurface, parentShellSurface, positioner, Test::waylandCompositor());
     auto transient = Test::renderAndWaitForShown(transientSurface, positioner.initialSize(), Qt::red);
     QVERIFY(transient);
 
     QVERIFY(!transient->isDecorated());
     QVERIFY(transient->hasTransientPlacementHint());
 
     QCOMPARE(transient->frameGeometry(), QRect(50, screens()->geometry(0).height() - 200 - 50, 200, 200));
 
     transientShellSurface->deleteLater();
     transientSurface->deleteLater();
     QVERIFY(Test::waitForWindowDestroyed(transient));
 
     // now parent to fullscreen - on fullscreen the panel is ignored
     QSignalSpy fullscreenSpy{parentShellSurface, &XdgShellSurface::configureRequested};
     QVERIFY(fullscreenSpy.isValid());
     parent->setFullScreen(true);
     QVERIFY(fullscreenSpy.wait());
     parentShellSurface->ackConfigure(fullscreenSpy.first().at(2).value<quint32>());
     QSignalSpy frameGeometryChangedSpy{parent, &AbstractClient::frameGeometryChanged};
     QVERIFY(frameGeometryChangedSpy.isValid());
     Test::render(parentSurface, fullscreenSpy.first().at(0).toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(parent->frameGeometry(), screens()->geometry(0));
     QVERIFY(parent->isFullScreen());
 
     // another transient, with same hints as before from bottom of window
     transientSurface = Test::createSurface(Test::waylandCompositor());
     QVERIFY(transientSurface);
 
     XdgPositioner positioner2(QSize(200,200), QRect(50,screens()->geometry(0).height()-100, 200,200));
     transientShellSurface = Test::createXdgShellStablePopup(transientSurface, parentShellSurface, positioner2, Test::waylandCompositor());
     transient = Test::renderAndWaitForShown(transientSurface, positioner2.initialSize(), Qt::red);
     QVERIFY(transient);
 
     QVERIFY(!transient->isDecorated());
     QVERIFY(transient->hasTransientPlacementHint());
 
     QCOMPARE(transient->frameGeometry(), QRect(50, screens()->geometry(0).height() - 200, 200, 200));
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::TransientPlacementTest)
 #include "transient_placement.moc"
diff --git a/autotests/integration/xdgshellclient_test.cpp b/autotests/integration/xdgshellclient_test.cpp
index 1a0a4fa2d..4cf7bfab4 100644
--- a/autotests/integration/xdgshellclient_test.cpp
+++ b/autotests/integration/xdgshellclient_test.cpp
@@ -1,1625 +1,1625 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 David Edmundson <davidedmundson@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "cursor.h"
 #include "decorations/decorationbridge.h"
 #include "decorations/settings.h"
 #include "effects.h"
 #include "deleted.h"
 #include "platform.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationSettings>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/output.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/subsurface.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/xdgshell.h>
 #include <KWayland/Client/xdgdecoration.h>
 #include <KWayland/Client/appmenu.h>
 
-#include <KWayland/Server/clientconnection.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/xdgdecoration_interface.h>
+#include <KWaylandServer/clientconnection.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/xdgdecoration_interface.h>
 
 #include <QDBusConnection>
 
 // system
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 #include <csignal>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xdgshellclient-0");
 
 class TestXdgShellClient : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testMapUnmapMap_data();
     void testMapUnmapMap();
     void testDesktopPresenceChanged();
     void testTransientPositionAfterRemap();
     void testWindowOutputs_data();
     void testWindowOutputs();
     void testMinimizeActiveWindow_data();
     void testMinimizeActiveWindow();
     void testFullscreen_data();
     void testFullscreen();
 
     void testFullscreenRestore_data();
     void testFullscreenRestore();
     void testUserCanSetFullscreen_data();
     void testUserCanSetFullscreen();
     void testUserSetFullscreen_data();
     void testUserSetFullscreen();
 
     void testMaximizedToFullscreen_data();
     void testMaximizedToFullscreen();
     void testWindowOpensLargerThanScreen_data();
     void testWindowOpensLargerThanScreen();
     void testHidden_data();
     void testHidden();
     void testDesktopFileName();
     void testCaptionSimplified();
     void testCaptionMultipleWindows();
     void testUnresponsiveWindow_data();
     void testUnresponsiveWindow();
     void testX11WindowId_data();
     void testX11WindowId();
     void testAppMenu();
     void testNoDecorationModeRequested_data();
     void testNoDecorationModeRequested();
     void testSendClientWithTransientToDesktop_data();
     void testSendClientWithTransientToDesktop();
     void testMinimizeWindowWithTransients_data();
     void testMinimizeWindowWithTransients();
     void testXdgDecoration_data();
     void testXdgDecoration();
     void testXdgNeverCommitted();
     void testXdgInitialState();
     void testXdgInitiallyMaximised();
     void testXdgInitiallyFullscreen();
     void testXdgInitiallyMinimized();
     void testXdgWindowGeometryIsntSet();
     void testXdgWindowGeometryAttachBuffer();
     void testXdgWindowGeometryAttachSubSurface();
     void testXdgWindowGeometryInteractiveResize();
     void testXdgWindowGeometryFullScreen();
     void testXdgWindowGeometryMaximize();
 };
 
 void TestXdgShellClient::initTestCase()
 {
     qRegisterMetaType<KWin::Deleted*>();
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWayland::Client::Output*>();
 
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 }
 
 void TestXdgShellClient::init()
 {
     QVERIFY(Test::setupWaylandConnection(Test::AdditionalWaylandInterface::Decoration |
                                          Test::AdditionalWaylandInterface::XdgDecoration |
                                          Test::AdditionalWaylandInterface::AppMenu));
 
     screens()->setCurrent(0);
     KWin::Cursors::self()->mouse()->setPos(QPoint(1280, 512));
 }
 
 void TestXdgShellClient::cleanup()
 {
     Test::destroyWaylandConnection();
 }
 
 void TestXdgShellClient::testMapUnmapMap_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testMapUnmapMap()
 {
     // this test verifies that mapping a previously mapped window works correctly
     QSignalSpy clientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(clientAddedSpy.isValid());
     QSignalSpy effectsWindowShownSpy(effects, &EffectsHandler::windowShown);
     QVERIFY(effectsWindowShownSpy.isValid());
     QSignalSpy effectsWindowHiddenSpy(effects, &EffectsHandler::windowHidden);
     QVERIFY(effectsWindowHiddenSpy.isValid());
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     // now let's render
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
 
     QVERIFY(clientAddedSpy.isEmpty());
     QVERIFY(clientAddedSpy.wait());
     auto client = clientAddedSpy.first().first().value<AbstractClient *>();
     QVERIFY(client);
     QVERIFY(client->isShown(true));
     QCOMPARE(client->isHiddenInternal(), false);
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->depth(), 32);
     QVERIFY(client->hasAlpha());
     QCOMPARE(client->icon().name(), QStringLiteral("wayland"));
     QCOMPARE(workspace()->activeClient(), client);
     QVERIFY(effectsWindowShownSpy.isEmpty());
     QVERIFY(client->isMaximizable());
     QVERIFY(client->isMovable());
     QVERIFY(client->isMovableAcrossScreens());
     QVERIFY(client->isResizable());
     QVERIFY(client->property("maximizable").toBool());
     QVERIFY(client->property("moveable").toBool());
     QVERIFY(client->property("moveableAcrossScreens").toBool());
     QVERIFY(client->property("resizeable").toBool());
     QCOMPARE(client->isInternal(), false);
     QVERIFY(client->effectWindow());
     QVERIFY(!client->effectWindow()->internalWindow());
     QCOMPARE(client->internalId().isNull(), false);
     const auto uuid = client->internalId();
     QUuid deletedUuid;
     QCOMPARE(deletedUuid.isNull(), true);
 
     connect(client, &AbstractClient::windowClosed, this, [&deletedUuid] (Toplevel *, Deleted *d) { deletedUuid = d->internalId(); });
 
     // now unmap
     QSignalSpy hiddenSpy(client, &AbstractClient::windowHidden);
     QVERIFY(hiddenSpy.isValid());
     QSignalSpy windowClosedSpy(client, &AbstractClient::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->isHiddenInternal(), true);
     QVERIFY(windowClosedSpy.isEmpty());
     QVERIFY(!workspace()->activeClient());
     QCOMPARE(effectsWindowHiddenSpy.count(), 1);
     QCOMPARE(effectsWindowHiddenSpy.first().first().value<EffectWindow*>(), client->effectWindow());
 
     QSignalSpy windowShownSpy(client, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     Test::render(surface.data(), QSize(100, 50), Qt::blue, QImage::Format_RGB32);
     QCOMPARE(clientAddedSpy.count(), 1);
     QVERIFY(windowShownSpy.wait());
     QCOMPARE(windowShownSpy.count(), 1);
     QCOMPARE(clientAddedSpy.count(), 1);
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->isHiddenInternal(), false);
     QCOMPARE(client->depth(), 24);
     QVERIFY(!client->hasAlpha());
     QCOMPARE(workspace()->activeClient(), client);
     QCOMPARE(effectsWindowShownSpy.count(), 1);
     QCOMPARE(effectsWindowShownSpy.first().first().value<EffectWindow*>(), client->effectWindow());
 
     // let's unmap again
     surface->attachBuffer(Buffer::Ptr());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(hiddenSpy.wait());
     QCOMPARE(hiddenSpy.count(), 2);
     QCOMPARE(client->readyForPainting(), true);
     QCOMPARE(client->isHiddenInternal(), true);
     QCOMPARE(client->internalId(), uuid);
     QVERIFY(windowClosedSpy.isEmpty());
     QCOMPARE(effectsWindowHiddenSpy.count(), 2);
     QCOMPARE(effectsWindowHiddenSpy.last().first().value<EffectWindow*>(), client->effectWindow());
 
     shellSurface.reset();
     surface.reset();
     QVERIFY(windowClosedSpy.wait());
     QCOMPARE(windowClosedSpy.count(), 1);
     QCOMPARE(effectsWindowHiddenSpy.count(), 2);
     QCOMPARE(deletedUuid.isNull(), false);
     QCOMPARE(deletedUuid, uuid);
 }
 
 void TestXdgShellClient::testDesktopPresenceChanged()
 {
     // this test verifies that the desktop presence changed signals are properly emitted
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->desktop(), 1);
     effects->setNumberOfDesktops(4);
     QSignalSpy desktopPresenceChangedClientSpy(c, &AbstractClient::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedClientSpy.isValid());
     QSignalSpy desktopPresenceChangedWorkspaceSpy(workspace(), &Workspace::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedWorkspaceSpy.isValid());
     QSignalSpy desktopPresenceChangedEffectsSpy(effects, &EffectsHandler::desktopPresenceChanged);
     QVERIFY(desktopPresenceChangedEffectsSpy.isValid());
 
     // let's change the desktop
     workspace()->sendClientToDesktop(c, 2, false);
     QCOMPARE(c->desktop(), 2);
     QCOMPARE(desktopPresenceChangedClientSpy.count(), 1);
     QCOMPARE(desktopPresenceChangedWorkspaceSpy.count(), 1);
     QCOMPARE(desktopPresenceChangedEffectsSpy.count(), 1);
 
     // verify the arguments
     QCOMPARE(desktopPresenceChangedClientSpy.first().at(0).value<AbstractClient*>(), c);
     QCOMPARE(desktopPresenceChangedClientSpy.first().at(1).toInt(), 1);
     QCOMPARE(desktopPresenceChangedWorkspaceSpy.first().at(0).value<AbstractClient*>(), c);
     QCOMPARE(desktopPresenceChangedWorkspaceSpy.first().at(1).toInt(), 1);
     QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(0).value<EffectWindow*>(), c->effectWindow());
     QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(1).toInt(), 1);
     QCOMPARE(desktopPresenceChangedEffectsSpy.first().at(2).toInt(), 2);
 }
 
 void TestXdgShellClient::testTransientPositionAfterRemap()
 {
     // this test simulates the situation that a transient window gets reused and the parent window
     // moved between the two usages
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // create the Transient window
     XdgPositioner positioner(QSize(50, 40), QRect(0, 0, 5, 10));
     positioner.setAnchorEdge(Qt::BottomEdge | Qt::RightEdge);
     positioner.setGravity(Qt::BottomEdge | Qt::RightEdge);
     QScopedPointer<Surface> transientSurface(Test::createSurface());
     QScopedPointer<XdgShellPopup> transientShellSurface(Test::createXdgShellStablePopup(transientSurface.data(), shellSurface.data(), positioner));
     auto transient = Test::renderAndWaitForShown(transientSurface.data(), positioner.initialSize(), Qt::blue);
     QVERIFY(transient);
     QCOMPARE(transient->frameGeometry(), QRect(c->frameGeometry().topLeft() + QPoint(5, 10), QSize(50, 40)));
 
     // unmap the transient
     QSignalSpy windowHiddenSpy(transient, &AbstractClient::windowHidden);
     QVERIFY(windowHiddenSpy.isValid());
     transientSurface->attachBuffer(Buffer::Ptr());
     transientSurface->commit(Surface::CommitFlag::None);
     QVERIFY(windowHiddenSpy.wait());
 
     // now move the parent surface
     c->setFrameGeometry(c->frameGeometry().translated(5, 10));
 
     // now map the transient again
     QSignalSpy windowShownSpy(transient, &AbstractClient::windowShown);
     QVERIFY(windowShownSpy.isValid());
     Test::render(transientSurface.data(), QSize(50, 40), Qt::blue);
     QVERIFY(windowShownSpy.wait());
     QCOMPARE(transient->frameGeometry(), QRect(c->frameGeometry().topLeft() + QPoint(5, 10), QSize(50, 40)));
 }
 
 void TestXdgShellClient::testWindowOutputs_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testWindowOutputs()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto size = QSize(200,200);
 
     QSignalSpy outputEnteredSpy(surface.data(), &Surface::outputEntered);
     QSignalSpy outputLeftSpy(surface.data(), &Surface::outputLeft);
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     //move to be in the first screen
     c->setFrameGeometry(QRect(QPoint(100,100), size));
     //we don't don't know where the compositor first placed this window,
     //this might fire, it might not
     outputEnteredSpy.wait(5);
     outputEnteredSpy.clear();
 
     QCOMPARE(surface->outputs().count(), 1);
     QCOMPARE(surface->outputs().first()->globalPosition(), QPoint(0,0));
 
     //move to overlapping both first and second screen
     c->setFrameGeometry(QRect(QPoint(1250,100), size));
     QVERIFY(outputEnteredSpy.wait());
     QCOMPARE(outputEnteredSpy.count(), 1);
     QCOMPARE(outputLeftSpy.count(), 0);
     QCOMPARE(surface->outputs().count(), 2);
     QVERIFY(surface->outputs()[0] != surface->outputs()[1]);
 
     //move entirely into second screen
     c->setFrameGeometry(QRect(QPoint(1400,100), size));
     QVERIFY(outputLeftSpy.wait());
     QCOMPARE(outputEnteredSpy.count(), 1);
     QCOMPARE(outputLeftSpy.count(), 1);
     QCOMPARE(surface->outputs().count(), 1);
     QCOMPARE(surface->outputs().first()->globalPosition(), QPoint(1280,0));
 }
 
 void TestXdgShellClient::testMinimizeActiveWindow_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testMinimizeActiveWindow()
 {
     // this test verifies that when minimizing the active window it gets deactivated
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<QObject> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(c->isShown(true));
 
     workspace()->slotWindowMinimize();
     QVERIFY(!c->isShown(true));
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(!c->isActive());
     QVERIFY(!workspace()->activeClient());
     QVERIFY(c->isMinimized());
 
     // unminimize again
     c->unminimize();
     QVERIFY(!c->isMinimized());
     QVERIFY(c->isActive());
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(c->isShown(true));
     QCOMPARE(workspace()->activeClient(), c);
 }
 
 void TestXdgShellClient::testFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<ServerSideDecoration::Mode>("decoMode");
 
     QTest::newRow("xdgShellWmBase") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Client;
 
     QTest::newRow("xdgShellWmBase - deco") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Server;
 }
 
 void TestXdgShellClient::testFullscreen()
 {
     // this test verifies that a window can be properly fullscreened
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(shellSurface);
 
     // create deco
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     QFETCH(ServerSideDecoration::Mode, decoMode);
     deco->requestMode(decoMode);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), decoMode);
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(c->layer(), NormalLayer);
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->clientSize(), QSize(100, 50));
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
     QCOMPARE(c->clientSizeToFrameSize(c->clientSize()), c->frameGeometry().size());
     QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeRequestedSpy.isValid());
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
 
     shellSurface->setFullscreen(true);
     QVERIFY(fullscreenChangedSpy.wait());
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 1);
     QCOMPARE(sizeChangeRequestedSpy.first().first().toSize(), QSize(screens()->size(0)));
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(c->isFullScreen());
     QCOMPARE(c->clientSize(), QSize(100, 50));
     QVERIFY(frameGeometryChangedSpy.isEmpty());
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), sizeChangeRequestedSpy.first().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QVERIFY(c->isFullScreen());
     QVERIFY(!c->isDecorated());
     QCOMPARE(c->frameGeometry(), QRect(QPoint(0, 0), sizeChangeRequestedSpy.first().first().toSize()));
     QCOMPARE(c->layer(), ActiveLayer);
 
     // swap back to normal
     shellSurface->setFullscreen(false);
     QVERIFY(fullscreenChangedSpy.wait());
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 2);
     QCOMPARE(sizeChangeRequestedSpy.last().first().toSize(), QSize(100, 50));
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->layer(), NormalLayer);
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
 }
 
 void TestXdgShellClient::testFullscreenRestore_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgShellWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testFullscreenRestore()
 {
     // this test verifies that windows created fullscreen can be later properly restored
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     XdgShellSurface *xdgShellSurface = Test::createXdgShellSurface(type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly);
     QSignalSpy configureRequestedSpy(xdgShellSurface, &XdgShellSurface::configureRequested);
 
     // fullscreen the window
     xdgShellSurface->setFullscreen(true);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, screens()->size(0));
     QVERIFY(state & KWayland::Client::XdgShellSurface::State::Fullscreen);
     xdgShellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isFullScreen());
 
     configureRequestedSpy.wait(100);
 
     QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
 
     // swap back to normal
     configureRequestedSpy.clear();
     xdgShellSurface->setFullscreen(false);
 
     QVERIFY(fullscreenChangedSpy.wait());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.last().first().toSize(), QSize(0, 0));
     QVERIFY(!c->isFullScreen());
 
     for (const auto &it: configureRequestedSpy) {
         xdgShellSurface->ackConfigure(it[2].toUInt());
     }
 
     Test::render(surface.data(), QSize(100, 50), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->frameGeometry().size(), QSize(100, 50));
 }
 
 void TestXdgShellClient::testUserCanSetFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testUserCanSetFullscreen()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isFullScreen());
     QVERIFY(c->userCanSetFullScreen());
 }
 
 void TestXdgShellClient::testUserSetFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testUserSetFullscreen()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(
         type, surface.data(), surface.data(), Test::CreationSetup::CreateOnly));
     QVERIFY(!shellSurface.isNull());
 
     // wait for the initial configure event
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isFullScreen());
 
     // The client gets activated, which gets another configure event. Though that's not relevant to the test
     configureRequestedSpy.wait(10);
 
     QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
     c->setFullScreen(true);
     QCOMPARE(c->isFullScreen(), true);
     configureRequestedSpy.clear();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.first().at(0).toSize(), screens()->size(0));
     const auto states = configureRequestedSpy.first().at(1).value<KWayland::Client::XdgShellSurface::States>();
     QVERIFY(states.testFlag(KWayland::Client::XdgShellSurface::State::Fullscreen));
     QVERIFY(states.testFlag(KWayland::Client::XdgShellSurface::State::Activated));
     QVERIFY(!states.testFlag(KWayland::Client::XdgShellSurface::State::Maximized));
     QVERIFY(!states.testFlag(KWayland::Client::XdgShellSurface::State::Resizing));
     QCOMPARE(fullscreenChangedSpy.count(), 1);
     QVERIFY(c->isFullScreen());
 
     shellSurface->ackConfigure(configureRequestedSpy.first().at(2).value<quint32>());
 
     // unset fullscreen again
     c->setFullScreen(false);
     QCOMPARE(c->isFullScreen(), false);
     configureRequestedSpy.clear();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
     QCOMPARE(configureRequestedSpy.first().at(0).toSize(), QSize(100, 50));
     QVERIFY(!configureRequestedSpy.first().at(1).value<KWayland::Client::XdgShellSurface::States>().testFlag(KWayland::Client::XdgShellSurface::State::Fullscreen));
     QCOMPARE(fullscreenChangedSpy.count(), 2);
     QVERIFY(!c->isFullScreen());
 }
 
 void TestXdgShellClient::testMaximizedToFullscreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
     QTest::addColumn<ServerSideDecoration::Mode>("decoMode");
 
     QTest::newRow("xdgShellWmBase") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Client;
 
     QTest::newRow("xdgShellWmBase - deco") << Test::XdgShellSurfaceType::XdgShellStable << ServerSideDecoration::Mode::Server;
 }
 
 void TestXdgShellClient::testMaximizedToFullscreen()
 {
     // this test verifies that a window can be properly fullscreened after maximizing
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QVERIFY(shellSurface);
 
     // create deco
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     QFETCH(ServerSideDecoration::Mode, decoMode);
     deco->requestMode(decoMode);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), decoMode);
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->clientSize(), QSize(100, 50));
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
     QSignalSpy fullscreenChangedSpy(c, &AbstractClient::fullScreenChanged);
     QVERIFY(fullscreenChangedSpy.isValid());
     QSignalSpy frameGeometryChangedSpy(c, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), &XdgShellSurface::sizeChanged);
     QVERIFY(sizeChangeRequestedSpy.isValid());
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     shellSurface->setMaximized(true);
     QVERIFY(sizeChangeRequestedSpy.wait());
     QCOMPARE(sizeChangeRequestedSpy.count(), 1);
 
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
     QVERIFY(frameGeometryChangedSpy.wait());
 
     QCOMPARE(c->maximizeMode(), MaximizeFull);
     QCOMPARE(frameGeometryChangedSpy.isEmpty(), false);
     frameGeometryChangedSpy.clear();
 
     // fullscreen the window
     shellSurface->setFullscreen(true);
     QVERIFY(fullscreenChangedSpy.wait());
     if (decoMode == ServerSideDecoration::Mode::Server) {
         QVERIFY(sizeChangeRequestedSpy.wait());
         QCOMPARE(sizeChangeRequestedSpy.count(), 2);
     }
     QCOMPARE(sizeChangeRequestedSpy.last().first().toSize(), QSize(screens()->size(0)));
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(c->isFullScreen());
 
     // render at the new size
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), sizeChangeRequestedSpy.last().first().toSize(), Qt::red);
 
     QVERIFY(c->isFullScreen());
     QVERIFY(!c->isDecorated());
     QCOMPARE(c->frameGeometry(), QRect(QPoint(0, 0), sizeChangeRequestedSpy.last().first().toSize()));
     sizeChangeRequestedSpy.clear();
 
     // swap back to normal
     shellSurface->setFullscreen(false);
     shellSurface->setMaximized(false);
     QVERIFY(fullscreenChangedSpy.wait());
     if (decoMode == ServerSideDecoration::Mode::Server) {
          QVERIFY(sizeChangeRequestedSpy.wait());
          // XDG will legitimately get two updates. They might be batched
          if (shellSurface && sizeChangeRequestedSpy.count() == 1) {
              QVERIFY(sizeChangeRequestedSpy.wait());
          }
          QCOMPARE(sizeChangeRequestedSpy.last().first().toSize(), QSize(100, 50));
     }
     // TODO: should switch to fullscreen once it's updated
     QVERIFY(!c->isFullScreen());
     QCOMPARE(c->isDecorated(), decoMode == ServerSideDecoration::Mode::Server);
 }
 
 void TestXdgShellClient::testWindowOpensLargerThanScreen_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testWindowOpensLargerThanScreen()
 {
     // this test creates a window which is as large as the screen, but is decorated
     // the window should get resized to fit into the screen, BUG: 366632
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QSignalSpy sizeChangeRequestedSpy(shellSurface.data(), SIGNAL(sizeChanged(QSize)));
     QVERIFY(sizeChangeRequestedSpy.isValid());
 
     // create deco
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     QVERIFY(decoSpy.wait());
     deco->requestMode(ServerSideDecoration::Mode::Server);
     QVERIFY(decoSpy.wait());
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
 
     auto c = Test::renderAndWaitForShown(surface.data(), screens()->size(0), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(c->clientSize(), screens()->size(0));
     QVERIFY(c->isDecorated());
     QEXPECT_FAIL("", "BUG 366632", Continue);
     QVERIFY(sizeChangeRequestedSpy.wait(10));
 }
 
 void TestXdgShellClient::testHidden_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testHidden()
 {
     // this test verifies that when hiding window it doesn't get shown
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<QObject> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->isActive());
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
     QVERIFY(c->isShown(true));
 
     c->hideClient(true);
     QVERIFY(!c->isShown(true));
     QVERIFY(!c->isActive());
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
 
     // unhide again
     c->hideClient(false);
     QVERIFY(c->isShown(true));
     QVERIFY(c->wantsInput());
     QVERIFY(c->wantsTabFocus());
 
     //QCOMPARE(workspace()->activeClient(), c);
 }
 
 void TestXdgShellClient::testDesktopFileName()
 {
     QIcon::setThemeName(QStringLiteral("breeze"));
     // this test verifies that desktop file name is passed correctly to the window
     QScopedPointer<Surface> surface(Test::createSurface());
     // only xdg-shell as ShellSurface misses the setter
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     shellSurface->setAppId(QByteArrayLiteral("org.kde.foo"));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->desktopFileName(), QByteArrayLiteral("org.kde.foo"));
     QCOMPARE(c->resourceClass(), QByteArrayLiteral("org.kde.foo"));
     QVERIFY(c->resourceName().startsWith("testXdgShellClient"));
     // the desktop file does not exist, so icon should be generic Wayland
     QCOMPARE(c->icon().name(), QStringLiteral("wayland"));
 
     QSignalSpy desktopFileNameChangedSpy(c, &AbstractClient::desktopFileNameChanged);
     QVERIFY(desktopFileNameChangedSpy.isValid());
     QSignalSpy iconChangedSpy(c, &AbstractClient::iconChanged);
     QVERIFY(iconChangedSpy.isValid());
     shellSurface->setAppId(QByteArrayLiteral("org.kde.bar"));
     QVERIFY(desktopFileNameChangedSpy.wait());
     QCOMPARE(c->desktopFileName(), QByteArrayLiteral("org.kde.bar"));
     QCOMPARE(c->resourceClass(), QByteArrayLiteral("org.kde.bar"));
     QVERIFY(c->resourceName().startsWith("testXdgShellClient"));
     // icon should still be wayland
     QCOMPARE(c->icon().name(), QStringLiteral("wayland"));
     QVERIFY(iconChangedSpy.isEmpty());
 
     const QString dfPath = QFINDTESTDATA("data/example.desktop");
     shellSurface->setAppId(dfPath.toUtf8());
     QVERIFY(desktopFileNameChangedSpy.wait());
     QCOMPARE(iconChangedSpy.count(), 1);
     QCOMPARE(QString::fromUtf8(c->desktopFileName()), dfPath);
     QCOMPARE(c->icon().name(), QStringLiteral("kwin"));
 }
 
 void TestXdgShellClient::testCaptionSimplified()
 {
     // this test verifies that caption is properly trimmed
     // see BUG 323798 comment #12
     QScopedPointer<Surface> surface(Test::createSurface());
     // only done for xdg-shell as ShellSurface misses the setter
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     const QString origTitle = QString::fromUtf8(QByteArrayLiteral("Was tun, wenn Schüler Autismus haben?\342\200\250\342\200\250\342\200\250 – Marlies Hübner - Mozilla Firefox"));
     shellSurface->setTitle(origTitle);
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->caption() != origTitle);
     QCOMPARE(c->caption(), origTitle.simplified());
 }
 
 void TestXdgShellClient::testCaptionMultipleWindows()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     shellSurface->setTitle(QStringLiteral("foo"));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->caption(), QStringLiteral("foo"));
     QCOMPARE(c->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c->captionSuffix(), QString());
 
     QScopedPointer<Surface> surface2(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface2(Test::createXdgShellStableSurface(surface2.data()));
     shellSurface2->setTitle(QStringLiteral("foo"));
     auto c2 = Test::renderAndWaitForShown(surface2.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c2);
     QCOMPARE(c2->caption(), QStringLiteral("foo <2>"));
     QCOMPARE(c2->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c2->captionSuffix(), QStringLiteral(" <2>"));
 
     QScopedPointer<Surface> surface3(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface3(Test::createXdgShellStableSurface(surface3.data()));
     shellSurface3->setTitle(QStringLiteral("foo"));
     auto c3 = Test::renderAndWaitForShown(surface3.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c3);
     QCOMPARE(c3->caption(), QStringLiteral("foo <3>"));
     QCOMPARE(c3->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c3->captionSuffix(), QStringLiteral(" <3>"));
 
     QScopedPointer<Surface> surface4(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface4(Test::createXdgShellStableSurface(surface4.data()));
     shellSurface4->setTitle(QStringLiteral("bar"));
     auto c4 = Test::renderAndWaitForShown(surface4.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c4);
     QCOMPARE(c4->caption(), QStringLiteral("bar"));
     QCOMPARE(c4->captionNormal(), QStringLiteral("bar"));
     QCOMPARE(c4->captionSuffix(), QString());
     QSignalSpy captionChangedSpy(c4, &AbstractClient::captionChanged);
     QVERIFY(captionChangedSpy.isValid());
     shellSurface4->setTitle(QStringLiteral("foo"));
     QVERIFY(captionChangedSpy.wait());
     QCOMPARE(captionChangedSpy.count(), 1);
     QCOMPARE(c4->caption(), QStringLiteral("foo <4>"));
     QCOMPARE(c4->captionNormal(), QStringLiteral("foo"));
     QCOMPARE(c4->captionSuffix(), QStringLiteral(" <4>"));
 }
 
 void TestXdgShellClient::testUnresponsiveWindow_data()
 {
     QTest::addColumn<QString>("shellInterface");//see env selection in qwaylandintegration.cpp
     QTest::addColumn<bool>("socketMode");
 
     QTest::newRow("xdg display") << "xdg-shell" << false;
     QTest::newRow("xdg socket") << "xdg-shell" << true;
 }
 
 void TestXdgShellClient::testUnresponsiveWindow()
 {
     // this test verifies that killWindow properly terminates a process
     // for this an external binary is launched
     const QString kill = QFINDTESTDATA(QStringLiteral("kill"));
     QVERIFY(!kill.isEmpty());
     QSignalSpy shellClientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(shellClientAddedSpy.isValid());
 
     QScopedPointer<QProcess> process(new QProcess);
     QProcessEnvironment env = QProcessEnvironment::systemEnvironment();
 
     QFETCH(QString, shellInterface);
     QFETCH(bool, socketMode);
     env.insert("QT_WAYLAND_SHELL_INTEGRATION", shellInterface);
     if (socketMode) {
         int sx[2];
         QVERIFY(socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) >= 0);
         waylandServer()->display()->createClient(sx[0]);
         int socket = dup(sx[1]);
         QVERIFY(socket != -1);
         env.insert(QStringLiteral("WAYLAND_SOCKET"), QByteArray::number(socket));
         env.remove("WAYLAND_DISPLAY");
     } else {
         env.insert("WAYLAND_DISPLAY", s_socketName);
     }
     process->setProcessEnvironment(env);
     process->setProcessChannelMode(QProcess::ForwardedChannels);
     process->setProgram(kill);
     QSignalSpy processStartedSpy{process.data(), &QProcess::started};
     QVERIFY(processStartedSpy.isValid());
     process->start();
     QVERIFY(processStartedSpy.wait());
 
     AbstractClient *killClient = nullptr;
     if (shellClientAddedSpy.isEmpty()) {
         QVERIFY(shellClientAddedSpy.wait());
     }
     ::kill(process->processId(), SIGUSR1); // send a signal to freeze the process
 
     killClient = shellClientAddedSpy.first().first().value<AbstractClient*>();
     QVERIFY(killClient);
     QSignalSpy unresponsiveSpy(killClient, &AbstractClient::unresponsiveChanged);
     QSignalSpy killedSpy(process.data(), static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished));
     QSignalSpy deletedSpy(killClient, &QObject::destroyed);
 
     qint64 startTime = QDateTime::currentMSecsSinceEpoch();
 
     //wait for the process to be frozen
     QTest::qWait(10);
 
     //pretend the user clicked the close button
     killClient->closeWindow();
 
     //client should not yet be marked unresponsive nor killed
     QVERIFY(!killClient->unresponsive());
     QVERIFY(killedSpy.isEmpty());
 
     QVERIFY(unresponsiveSpy.wait());
     //client should be marked unresponsive but not killed
     auto elapsed1 = QDateTime::currentMSecsSinceEpoch() - startTime;
     QVERIFY(elapsed1 > 900  && elapsed1 < 1200); //ping timer is 1s, but coarse timers on a test across two processes means we need a fuzzy compare
     QVERIFY(killClient->unresponsive());
     QVERIFY(killedSpy.isEmpty());
 
     QVERIFY(deletedSpy.wait());
     if (!socketMode) {
         //process was killed - because we're across process this could happen in either order
         QVERIFY(killedSpy.count() || killedSpy.wait());
     }
 
     auto elapsed2 = QDateTime::currentMSecsSinceEpoch() - startTime;
     QVERIFY(elapsed2 > 1800); //second ping comes in a second later
 }
 
 void TestXdgShellClient::testX11WindowId_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testX11WindowId()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(c->windowId() != 0);
     QCOMPARE(c->window(), 0u);
 }
 
 void TestXdgShellClient::testAppMenu()
 {
     //register a faux appmenu client
     QVERIFY (QDBusConnection::sessionBus().registerService("org.kde.kappmenu"));
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QScopedPointer<AppMenu> menu(Test::waylandAppMenuManager()->create(surface.data()));
     QSignalSpy spy(c, &AbstractClient::hasApplicationMenuChanged);
     menu->setAddress("service.name", "object/path");
     spy.wait();
     QCOMPARE(c->hasApplicationMenu(), true);
     QCOMPARE(c->applicationMenuServiceName(), QString("service.name"));
     QCOMPARE(c->applicationMenuObjectPath(), QString("object/path"));
 
     QVERIFY (QDBusConnection::sessionBus().unregisterService("org.kde.kappmenu"));
 }
 
 void TestXdgShellClient::testNoDecorationModeRequested_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testNoDecorationModeRequested()
 {
     // this test verifies that the decoration follows the default mode if no mode is explicitly requested
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     QScopedPointer<ServerSideDecoration> deco(Test::waylandServerSideDecoration()->create(surface.data()));
     QSignalSpy decoSpy(deco.data(), &ServerSideDecoration::modeChanged);
     QVERIFY(decoSpy.isValid());
     if (deco->mode() != ServerSideDecoration::Mode::Server) {
         QVERIFY(decoSpy.wait());
     }
     QCOMPARE(deco->mode(), ServerSideDecoration::Mode::Server);
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QCOMPARE(c->noBorder(), false);
     QCOMPARE(c->isDecorated(), true);
 }
 
 void TestXdgShellClient::testSendClientWithTransientToDesktop_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase") << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testSendClientWithTransientToDesktop()
 {
     // this test verifies that when sending a client to a desktop all transients are also send to that desktop
 
     VirtualDesktopManager::self()->setCount(2);
     QScopedPointer<Surface> surface{Test::createSurface()};
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
 
     // let's create a transient window
     QScopedPointer<Surface> transientSurface{Test::createSurface()};
     QScopedPointer<XdgShellSurface> transientShellSurface(Test::createXdgShellSurface(type, transientSurface.data()));
     transientShellSurface->setTransientFor(shellSurface.data());
 
     auto transient = Test::renderAndWaitForShown(transientSurface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(transient);
     QCOMPARE(workspace()->activeClient(), transient);
     QCOMPARE(transient->transientFor(), c);
     QVERIFY(c->transients().contains(transient));
 
     QCOMPARE(c->desktop(), 1);
     QVERIFY(!c->isOnAllDesktops());
     QCOMPARE(transient->desktop(), 1);
     QVERIFY(!transient->isOnAllDesktops());
     workspace()->slotWindowToDesktop(2);
 
     QCOMPARE(c->desktop(), 1);
     QCOMPARE(transient->desktop(), 2);
 
     // activate c
     workspace()->activateClient(c);
     QCOMPARE(workspace()->activeClient(), c);
     QVERIFY(c->isActive());
 
     // and send it to the desktop it's already on
     QCOMPARE(c->desktop(), 1);
     QCOMPARE(transient->desktop(), 2);
     workspace()->slotWindowToDesktop(1);
 
     // which should move the transient back to the desktop
     QCOMPARE(c->desktop(), 1);
     QCOMPARE(transient->desktop(), 1);
 }
 
 void TestXdgShellClient::testMinimizeWindowWithTransients_data()
 {
     QTest::addColumn<Test::XdgShellSurfaceType>("type");
 
     QTest::newRow("xdgWmBase")  << Test::XdgShellSurfaceType::XdgShellStable;
 }
 
 void TestXdgShellClient::testMinimizeWindowWithTransients()
 {
     // this test verifies that when minimizing/unminimizing a window all its
     // transients will be minimized/unminimized as well
 
     // create the main window
     QScopedPointer<Surface> surface(Test::createSurface());
     QFETCH(Test::XdgShellSurfaceType, type);
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellSurface(type, surface.data()));
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(c);
     QVERIFY(!c->isMinimized());
 
     // create a transient window
     QScopedPointer<Surface> transientSurface(Test::createSurface());
     QScopedPointer<XdgShellSurface> transientShellSurface(Test::createXdgShellSurface(type, transientSurface.data()));
     transientShellSurface->setTransientFor(shellSurface.data());
     auto transient = Test::renderAndWaitForShown(transientSurface.data(), QSize(100, 50), Qt::red);
     QVERIFY(transient);
     QVERIFY(!transient->isMinimized());
     QCOMPARE(transient->transientFor(), c);
     QVERIFY(c->hasTransient(transient, false));
 
     // minimize the main window, the transient should be minimized as well
     c->minimize();
     QVERIFY(c->isMinimized());
     QVERIFY(transient->isMinimized());
 
     // unminimize the main window, the transient should be unminimized as well
     c->unminimize();
     QVERIFY(!c->isMinimized());
     QVERIFY(!transient->isMinimized());
 }
 
 void TestXdgShellClient::testXdgDecoration_data()
 {
     QTest::addColumn<KWayland::Client::XdgDecoration::Mode>("requestedMode");
     QTest::addColumn<KWayland::Client::XdgDecoration::Mode>("expectedMode");
 
     QTest::newRow("client side requested") << XdgDecoration::Mode::ClientSide << XdgDecoration::Mode::ClientSide;
     QTest::newRow("server side requested") << XdgDecoration::Mode::ServerSide << XdgDecoration::Mode::ServerSide;
 }
 
 void TestXdgShellClient::testXdgDecoration()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     QScopedPointer<XdgDecoration> deco(Test::xdgDecorationManager()->getToplevelDecoration(shellSurface.data()));
 
     QSignalSpy decorationConfiguredSpy(deco.data(), &XdgDecoration::modeChanged);
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     QFETCH(KWayland::Client::XdgDecoration::Mode, requestedMode);
     QFETCH(KWayland::Client::XdgDecoration::Mode, expectedMode);
 
     //request a mode
     deco->setMode(requestedMode);
 
     //kwin will send a configure
     decorationConfiguredSpy.wait();
     configureRequestedSpy.wait();
 
     QCOMPARE(decorationConfiguredSpy.count(), 1);
     QCOMPARE(decorationConfiguredSpy.first()[0].value<KWayland::Client::XdgDecoration::Mode>(), expectedMode);
     QVERIFY(configureRequestedSpy.count() > 0);
 
     shellSurface->ackConfigure(configureRequestedSpy.last()[2].toInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(100, 50), Qt::blue);
     QCOMPARE(c->userCanSetNoBorder(), expectedMode == XdgDecoration::Mode::ServerSide);
     QCOMPARE(c->isDecorated(), expectedMode == XdgDecoration::Mode::ServerSide);
 }
 
 void TestXdgShellClient::testXdgNeverCommitted()
 {
     //check we don't crash if we create a shell object but delete the XdgShellClient before committing it
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
 }
 
 void TestXdgShellClient::testXdgInitialState()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
 
     QCOMPARE(size, QSize(0, 0)); //client should chose it's preferred size
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), QSize(200,100), Qt::blue);
     QCOMPARE(c->size(), QSize(200, 100));
 }
 
 void TestXdgShellClient::testXdgInitiallyMaximised()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     shellSurface->setMaximized(true);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, QSize(1280, 1024));
     QVERIFY(state & KWayland::Client::XdgShellSurface::State::Maximized);
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     QCOMPARE(c->maximizeMode(), MaximizeFull);
     QCOMPARE(c->size(), QSize(1280, 1024));
 }
 
 void TestXdgShellClient::testXdgInitiallyFullscreen()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     shellSurface->setFullscreen(true);
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, QSize(1280, 1024));
     QVERIFY(state & KWayland::Client::XdgShellSurface::State::Fullscreen);
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue);
     QCOMPARE(c->isFullScreen(), true);
     QCOMPARE(c->size(), QSize(1280, 1024));
 }
 
 void TestXdgShellClient::testXdgInitiallyMinimized()
 {
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data(), nullptr, Test::CreationSetup::CreateOnly));
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
 
     shellSurface->requestMinimize();
     surface->commit(Surface::CommitFlag::None);
 
     configureRequestedSpy.wait();
 
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     const auto size = configureRequestedSpy.first()[0].value<QSize>();
     const auto state = configureRequestedSpy.first()[1].value<KWayland::Client::XdgShellSurface::States>();
 
     QCOMPARE(size, QSize(0, 0));
     QCOMPARE(state, 0);
 
     shellSurface->ackConfigure(configureRequestedSpy.first()[2].toUInt());
 
     QEXPECT_FAIL("", "Client created in a minimised state is not exposed to kwin bug 404838", Abort);
     auto c = Test::renderAndWaitForShown(surface.data(), size, Qt::blue, QImage::Format_ARGB32, 10);
     QVERIFY(c);
     QVERIFY(c->isMinimized());
 }
 
 void TestXdgShellClient::testXdgWindowGeometryIsntSet()
 {
     // This test verifies that the effective window geometry corresponds to the
     // bounding rectangle of the main surface and its sub-surfaces if no window
     // geometry is set by the client.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     const QPoint oldPosition = client->pos();
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(100, 50));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition);
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 
     QScopedPointer<Surface> childSurface(Test::createSurface());
     QScopedPointer<SubSurface> subSurface(Test::createSubSurface(childSurface.data(), surface.data()));
     QVERIFY(subSurface);
     subSurface->setPosition(QPoint(-20, -10));
     Test::render(childSurface.data(), QSize(100, 50), Qt::blue);
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(120, 60));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition + QPoint(20, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryAttachBuffer()
 {
     // This test verifies that the effective window geometry remains the same when
     // a new buffer is attached and xdg_surface.set_window_geometry is not called
     // again. Notice that the window geometry must remain the same even if the new
     // buffer is smaller.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     const QPoint oldPosition = client->pos();
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 1);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 
     Test::render(surface.data(), QSize(100, 50), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 2);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(100, 50));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 
     shellSurface->setWindowGeometry(QRect(5, 5, 90, 40));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(frameGeometryChangedSpy.count(), 3);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(90, 40));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(5, 5));
     QCOMPARE(client->bufferGeometry().size(), QSize(100, 50));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryAttachSubSurface()
 {
     // This test verifies that the effective window geometry remains the same
     // when a new sub-surface is added and xdg_surface.set_window_geometry is
     // not called again.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     const QPoint oldPosition = client->pos();
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 
     QScopedPointer<Surface> childSurface(Test::createSurface());
     QScopedPointer<SubSurface> subSurface(Test::createSubSurface(childSurface.data(), surface.data()));
     QVERIFY(subSurface);
     subSurface->setPosition(QPoint(-20, -20));
     Test::render(childSurface.data(), QSize(100, 50), Qt::blue);
     surface->commit(Surface::CommitFlag::None);
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(10, 10));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 
     shellSurface->setWindowGeometry(QRect(-15, -15, 50, 40));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->frameGeometry().topLeft(), oldPosition);
     QCOMPARE(client->frameGeometry().size(), QSize(50, 40));
     QCOMPARE(client->bufferGeometry().topLeft(), oldPosition - QPoint(-15, -15));
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryInteractiveResize()
 {
     // This test verifies that correct window geometry is provided along each
     // configure event when an xdg-shell is being interactively resized.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     QSignalSpy clientStartMoveResizedSpy(client, &AbstractClient::clientStartUserMovedResized);
     QVERIFY(clientStartMoveResizedSpy.isValid());
     QSignalSpy clientStepUserMovedResizedSpy(client, &AbstractClient::clientStepUserMovedResized);
     QVERIFY(clientStepUserMovedResizedSpy.isValid());
     QSignalSpy clientFinishUserMovedResizedSpy(client, &AbstractClient::clientFinishUserMovedResized);
     QVERIFY(clientFinishUserMovedResizedSpy.isValid());
 
     // Start interactively resizing the client.
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
     workspace()->slotWindowResize();
     QCOMPARE(workspace()->moveResizeClient(), client);
     QCOMPARE(clientStartMoveResizedSpy.count(), 1);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
 
     // Go right.
     QPoint cursorPos = KWin::Cursors::self()->mouse()->pos();
     client->keyPressEvent(Qt::Key_Right);
     client->updateMoveResize(KWin::Cursors::self()->mouse()->pos());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(8, 0));
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(188, 80));
     shellSurface->setWindowGeometry(QRect(10, 10, 188, 80));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(208, 100), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 1);
     QCOMPARE(client->bufferGeometry().size(), QSize(208, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(188, 80));
 
     // Go down.
     cursorPos = KWin::Cursors::self()->mouse()->pos();
     client->keyPressEvent(Qt::Key_Down);
     client->updateMoveResize(KWin::Cursors::self()->mouse()->pos());
     QCOMPARE(KWin::Cursors::self()->mouse()->pos(), cursorPos + QPoint(0, 8));
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 4);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Resizing));
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(188, 88));
     shellSurface->setWindowGeometry(QRect(10, 10, 188, 88));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(208, 108), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(clientStepUserMovedResizedSpy.count(), 2);
     QCOMPARE(client->bufferGeometry().size(), QSize(208, 108));
     QCOMPARE(client->frameGeometry().size(), QSize(188, 88));
 
     // Finish resizing the client.
     client->keyPressEvent(Qt::Key_Enter);
     QCOMPARE(clientFinishUserMovedResizedSpy.count(), 1);
     QCOMPARE(workspace()->moveResizeClient(), nullptr);
 #if 0
     QEXPECT_FAIL("", "XdgShellClient currently doesn't send final configure event", Abort);
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 5);
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Resizing));
 #endif
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryFullScreen()
 {
     // This test verifies that an xdg-shell receives correct window geometry when
     // its fullscreen state gets changed.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     workspace()->slotWindowFullScreen();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
     XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Fullscreen));
     shellSurface->setWindowGeometry(QRect(0, 0, 1280, 1024));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(1280, 1024));
     QCOMPARE(client->frameGeometry().size(), QSize(1280, 1024));
 
     workspace()->slotWindowFullScreen();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(180, 80));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Fullscreen));
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(200, 100), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 void TestXdgShellClient::testXdgWindowGeometryMaximize()
 {
     // This test verifies that an xdg-shell receives correct window geometry when
     // its maximized state gets changed.
 
     QScopedPointer<Surface> surface(Test::createSurface());
     QScopedPointer<XdgShellSurface> shellSurface(Test::createXdgShellStableSurface(surface.data()));
     AbstractClient *client = Test::renderAndWaitForShown(surface.data(), QSize(200, 100), Qt::red);
     QVERIFY(client);
     QVERIFY(client->isActive());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(200, 100));
 
     QSignalSpy configureRequestedSpy(shellSurface.data(), &XdgShellSurface::configureRequested);
     QVERIFY(configureRequestedSpy.isValid());
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 1);
 
     QSignalSpy frameGeometryChangedSpy(client, &AbstractClient::frameGeometryChanged);
     QVERIFY(frameGeometryChangedSpy.isValid());
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     surface->commit(Surface::CommitFlag::None);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 2);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
     XdgShellSurface::States states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(states.testFlag(XdgShellSurface::State::Maximized));
     shellSurface->setWindowGeometry(QRect(0, 0, 1280, 1024));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(1280, 1024), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(1280, 1024));
     QCOMPARE(client->frameGeometry().size(), QSize(1280, 1024));
 
     workspace()->slotWindowMaximize();
     QVERIFY(configureRequestedSpy.wait());
     QCOMPARE(configureRequestedSpy.count(), 3);
     QCOMPARE(configureRequestedSpy.last().at(0).toSize(), QSize(180, 80));
     states = configureRequestedSpy.last().at(1).value<XdgShellSurface::States>();
     QVERIFY(!states.testFlag(XdgShellSurface::State::Maximized));
     shellSurface->setWindowGeometry(QRect(10, 10, 180, 80));
     shellSurface->ackConfigure(configureRequestedSpy.last().at(2).value<quint32>());
     Test::render(surface.data(), QSize(200, 100), Qt::blue);
     QVERIFY(frameGeometryChangedSpy.wait());
     QCOMPARE(client->bufferGeometry().size(), QSize(200, 100));
     QCOMPARE(client->frameGeometry().size(), QSize(180, 80));
 
     shellSurface.reset();
     QVERIFY(Test::waitForWindowDestroyed(client));
 }
 
 WAYLANDTEST_MAIN(TestXdgShellClient)
 #include "xdgshellclient_test.moc"
diff --git a/autotests/integration/xwayland_input_test.cpp b/autotests/integration/xwayland_input_test.cpp
index a75264b3a..1eb7a61d0 100644
--- a/autotests/integration/xwayland_input_test.cpp
+++ b/autotests/integration/xwayland_input_test.cpp
@@ -1,313 +1,313 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "platform.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <QSocketNotifier>
 
 #include <netwm.h>
 #include <xcb/xcb_icccm.h>
 
 namespace KWin
 {
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xwayland_input-0");
 
 class XWaylandInputTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void testPointerEnterLeaveSsd();
     void testPointerEventLeaveCsd();
 };
 
 void XWaylandInputTest::initTestCase()
 {
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<KWin::Deleted*>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     setenv("QT_QPA_PLATFORM", "wayland", true);
     waylandServer()->initWorkspace();
 }
 
 void XWaylandInputTest::init()
 {
     screens()->setCurrent(0);
     Cursors::self()->mouse()->setPos(QPoint(640, 512));
     xcb_warp_pointer(connection(), XCB_WINDOW_NONE, kwinApp()->x11RootWindow(), 0, 0, 0, 0, 640, 512);
     xcb_flush(connection());
     QVERIFY(waylandServer()->clients().isEmpty());
 }
 
 struct XcbConnectionDeleter
 {
     static inline void cleanup(xcb_connection_t *pointer)
     {
         xcb_disconnect(pointer);
     }
 };
 
 class X11EventReaderHelper : public QObject
 {
     Q_OBJECT
 public:
     X11EventReaderHelper(xcb_connection_t *c);
 
 Q_SIGNALS:
     void entered(const QPoint &localPoint);
     void left(const QPoint &localPoint);
 
 private:
     void processXcbEvents();
     xcb_connection_t *m_connection;
     QSocketNotifier *m_notifier;
 };
 
 X11EventReaderHelper::X11EventReaderHelper(xcb_connection_t *c)
     : QObject()
     , m_connection(c)
     , m_notifier(new QSocketNotifier(xcb_get_file_descriptor(m_connection), QSocketNotifier::Read, this))
 {
     connect(m_notifier, &QSocketNotifier::activated, this, &X11EventReaderHelper::processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::aboutToBlock, this, &X11EventReaderHelper::processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::awake, this, &X11EventReaderHelper::processXcbEvents);
 }
 
 void X11EventReaderHelper::processXcbEvents()
 {
     while (auto event = xcb_poll_for_event(m_connection)) {
         const uint8_t eventType = event->response_type & ~0x80;
         switch (eventType) {
             case XCB_ENTER_NOTIFY: {
                 auto enterEvent = reinterpret_cast<xcb_enter_notify_event_t *>(event);
                 emit entered(QPoint(enterEvent->event_x, enterEvent->event_y));
                 break; }
             case XCB_LEAVE_NOTIFY: {
                 auto leaveEvent = reinterpret_cast<xcb_leave_notify_event_t *>(event);
                 emit left(QPoint(leaveEvent->event_x, leaveEvent->event_y));
                 break; }
         }
         free(event);
     }
     xcb_flush(m_connection);
 }
 
 void XWaylandInputTest::testPointerEnterLeaveSsd()
 {
     // this test simulates a pointer enter and pointer leave on a server-side decorated X11 window
 
     // create the test window
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
     if (xcb_get_setup(c.data())->release_number < 11800000) {
         QSKIP("XWayland 1.18 required");
     }
     X11EventReaderHelper eventReader(c.data());
     QSignalSpy enteredSpy(&eventReader, &X11EventReaderHelper::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(&eventReader, &X11EventReaderHelper::left);
     QVERIFY(leftSpy.isValid());
     // atom for the screenedge show hide functionality
     Xcb::Atom atom(QByteArrayLiteral("_KDE_NET_WM_SCREEN_EDGE_SHOW"), false, c.data());
 
     xcb_window_t w = xcb_generate_id(c.data());
     const QRect windowGeometry = QRect(0, 0, 100, 200);
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, w, rootWindow(),
                       windowGeometry.x(),
                       windowGeometry.y(),
                       windowGeometry.width(),
                       windowGeometry.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, windowGeometry.x(), windowGeometry.y());
     xcb_icccm_size_hints_set_size(&hints, 1, windowGeometry.width(), windowGeometry.height());
     xcb_icccm_set_wm_normal_hints(c.data(), w, &hints);
     NETWinInfo info(c.data(), w, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     xcb_map_window(c.data(), w);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(client->isDecorated());
     QVERIFY(!client->hasStrut());
     QVERIFY(!client->isHiddenInternal());
     QVERIFY(!client->readyForPainting());
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
     QVERIFY(!client->surface());
     QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
     QVERIFY(surfaceChangedSpy.isValid());
     QVERIFY(surfaceChangedSpy.wait());
     QVERIFY(client->surface());
 
     // move pointer into the window, should trigger an enter
     QVERIFY(!client->frameGeometry().contains(Cursors::self()->mouse()->pos()));
     QVERIFY(enteredSpy.isEmpty());
     Cursors::self()->mouse()->setPos(client->frameGeometry().center());
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), client->surface());
     QVERIFY(waylandServer()->seat()->focusedPointer());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.last().first(), client->frameGeometry().center() - client->clientPos());
 
     // move out of window
     Cursors::self()->mouse()->setPos(client->frameGeometry().bottomRight() + QPoint(10, 10));
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.last().first(), client->frameGeometry().center() - client->clientPos());
 
     // destroy window again
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), w);
     xcb_destroy_window(c.data(), w);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 void XWaylandInputTest::testPointerEventLeaveCsd()
 {
     // this test simulates a pointer enter and pointer leave on a client-side decorated X11 window
 
     QScopedPointer<xcb_connection_t, XcbConnectionDeleter> c(xcb_connect(nullptr, nullptr));
     QVERIFY(!xcb_connection_has_error(c.data()));
 
     if (xcb_get_setup(c.data())->release_number < 11800000) {
         QSKIP("XWayland 1.18 required");
     }
     if (!Xcb::Extensions::self()->isShapeAvailable()) {
         QSKIP("SHAPE extension is required");
     }
 
     X11EventReaderHelper eventReader(c.data());
     QSignalSpy enteredSpy(&eventReader, &X11EventReaderHelper::entered);
     QVERIFY(enteredSpy.isValid());
     QSignalSpy leftSpy(&eventReader, &X11EventReaderHelper::left);
     QVERIFY(leftSpy.isValid());
 
     // Extents of the client-side drop-shadow.
     NETStrut clientFrameExtent;
     clientFrameExtent.left = 10;
     clientFrameExtent.right = 10;
     clientFrameExtent.top = 5;
     clientFrameExtent.bottom = 20;
 
     // Need to set the bounding shape in order to create a window without decoration.
     xcb_rectangle_t boundingRect;
     boundingRect.x = 0;
     boundingRect.y = 0;
     boundingRect.width = 100 + clientFrameExtent.left + clientFrameExtent.right;
     boundingRect.height = 200 + clientFrameExtent.top + clientFrameExtent.bottom;
 
     xcb_window_t window = xcb_generate_id(c.data());
     const uint32_t values[] = {
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW
     };
     xcb_create_window(c.data(), XCB_COPY_FROM_PARENT, window, rootWindow(),
                       boundingRect.x, boundingRect.y, boundingRect.width, boundingRect.height,
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT, XCB_CW_EVENT_MASK, values);
     xcb_size_hints_t hints;
     memset(&hints, 0, sizeof(hints));
     xcb_icccm_size_hints_set_position(&hints, 1, boundingRect.x, boundingRect.y);
     xcb_icccm_size_hints_set_size(&hints, 1, boundingRect.width, boundingRect.height);
     xcb_icccm_set_wm_normal_hints(c.data(), window, &hints);
     xcb_shape_rectangles(c.data(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING,
                          XCB_CLIP_ORDERING_UNSORTED, window, 0, 0, 1, &boundingRect);
     NETWinInfo info(c.data(), window, rootWindow(), NET::WMAllProperties, NET::WM2AllProperties);
     info.setWindowType(NET::Normal);
     info.setGtkFrameExtents(clientFrameExtent);
     xcb_map_window(c.data(), window);
     xcb_flush(c.data());
 
     QSignalSpy windowCreatedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(windowCreatedSpy.isValid());
     QVERIFY(windowCreatedSpy.wait());
     X11Client *client = windowCreatedSpy.last().first().value<X11Client *>();
     QVERIFY(client);
     QVERIFY(!client->isDecorated());
     QVERIFY(client->isClientSideDecorated());
     QCOMPARE(client->bufferGeometry(), QRect(0, 0, 120, 225));
     QCOMPARE(client->frameGeometry(), QRect(10, 5, 100, 200));
 
     QMetaObject::invokeMethod(client, "setReadyForPainting");
     QVERIFY(client->readyForPainting());
     QVERIFY(!client->surface());
     QSignalSpy surfaceChangedSpy(client, &Toplevel::surfaceChanged);
     QVERIFY(surfaceChangedSpy.isValid());
     QVERIFY(surfaceChangedSpy.wait());
     QVERIFY(client->surface());
 
     // Move pointer into the window, should trigger an enter.
     QVERIFY(!client->frameGeometry().contains(Cursors::self()->mouse()->pos()));
     QVERIFY(enteredSpy.isEmpty());
     Cursors::self()->mouse()->setPos(client->frameGeometry().center());
     QCOMPARE(waylandServer()->seat()->focusedPointerSurface(), client->surface());
     QVERIFY(waylandServer()->seat()->focusedPointer());
     QVERIFY(enteredSpy.wait());
     QCOMPARE(enteredSpy.last().first(), QPoint(59, 104));
 
     // Move out of the window, should trigger a leave.
     QVERIFY(leftSpy.isEmpty());
     Cursors::self()->mouse()->setPos(client->frameGeometry().bottomRight() + QPoint(100, 100));
     QVERIFY(leftSpy.wait());
     QCOMPARE(leftSpy.last().first(), QPoint(59, 104));
 
     // Destroy the window.
     QSignalSpy windowClosedSpy(client, &X11Client::windowClosed);
     QVERIFY(windowClosedSpy.isValid());
     xcb_unmap_window(c.data(), window);
     xcb_destroy_window(c.data(), window);
     xcb_flush(c.data());
     QVERIFY(windowClosedSpy.wait());
 }
 
 }
 
 WAYLANDTEST_MAIN(KWin::XWaylandInputTest)
 #include "xwayland_input_test.moc"
diff --git a/autotests/integration/xwayland_selections_test.cpp b/autotests/integration/xwayland_selections_test.cpp
index 75867d896..975363652 100644
--- a/autotests/integration/xwayland_selections_test.cpp
+++ b/autotests/integration/xwayland_selections_test.cpp
@@ -1,196 +1,196 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "kwin_wayland_test.h"
 #include "abstract_client.h"
 #include "platform.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "../../xwl/databridge.h"
 
-#include <KWayland/Server/datadevice_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
 
 #include <QProcess>
 #include <QProcessEnvironment>
 
 using namespace KWin;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_xwayland_selections-0");
 
 class XwaylandSelectionsTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void cleanup();
     void testSync_data();
     void testSync();
 
 private:
     QProcess *m_copyProcess = nullptr;
     QProcess *m_pasteProcess = nullptr;
 };
 
 void XwaylandSelectionsTest::initTestCase()
 {
     QSKIP("Skipped as it fails for unknown reasons on build.kde.org");
     qRegisterMetaType<KWin::AbstractClient*>();
     qRegisterMetaType<QProcess::ExitStatus>();
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
 //    QSignalSpy clipboardSyncDevicedCreated{waylandServer(), &WaylandServer::xclipboardSyncDataDeviceCreated};
 //    QVERIFY(clipboardSyncDevicedCreated.isValid());
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
     QMetaObject::invokeMethod(kwinApp()->platform(), "setVirtualOutputs", Qt::DirectConnection, Q_ARG(int, 2));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     QCOMPARE(screens()->count(), 2);
     QCOMPARE(screens()->geometry(0), QRect(0, 0, 1280, 1024));
     QCOMPARE(screens()->geometry(1), QRect(1280, 0, 1280, 1024));
     waylandServer()->initWorkspace();
 //    // wait till the xclipboard sync data device is created
 //    if (clipboardSyncDevicedCreated.empty()) {
 //        QVERIFY(clipboardSyncDevicedCreated.wait());
 //    }
     // wait till the DataBridge sync data device is created
     while (Xwl::DataBridge::self()->dataDeviceIface() == nullptr) {
         QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
     }
     QVERIFY(Xwl::DataBridge::self()->dataDeviceIface() != nullptr);
 }
 
 void XwaylandSelectionsTest::cleanup()
 {
     if (m_copyProcess) {
         m_copyProcess->terminate();
         QVERIFY(m_copyProcess->waitForFinished());
         m_copyProcess = nullptr;
     }
     if (m_pasteProcess) {
         m_pasteProcess->terminate();
         QVERIFY(m_pasteProcess->waitForFinished());
         m_pasteProcess = nullptr;
     }
 }
 
 void XwaylandSelectionsTest::testSync_data()
 {
     QTest::addColumn<QString>("copyPlatform");
     QTest::addColumn<QString>("pastePlatform");
 
     QTest::newRow("x11->wayland") << QStringLiteral("xcb") << QStringLiteral("wayland");
     QTest::newRow("wayland->x11") << QStringLiteral("wayland") << QStringLiteral("xcb");
 }
 
 void XwaylandSelectionsTest::testSync()
 {
     // this test verifies the syncing of X11 to Wayland clipboard
     const QString copy = QFINDTESTDATA(QStringLiteral("copy"));
     QVERIFY(!copy.isEmpty());
     const QString paste = QFINDTESTDATA(QStringLiteral("paste"));
     QVERIFY(!paste.isEmpty());
 
     QSignalSpy clientAddedSpy(workspace(), &Workspace::clientAdded);
     QVERIFY(clientAddedSpy.isValid());
     QSignalSpy shellClientAddedSpy(waylandServer(), &WaylandServer::shellClientAdded);
     QVERIFY(shellClientAddedSpy.isValid());
-    QSignalSpy clipboardChangedSpy(Xwl::DataBridge::self()->dataDeviceIface(), &KWayland::Server::DataDeviceInterface::selectionChanged);
+    QSignalSpy clipboardChangedSpy(Xwl::DataBridge::self()->dataDeviceIface(), &KWaylandServer::DataDeviceInterface::selectionChanged);
     QVERIFY(clipboardChangedSpy.isValid());
 
     QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
 
     // start the copy process
     QFETCH(QString, copyPlatform);
     environment.insert(QStringLiteral("QT_QPA_PLATFORM"), copyPlatform);
     environment.insert(QStringLiteral("WAYLAND_DISPLAY"), s_socketName);
     m_copyProcess = new QProcess();
     m_copyProcess->setProcessEnvironment(environment);
     m_copyProcess->setProcessChannelMode(QProcess::ForwardedChannels);
     m_copyProcess->setProgram(copy);
     m_copyProcess->start();
     QVERIFY(m_copyProcess->waitForStarted());
 
     AbstractClient *copyClient = nullptr;
     if (copyPlatform == QLatin1String("xcb")) {
         QVERIFY(clientAddedSpy.wait());
         copyClient = clientAddedSpy.first().first().value<AbstractClient*>();
     } else {
         QVERIFY(shellClientAddedSpy.wait());
         copyClient = shellClientAddedSpy.first().first().value<AbstractClient*>();
     }
     QVERIFY(copyClient);
     if (workspace()->activeClient() != copyClient) {
         workspace()->activateClient(copyClient);
     }
     QCOMPARE(workspace()->activeClient(), copyClient);
     if (copyPlatform == QLatin1String("xcb")) {
         QVERIFY(clipboardChangedSpy.isEmpty());
         QVERIFY(clipboardChangedSpy.wait());
     } else {
         // TODO: it would be better to be able to connect to a signal, instead of waiting
         // the idea is to make sure that the clipboard is updated, thus we need to give it
         // enough time before starting the paste process which creates another window
         QTest::qWait(250);
     }
 
     // start the paste process
     m_pasteProcess = new QProcess();
     QSignalSpy finishedSpy(m_pasteProcess, static_cast<void(QProcess::*)(int,QProcess::ExitStatus)>(&QProcess::finished));
     QVERIFY(finishedSpy.isValid());
     QFETCH(QString, pastePlatform);
     environment.insert(QStringLiteral("QT_QPA_PLATFORM"), pastePlatform);
     m_pasteProcess->setProcessEnvironment(environment);
     m_pasteProcess->setProcessChannelMode(QProcess::ForwardedChannels);
     m_pasteProcess->setProgram(paste);
     m_pasteProcess->start();
     QVERIFY(m_pasteProcess->waitForStarted());
 
     AbstractClient *pasteClient = nullptr;
     if (pastePlatform == QLatin1String("xcb")) {
         QVERIFY(clientAddedSpy.wait());
         pasteClient = clientAddedSpy.last().first().value<AbstractClient*>();
     } else {
         QVERIFY(shellClientAddedSpy.wait());
         pasteClient = shellClientAddedSpy.last().first().value<AbstractClient*>();
     }
     QCOMPARE(clientAddedSpy.count(), 1);
     QCOMPARE(shellClientAddedSpy.count(), 1);
     QVERIFY(pasteClient);
 
     if (workspace()->activeClient() != pasteClient) {
         QSignalSpy clientActivatedSpy(workspace(), &Workspace::clientActivated);
         QVERIFY(clientActivatedSpy.isValid());
         workspace()->activateClient(pasteClient);
         QVERIFY(clientActivatedSpy.wait());
     }
     QTRY_COMPARE(workspace()->activeClient(), pasteClient);
     QVERIFY(finishedSpy.wait());
     QCOMPARE(finishedSpy.first().first().toInt(), 0);
     delete m_pasteProcess;
     m_pasteProcess = nullptr;
     delete m_copyProcess;
     m_copyProcess = nullptr;
 }
 
 WAYLANDTEST_MAIN(XwaylandSelectionsTest)
 #include "xwayland_selections_test.moc"
diff --git a/autotests/mock_effectshandler.h b/autotests/mock_effectshandler.h
index af62e3130..ed38dd6f0 100644
--- a/autotests/mock_effectshandler.h
+++ b/autotests/mock_effectshandler.h
@@ -1,291 +1,291 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef MOCK_EFFECTS_HANDLER_H
 #define MOCK_EFFECTS_HANDLER_H
 
 #include <kwineffects.h>
 #include <QX11Info>
 
 class MockEffectsHandler : public KWin::EffectsHandler
 {
     Q_OBJECT
 public:
     explicit MockEffectsHandler(KWin::CompositingType type);
     void activateWindow(KWin::EffectWindow *) override {}
     KWin::Effect *activeFullScreenEffect() const override {
         return nullptr;
     }
     bool hasActiveFullScreenEffect() const override {
         return false;
     }
     int activeScreen() const override {
         return 0;
     }
     KWin::EffectWindow *activeWindow() const override {
         return nullptr;
     }
     void addRepaint(const QRect &) override {}
     void addRepaint(const QRegion &) override {}
     void addRepaint(int, int, int, int) override {}
     void addRepaintFull() override {}
     double animationTimeFactor() const override {
         return 0;
     }
     xcb_atom_t announceSupportProperty(const QByteArray &, KWin::Effect *) override {
         return XCB_ATOM_NONE;
     }
     void buildQuads(KWin::EffectWindow *, KWin::WindowQuadList &) override {}
     QRect clientArea(KWin::clientAreaOption, const QPoint &, int) const override {
         return QRect();
     }
     QRect clientArea(KWin::clientAreaOption, const KWin::EffectWindow *) const override {
         return QRect();
     }
     QRect clientArea(KWin::clientAreaOption, int, int) const override {
         return QRect();
     }
     void closeTabBox() override {}
     QString currentActivity() const override {
         return QString();
     }
     int currentDesktop() const override {
         return 0;
     }
     int currentTabBoxDesktop() const override {
         return 0;
     }
     QList< int > currentTabBoxDesktopList() const override {
         return QList<int>();
     }
     KWin::EffectWindow *currentTabBoxWindow() const override {
         return nullptr;
     }
     KWin::EffectWindowList currentTabBoxWindowList() const override {
         return KWin::EffectWindowList();
     }
     QPoint cursorPos() const override {
         return QPoint();
     }
     bool decorationsHaveAlpha() const override {
         return false;
     }
     bool decorationSupportsBlurBehind() const override {
         return false;
     }
     void defineCursor(Qt::CursorShape) override {}
     int desktopAbove(int, bool) const override {
         return 0;
     }
     int desktopAtCoords(QPoint) const override {
         return 0;
     }
     int desktopBelow(int, bool) const override {
         return 0;
     }
     QPoint desktopCoords(int) const override {
         return QPoint();
     }
     QPoint desktopGridCoords(int) const override {
         return QPoint();
     }
     int desktopGridHeight() const override {
         return 0;
     }
     QSize desktopGridSize() const override {
         return QSize();
     }
     int desktopGridWidth() const override {
         return 0;
     }
     QString desktopName(int) const override {
         return QString();
     }
     int desktopToLeft(int, bool) const override {
         return 0;
     }
     int desktopToRight(int, bool) const override {
         return 0;
     }
     void doneOpenGLContextCurrent() override {}
     void drawWindow(KWin::EffectWindow *, int, const QRegion &, KWin::WindowPaintData &) override {}
     KWin::EffectFrame *effectFrame(KWin::EffectFrameStyle, bool, const QPoint &, Qt::Alignment) const override {
         return nullptr;
     }
     KWin::EffectWindow *findWindow(WId) const override {
         return nullptr;
     }
-    KWin::EffectWindow *findWindow(KWayland::Server::SurfaceInterface *) const override {
+    KWin::EffectWindow *findWindow(KWaylandServer::SurfaceInterface *) const override {
         return nullptr;
     }
     KWin::EffectWindow *findWindow(QWindow *w) const override {
         Q_UNUSED(w)
         return nullptr;
     }
     KWin::EffectWindow *findWindow(const QUuid &id) const override {
         Q_UNUSED(id)
         return nullptr;
     }
     void *getProxy(QString) override {
         return nullptr;
     }
     bool grabKeyboard(KWin::Effect *) override {
         return false;
     }
     bool hasDecorationShadows() const override {
         return false;
     }
     bool isScreenLocked() const override {
         return false;
     }
     QVariant kwinOption(KWin::KWinOption) override {
         return QVariant();
     }
     bool makeOpenGLContextCurrent() override {
         return false;
     }
     void moveWindow(KWin::EffectWindow *, const QPoint &, bool, double) override {}
     KWin::WindowQuadType newWindowQuadType() override {
         return KWin::WindowQuadError;
     }
     int numberOfDesktops() const override {
         return 0;
     }
     int numScreens() const override {
         return 0;
     }
     bool optionRollOverDesktops() const override {
         return false;
     }
     void paintEffectFrame(KWin::EffectFrame *, const QRegion &, double, double) override {}
     void paintScreen(int, const QRegion &, KWin::ScreenPaintData &) override {}
     void paintWindow(KWin::EffectWindow *, int, const QRegion &, KWin::WindowPaintData &) override {}
     void postPaintScreen() override {}
     void postPaintWindow(KWin::EffectWindow *) override {}
     void prePaintScreen(KWin::ScreenPrePaintData &, int) override {}
     void prePaintWindow(KWin::EffectWindow *, KWin::WindowPrePaintData &, int) override {}
     QByteArray readRootProperty(long int, long int, int) const override {
         return QByteArray();
     }
     void reconfigure() override {}
     void refTabBox() override {}
     void registerAxisShortcut(Qt::KeyboardModifiers, KWin::PointerAxisDirection, QAction *) override {}
     void registerGlobalShortcut(const QKeySequence &, QAction *) override {}
     void registerPointerShortcut(Qt::KeyboardModifiers, Qt::MouseButton, QAction *) override {}
     void registerTouchpadSwipeShortcut(KWin::SwipeDirection, QAction *) override {}
     void reloadEffect(KWin::Effect *) override {}
     void removeSupportProperty(const QByteArray &, KWin::Effect *) override {}
     void reserveElectricBorder(KWin::ElectricBorder, KWin::Effect *) override {}
     void registerTouchBorder(KWin::ElectricBorder, QAction *) override {}
     void unregisterTouchBorder(KWin::ElectricBorder, QAction *) override {}
     QPainter *scenePainter() override {
         return nullptr;
     }
     int screenNumber(const QPoint &) const override {
         return 0;
     }
     void setActiveFullScreenEffect(KWin::Effect *) override {}
     void setCurrentDesktop(int) override {}
     void setElevatedWindow(KWin::EffectWindow *, bool) override {}
     void setNumberOfDesktops(int) override {}
     void setShowingDesktop(bool) override {}
     void setTabBoxDesktop(int) override {}
     void setTabBoxWindow(KWin::EffectWindow*) override {}
     KWin::EffectWindowList stackingOrder() const override {
         return KWin::EffectWindowList();
     }
     void startMouseInterception(KWin::Effect *, Qt::CursorShape) override {}
     void startMousePolling() override {}
     void stopMouseInterception(KWin::Effect *) override {}
     void stopMousePolling() override {}
     void ungrabKeyboard() override {}
     void unrefTabBox() override {}
     void unreserveElectricBorder(KWin::ElectricBorder, KWin::Effect *) override {}
     QRect virtualScreenGeometry() const override {
         return QRect();
     }
     QSize virtualScreenSize() const override {
         return QSize();
     }
     void windowToDesktop(KWin::EffectWindow *, int) override {}
     void windowToScreen(KWin::EffectWindow *, int) override {}
     int workspaceHeight() const override {
         return 0;
     }
     int workspaceWidth() const override {
         return 0;
     }
     long unsigned int xrenderBufferPicture() override {
         return 0;
     }
     xcb_connection_t *xcbConnection() const override {
         return QX11Info::connection();
     }
     xcb_window_t x11RootWindow() const override {
         return QX11Info::appRootWindow();
     }
-    KWayland::Server::Display *waylandDisplay() const override {
+    KWaylandServer::Display *waylandDisplay() const override {
         return nullptr;
     }
 
     bool animationsSupported() const override {
         return m_animationsSuported;
     }
     void setAnimationsSupported(bool set) {
         m_animationsSuported = set;
     }
 
     KWin::PlatformCursorImage cursorImage() const override {
         return KWin::PlatformCursorImage();
     }
 
     void hideCursor() override {}
 
     void showCursor() override {}
 
     void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override {
         callback(nullptr);
     }
     void startInteractivePositionSelection(std::function<void (const QPoint &)> callback) override {
         callback(QPoint(-1, -1));
     }
     void showOnScreenMessage(const QString &message, const QString &iconName = QString()) override {
         Q_UNUSED(message)
         Q_UNUSED(iconName)
     }
     void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags()) override { Q_UNUSED(flags)}
 
     void windowToDesktops(KWin::EffectWindow *w, const QVector<uint> &desktops) override {
         Q_UNUSED(w)
         Q_UNUSED(desktops)
     }
 
     KSharedConfigPtr config() const override;
     KSharedConfigPtr inputConfig() const override;
     void renderEffectQuickView(KWin::EffectQuickView *quickView) const override {
         Q_UNUSED(quickView);
     }
     KWin::SessionState sessionState() const override {
         return KWin::SessionState::Normal;
     }
 
 private:
     bool m_animationsSuported = true;
 };
 #endif
diff --git a/autotests/test_window_paint_data.cpp b/autotests/test_window_paint_data.cpp
index b645b7446..00f581172 100644
--- a/autotests/test_window_paint_data.cpp
+++ b/autotests/test_window_paint_data.cpp
@@ -1,562 +1,562 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include <kwineffects.h>
 #include "../virtualdesktops.h"
 
 #include <QVector2D>
 #include <QGraphicsRotation>
 #include <QGraphicsScale>
 
 #include <QtTest>
 
 using namespace KWin;
 
 class MockEffectWindow : public EffectWindow
 {
     Q_OBJECT
 public:
     MockEffectWindow(QObject *parent = nullptr);
     WindowQuadList buildQuads(bool force = false) const override;
     QVariant data(int role) const override;
     QRect decorationInnerRect() const override;
     void deleteProperty(long int atom) const override;
     void disablePainting(int reason) override;
     void enablePainting(int reason) override;
     void addRepaint(const QRect &r) override;
     void addRepaint(int x, int y, int w, int h) override;
     void addRepaintFull() override;
     void addLayerRepaint(const QRect &r) override;
     void addLayerRepaint(int x, int y, int w, int h) override;
     EffectWindow *findModal() override;
     const EffectWindowGroup *group() const override;
     bool isPaintingEnabled() override;
     EffectWindowList mainWindows() const override;
     QByteArray readProperty(long int atom, long int type, int format) const override;
     void refWindow() override;
     void unrefWindow() override;
     QRegion shape() const override;
     void setData(int role, const QVariant &data) override;
     void minimize() override;
     void unminimize() override;
     void closeWindow() override;
     void referencePreviousWindowPixmap() override {}
     void unreferencePreviousWindowPixmap() override {}
     QWindow *internalWindow() const override {
         return nullptr;
     }
     bool isDeleted() const override {
         return false;
     }
     bool isMinimized() const override {
         return false;
     }
     double opacity() const override {
         return m_opacity;
     }
     void setOpacity(qreal opacity) {
         m_opacity = opacity;
     }
     bool hasAlpha() const override {
         return true;
     }
     QStringList activities() const override {
         return QStringList();
     }
     int desktop() const override {
         return 0;
     }
     QVector<uint> desktops() const override {
         return {};
     }
     int x() const override {
         return 0;
     }
     int y() const override {
         return 0;
     }
     int width() const override {
         return 100;
     }
     int height() const override {
         return 100;
     }
     QSize basicUnit() const override {
         return QSize();
     }
     QRect geometry() const override {
         return QRect();
     }
     QRect expandedGeometry() const override {
         return QRect();
     }
     QRect frameGeometry() const override {
         return QRect();
     }
     QRect bufferGeometry() const override {
         return QRect();
     }
     int screen() const override {
         return 0;
     }
     bool hasOwnShape() const override {
         return false;
     }
     QPoint pos() const override {
         return QPoint();
     }
     QSize size() const override {
         return QSize(100,100);
     }
     QRect rect() const override {
         return QRect(0,0,100,100);
     }
     bool isMovable() const override {
         return true;
     }
     bool isMovableAcrossScreens() const override {
         return true;
     }
     bool isUserMove() const override {
         return false;
     }
     bool isUserResize() const override {
         return false;
     }
     QRect iconGeometry() const override {
         return QRect();
     }
     bool isDesktop() const override {
         return false;
     }
     bool isDock() const override {
         return false;
     }
     bool isToolbar() const override {
         return false;
     }
     bool isMenu() const override {
         return false;
     }
     bool isNormalWindow() const override {
         return true;
     }
     bool isSpecialWindow() const override {
         return false;
     }
     bool isDialog() const override {
         return false;
     }
     bool isSplash() const override {
         return false;
     }
     bool isUtility() const override {
         return false;
     }
     bool isDropdownMenu() const override {
         return false;
     }
     bool isPopupMenu() const override {
         return false;
     }
     bool isTooltip() const override {
         return false;
     }
     bool isNotification() const override {
         return false;
     }
     bool isCriticalNotification() const override {
         return false;
     }
     bool isOnScreenDisplay() const override  {
         return false;
     }
     bool isComboBox() const override {
         return false;
     }
     bool isDNDIcon() const override {
         return false;
     }
     QRect contentsRect() const override {
         return QRect();
     }
     bool decorationHasAlpha() const override {
         return false;
     }
     QString caption() const override {
         return QString();
     }
     QIcon icon() const override {
         return QIcon();
     }
     QString windowClass() const override {
         return QString();
     }
     QString windowRole() const override {
         return QString();
     }
     NET::WindowType windowType() const override {
         return NET::Normal;
     }
     bool acceptsFocus() const override {
         return true;
     }
     bool keepAbove() const override {
         return false;
     }
     bool keepBelow() const override {
         return false;
     }
     bool isModal() const override {
         return false;
     }
     bool isSkipSwitcher() const override {
         return false;
     }
     bool isCurrentTab() const override {
         return true;
     }
     bool skipsCloseAnimation() const override {
         return false;
     }
-    KWayland::Server::SurfaceInterface *surface() const override {
+    KWaylandServer::SurfaceInterface *surface() const override {
         return nullptr;
     }
     bool isFullScreen() const override {
         return false;
     }
     bool isUnresponsive() const override {
         return false;
     }
     bool isPopupWindow() const override {
         return false;
     }
     bool isManaged() const override {
         return true;
     }
     bool isWaylandClient() const override {
         return true;
     }
     bool isX11Client() const override {
         return false;
     }
     bool isOutline() const override {
         return false;
     }
     pid_t pid() const override {
         return 0;
     }
 
 private:
     qreal m_opacity = 1.0;
 };
 
 MockEffectWindow::MockEffectWindow(QObject *parent)
     : EffectWindow(parent)
 {
 }
 
 WindowQuadList MockEffectWindow::buildQuads(bool force) const
 {
     Q_UNUSED(force)
     return WindowQuadList();
 }
 
 QVariant MockEffectWindow::data(int role) const
 {
     Q_UNUSED(role)
     return QVariant();
 }
 
 QRect MockEffectWindow::decorationInnerRect() const
 {
     return QRect();
 }
 
 void MockEffectWindow::deleteProperty(long int atom) const
 {
     Q_UNUSED(atom)
 }
 
 void MockEffectWindow::disablePainting(int reason)
 {
     Q_UNUSED(reason)
 }
 
 void MockEffectWindow::enablePainting(int reason)
 {
     Q_UNUSED(reason)
 }
 
 void MockEffectWindow::addRepaint(const QRect &r)
 {
     Q_UNUSED(r)
 }
 
 void MockEffectWindow::addRepaint(int x, int y, int w, int h)
 {
     Q_UNUSED(x)
     Q_UNUSED(y)
     Q_UNUSED(w)
     Q_UNUSED(h)
 }
 
 void MockEffectWindow::addRepaintFull()
 {
 }
 
 void MockEffectWindow::addLayerRepaint(const QRect &r)
 {
     Q_UNUSED(r)
 }
 
 void MockEffectWindow::addLayerRepaint(int x, int y, int w, int h)
 {
     Q_UNUSED(x)
     Q_UNUSED(y)
     Q_UNUSED(w)
     Q_UNUSED(h)
 }
 
 EffectWindow *MockEffectWindow::findModal()
 {
     return nullptr;
 }
 
 const EffectWindowGroup *MockEffectWindow::group() const
 {
     return nullptr;
 }
 
 bool MockEffectWindow::isPaintingEnabled()
 {
     return true;
 }
 
 EffectWindowList MockEffectWindow::mainWindows() const
 {
     return EffectWindowList();
 }
 
 QByteArray MockEffectWindow::readProperty(long int atom, long int type, int format) const
 {
     Q_UNUSED(atom)
     Q_UNUSED(type)
     Q_UNUSED(format)
     return QByteArray();
 }
 
 void MockEffectWindow::refWindow()
 {
 }
 
 void MockEffectWindow::setData(int role, const QVariant &data)
 {
     Q_UNUSED(role)
     Q_UNUSED(data)
 }
 
 void MockEffectWindow::minimize()
 {
 }
 
 void MockEffectWindow::unminimize()
 {
 }
 
 void MockEffectWindow::closeWindow()
 {
 }
 
 QRegion MockEffectWindow::shape() const
 {
     return QRegion();
 }
 
 void MockEffectWindow::unrefWindow()
 {
 }
 
 class TestWindowPaintData : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void testCtor();
     void testCopyCtor();
     void testOperatorMultiplyAssign();
     void testOperatorPlus();
     void testMultiplyOpacity();
     void testMultiplySaturation();
     void testMultiplyBrightness();
 };
 
 void TestWindowPaintData::testCtor()
 {
     MockEffectWindow w;
     w.setOpacity(0.5);
     WindowPaintData data(&w);
     QCOMPARE(data.xScale(), 1.0);
     QCOMPARE(data.yScale(), 1.0);
     QCOMPARE(data.zScale(), 1.0);
     QCOMPARE(data.xTranslation(), 0.0);
     QCOMPARE(data.yTranslation(), 0.0);
     QCOMPARE(data.zTranslation(), 0.0);
     QCOMPARE(data.translation(), QVector3D());
     QCOMPARE(data.rotationAngle(), 0.0);
     QCOMPARE(data.rotationOrigin(), QVector3D());
     QCOMPARE(data.rotationAxis(), QVector3D(0.0, 0.0, 1.0));
     QCOMPARE(data.opacity(), 0.5);
     QCOMPARE(data.brightness(), 1.0);
     QCOMPARE(data.saturation(), 1.0);
 }
 
 void TestWindowPaintData::testCopyCtor()
 {
     MockEffectWindow w;
     WindowPaintData data(&w);
     WindowPaintData data2(data);
     // no value had been changed
     QCOMPARE(data2.xScale(), 1.0);
     QCOMPARE(data2.yScale(), 1.0);
     QCOMPARE(data2.zScale(), 1.0);
     QCOMPARE(data2.xTranslation(), 0.0);
     QCOMPARE(data2.yTranslation(), 0.0);
     QCOMPARE(data2.zTranslation(), 0.0);
     QCOMPARE(data2.translation(), QVector3D());
     QCOMPARE(data2.rotationAngle(), 0.0);
     QCOMPARE(data2.rotationOrigin(), QVector3D());
     QCOMPARE(data2.rotationAxis(), QVector3D(0.0, 0.0, 1.0));
     QCOMPARE(data2.opacity(), 1.0);
     QCOMPARE(data2.brightness(), 1.0);
     QCOMPARE(data2.saturation(), 1.0);
 
     data2.setScale(QVector3D(0.5, 2.0, 3.0));
     data2.translate(0.5, 2.0, 3.0);
     data2.setRotationAngle(45.0);
     data2.setRotationOrigin(QVector3D(1.0, 2.0, 3.0));
     data2.setRotationAxis(QVector3D(1.0, 1.0, 0.0));
     data2.setOpacity(0.1);
     data2.setBrightness(0.3);
     data2.setSaturation(0.4);
 
     WindowPaintData data3(data2);
     QCOMPARE(data3.xScale(), 0.5);
     QCOMPARE(data3.yScale(), 2.0);
     QCOMPARE(data3.zScale(), 3.0);
     QCOMPARE(data3.xTranslation(), 0.5);
     QCOMPARE(data3.yTranslation(), 2.0);
     QCOMPARE(data3.zTranslation(), 3.0);
     QCOMPARE(data3.translation(), QVector3D(0.5, 2.0, 3.0));
     QCOMPARE(data3.rotationAngle(), 45.0);
     QCOMPARE(data3.rotationOrigin(), QVector3D(1.0, 2.0, 3.0));
     QCOMPARE(data3.rotationAxis(), QVector3D(1.0, 1.0, 0.0));
     QCOMPARE(data3.opacity(), 0.1);
     QCOMPARE(data3.brightness(), 0.3);
     QCOMPARE(data3.saturation(), 0.4);
 }
 
 void TestWindowPaintData::testOperatorMultiplyAssign()
 {
     MockEffectWindow w;
     WindowPaintData data(&w);
     // without anything set, it's 1.0 on all axis
     QCOMPARE(data.xScale(), 1.0);
     QCOMPARE(data.yScale(), 1.0);
     QCOMPARE(data.zScale(), 1.0);
     // multiplying by a factor should set all components
     data *= 2.0;
     QCOMPARE(data.xScale(), 2.0);
     QCOMPARE(data.yScale(), 2.0);
     QCOMPARE(data.zScale(), 2.0);
     // multiplying by a vector2D should set x and y components
     data *= QVector2D(2.0, 3.0);
     QCOMPARE(data.xScale(), 4.0);
     QCOMPARE(data.yScale(), 6.0);
     QCOMPARE(data.zScale(), 2.0);
     // multiplying by a vector3d should set all components
     data *= QVector3D(0.5, 1.5, 2.0);
     QCOMPARE(data.xScale(), 2.0);
     QCOMPARE(data.yScale(), 9.0);
     QCOMPARE(data.zScale(), 4.0);
 }
 
 void TestWindowPaintData::testOperatorPlus()
 {
     MockEffectWindow w;
     WindowPaintData data(&w);
     QCOMPARE(data.xTranslation(), 0.0);
     QCOMPARE(data.yTranslation(), 0.0);
     QCOMPARE(data.zTranslation(), 0.0);
     QCOMPARE(data.translation(), QVector3D());
     // test with point
     data += QPoint(1, 2);
     QCOMPARE(data.translation(), QVector3D(1.0, 2.0, 0.0));
     // test with pointf
     data += QPointF(0.5, 0.75);
     QCOMPARE(data.translation(), QVector3D(1.5, 2.75, 0.0));
     // test with QVector2D
     data += QVector2D(0.25, 1.5);
     QCOMPARE(data.translation(), QVector3D(1.75, 4.25, 0.0));
     // test with QVector3D
     data += QVector3D(1.0, 2.0, 3.5);
     QCOMPARE(data.translation(), QVector3D(2.75, 6.25, 3.5));
 }
 
 void TestWindowPaintData::testMultiplyBrightness()
 {
     MockEffectWindow w;
     WindowPaintData data(&w);
     QCOMPARE(0.2, data.multiplyBrightness(0.2));
     QCOMPARE(0.2, data.brightness());
     QCOMPARE(0.6, data.multiplyBrightness(3.0));
     QCOMPARE(0.6, data.brightness());
     // just for safety
     QCOMPARE(1.0, data.opacity());
     QCOMPARE(1.0, data.saturation());
 }
 
 void TestWindowPaintData::testMultiplyOpacity()
 {
     MockEffectWindow w;
     WindowPaintData data(&w);
     QCOMPARE(0.2, data.multiplyOpacity(0.2));
     QCOMPARE(0.2, data.opacity());
     QCOMPARE(0.6, data.multiplyOpacity(3.0));
     QCOMPARE(0.6, data.opacity());
     // just for safety
     QCOMPARE(1.0, data.brightness());
     QCOMPARE(1.0, data.saturation());
 }
 
 void TestWindowPaintData::testMultiplySaturation()
 {
     MockEffectWindow w;
     WindowPaintData data(&w);
     QCOMPARE(0.2, data.multiplySaturation(0.2));
     QCOMPARE(0.2, data.saturation());
     QCOMPARE(0.6, data.multiplySaturation(3.0));
     QCOMPARE(0.6, data.saturation());
     // just for safety
     QCOMPARE(1.0, data.brightness());
     QCOMPARE(1.0, data.opacity());
 }
 
 QTEST_MAIN(TestWindowPaintData)
 #include "test_window_paint_data.moc"
diff --git a/composite.cpp b/composite.cpp
index 80880a285..ee0b17414 100644
--- a/composite.cpp
+++ b/composite.cpp
@@ -1,1067 +1,1067 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "composite.h"
 
 #include "dbusinterface.h"
 #include "x11client.h"
 #include "decorations/decoratedclient.h"
 #include "deleted.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "overlaywindow.h"
 #include "platform.h"
 #include "scene.h"
 #include "screens.h"
 #include "shadow.h"
 #include "unmanaged.h"
 #include "useractions.h"
 #include "utils.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xcbutils.h"
 
 #include <kwingltexture.h>
 
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginLoader>
 #include <KPluginMetaData>
 #include <KNotification>
 #include <KSelectionOwner>
 
 #include <QDateTime>
 #include <QFutureWatcher>
 #include <QMenu>
 #include <QOpenGLContext>
 #include <QQuickWindow>
 #include <QtConcurrentRun>
 #include <QTextStream>
 #include <QTimerEvent>
 
 #include <xcb/composite.h>
 #include <xcb/damage.h>
 
 #include <cstdio>
 
 Q_DECLARE_METATYPE(KWin::X11Compositor::SuspendReason)
 
 namespace KWin
 {
 
 // See main.cpp:
 extern int screen_number;
 
 extern bool is_multihead;
 extern int currentRefreshRate();
 
 Compositor *Compositor::s_compositor = nullptr;
 Compositor *Compositor::self()
 {
     return s_compositor;
 }
 
 WaylandCompositor *WaylandCompositor::create(QObject *parent)
 {
     Q_ASSERT(!s_compositor);
     auto *compositor = new WaylandCompositor(parent);
     s_compositor = compositor;
     return compositor;
 }
 X11Compositor *X11Compositor::create(QObject *parent)
 {
     Q_ASSERT(!s_compositor);
     auto *compositor = new X11Compositor(parent);
     s_compositor = compositor;
     return compositor;
 }
 
 class CompositorSelectionOwner : public KSelectionOwner
 {
     Q_OBJECT
 public:
     CompositorSelectionOwner(const char *selection)
         : KSelectionOwner(selection, connection(), rootWindow())
         , m_owning(false)
     {
         connect (this, &CompositorSelectionOwner::lostOwnership,
                  this, [this]() { m_owning = false; });
     }
     bool owning() const {
         return m_owning;
     }
     void setOwning(bool own) {
         m_owning = own;
     }
 private:
     bool m_owning;
 };
 
 static inline qint64 milliToNano(int milli) { return qint64(milli) * 1000 * 1000; }
 static inline qint64 nanoToMilli(int nano) { return nano / (1000*1000); }
 
 Compositor::Compositor(QObject* workspace)
     : QObject(workspace)
     , m_state(State::Off)
     , m_selectionOwner(nullptr)
     , vBlankInterval(0)
     , fpsInterval(0)
     , m_timeSinceLastVBlank(0)
     , m_scene(nullptr)
     , m_bufferSwapPending(false)
     , m_composeAtSwapCompletion(false)
 {
     connect(options, &Options::configChanged, this, &Compositor::configChanged);
     connect(options, &Options::animationSpeedChanged, this, &Compositor::configChanged);
 
     m_monotonicClock.start();
 
     // 2 sec which should be enough to restart the compositor.
     static const int compositorLostMessageDelay = 2000;
 
     m_releaseSelectionTimer.setSingleShot(true);
     m_releaseSelectionTimer.setInterval(compositorLostMessageDelay);
     connect(&m_releaseSelectionTimer, &QTimer::timeout,
             this, &Compositor::releaseCompositorSelection);
 
     m_unusedSupportPropertyTimer.setInterval(compositorLostMessageDelay);
     m_unusedSupportPropertyTimer.setSingleShot(true);
     connect(&m_unusedSupportPropertyTimer, &QTimer::timeout,
             this, &Compositor::deleteUnusedSupportProperties);
 
     // Delay the call to start by one event cycle.
     // The ctor of this class is invoked from the Workspace ctor, that means before
     // Workspace is completely constructed, so calling Workspace::self() would result
     // in undefined behavior. This is fixed by using a delayed invocation.
     if (kwinApp()->platform()->isReady()) {
         QTimer::singleShot(0, this, &Compositor::start);
     }
     connect(kwinApp()->platform(), &Platform::readyChanged, this,
         [this] (bool ready) {
             if (ready) {
                 start();
             } else {
                 stop();
             }
         }, Qt::QueuedConnection
     );
 
     if (qEnvironmentVariableIsSet("KWIN_MAX_FRAMES_TESTED"))
        m_framesToTestForSafety = qEnvironmentVariableIntValue("KWIN_MAX_FRAMES_TESTED");
 
     // register DBus
     new CompositorDBusInterface(this);
 }
 
 Compositor::~Compositor()
 {
     emit aboutToDestroy();
     stop();
     deleteUnusedSupportProperties();
     destroyCompositorSelection();
     s_compositor = nullptr;
 }
 
 bool Compositor::setupStart()
 {
     if (kwinApp()->isTerminating()) {
         // Don't start while KWin is terminating. An event to restart might be lingering
         // in the event queue due to graphics reset.
         return false;
     }
     if (m_state != State::Off) {
         return false;
     }
     m_state = State::Starting;
 
     options->reloadCompositingSettings(true);
 
     setupX11Support();
 
     // There might still be a deleted around, needs to be cleared before
     // creating the scene (BUG 333275).
     if (Workspace::self()) {
         while (!Workspace::self()->deletedList().isEmpty()) {
             Workspace::self()->deletedList().first()->discard();
         }
     }
 
     emit aboutToToggleCompositing();
 
     auto supportedCompositors = kwinApp()->platform()->supportedCompositors();
     const auto userConfigIt = std::find(supportedCompositors.begin(), supportedCompositors.end(),
                                         options->compositingMode());
 
     if (userConfigIt != supportedCompositors.end()) {
         supportedCompositors.erase(userConfigIt);
         supportedCompositors.prepend(options->compositingMode());
     } else {
         qCWarning(KWIN_CORE)
                 << "Configured compositor not supported by Platform. Falling back to defaults";
     }
 
     const auto availablePlugins = KPluginLoader::findPlugins(QStringLiteral("org.kde.kwin.scenes"));
 
     for (const KPluginMetaData &pluginMetaData : availablePlugins) {
         qCDebug(KWIN_CORE) << "Available scene plugin:" << pluginMetaData.fileName();
     }
 
     for (auto type : qAsConst(supportedCompositors)) {
         switch (type) {
         case XRenderCompositing:
             qCDebug(KWIN_CORE) << "Attempting to load the XRender scene";
             break;
         case OpenGLCompositing:
         case OpenGL2Compositing:
             qCDebug(KWIN_CORE) << "Attempting to load the OpenGL scene";
             break;
         case QPainterCompositing:
             qCDebug(KWIN_CORE) << "Attempting to load the QPainter scene";
             break;
         case NoCompositing:
             Q_UNREACHABLE();
         }
         const auto pluginIt = std::find_if(availablePlugins.begin(), availablePlugins.end(),
             [type] (const auto &plugin) {
                 const auto &metaData = plugin.rawData();
                 auto it = metaData.find(QStringLiteral("CompositingType"));
                 if (it != metaData.end()) {
                     if ((*it).toInt() == int{type}) {
                         return true;
                     }
                 }
                 return false;
             });
         if (pluginIt != availablePlugins.end()) {
             std::unique_ptr<SceneFactory>
                     factory{ qobject_cast<SceneFactory*>(pluginIt->instantiate()) };
             if (factory) {
                 m_scene = factory->create(this);
                 if (m_scene) {
                     if (!m_scene->initFailed()) {
                         qCDebug(KWIN_CORE) << "Instantiated compositing plugin:"
                                            << pluginIt->name();
                         break;
                     } else {
                         delete m_scene;
                         m_scene = nullptr;
                     }
                 }
             }
         }
     }
 
     if (m_scene == nullptr || m_scene->initFailed()) {
         qCCritical(KWIN_CORE) << "Failed to initialize compositing, compositing disabled";
         m_state = State::Off;
 
         delete m_scene;
         m_scene = nullptr;
 
         if (m_selectionOwner) {
             m_selectionOwner->setOwning(false);
             m_selectionOwner->release();
         }
         if (!supportedCompositors.contains(NoCompositing)) {
             qCCritical(KWIN_CORE) << "The used windowing system requires compositing";
             qCCritical(KWIN_CORE) << "We are going to quit KWin now as it is broken";
             qApp->quit();
         }
         return false;
     }
 
     CompositingType compositingType = m_scene->compositingType();
     if (compositingType & OpenGLCompositing) {
         // Override for OpenGl sub-type OpenGL2Compositing.
         compositingType = OpenGLCompositing;
     }
     kwinApp()->platform()->setSelectedCompositor(compositingType);
 
     if (!Workspace::self() && m_scene && m_scene->compositingType() == QPainterCompositing) {
         // Force Software QtQuick on first startup with QPainter.
         QQuickWindow::setSceneGraphBackend(QSGRendererInterface::Software);
     }
 
     connect(m_scene, &Scene::resetCompositing, this, &Compositor::reinitialize);
     emit sceneCreated();
 
     return true;
 }
 
 void Compositor::claimCompositorSelection()
 {
     if (!m_selectionOwner) {
         char selection_name[ 100 ];
         sprintf(selection_name, "_NET_WM_CM_S%d", Application::x11ScreenNumber());
         m_selectionOwner = new CompositorSelectionOwner(selection_name);
         connect(m_selectionOwner, &CompositorSelectionOwner::lostOwnership,
                 this, &Compositor::stop);
     }
 
     if (!m_selectionOwner) {
         // No X11 yet.
         return;
     }
     if (!m_selectionOwner->owning()) {
         // Force claim ownership.
         m_selectionOwner->claim(true);
         m_selectionOwner->setOwning(true);
     }
 }
 
 void Compositor::setupX11Support()
 {
     auto *con = kwinApp()->x11Connection();
     if (!con) {
         delete m_selectionOwner;
         m_selectionOwner = nullptr;
         return;
     }
     claimCompositorSelection();
     xcb_composite_redirect_subwindows(con, kwinApp()->x11RootWindow(),
                                       XCB_COMPOSITE_REDIRECT_MANUAL);
 }
 
 void Compositor::startupWithWorkspace()
 {
     connect(kwinApp(), &Application::x11ConnectionChanged,
             this, &Compositor::setupX11Support, Qt::UniqueConnection);
     Workspace::self()->markXStackingOrderAsDirty();
     Q_ASSERT(m_scene);
 
     connect(workspace(), &Workspace::destroyed, this, [this] { compositeTimer.stop(); });
     setupX11Support();
     fpsInterval = options->maxFpsInterval();
 
     if (m_scene->syncsToVBlank()) {
         // If we do vsync, set the fps to the next multiple of the vblank rate.
         vBlankInterval = milliToNano(1000) / currentRefreshRate();
         fpsInterval = qMax((fpsInterval / vBlankInterval) * vBlankInterval, vBlankInterval);
     } else {
         // No vsync - DO NOT set "0", would cause div-by-zero segfaults.
         vBlankInterval = milliToNano(1);
     }
 
     // Sets also the 'effects' pointer.
     kwinApp()->platform()->createEffectsHandler(this, m_scene);
     connect(Workspace::self(), &Workspace::deletedRemoved, m_scene, &Scene::removeToplevel);
     connect(effects, &EffectsHandler::screenGeometryChanged, this, &Compositor::addRepaintFull);
 
     for (X11Client *c : Workspace::self()->clientList()) {
         c->setupCompositing();
         c->updateShadow();
     }
     for (X11Client *c : Workspace::self()->desktopList()) {
         c->setupCompositing();
     }
     for (Unmanaged *c : Workspace::self()->unmanagedList()) {
         c->setupCompositing();
         c->updateShadow();
     }
     for (InternalClient *client : workspace()->internalClients()) {
         client->setupCompositing();
         client->updateShadow();
     }
 
     if (auto *server = waylandServer()) {
         const auto clients = server->clients();
         for (AbstractClient *c : clients) {
             c->setupCompositing();
             c->updateShadow();
         }
     }
 
     m_state = State::On;
     emit compositingToggled(true);
 
     if (m_releaseSelectionTimer.isActive()) {
         m_releaseSelectionTimer.stop();
     }
 
     // Render at least once.
     addRepaintFull();
     performCompositing();
 }
 
 void Compositor::scheduleRepaint()
 {
     if (!compositeTimer.isActive())
         setCompositeTimer();
 }
 
 void Compositor::stop()
 {
     if (m_state == State::Off || m_state == State::Stopping) {
         return;
     }
     m_state = State::Stopping;
     emit aboutToToggleCompositing();
 
     m_releaseSelectionTimer.start();
 
     // Some effects might need access to effect windows when they are about to
     // be destroyed, for example to unreference deleted windows, so we have to
     // make sure that effect windows outlive effects.
     delete effects;
     effects = nullptr;
 
     if (Workspace::self()) {
         for (X11Client *c : Workspace::self()->clientList()) {
             m_scene->removeToplevel(c);
         }
         for (X11Client *c : Workspace::self()->desktopList()) {
             m_scene->removeToplevel(c);
         }
         for (Unmanaged *c : Workspace::self()->unmanagedList()) {
             m_scene->removeToplevel(c);
         }
         for (InternalClient *client : workspace()->internalClients()) {
             m_scene->removeToplevel(client);
         }
         for (X11Client *c : Workspace::self()->clientList()) {
             c->finishCompositing();
         }
         for (X11Client *c : Workspace::self()->desktopList()) {
             c->finishCompositing();
         }
         for (Unmanaged *c : Workspace::self()->unmanagedList()) {
             c->finishCompositing();
         }
         for (InternalClient *client : workspace()->internalClients()) {
             client->finishCompositing();
         }
         if (auto *con = kwinApp()->x11Connection()) {
             xcb_composite_unredirect_subwindows(con, kwinApp()->x11RootWindow(),
                                                 XCB_COMPOSITE_REDIRECT_MANUAL);
         }
         while (!workspace()->deletedList().isEmpty()) {
             workspace()->deletedList().first()->discard();
         }
     }
 
     if (waylandServer()) {
         for (AbstractClient *c : waylandServer()->clients()) {
             m_scene->removeToplevel(c);
         }
         for (AbstractClient *c : waylandServer()->clients()) {
             c->finishCompositing();
         }
     }
 
     delete m_scene;
     m_scene = nullptr;
     compositeTimer.stop();
     repaints_region = QRegion();
 
     m_state = State::Off;
     emit compositingToggled(false);
 }
 
 void Compositor::destroyCompositorSelection()
 {
     delete m_selectionOwner;
     m_selectionOwner = nullptr;
 }
 
 void Compositor::releaseCompositorSelection()
 {
     switch (m_state) {
     case State::On:
         // We are compositing at the moment. Don't release.
         break;
     case State::Off:
         if (m_selectionOwner) {
             qCDebug(KWIN_CORE) << "Releasing compositor selection";
             m_selectionOwner->setOwning(false);
             m_selectionOwner->release();
         }
         break;
     case State::Starting:
     case State::Stopping:
         // Still starting or shutting down the compositor. Starting might fail
         // or after stopping a restart might follow. So test again later on.
         m_releaseSelectionTimer.start();
         break;
     }
 }
 
 void Compositor::keepSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties.removeAll(atom);
 }
 
 void Compositor::removeSupportProperty(xcb_atom_t atom)
 {
     m_unusedSupportProperties << atom;
     m_unusedSupportPropertyTimer.start();
 }
 
 void Compositor::deleteUnusedSupportProperties()
 {
     if (m_state == State::Starting || m_state == State::Stopping) {
         // Currently still maybe restarting the compositor.
         m_unusedSupportPropertyTimer.start();
         return;
     }
     if (auto *con = kwinApp()->x11Connection()) {
         for (const xcb_atom_t &atom : qAsConst(m_unusedSupportProperties)) {
             // remove property from root window
             xcb_delete_property(con, kwinApp()->x11RootWindow(), atom);
         }
         m_unusedSupportProperties.clear();
     }
 }
 
 void Compositor::configChanged()
 {
     reinitialize();
     addRepaintFull();
 }
 
 void Compositor::reinitialize()
 {
     // Reparse config. Config options will be reloaded by start()
     kwinApp()->config()->reparseConfiguration();
 
     // Restart compositing
     stop();
     start();
 
     if (effects) { // start() may fail
         effects->reconfigure();
     }
 }
 
 void Compositor::addRepaint(int x, int y, int w, int h)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += QRegion(x, y, w, h);
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRect& r)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaint(const QRegion& r)
 {
     if (m_state != State::On) {
         return;
     }
     repaints_region += r;
     scheduleRepaint();
 }
 
 void Compositor::addRepaintFull()
 {
     if (m_state != State::On) {
         return;
     }
     const QSize &s = screens()->size();
     repaints_region = QRegion(0, 0, s.width(), s.height());
     scheduleRepaint();
 }
 
 void Compositor::timerEvent(QTimerEvent *te)
 {
     if (te->timerId() == compositeTimer.timerId()) {
         performCompositing();
     } else
         QObject::timerEvent(te);
 }
 
 void Compositor::aboutToSwapBuffers()
 {
     Q_ASSERT(!m_bufferSwapPending);
 
     m_bufferSwapPending = true;
 }
 
 void Compositor::bufferSwapComplete()
 {
     Q_ASSERT(m_bufferSwapPending);
     m_bufferSwapPending = false;
 
     emit bufferSwapCompleted();
 
     if (m_composeAtSwapCompletion) {
         m_composeAtSwapCompletion = false;
         performCompositing();
     }
 }
 
 void Compositor::performCompositing()
 {
     // If a buffer swap is still pending, we return to the event loop and
     // continue processing events until the swap has completed.
     if (m_bufferSwapPending) {
         m_composeAtSwapCompletion = true;
         compositeTimer.stop();
         return;
     }
 
     // If outputs are disabled, we return to the event loop and
     // continue processing events until the outputs are enabled again
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         compositeTimer.stop();
         return;
     }
 
     // Create a list of all windows in the stacking order
     QList<Toplevel *> windows = Workspace::self()->xStackingOrder();
     QList<Toplevel *> damaged;
 
     // Reset the damage state of each window and fetch the damage region
     // without waiting for a reply
     for (Toplevel *win : windows) {
         if (win->resetAndFetchDamage()) {
             damaged << win;
         }
     }
 
     if (damaged.count() > 0) {
         m_scene->triggerFence();
         if (auto c = kwinApp()->x11Connection()) {
             xcb_flush(c);
         }
     }
 
     // Move elevated windows to the top of the stacking order
     for (EffectWindow *c : static_cast<EffectsHandlerImpl *>(effects)->elevatedWindows()) {
         Toplevel *t = static_cast<EffectWindowImpl *>(c)->window();
         windows.removeAll(t);
         windows.append(t);
     }
 
     // Get the replies
     for (Toplevel *win : damaged) {
         // Discard the cached lanczos texture
         if (win->effectWindow()) {
             const QVariant texture = win->effectWindow()->data(LanczosCacheRole);
             if (texture.isValid()) {
                 delete static_cast<GLTexture *>(texture.value<void*>());
                 win->effectWindow()->setData(LanczosCacheRole, QVariant());
             }
         }
 
         win->getDamageRegionReply();
     }
 
     if (repaints_region.isEmpty() && !windowRepaintsPending()) {
         m_scene->idle();
         m_timeSinceLastVBlank = fpsInterval - (options->vBlankTime() + 1); // means "start now"
         // Note: It would seem here we should undo suspended unredirect, but when scenes need
         // it for some reason, e.g. transformations or translucency, the next pass that does not
         // need this anymore and paints normally will also reset the suspended unredirect.
         // Otherwise the window would not be painted normally anyway.
         compositeTimer.stop();
         return;
     }
 
     // Skip windows that are not yet ready for being painted and if screen is locked skip windows
     // that are neither lockscreen nor inputmethod windows.
     //
     // TODO? This cannot be used so carelessly - needs protections against broken clients, the
     // window should not get focus before it's displayed, handle unredirected windows properly and
     // so on.
     for (Toplevel *win : windows) {
         if (!win->readyForPainting()) {
             windows.removeAll(win);
         }
         if (waylandServer() && waylandServer()->isScreenLocked()) {
             if(!win->isLockScreen() && !win->isInputMethod()) {
                 windows.removeAll(win);
             }
         }
     }
 
     QRegion repaints = repaints_region;
     // clear all repaints, so that post-pass can add repaints for the next repaint
     repaints_region = QRegion();
 
     if (m_framesToTestForSafety > 0 && (m_scene->compositingType() & OpenGLCompositing)) {
         kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreFrame);
     }
     m_timeSinceLastVBlank = m_scene->paint(repaints, windows);
     if (m_framesToTestForSafety > 0) {
         if (m_scene->compositingType() & OpenGLCompositing) {
             kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostFrame);
         }
         m_framesToTestForSafety--;
         if (m_framesToTestForSafety == 0 && (m_scene->compositingType() & OpenGLCompositing)) {
             kwinApp()->platform()->createOpenGLSafePoint(
                 Platform::OpenGLSafePoint::PostLastGuardedFrame);
         }
     }
 
     if (waylandServer()) {
         const auto currentTime = static_cast<quint32>(m_monotonicClock.elapsed());
         for (Toplevel *win : qAsConst(windows)) {
             if (auto surface = win->surface()) {
                 surface->frameRendered(currentTime);
             }
         }
     }
 
     // Stop here to ensure *we* cause the next repaint schedule - not some effect
     // through m_scene->paint().
     compositeTimer.stop();
 
     // Trigger at least one more pass even if there would be nothing to paint, so that scene->idle()
     // is called the next time. If there would be nothing pending, it will not restart the timer and
     // scheduleRepaint() would restart it again somewhen later, called from functions that
     // would again add something pending.
     if (m_bufferSwapPending && m_scene->syncsToVBlank()) {
         m_composeAtSwapCompletion = true;
     } else {
         scheduleRepaint();
     }
 }
 
 template <class T>
 static bool repaintsPending(const QList<T*> &windows)
 {
     return std::any_of(windows.begin(), windows.end(),
                        [](T *t) { return !t->repaints().isEmpty(); });
 }
 
 bool Compositor::windowRepaintsPending() const
 {
     if (repaintsPending(Workspace::self()->clientList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->desktopList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->unmanagedList())) {
         return true;
     }
     if (repaintsPending(Workspace::self()->deletedList())) {
         return true;
     }
     if (auto *server = waylandServer()) {
         const auto &clients = server->clients();
         auto test = [](AbstractClient *c) {
             return c->readyForPainting() && !c->repaints().isEmpty();
         };
         if (std::any_of(clients.begin(), clients.end(), test)) {
             return true;
         }
     }
     const auto &internalClients = workspace()->internalClients();
     auto internalTest = [] (InternalClient *client) {
         return client->isShown(true) && !client->repaints().isEmpty();
     };
     if (std::any_of(internalClients.begin(), internalClients.end(), internalTest)) {
         return true;
     }
     return false;
 }
 
 void Compositor::setCompositeTimer()
 {
     if (m_state != State::On) {
         return;
     }
 
     // Don't start the timer if we're waiting for a swap event
     if (m_bufferSwapPending && m_composeAtSwapCompletion)
         return;
 
     // Don't start the timer if all outputs are disabled
     if (!kwinApp()->platform()->areOutputsEnabled()) {
         return;
     }
 
     uint waitTime = 1;
 
     if (m_scene->blocksForRetrace()) {
 
         // TODO: make vBlankTime dynamic?!
         // It's required because glXWaitVideoSync will *likely* block a full frame if one enters
         // a retrace pass which can last a variable amount of time, depending on the actual screen
         // Now, my ooold 19" CRT can do such retrace so that 2ms are entirely sufficient,
         // while another ooold 15" TFT requires about 6ms
 
         qint64 padding = m_timeSinceLastVBlank;
         if (padding > fpsInterval) {
             // We're at low repaints or spent more time in painting than the user wanted to wait
             // for that frame. Align to next vblank:
             padding = vBlankInterval - (padding % vBlankInterval);
         } else {
             // Align to the next maxFps tick:
             // "remaining time of the first vsync" + "time for the other vsyncs of the frame"
             padding = ((vBlankInterval - padding % vBlankInterval) +
                        (fpsInterval / vBlankInterval - 1) * vBlankInterval);
         }
 
         if (padding < options->vBlankTime()) {
             // We'll likely miss this frame so we add one:
             waitTime = nanoToMilli(padding + vBlankInterval - options->vBlankTime());
         } else {
             waitTime = nanoToMilli(padding - options->vBlankTime());
         }
     }
     else { // w/o blocking vsync we just jump to the next demanded tick
         if (fpsInterval > m_timeSinceLastVBlank) {
             waitTime = nanoToMilli(fpsInterval - m_timeSinceLastVBlank);
             if (!waitTime) {
                 // Will ensure we don't block out the eventloop - the system's just not faster ...
                 waitTime = 1;
             }
         }
         /* else if (m_scene->syncsToVBlank() && m_timeSinceLastVBlank - fpsInterval < (vBlankInterval<<1)) {
             // NOTICE - "for later" ------------------------------------------------------------------
             // It can happen that we push two frames within one refresh cycle.
             // Swapping will then block even with triple buffering when the GPU does not discard but
             // queues frames
             // now here's the mean part: if we take that as "OMG, we're late - next frame ASAP",
             // there'll immediately be 2 frames in the pipe, swapping will block, we think we're
             // late ... ewww
             // so instead we pad to the clock again and add 2ms safety to ensure the pipe is really
             // free
             // NOTICE: obviously m_timeSinceLastVBlank can be too big because we're too slow as well
             // So if this code was enabled, we'd needlessly half the framerate once more (15 instead of 30)
             waitTime = nanoToMilli(vBlankInterval - (m_timeSinceLastVBlank - fpsInterval)%vBlankInterval) + 2;
         }*/
         else {
             // "0" would be sufficient here, but the compositor isn't the WMs only task.
             waitTime = 1;
         }
     }
     // Force 4fps minimum:
     compositeTimer.start(qMin(waitTime, 250u), this);
 }
 
 bool Compositor::isActive()
 {
     return m_state == State::On;
 }
 
 WaylandCompositor::WaylandCompositor(QObject *parent)
     : Compositor(parent)
 {
     connect(kwinApp(), &Application::x11ConnectionAboutToBeDestroyed,
             this, &WaylandCompositor::destroyCompositorSelection);
 }
 
 void WaylandCompositor::toggleCompositing()
 {
     // For the shortcut. Not possible on Wayland because we always composite.
 }
 
 void WaylandCompositor::start()
 {
     if (!Compositor::setupStart()) {
         // Internal setup failed, abort.
         return;
     }
 
     if (Workspace::self()) {
         startupWithWorkspace();
     } else {
         connect(kwinApp(), &Application::workspaceCreated,
                 this, &WaylandCompositor::startupWithWorkspace);
     }
 }
 
 int WaylandCompositor::refreshRate() const
 {
     // TODO: This makes no sense on Wayland. First step would be to atleast
     //       set the refresh rate to the highest available one. Second step
     //       would be to not use a uniform value at all but per screen.
     return KWin::currentRefreshRate();
 }
 
 X11Compositor::X11Compositor(QObject *parent)
     : Compositor(parent)
     , m_suspended(options->isUseCompositing() ? NoReasonSuspend : UserSuspend)
     , m_xrrRefreshRate(0)
 {
 }
 
 void X11Compositor::toggleCompositing()
 {
     if (m_suspended) {
         // Direct user call; clear all bits.
         resume(AllReasonSuspend);
     } else {
         // But only set the user one (sufficient to suspend).
         suspend(UserSuspend);
     }
 }
 
 void X11Compositor::reinitialize()
 {
     // Resume compositing if suspended.
     m_suspended = NoReasonSuspend;
     Compositor::reinitialize();
 }
 
 void X11Compositor::configChanged()
 {
     if (m_suspended) {
         stop();
         return;
     }
     Compositor::configChanged();
 }
 
 void X11Compositor::suspend(X11Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended |= reason;
 
     if (reason & ScriptSuspend) {
         // When disabled show a shortcut how the user can get back compositing.
         const auto shortcuts = KGlobalAccel::self()->shortcut(
             workspace()->findChild<QAction*>(QStringLiteral("Suspend Compositing")));
         if (!shortcuts.isEmpty()) {
             // Display notification only if there is the shortcut.
             const QString message =
                     i18n("Desktop effects have been suspended by another application.<br/>"
                          "You can resume using the '%1' shortcut.",
                          shortcuts.first().toString(QKeySequence::NativeText));
             KNotification::event(QStringLiteral("compositingsuspendeddbus"), message);
         }
     }
     stop();
 }
 
 void X11Compositor::resume(X11Compositor::SuspendReason reason)
 {
     Q_ASSERT(reason != NoReasonSuspend);
     m_suspended &= ~reason;
     start();
 }
 
 void X11Compositor::start()
 {
     if (m_suspended) {
         QStringList reasons;
         if (m_suspended & UserSuspend) {
             reasons << QStringLiteral("Disabled by User");
         }
         if (m_suspended & BlockRuleSuspend) {
             reasons << QStringLiteral("Disabled by Window");
         }
         if (m_suspended & ScriptSuspend) {
             reasons << QStringLiteral("Disabled by Script");
         }
         qCDebug(KWIN_CORE) << "Compositing is suspended, reason:" << reasons;
         return;
     } else if (!kwinApp()->platform()->compositingPossible()) {
         qCCritical(KWIN_CORE) << "Compositing is not possible";
         return;
     }
     if (!Compositor::setupStart()) {
         // Internal setup failed, abort.
         return;
     }
     m_xrrRefreshRate = KWin::currentRefreshRate();
     startupWithWorkspace();
 }
 void X11Compositor::performCompositing()
 {
     if (scene()->usesOverlayWindow() && !isOverlayWindowVisible()) {
         // Return since nothing is visible.
         return;
     }
     Compositor::performCompositing();
 }
 
 bool X11Compositor::checkForOverlayWindow(WId w) const
 {
     if (!scene()) {
         // No scene, so it cannot be the overlay window.
         return false;
     }
     if (!scene()->overlayWindow()) {
         // No overlay window, it cannot be the overlay.
         return false;
     }
     // Compare the window ID's.
     return w == scene()->overlayWindow()->window();
 }
 
 bool X11Compositor::isOverlayWindowVisible() const
 {
     if (!scene()) {
         return false;
     }
     if (!scene()->overlayWindow()) {
         return false;
     }
     return scene()->overlayWindow()->isVisible();
 }
 
 int X11Compositor::refreshRate() const
 {
     return m_xrrRefreshRate;
 }
 
 void X11Compositor::updateClientCompositeBlocking(X11Client *c)
 {
     if (c) {
         if (c->isBlockingCompositing()) {
             // Do NOT attempt to call suspend(true) from within the eventchain!
             if (!(m_suspended & BlockRuleSuspend))
                 QMetaObject::invokeMethod(this, [this]() {
                         suspend(BlockRuleSuspend);
                     }, Qt::QueuedConnection);
         }
     }
     else if (m_suspended & BlockRuleSuspend) {
         // If !c we just check if we can resume in case a blocking client was lost.
         bool shouldResume = true;
 
         for (auto it = Workspace::self()->clientList().constBegin();
              it != Workspace::self()->clientList().constEnd(); ++it) {
             if ((*it)->isBlockingCompositing()) {
                 shouldResume = false;
                 break;
             }
         }
         if (shouldResume) {
             // Do NOT attempt to call suspend(false) from within the eventchain!
                 QMetaObject::invokeMethod(this, [this]() {
                         resume(BlockRuleSuspend);
                     }, Qt::QueuedConnection);
         }
     }
 }
 
 X11Compositor *X11Compositor::self()
 {
     return qobject_cast<X11Compositor *>(Compositor::self());
 }
 
 }
 
 // included for CompositorSelectionOwner
 #include "composite.moc"
diff --git a/debug_console.cpp b/debug_console.cpp
index 1e759abaa..4c0bf101a 100644
--- a/debug_console.cpp
+++ b/debug_console.cpp
@@ -1,1596 +1,1596 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "debug_console.h"
 #include "composite.h"
 #include "x11client.h"
 #include "input_event.h"
 #include "internal_client.h"
 #include "main.h"
 #include "scene.h"
 #include "unmanaged.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "keyboard_input.h"
 #include "input_event.h"
 #include "libinput/connection.h"
 #include "libinput/device.h"
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 
 #include "ui_debug_console.h"
 
 // KWayland
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/clientconnection.h>
-#include <KWayland/Server/subcompositor_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/clientconnection.h>
+#include <KWaylandServer/subcompositor_interface.h>
+#include <KWaylandServer/surface_interface.h>
 // frameworks
 #include <KLocalizedString>
 #include <NETWM>
 // Qt
 #include <QMouseEvent>
 #include <QMetaProperty>
 #include <QMetaType>
 
 // xkb
 #include <xkbcommon/xkbcommon.h>
 
 #include <functional>
 
 namespace KWin
 {
 
 
 static QString tableHeaderRow(const QString &title)
 {
     return QStringLiteral("<tr><th colspan=\"2\">%1</th></tr>").arg(title);
 }
 
 template<typename T>
 static
 QString tableRow(const QString &title, const T &argument)
 {
     return QStringLiteral("<tr><td>%1</td><td>%2</td></tr>").arg(title).arg(argument);
 }
 
 static QString timestampRow(quint32 timestamp)
 {
     return tableRow(i18n("Timestamp"), timestamp);
 }
 
 static QString timestampRowUsec(quint64 timestamp)
 {
     return tableRow(i18n("Timestamp (µsec)"), timestamp);
 }
 
 static QString buttonToString(Qt::MouseButton button)
 {
     switch (button) {
         case Qt::LeftButton:
             return i18nc("A mouse button", "Left");
         case Qt::RightButton:
             return i18nc("A mouse button", "Right");
         case Qt::MiddleButton:
             return i18nc("A mouse button", "Middle");
         case Qt::BackButton:
             return i18nc("A mouse button", "Back");
         case Qt::ForwardButton:
             return i18nc("A mouse button", "Forward");
         case Qt::TaskButton:
             return i18nc("A mouse button", "Task");
         case Qt::ExtraButton4:
             return i18nc("A mouse button", "Extra Button 4");
         case Qt::ExtraButton5:
             return i18nc("A mouse button", "Extra Button 5");
         case Qt::ExtraButton6:
             return i18nc("A mouse button", "Extra Button 6");
         case Qt::ExtraButton7:
             return i18nc("A mouse button", "Extra Button 7");
         case Qt::ExtraButton8:
             return i18nc("A mouse button", "Extra Button 8");
         case Qt::ExtraButton9:
             return i18nc("A mouse button", "Extra Button 9");
         case Qt::ExtraButton10:
             return i18nc("A mouse button", "Extra Button 10");
         case Qt::ExtraButton11:
             return i18nc("A mouse button", "Extra Button 11");
         case Qt::ExtraButton12:
             return i18nc("A mouse button", "Extra Button 12");
         case Qt::ExtraButton13:
             return i18nc("A mouse button", "Extra Button 13");
         case Qt::ExtraButton14:
             return i18nc("A mouse button", "Extra Button 14");
         case Qt::ExtraButton15:
             return i18nc("A mouse button", "Extra Button 15");
         case Qt::ExtraButton16:
             return i18nc("A mouse button", "Extra Button 16");
         case Qt::ExtraButton17:
             return i18nc("A mouse button", "Extra Button 17");
         case Qt::ExtraButton18:
             return i18nc("A mouse button", "Extra Button 18");
         case Qt::ExtraButton19:
             return i18nc("A mouse button", "Extra Button 19");
         case Qt::ExtraButton20:
             return i18nc("A mouse button", "Extra Button 20");
         case Qt::ExtraButton21:
             return i18nc("A mouse button", "Extra Button 21");
         case Qt::ExtraButton22:
             return i18nc("A mouse button", "Extra Button 22");
         case Qt::ExtraButton23:
             return i18nc("A mouse button", "Extra Button 23");
         case Qt::ExtraButton24:
             return i18nc("A mouse button", "Extra Button 24");
     default:
         return QString();
     }
 }
 
 static QString deviceRow(LibInput::Device *device)
 {
     if (!device) {
         return tableRow(i18n("Input Device"), i18nc("The input device of the event is not known", "Unknown"));
     }
     return tableRow(i18n("Input Device"), QStringLiteral("%1 (%2)").arg(device->name()).arg(device->sysName()));
 }
 
 static QString buttonsToString(Qt::MouseButtons buttons)
 {
     QString ret;
     for (uint i = 1; i < Qt::ExtraButton24; i = i << 1) {
         if (buttons & i) {
             ret.append(buttonToString(Qt::MouseButton(uint(buttons) & i)));
             ret.append(QStringLiteral(" "));
         }
     };
     return ret.trimmed();
 }
 
 static const QString s_hr = QStringLiteral("<hr/>");
 static const QString s_tableStart = QStringLiteral("<table>");
 static const QString s_tableEnd = QStringLiteral("</table>");
 
 DebugConsoleFilter::DebugConsoleFilter(QTextEdit *textEdit)
     : InputEventSpy()
     , m_textEdit(textEdit)
 {
 }
 
 DebugConsoleFilter::~DebugConsoleFilter() = default;
 
 void DebugConsoleFilter::pointerEvent(MouseEvent *event)
 {
     QString text = s_hr;
     const QString timestamp = timestampRow(event->timestamp());
 
     text.append(s_tableStart);
     switch (event->type()) {
     case QEvent::MouseMove: {
         text.append(tableHeaderRow(i18nc("A mouse pointer motion event", "Pointer Motion")));
         text.append(deviceRow(event->device()));
         text.append(timestamp);
         if (event->timestampMicroseconds() != 0) {
             text.append(timestampRowUsec(event->timestampMicroseconds()));
         }
         if (event->delta() != QSizeF()) {
             text.append(tableRow(i18nc("The relative mouse movement", "Delta"),
                                  QStringLiteral("%1/%2").arg(event->delta().width()).arg(event->delta().height())));
         }
         if (event->deltaUnaccelerated() != QSizeF()) {
             text.append(tableRow(i18nc("The relative mouse movement", "Delta (not accelerated)"),
                                  QStringLiteral("%1/%2").arg(event->deltaUnaccelerated().width()).arg(event->deltaUnaccelerated().height())));
         }
         text.append(tableRow(i18nc("The global mouse pointer position", "Global Position"), QStringLiteral("%1/%2").arg(event->pos().x()).arg(event->pos().y())));
         break;
     }
     case QEvent::MouseButtonPress:
         text.append(tableHeaderRow(i18nc("A mouse pointer button press event", "Pointer Button Press")));
         text.append(deviceRow(event->device()));
         text.append(timestamp);
         text.append(tableRow(i18nc("A button in a mouse press/release event", "Button"), buttonToString(event->button())));
         text.append(tableRow(i18nc("A button in a mouse press/release event",  "Native Button code"), event->nativeButton()));
         text.append(tableRow(i18nc("All currently pressed buttons in a mouse press/release event", "Pressed Buttons"), buttonsToString(event->buttons())));
         break;
     case QEvent::MouseButtonRelease:
         text.append(tableHeaderRow(i18nc("A mouse pointer button release event", "Pointer Button Release")));
         text.append(deviceRow(event->device()));
         text.append(timestamp);
         text.append(tableRow(i18nc("A button in a mouse press/release event", "Button"), buttonToString(event->button())));
         text.append(tableRow(i18nc("A button in a mouse press/release event", "Native Button code"), event->nativeButton()));
         text.append(tableRow(i18nc("All currently pressed buttons in a mouse press/release event", "Pressed Buttons"), buttonsToString(event->buttons())));
         break;
     default:
         break;
     }
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::wheelEvent(WheelEvent *event)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A mouse pointer axis (wheel) event", "Pointer Axis")));
     text.append(deviceRow(event->device()));
     text.append(timestampRow(event->timestamp()));
     const Qt::Orientation orientation = event->angleDelta().x() == 0 ? Qt::Vertical : Qt::Horizontal;
     text.append(tableRow(i18nc("The orientation of a pointer axis event", "Orientation"),
                          orientation == Qt::Horizontal ? i18nc("An orientation of a pointer axis event", "Horizontal")
                                                        : i18nc("An orientation of a pointer axis event", "Vertical")));
     text.append(tableRow(i18nc("The angle delta of a pointer axis event", "Delta"),
                          orientation == Qt::Horizontal ? event->angleDelta().x() : event->angleDelta().y()));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::keyEvent(KeyEvent *event)
 {
     QString text = s_hr;
     text.append(s_tableStart);
 
     switch (event->type()) {
     case QEvent::KeyPress:
         text.append(tableHeaderRow(i18nc("A key press event", "Key Press")));
         break;
     case QEvent::KeyRelease:
         text.append(tableHeaderRow(i18nc("A key release event", "Key Release")));
         break;
     default:
         break;
     }
     text.append(deviceRow(event->device()));
     auto modifiersToString = [event] {
         QString ret;
         if (event->modifiers().testFlag(Qt::ShiftModifier)) {
             ret.append(i18nc("A keyboard modifier", "Shift"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::ControlModifier)) {
             ret.append(i18nc("A keyboard modifier", "Control"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::AltModifier)) {
             ret.append(i18nc("A keyboard modifier", "Alt"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::MetaModifier)) {
             ret.append(i18nc("A keyboard modifier", "Meta"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::KeypadModifier)) {
             ret.append(i18nc("A keyboard modifier", "Keypad"));
             ret.append(QStringLiteral(" "));
         }
         if (event->modifiers().testFlag(Qt::GroupSwitchModifier)) {
             ret.append(i18nc("A keyboard modifier", "Group-switch"));
             ret.append(QStringLiteral(" "));
         }
         return ret;
     };
     text.append(timestampRow(event->timestamp()));
     text.append(tableRow(i18nc("Whether the event is an automatic key repeat", "Repeat"), event->isAutoRepeat()));
 
     const auto keyMetaObject = Qt::qt_getEnumMetaObject(Qt::Key());
     const auto enumerator = keyMetaObject->enumerator(keyMetaObject->indexOfEnumerator("Key"));
     text.append(tableRow(i18nc("The code as read from the input device", "Scan code"), event->nativeScanCode()));
     text.append(tableRow(i18nc("Key according to Qt", "Qt::Key code"),
                          enumerator.valueToKey(event->key())));
     text.append(tableRow(i18nc("The translated code to an Xkb symbol", "Xkb symbol"), event->nativeVirtualKey()));
     text.append(tableRow(i18nc("The translated code interpreted as text", "Utf8"), event->text()));
     text.append(tableRow(i18nc("The currently active modifiers", "Modifiers"), modifiersToString()));
 
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A touch down event", "Touch down")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("The id of the touch point in the touch event", "Point identifier"), id));
     text.append(tableRow(i18nc("The global position of the touch point", "Global position"),
                          QStringLiteral("%1/%2").arg(pos.x()).arg(pos.y())));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A touch motion event", "Touch Motion")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("The id of the touch point in the touch event", "Point identifier"), id));
     text.append(tableRow(i18nc("The global position of the touch point", "Global position"),
                          QStringLiteral("%1/%2").arg(pos.x()).arg(pos.y())));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::touchUp(qint32 id, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A touch up event", "Touch Up")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("The id of the touch point in the touch event", "Point identifier"), id));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureBegin(int fingerCount, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture is started", "Pinch start")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Number of fingers in this pinch gesture", "Finger count"), fingerCount));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture is updated", "Pinch update")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Current scale in pinch gesture", "Scale"), scale));
     text.append(tableRow(i18nc("Current angle in pinch gesture", "Angle delta"), angleDelta));
     text.append(tableRow(i18nc("Current delta in pinch gesture", "Delta x"), delta.width()));
     text.append(tableRow(i18nc("Current delta in pinch gesture", "Delta y"), delta.height()));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureEnd(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture ended", "Pinch end")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::pinchGestureCancelled(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A pinch gesture got cancelled", "Pinch cancelled")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureBegin(int fingerCount, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture is started", "Swipe start")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Number of fingers in this swipe gesture", "Finger count"), fingerCount));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture is updated", "Swipe update")));
     text.append(timestampRow(time));
     text.append(tableRow(i18nc("Current delta in swipe gesture", "Delta x"), delta.width()));
     text.append(tableRow(i18nc("Current delta in swipe gesture", "Delta y"), delta.height()));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureEnd(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture ended", "Swipe end")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::swipeGestureCancelled(quint32 time)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A swipe gesture got cancelled", "Swipe cancelled")));
     text.append(timestampRow(time));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::switchEvent(SwitchEvent *event)
 {
     QString text = s_hr;
     text.append(s_tableStart);
     text.append(tableHeaderRow(i18nc("A hardware switch (e.g. notebook lid) got toggled", "Switch toggled")));
     text.append(timestampRow(event->timestamp()));
     if (event->timestampMicroseconds() != 0) {
         text.append(timestampRowUsec(event->timestampMicroseconds()));
     }
     text.append(deviceRow(event->device()));
     QString switchName;
     if (event->device()->isLidSwitch()) {
         switchName = i18nc("Name of a hardware switch", "Notebook lid");
     } else if (event->device()->isTabletModeSwitch()) {
         switchName = i18nc("Name of a hardware switch", "Tablet mode");
     }
     text.append(tableRow(i18nc("A hardware switch", "Switch"), switchName));
     QString switchState;
     switch (event->state()) {
     case SwitchEvent::State::Off:
         switchState = i18nc("The hardware switch got turned off", "Off");
         break;
     case SwitchEvent::State::On:
         switchState = i18nc("The hardware switch got turned on", "On");
         break;
     default:
         Q_UNREACHABLE();
     }
     text.append(tableRow(i18nc("State of a hardware switch (on/off)", "State"), switchState));
     text.append(s_tableEnd);
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletToolEvent(TabletEvent *event)
 {
     QString typeString;
     {
         QDebug d(&typeString);
         d << event->type();
     }
 
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Tool"))
                  + tableRow(i18n("EventType"), typeString)
                  + tableRow(i18n("Position"),
                             QStringLiteral("%1,%2").arg(event->pos().x()).arg(event->pos().y()))
                  + tableRow(i18n("Tilt"),
                             QStringLiteral("%1,%2").arg(event->xTilt()).arg(event->yTilt()))
                  + tableRow(i18n("Rotation"), QString::number(event->rotation()))
                  + tableRow(i18n("Pressure"), QString::number(event->pressure()))
                  + tableRow(i18n("Buttons"), QString::number(event->buttons()))
                  + tableRow(i18n("Modifiers"), QString::number(event->modifiers()))
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletToolButtonEvent(const QSet<uint> &pressedButtons)
 {
     QString buttons;
     for (uint b : pressedButtons) {
         buttons += QString::number(b) + ' ';
     }
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Tool Button"))
                  + tableRow(i18n("Pressed Buttons"), buttons)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletPadButtonEvent(const QSet<uint> &pressedButtons)
 {
     QString buttons;
     for (uint b : pressedButtons) {
         buttons += QString::number(b) + ' ';
     }
     QString text = s_hr + s_tableStart
                  + tableHeaderRow(i18n("Tablet Pad Button"))
                  + tableRow(i18n("Pressed Buttons"), buttons)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletPadStripEvent(int number, int position, bool isFinger)
 {
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Pad Strip"))
                  + tableRow(i18n("Number"), number)
                  + tableRow(i18n("Position"), position)
                  + tableRow(i18n("isFinger"), isFinger)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 void DebugConsoleFilter::tabletPadRingEvent(int number, int position, bool isFinger)
 {
     QString text = s_hr + s_tableStart + tableHeaderRow(i18n("Tablet Pad Ring"))
                  + tableRow(i18n("Number"), number)
                  + tableRow(i18n("Position"), position)
                  + tableRow(i18n("isFinger"), isFinger)
                  + s_tableEnd;
 
     m_textEdit->insertHtml(text);
     m_textEdit->ensureCursorVisible();
 }
 
 DebugConsole::DebugConsole()
     : QWidget()
     , m_ui(new Ui::DebugConsole)
 {
     setAttribute(Qt::WA_ShowWithoutActivating);
     m_ui->setupUi(this);
     m_ui->windowsView->setItemDelegate(new DebugConsoleDelegate(this));
     m_ui->windowsView->setModel(new DebugConsoleModel(this));
     m_ui->surfacesView->setModel(new SurfaceTreeModel(this));
     if (kwinApp()->usesLibinput()) {
         m_ui->inputDevicesView->setModel(new InputDeviceModel(this));
         m_ui->inputDevicesView->setItemDelegate(new DebugConsoleDelegate(this));
     }
     m_ui->quitButton->setIcon(QIcon::fromTheme(QStringLiteral("application-exit")));
     m_ui->tabWidget->setTabIcon(0, QIcon::fromTheme(QStringLiteral("view-list-tree")));
     m_ui->tabWidget->setTabIcon(1, QIcon::fromTheme(QStringLiteral("view-list-tree")));
 
     if (kwinApp()->operationMode() == Application::OperationMode::OperationModeX11) {
         m_ui->tabWidget->setTabEnabled(1, false);
         m_ui->tabWidget->setTabEnabled(2, false);
     }
     if (!kwinApp()->usesLibinput()) {
         m_ui->tabWidget->setTabEnabled(3, false);
     }
 
     connect(m_ui->quitButton, &QAbstractButton::clicked, this, &DebugConsole::deleteLater);
     connect(m_ui->tabWidget, &QTabWidget::currentChanged, this,
         [this] (int index) {
             // delay creation of input event filter until the tab is selected
             if (index == 2 && m_inputFilter.isNull()) {
                 m_inputFilter.reset(new DebugConsoleFilter(m_ui->inputTextEdit));
                 input()->installInputEventSpy(m_inputFilter.data());
             }
             if (index == 5) {
                 updateKeyboardTab();
                 connect(input(), &InputRedirection::keyStateChanged, this, &DebugConsole::updateKeyboardTab);
             }
         }
     );
 
     // for X11
     setWindowFlags(Qt::X11BypassWindowManagerHint);
 
     initGLTab();
 }
 
 DebugConsole::~DebugConsole() = default;
 
 void DebugConsole::initGLTab()
 {
     if (!effects || !effects->isOpenGLCompositing()) {
         m_ui->noOpenGLLabel->setVisible(true);
         m_ui->glInfoScrollArea->setVisible(false);
         return;
     }
     GLPlatform *gl = GLPlatform::instance();
     m_ui->noOpenGLLabel->setVisible(false);
     m_ui->glInfoScrollArea->setVisible(true);
     m_ui->glVendorStringLabel->setText(QString::fromLocal8Bit(gl->glVendorString()));
     m_ui->glRendererStringLabel->setText(QString::fromLocal8Bit(gl->glRendererString()));
     m_ui->glVersionStringLabel->setText(QString::fromLocal8Bit(gl->glVersionString()));
     m_ui->glslVersionStringLabel->setText(QString::fromLocal8Bit(gl->glShadingLanguageVersionString()));
     m_ui->glDriverLabel->setText(GLPlatform::driverToString(gl->driver()));
     m_ui->glGPULabel->setText(GLPlatform::chipClassToString(gl->chipClass()));
     m_ui->glVersionLabel->setText(GLPlatform::versionToString(gl->glVersion()));
     m_ui->glslLabel->setText(GLPlatform::versionToString(gl->glslVersion()));
 
     auto extensionsString = [] (const auto &extensions) {
         QString text = QStringLiteral("<ul>");
         for (auto extension : extensions) {
             text.append(QStringLiteral("<li>%1</li>").arg(QString::fromLocal8Bit(extension)));
         }
         text.append(QStringLiteral("</ul>"));
         return text;
     };
 
     m_ui->platformExtensionsLabel->setText(extensionsString(Compositor::self()->scene()->openGLPlatformInterfaceExtensions()));
     m_ui->openGLExtensionsLabel->setText(extensionsString(openGLExtensions()));
 }
 
 template <typename T>
 QString keymapComponentToString(xkb_keymap *map, const T &count, std::function<const char*(xkb_keymap*,T)> f)
 {
     QString text = QStringLiteral("<ul>");
     for (T i = 0; i < count; i++) {
         text.append(QStringLiteral("<li>%1</li>").arg(QString::fromLocal8Bit(f(map, i))));
     }
     text.append(QStringLiteral("</ul>"));
     return text;
 }
 
 template <typename T>
 QString stateActiveComponents(xkb_state *state, const T &count, std::function<int(xkb_state*,T)> f, std::function<const char*(xkb_keymap*,T)> name)
 {
     QString text = QStringLiteral("<ul>");
     xkb_keymap *map = xkb_state_get_keymap(state);
     for (T i = 0; i < count; i++) {
         if (f(state, i) == 1) {
             text.append(QStringLiteral("<li>%1</li>").arg(QString::fromLocal8Bit(name(map, i))));
         }
     }
     text.append(QStringLiteral("</ul>"));
     return text;
 }
 
 void DebugConsole::updateKeyboardTab()
 {
     auto xkb = input()->keyboard()->xkb();
     xkb_keymap *map = xkb->keymap();
     xkb_state *state = xkb->state();
     m_ui->layoutsLabel->setText(keymapComponentToString<xkb_layout_index_t>(map, xkb_keymap_num_layouts(map), &xkb_keymap_layout_get_name));
     m_ui->currentLayoutLabel->setText(xkb_keymap_layout_get_name(map, xkb->currentLayout()));
     m_ui->modifiersLabel->setText(keymapComponentToString<xkb_mod_index_t>(map, xkb_keymap_num_mods(map), &xkb_keymap_mod_get_name));
     m_ui->ledsLabel->setText(keymapComponentToString<xkb_led_index_t>(map, xkb_keymap_num_leds(map), &xkb_keymap_led_get_name));
     m_ui->activeLedsLabel->setText(stateActiveComponents<xkb_led_index_t>(state, xkb_keymap_num_leds(map), &xkb_state_led_index_is_active, &xkb_keymap_led_get_name));
 
     using namespace std::placeholders;
     auto modActive = std::bind(xkb_state_mod_index_is_active, _1, _2, XKB_STATE_MODS_EFFECTIVE);
     m_ui->activeModifiersLabel->setText(stateActiveComponents<xkb_mod_index_t>(state, xkb_keymap_num_mods(map), modActive, &xkb_keymap_mod_get_name));
 }
 
 void DebugConsole::showEvent(QShowEvent *event)
 {
     QWidget::showEvent(event);
 
     // delay the connection to the show event as in ctor the windowHandle returns null
     connect(windowHandle(), &QWindow::visibleChanged, this,
         [this] (bool visible) {
             if (visible) {
                 // ignore
                 return;
             }
             deleteLater();
         }
     );
 }
 
 DebugConsoleDelegate::DebugConsoleDelegate(QObject *parent)
     : QStyledItemDelegate(parent)
 {
 }
 
 DebugConsoleDelegate::~DebugConsoleDelegate() = default;
 
 QString DebugConsoleDelegate::displayText(const QVariant &value, const QLocale &locale) const
 {
     switch (value.userType()) {
     case QMetaType::QPoint: {
         const QPoint p = value.toPoint();
         return QStringLiteral("%1,%2").arg(p.x()).arg(p.y());
     }
     case QMetaType::QPointF: {
         const QPointF p = value.toPointF();
         return QStringLiteral("%1,%2").arg(p.x()).arg(p.y());
     }
     case QMetaType::QSize: {
         const QSize s = value.toSize();
         return QStringLiteral("%1x%2").arg(s.width()).arg(s.height());
     }
     case QMetaType::QSizeF: {
         const QSizeF s = value.toSizeF();
         return QStringLiteral("%1x%2").arg(s.width()).arg(s.height());
     }
     case QMetaType::QRect: {
         const QRect r = value.toRect();
         return QStringLiteral("%1,%2 %3x%4").arg(r.x()).arg(r.y()).arg(r.width()).arg(r.height());
     }
     default:
-        if (value.userType() == qMetaTypeId<KWayland::Server::SurfaceInterface*>()) {
-            if (auto s = value.value<KWayland::Server::SurfaceInterface*>()) {
-                return QStringLiteral("KWayland::Server::SurfaceInterface(0x%1)").arg(qulonglong(s), 0, 16);
+        if (value.userType() == qMetaTypeId<KWaylandServer::SurfaceInterface*>()) {
+            if (auto s = value.value<KWaylandServer::SurfaceInterface*>()) {
+                return QStringLiteral("KWaylandServer::SurfaceInterface(0x%1)").arg(qulonglong(s), 0, 16);
             } else {
                 return QStringLiteral("nullptr");
             }
         }
         if (value.userType() == qMetaTypeId<Qt::MouseButtons>()) {
             const auto buttons = value.value<Qt::MouseButtons>();
             if (buttons == Qt::NoButton) {
                 return i18n("No Mouse Buttons");
             }
             QStringList list;
             if (buttons.testFlag(Qt::LeftButton)) {
                 list << i18nc("Mouse Button", "left");
             }
             if (buttons.testFlag(Qt::RightButton)) {
                 list << i18nc("Mouse Button", "right");
             }
             if (buttons.testFlag(Qt::MiddleButton)) {
                 list << i18nc("Mouse Button", "middle");
             }
             if (buttons.testFlag(Qt::BackButton)) {
                 list << i18nc("Mouse Button", "back");
             }
             if (buttons.testFlag(Qt::ForwardButton)) {
                 list << i18nc("Mouse Button", "forward");
             }
             if (buttons.testFlag(Qt::ExtraButton1)) {
                 list << i18nc("Mouse Button", "extra 1");
             }
             if (buttons.testFlag(Qt::ExtraButton2)) {
                 list << i18nc("Mouse Button", "extra 2");
             }
             if (buttons.testFlag(Qt::ExtraButton3)) {
                 list << i18nc("Mouse Button", "extra 3");
             }
             if (buttons.testFlag(Qt::ExtraButton4)) {
                 list << i18nc("Mouse Button", "extra 4");
             }
             if (buttons.testFlag(Qt::ExtraButton5)) {
                 list << i18nc("Mouse Button", "extra 5");
             }
             if (buttons.testFlag(Qt::ExtraButton6)) {
                 list << i18nc("Mouse Button", "extra 6");
             }
             if (buttons.testFlag(Qt::ExtraButton7)) {
                 list << i18nc("Mouse Button", "extra 7");
             }
             if (buttons.testFlag(Qt::ExtraButton8)) {
                 list << i18nc("Mouse Button", "extra 8");
             }
             if (buttons.testFlag(Qt::ExtraButton9)) {
                 list << i18nc("Mouse Button", "extra 9");
             }
             if (buttons.testFlag(Qt::ExtraButton10)) {
                 list << i18nc("Mouse Button", "extra 10");
             }
             if (buttons.testFlag(Qt::ExtraButton11)) {
                 list << i18nc("Mouse Button", "extra 11");
             }
             if (buttons.testFlag(Qt::ExtraButton12)) {
                 list << i18nc("Mouse Button", "extra 12");
             }
             if (buttons.testFlag(Qt::ExtraButton13)) {
                 list << i18nc("Mouse Button", "extra 13");
             }
             if (buttons.testFlag(Qt::ExtraButton14)) {
                 list << i18nc("Mouse Button", "extra 14");
             }
             if (buttons.testFlag(Qt::ExtraButton15)) {
                 list << i18nc("Mouse Button", "extra 15");
             }
             if (buttons.testFlag(Qt::ExtraButton16)) {
                 list << i18nc("Mouse Button", "extra 16");
             }
             if (buttons.testFlag(Qt::ExtraButton17)) {
                 list << i18nc("Mouse Button", "extra 17");
             }
             if (buttons.testFlag(Qt::ExtraButton18)) {
                 list << i18nc("Mouse Button", "extra 18");
             }
             if (buttons.testFlag(Qt::ExtraButton19)) {
                 list << i18nc("Mouse Button", "extra 19");
             }
             if (buttons.testFlag(Qt::ExtraButton20)) {
                 list << i18nc("Mouse Button", "extra 20");
             }
             if (buttons.testFlag(Qt::ExtraButton21)) {
                 list << i18nc("Mouse Button", "extra 21");
             }
             if (buttons.testFlag(Qt::ExtraButton22)) {
                 list << i18nc("Mouse Button", "extra 22");
             }
             if (buttons.testFlag(Qt::ExtraButton23)) {
                 list << i18nc("Mouse Button", "extra 23");
             }
             if (buttons.testFlag(Qt::ExtraButton24)) {
                 list << i18nc("Mouse Button", "extra 24");
             }
             if (buttons.testFlag(Qt::TaskButton)) {
                 list << i18nc("Mouse Button", "task");
             }
             return list.join(QStringLiteral(", "));
         }
         break;
     }
     return QStyledItemDelegate::displayText(value, locale);
 }
 
 static const int s_x11ClientId = 1;
 static const int s_x11UnmanagedId = 2;
 static const int s_waylandClientId = 3;
 static const int s_workspaceInternalId = 4;
 static const quint32 s_propertyBitMask = 0xFFFF0000;
 static const quint32 s_clientBitMask   = 0x0000FFFF;
 static const quint32 s_idDistance = 10000;
 
 template <class T>
 void DebugConsoleModel::add(int parentRow, QVector<T*> &clients, T *client)
 {
     beginInsertRows(index(parentRow, 0, QModelIndex()), clients.count(), clients.count());
     clients.append(client);
     endInsertRows();
 }
 
 template <class T>
 void DebugConsoleModel::remove(int parentRow, QVector<T*> &clients, T *client)
 {
     const int remove = clients.indexOf(client);
     if (remove == -1) {
         return;
     }
     beginRemoveRows(index(parentRow, 0, QModelIndex()), remove, remove);
     clients.removeAt(remove);
     endRemoveRows();
 }
 
 DebugConsoleModel::DebugConsoleModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
     if (waylandServer()) {
         const auto clients = waylandServer()->clients();
         for (auto c : clients) {
             m_waylandClients.append(c);
         }
         // TODO: that only includes windows getting shown, not those which are only created
         connect(waylandServer(), &WaylandServer::shellClientAdded, this,
             [this] (AbstractClient *c) {
                 add(s_waylandClientId -1, m_waylandClients, c);
             }
         );
         connect(waylandServer(), &WaylandServer::shellClientRemoved, this,
             [this] (AbstractClient *c) {
                 remove(s_waylandClientId -1, m_waylandClients, c);
             }
         );
     }
     const auto x11Clients = workspace()->clientList();
     for (auto c : x11Clients) {
         m_x11Clients.append(c);
     }
     const auto x11DesktopClients = workspace()->desktopList();
     for (auto c : x11DesktopClients) {
         m_x11Clients.append(c);
     }
     connect(workspace(), &Workspace::clientAdded, this,
         [this] (X11Client *c) {
             add(s_x11ClientId -1, m_x11Clients, c);
         }
     );
     connect(workspace(), &Workspace::clientRemoved, this,
         [this] (AbstractClient *ac) {
             X11Client *c = qobject_cast<X11Client *>(ac);
             if (!c) {
                 return;
             }
             remove(s_x11ClientId -1, m_x11Clients, c);
         }
     );
 
     const auto unmangeds = workspace()->unmanagedList();
     for (auto u : unmangeds) {
         m_unmanageds.append(u);
     }
     connect(workspace(), &Workspace::unmanagedAdded, this,
         [this] (Unmanaged *u) {
             add(s_x11UnmanagedId -1, m_unmanageds, u);
         }
     );
     connect(workspace(), &Workspace::unmanagedRemoved, this,
         [this] (Unmanaged *u) {
             remove(s_x11UnmanagedId -1, m_unmanageds, u);
         }
     );
     for (InternalClient *client : workspace()->internalClients()) {
         m_internalClients.append(client);
     }
     connect(workspace(), &Workspace::internalClientAdded, this,
         [this](InternalClient *client) {
             add(s_workspaceInternalId -1, m_internalClients, client);
         }
     );
     connect(workspace(), &Workspace::internalClientRemoved, this,
         [this](InternalClient *client) {
             remove(s_workspaceInternalId -1, m_internalClients, client);
         }
     );
 }
 
 DebugConsoleModel::~DebugConsoleModel() = default;
 
 int DebugConsoleModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 2;
 }
 
 int DebugConsoleModel::topLevelRowCount() const
 {
     return kwinApp()->shouldUseWaylandForCompositing() ? 4 : 2;
 }
 
 template <class T>
 int DebugConsoleModel::propertyCount(const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const
 {
     if (T *t = (this->*filter)(parent)) {
         return t->metaObject()->propertyCount();
     }
     return 0;
 }
 
 int DebugConsoleModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return topLevelRowCount();
     }
 
     switch (parent.internalId()) {
     case s_x11ClientId:
         return m_x11Clients.count();
     case s_x11UnmanagedId:
         return m_unmanageds.count();
     case s_waylandClientId:
         return m_waylandClients.count();
     case s_workspaceInternalId:
         return m_internalClients.count();
     default:
         break;
     }
 
     if (parent.internalId() & s_propertyBitMask) {
         // properties do not have children
         return 0;
     }
 
     if (parent.internalId() < s_idDistance * (s_x11ClientId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::x11Client);
     } else if (parent.internalId() < s_idDistance * (s_x11UnmanagedId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::unmanaged);
     } else if (parent.internalId() < s_idDistance * (s_waylandClientId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::waylandClient);
     } else if (parent.internalId() < s_idDistance * (s_workspaceInternalId + 1)) {
         return propertyCount(parent, &DebugConsoleModel::internalClient);
     }
 
     return 0;
 }
 
 template <class T>
 QModelIndex DebugConsoleModel::indexForClient(int row, int column, const QVector<T*> &clients, int id) const
 {
     if (column != 0) {
         return QModelIndex();
     }
     if (row >= clients.count()) {
         return QModelIndex();
     }
     return createIndex(row, column, s_idDistance * id + row);
 }
 
 template <class T>
 QModelIndex DebugConsoleModel::indexForProperty(int row, int column, const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const
 {
     if (T *t = (this->*filter)(parent)) {
         if (row >= t->metaObject()->propertyCount()) {
             return QModelIndex();
         }
         return createIndex(row, column, quint32(row + 1) << 16 | parent.internalId());
     }
     return QModelIndex();
 }
 
 QModelIndex DebugConsoleModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         // index for a top level item
         if (column != 0 || row >= topLevelRowCount()) {
             return QModelIndex();
         }
         return createIndex(row, column, row + 1);
     }
     if (column >= 2) {
         // max of 2 columns
         return QModelIndex();
     }
     // index for a client (second level)
     switch (parent.internalId()) {
     case s_x11ClientId:
         return indexForClient(row, column, m_x11Clients, s_x11ClientId);
     case s_x11UnmanagedId:
         return indexForClient(row, column, m_unmanageds, s_x11UnmanagedId);
     case s_waylandClientId:
         return indexForClient(row, column, m_waylandClients, s_waylandClientId);
     case s_workspaceInternalId:
         return indexForClient(row, column, m_internalClients, s_workspaceInternalId);
     default:
         break;
     }
 
     // index for a property (third level)
     if (parent.internalId() < s_idDistance * (s_x11ClientId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::x11Client);
     } else if (parent.internalId() < s_idDistance * (s_x11UnmanagedId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::unmanaged);
     } else if (parent.internalId() < s_idDistance * (s_waylandClientId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::waylandClient);
     } else if (parent.internalId() < s_idDistance * (s_workspaceInternalId + 1)) {
         return indexForProperty(row, column, parent, &DebugConsoleModel::internalClient);
     }
 
     return QModelIndex();
 }
 
 QModelIndex DebugConsoleModel::parent(const QModelIndex &child) const
 {
     if (child.internalId() <= s_workspaceInternalId) {
         return QModelIndex();
     }
     if (child.internalId() & s_propertyBitMask) {
         // a property
         const quint32 parentId = child.internalId() & s_clientBitMask;
         if (parentId < s_idDistance * (s_x11ClientId + 1)) {
             return createIndex(parentId - (s_idDistance * s_x11ClientId), 0, parentId);
         } else if (parentId < s_idDistance * (s_x11UnmanagedId + 1)) {
             return createIndex(parentId - (s_idDistance * s_x11UnmanagedId), 0, parentId);
         } else if (parentId < s_idDistance * (s_waylandClientId + 1)) {
             return createIndex(parentId - (s_idDistance * s_waylandClientId), 0, parentId);
         } else if (parentId < s_idDistance * (s_workspaceInternalId + 1)) {
             return createIndex(parentId - (s_idDistance * s_workspaceInternalId), 0, parentId);
         }
         return QModelIndex();
     }
     if (child.internalId() < s_idDistance * (s_x11ClientId + 1)) {
         return createIndex(s_x11ClientId -1, 0, s_x11ClientId);
     } else if (child.internalId() < s_idDistance * (s_x11UnmanagedId + 1)) {
         return createIndex(s_x11UnmanagedId -1, 0, s_x11UnmanagedId);
     } else if (child.internalId() < s_idDistance * (s_waylandClientId + 1)) {
         return createIndex(s_waylandClientId -1, 0, s_waylandClientId);
     } else if (child.internalId() < s_idDistance * (s_workspaceInternalId + 1)) {
         return createIndex(s_workspaceInternalId -1, 0, s_workspaceInternalId);
     }
     return QModelIndex();
 }
 
 QVariant DebugConsoleModel::propertyData(QObject *object, const QModelIndex &index, int role) const
 {
     Q_UNUSED(role)
     const auto property = object->metaObject()->property(index.row());
     if (index.column() == 0) {
         return property.name();
     } else {
         const QVariant value = property.read(object);
         if (qstrcmp(property.name(), "windowType") == 0) {
             switch (value.toInt()) {
             case NET::Normal:
                 return QStringLiteral("NET::Normal");
             case NET::Desktop:
                 return QStringLiteral("NET::Desktop");
             case NET::Dock:
                 return QStringLiteral("NET::Dock");
             case NET::Toolbar:
                 return QStringLiteral("NET::Toolbar");
             case NET::Menu:
                 return QStringLiteral("NET::Menu");
             case NET::Dialog:
                 return QStringLiteral("NET::Dialog");
             case NET::Override:
                 return QStringLiteral("NET::Override");
             case NET::TopMenu:
                 return QStringLiteral("NET::TopMenu");
             case NET::Utility:
                 return QStringLiteral("NET::Utility");
             case NET::Splash:
                 return QStringLiteral("NET::Splash");
             case NET::DropdownMenu:
                 return QStringLiteral("NET::DropdownMenu");
             case NET::PopupMenu:
                 return QStringLiteral("NET::PopupMenu");
             case NET::Tooltip:
                 return QStringLiteral("NET::Tooltip");
             case NET::Notification:
                 return QStringLiteral("NET::Notification");
             case NET::ComboBox:
                 return QStringLiteral("NET::ComboBox");
             case NET::DNDIcon:
                 return QStringLiteral("NET::DNDIcon");
             case NET::OnScreenDisplay:
                 return QStringLiteral("NET::OnScreenDisplay");
             case NET::CriticalNotification:
                 return QStringLiteral("NET::CriticalNotification");
             case NET::Unknown:
             default:
                 return QStringLiteral("NET::Unknown");
             }
         }
         return value;
     }
     return QVariant();
 }
 
 template <class T>
 QVariant DebugConsoleModel::clientData(const QModelIndex &index, int role, const QVector<T*> clients) const
 {
     if (index.row() >= clients.count()) {
         return QVariant();
     }
     auto c = clients.at(index.row());
     if (role == Qt::DisplayRole) {
         return QStringLiteral("%1: %2").arg(c->window()).arg(c->caption());
     } else if (role == Qt::DecorationRole) {
         return c->icon();
     }
     return QVariant();
 }
 
 QVariant DebugConsoleModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     if (!index.parent().isValid()) {
         // one of the top levels
         if (index.column() != 0 || role != Qt::DisplayRole) {
             return QVariant();
         }
         switch (index.internalId()) {
         case s_x11ClientId:
             return i18n("X11 Client Windows");
         case s_x11UnmanagedId:
             return i18n("X11 Unmanaged Windows");
         case s_waylandClientId:
             return i18n("Wayland Windows");
         case s_workspaceInternalId:
             return i18n("Internal Windows");
         default:
             return QVariant();
         }
     }
     if (index.internalId() & s_propertyBitMask) {
         if (index.column() >= 2 || role != Qt::DisplayRole) {
             return QVariant();
         }
         if (AbstractClient *c = waylandClient(index)) {
             return propertyData(c, index, role);
         } else if (InternalClient *c = internalClient(index)) {
             return propertyData(c, index, role);
         } else if (X11Client *c = x11Client(index)) {
             return propertyData(c, index, role);
         } else if (Unmanaged *u = unmanaged(index)) {
             return propertyData(u, index, role);
         }
     } else {
         if (index.column() != 0) {
             return QVariant();
         }
         switch (index.parent().internalId()) {
         case s_x11ClientId:
             return clientData(index, role, m_x11Clients);
         case s_x11UnmanagedId: {
             if (index.row() >= m_unmanageds.count()) {
                 return QVariant();
             }
             auto u = m_unmanageds.at(index.row());
             if (role == Qt::DisplayRole) {
                 return u->window();
             }
             break;
         }
         case s_waylandClientId:
             return clientData(index, role, m_waylandClients);
         case s_workspaceInternalId:
             return clientData(index, role, m_internalClients);
         default:
             break;
         }
     }
 
     return QVariant();
 }
 
 template<class T>
 static T *clientForIndex(const QModelIndex &index, const QVector<T*> &clients, int id)
 {
     const qint32 row = (index.internalId() & s_clientBitMask) - (s_idDistance * id);
     if (row < 0 || row >= clients.count()) {
         return nullptr;
     }
     return clients.at(row);
 }
 
 AbstractClient *DebugConsoleModel::waylandClient(const QModelIndex &index) const
 {
     return clientForIndex(index, m_waylandClients, s_waylandClientId);
 }
 
 InternalClient *DebugConsoleModel::internalClient(const QModelIndex &index) const
 {
     return clientForIndex(index, m_internalClients, s_workspaceInternalId);
 }
 
 X11Client *DebugConsoleModel::x11Client(const QModelIndex &index) const
 {
     return clientForIndex(index, m_x11Clients, s_x11ClientId);
 }
 
 Unmanaged *DebugConsoleModel::unmanaged(const QModelIndex &index) const
 {
     return clientForIndex(index, m_unmanageds, s_x11UnmanagedId);
 }
 
 /////////////////////////////////////// SurfaceTreeModel
 SurfaceTreeModel::SurfaceTreeModel(QObject *parent)
     : QAbstractItemModel(parent)
 {
     // TODO: it would be nice to not have to reset the model on each change
     auto reset = [this] {
         beginResetModel();
         endResetModel();
     };
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
 
     const auto unmangeds = workspace()->unmanagedList();
     for (auto u : unmangeds) {
         if (!u->surface()) {
             continue;
         }
         connect(u->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
     }
     for (auto c : workspace()->allClientList()) {
         if (!c->surface()) {
             continue;
         }
         connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
     }
     for (auto c : workspace()->desktopList()) {
         if (!c->surface()) {
             continue;
         }
         connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
     }
     if (waylandServer()) {
         connect(waylandServer(), &WaylandServer::shellClientAdded, this,
             [this, reset] (AbstractClient *c) {
                 connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
                 reset();
             }
         );
     }
     connect(workspace(), &Workspace::clientAdded, this,
         [this, reset] (AbstractClient *c) {
             if (c->surface()) {
                 connect(c->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
             }
             reset();
         }
     );
     connect(workspace(), &Workspace::clientRemoved, this, reset);
     connect(workspace(), &Workspace::unmanagedAdded, this,
         [this, reset] (Unmanaged *u) {
             if (u->surface()) {
                 connect(u->surface(), &SurfaceInterface::subSurfaceTreeChanged, this, reset);
             }
             reset();
         }
     );
     connect(workspace(), &Workspace::unmanagedRemoved, this, reset);
 }
 
 SurfaceTreeModel::~SurfaceTreeModel() = default;
 
 int SurfaceTreeModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 1;
 }
 
 int SurfaceTreeModel::rowCount(const QModelIndex &parent) const
 {
     if (parent.isValid()) {
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
         if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(parent.internalPointer())) {
             const auto &children = surface->childSubSurfaces();
             return children.count();
         }
         return 0;
     }
     // toplevel are all windows
     return workspace()->allClientList().count() +
            workspace()->desktopList().count() +
            workspace()->unmanagedList().count();
 }
 
 QModelIndex SurfaceTreeModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (column != 0) {
         // invalid column
         return QModelIndex();
     }
 
     if (parent.isValid()) {
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
         if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(parent.internalPointer())) {
             const auto &children = surface->childSubSurfaces();
             if (row < children.count()) {
                 return createIndex(row, column, children.at(row)->surface().data());
             }
         }
         return QModelIndex();
     }
     // a window
     const auto &allClients = workspace()->allClientList();
     if (row < allClients.count()) {
         // references a client
         return createIndex(row, column, allClients.at(row)->surface());
     }
     int reference = allClients.count();
     const auto &desktopClients = workspace()->desktopList();
     if (row < reference + desktopClients.count()) {
         return createIndex(row, column, desktopClients.at(row-reference)->surface());
     }
     reference += desktopClients.count();
     const auto &unmanaged = workspace()->unmanagedList();
     if (row < reference + unmanaged.count()) {
         return createIndex(row, column, unmanaged.at(row-reference)->surface());
     }
     reference += unmanaged.count();
     // not found
     return QModelIndex();
 }
 
 QModelIndex SurfaceTreeModel::parent(const QModelIndex &child) const
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(child.internalPointer())) {
         const auto &subsurface = surface->subSurface();
         if (subsurface.isNull()) {
             // doesn't reference a subsurface, this is a top-level window
             return QModelIndex();
         }
         SurfaceInterface *parent = subsurface->parentSurface().data();
         if (!parent) {
             // something is wrong
             return QModelIndex();
         }
         // is the parent a subsurface itself?
         if (parent->subSurface()) {
             auto grandParent = parent->subSurface()->parentSurface();
             if (grandParent.isNull()) {
                 // something is wrong
                 return QModelIndex();
             }
             const auto &children = grandParent->childSubSurfaces();
             for (int row = 0; row < children.count(); row++) {
                 if (children.at(row).data() == parent->subSurface().data()) {
                     return createIndex(row, 0, parent);
                 }
             }
             return QModelIndex();
         }
         // not a subsurface, thus it's a true window
         int row = 0;
         const auto &allClients = workspace()->allClientList();
         for (; row < allClients.count(); row++) {
             if (allClients.at(row)->surface() == parent) {
                 return createIndex(row, 0, parent);
             }
         }
         row = allClients.count();
         const auto &desktopClients = workspace()->desktopList();
         for (int i = 0; i < desktopClients.count(); i++) {
             if (desktopClients.at(i)->surface() == parent) {
                 return createIndex(row + i, 0, parent);
             }
         }
         row += desktopClients.count();
         const auto &unmanaged = workspace()->unmanagedList();
         for (int i = 0; i < unmanaged.count(); i++) {
             if (unmanaged.at(i)->surface() == parent) {
                 return createIndex(row + i, 0, parent);
             }
         }
         row += unmanaged.count();
     }
     return QModelIndex();
 }
 
 QVariant SurfaceTreeModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     if (SurfaceInterface *surface = static_cast<SurfaceInterface*>(index.internalPointer())) {
         if (role == Qt::DisplayRole || role == Qt::ToolTipRole) {
             return QStringLiteral("%1 (%2) - %3").arg(surface->client()->executablePath())
                                                 .arg(surface->client()->processId())
                                                 .arg(surface->id());
         } else if (role == Qt::DecorationRole) {
             if (auto buffer = surface->buffer()) {
                 if (buffer->shmBuffer()) {
                     return buffer->data().scaled(QSize(64, 64), Qt::KeepAspectRatio);
                 }
             }
         }
     }
     return QVariant();
 }
 
 InputDeviceModel::InputDeviceModel(QObject *parent)
     : QAbstractItemModel(parent)
     , m_devices(LibInput::Connection::self()->devices())
 {
     for (auto it = m_devices.constBegin(); it != m_devices.constEnd(); ++it) {
         setupDeviceConnections(*it);
     }
     auto c = LibInput::Connection::self();
     connect(c, &LibInput::Connection::deviceAdded, this,
         [this] (LibInput::Device *d) {
             beginInsertRows(QModelIndex(), m_devices.count(), m_devices.count());
             m_devices << d;
             setupDeviceConnections(d);
             endInsertRows();
         }
     );
     connect(c, &LibInput::Connection::deviceRemoved, this,
         [this] (LibInput::Device *d) {
             const int index = m_devices.indexOf(d);
             if (index == -1) {
                 return;
             }
             beginRemoveRows(QModelIndex(), index, index);
             m_devices.removeAt(index);
             endRemoveRows();
         }
     );
 }
 
 InputDeviceModel::~InputDeviceModel() = default;
 
 
 int InputDeviceModel::columnCount(const QModelIndex &parent) const
 {
     Q_UNUSED(parent)
     return 2;
 }
 
 QVariant InputDeviceModel::data(const QModelIndex &index, int role) const
 {
     if (!index.isValid()) {
         return QVariant();
     }
     if (!index.parent().isValid() && index.column() == 0) {
         const auto devices = LibInput::Connection::self()->devices();
         if (index.row() >= devices.count()) {
             return QVariant();
         }
         if (role == Qt::DisplayRole) {
             return devices.at(index.row())->name();
         }
     }
     if (index.parent().isValid()) {
         if (role == Qt::DisplayRole) {
             const auto device = LibInput::Connection::self()->devices().at(index.parent().row());
             const auto property = device->metaObject()->property(index.row());
             if (index.column() == 0) {
                 return property.name();
             } else if (index.column() == 1) {
                 return device->property(property.name());
             }
         }
     }
     return QVariant();
 }
 
 QModelIndex InputDeviceModel::index(int row, int column, const QModelIndex &parent) const
 {
     if (column >= 2) {
         return QModelIndex();
     }
     if (parent.isValid()) {
         if (parent.internalId() & s_propertyBitMask) {
             return QModelIndex();
         }
         if (row >= LibInput::Connection::self()->devices().at(parent.row())->metaObject()->propertyCount()) {
             return QModelIndex();
         }
         return createIndex(row, column, quint32(row + 1) << 16 | parent.internalId());
     }
     if (row >= LibInput::Connection::self()->devices().count()) {
         return QModelIndex();
     }
     return createIndex(row, column, row + 1);
 }
 
 int InputDeviceModel::rowCount(const QModelIndex &parent) const
 {
     if (!parent.isValid()) {
         return LibInput::Connection::self()->devices().count();
     }
     if (parent.internalId() & s_propertyBitMask) {
         return 0;
     }
 
     return LibInput::Connection::self()->devices().at(parent.row())->metaObject()->propertyCount();
 }
 
 QModelIndex InputDeviceModel::parent(const QModelIndex &child) const
 {
     if (child.internalId() & s_propertyBitMask) {
         const quintptr parentId = child.internalId() & s_clientBitMask;
         return createIndex(parentId - 1, 0, parentId);
     }
     return QModelIndex();
 }
 
 void InputDeviceModel::setupDeviceConnections(LibInput::Device *device)
 {
     connect(device, &LibInput::Device::enabledChanged, this,
         [this, device] {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(device->metaObject()->indexOfProperty("enabled"), 1, parent);
             emit dataChanged(child, child, QVector<int>{Qt::DisplayRole});
         }
     );
     connect(device, &LibInput::Device::leftHandedChanged, this,
         [this, device] {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(device->metaObject()->indexOfProperty("leftHanded"), 1, parent);
             emit dataChanged(child, child, QVector<int>{Qt::DisplayRole});
         }
     );
     connect(device, &LibInput::Device::pointerAccelerationChanged, this,
         [this, device] {
             const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
             const QModelIndex child = index(device->metaObject()->indexOfProperty("pointerAcceleration"), 1, parent);
             emit dataChanged(child, child, QVector<int>{Qt::DisplayRole});
         }
     );
 }
 
 }
diff --git a/decorations/decorationbridge.cpp b/decorations/decorationbridge.cpp
index c3b4867e8..259645375 100644
--- a/decorations/decorationbridge.cpp
+++ b/decorations/decorationbridge.cpp
@@ -1,334 +1,334 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "decorationbridge.h"
 #include "decoratedclient.h"
 #include "decorationrenderer.h"
 #include "decorations_logging.h"
 #include "settings.h"
 // KWin core
 #include "abstract_client.h"
 #include "composite.h"
 #include "scene.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include <config-kwin.h>
 
 // KDecoration
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/DecorationSettings>
 
 // KWayland
-#include <KWayland/Server/server_decoration_interface.h>
+#include <KWaylandServer/server_decoration_interface.h>
 
 // Frameworks
 #include <KPluginMetaData>
 #include <KPluginLoader>
 
 // Qt
 #include <QMetaProperty>
 #include <QPainter>
 
 namespace KWin
 {
 namespace Decoration
 {
 
 static const QString s_aurorae = QStringLiteral("org.kde.kwin.aurorae");
 static const QString s_pluginName = QStringLiteral("org.kde.kdecoration2");
 #if HAVE_BREEZE_DECO
 static const QString s_defaultPlugin = QStringLiteral(BREEZE_KDECORATION_PLUGIN_ID);
 #else
 static const QString s_defaultPlugin = s_aurorae;
 #endif
 
 KWIN_SINGLETON_FACTORY(DecorationBridge)
 
 DecorationBridge::DecorationBridge(QObject *parent)
     : KDecoration2::DecorationBridge(parent)
     , m_factory(nullptr)
     , m_blur(false)
     , m_showToolTips(false)
     , m_settings()
     , m_noPlugin(false)
 {
     KConfigGroup cg(KSharedConfig::openConfig(), "KDE");
 
     // try to extract the proper defaults file from a lookandfeel package
     const QString looknfeel = cg.readEntry(QStringLiteral("LookAndFeelPackage"), "org.kde.breeze.desktop");
     m_lnfConfig = KSharedConfig::openConfig(QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("plasma/look-and-feel/") + looknfeel + QStringLiteral("/contents/defaults")));
 
     readDecorationOptions();
 }
 
 DecorationBridge::~DecorationBridge()
 {
     s_self = nullptr;
 }
 
 QString DecorationBridge::readPlugin()
 {
     //Try to get a default from look and feel
     KConfigGroup cg(m_lnfConfig, "kwinrc");
     cg = KConfigGroup(&cg, "org.kde.kdecoration2");
     return kwinApp()->config()->group(s_pluginName).readEntry("library", cg.readEntry("library", s_defaultPlugin));
 }
 
 static bool readNoPlugin()
 {
     return kwinApp()->config()->group(s_pluginName).readEntry("NoPlugin", false);
 }
 
 QString DecorationBridge::readTheme() const
 {
     //Try to get a default from look and feel
     KConfigGroup cg(m_lnfConfig, "kwinrc");
     cg = KConfigGroup(&cg, "org.kde.kdecoration2");
     return kwinApp()->config()->group(s_pluginName).readEntry("theme", cg.readEntry("theme", m_defaultTheme));
 }
 
 void DecorationBridge::readDecorationOptions()
 {
     m_showToolTips = kwinApp()->config()->group(s_pluginName).readEntry("ShowToolTips", true);
 }
 
 void DecorationBridge::init()
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     m_noPlugin = readNoPlugin();
     if (m_noPlugin) {
         if (waylandServer()) {
             waylandServer()->decorationManager()->setDefaultMode(ServerSideDecorationManagerInterface::Mode::None);
         }
         return;
     }
     m_plugin = readPlugin();
     m_settings = QSharedPointer<KDecoration2::DecorationSettings>::create(this);
     initPlugin();
     if (!m_factory) {
         if (m_plugin != s_defaultPlugin) {
             // try loading default plugin
             m_plugin = s_defaultPlugin;
             initPlugin();
         }
         // default plugin failed to load, try fallback
         if (!m_factory) {
             m_plugin = s_aurorae;
             initPlugin();
         }
     }
     if (waylandServer()) {
         waylandServer()->decorationManager()->setDefaultMode(m_factory ? ServerSideDecorationManagerInterface::Mode::Server : ServerSideDecorationManagerInterface::Mode::None);
     }
 }
 
 void DecorationBridge::initPlugin()
 {
     const auto offers = KPluginLoader::findPluginsById(s_pluginName, m_plugin);
     if (offers.isEmpty()) {
         qCWarning(KWIN_DECORATIONS) << "Could not locate decoration plugin";
         return;
     }
     qCDebug(KWIN_DECORATIONS) << "Trying to load decoration plugin: " << offers.first().fileName();
     KPluginLoader loader(offers.first().fileName());
     KPluginFactory *factory = loader.factory();
     if (!factory) {
         qCWarning(KWIN_DECORATIONS) << "Error loading plugin:" << loader.errorString();
     } else {
         m_factory = factory;
         loadMetaData(loader.metaData().value(QStringLiteral("MetaData")).toObject());
     }
 }
 
 static void recreateDecorations()
 {
     Workspace::self()->forEachAbstractClient([](AbstractClient *c) { c->updateDecoration(true, true); });
 }
 
 void DecorationBridge::reconfigure()
 {
     readDecorationOptions();
 
     if (m_noPlugin != readNoPlugin()) {
         m_noPlugin = !m_noPlugin;
         // no plugin setting changed
         if (m_noPlugin) {
             // decorations disabled now
             m_plugin = QString();
             delete m_factory;
             m_factory = nullptr;
             m_settings.clear();
         } else {
             // decorations enabled now
             init();
         }
         recreateDecorations();
         return;
     }
 
     const QString newPlugin = readPlugin();
     if (newPlugin != m_plugin) {
         // plugin changed, recreate everything
         auto oldFactory = m_factory;
         const auto oldPluginName = m_plugin;
         m_plugin = newPlugin;
         initPlugin();
         if (m_factory == oldFactory) {
             // loading new plugin failed
             m_factory = oldFactory;
             m_plugin = oldPluginName;
         } else {
             recreateDecorations();
             // TODO: unload and destroy old plugin
         }
     } else {
         // same plugin, but theme might have changed
         const QString oldTheme = m_theme;
         m_theme = readTheme();
         if (m_theme != oldTheme) {
             recreateDecorations();
         }
     }
 }
 
 void DecorationBridge::loadMetaData(const QJsonObject &object)
 {
     // reset all settings
     m_blur = false;
     m_recommendedBorderSize = QString();
     m_theme = QString();
     m_defaultTheme = QString();
 
     // load the settings
     const QJsonValue decoSettings = object.value(s_pluginName);
     if (decoSettings.isUndefined()) {
         // no settings
         return;
     }
     const QVariantMap decoSettingsMap = decoSettings.toObject().toVariantMap();
     auto blurIt = decoSettingsMap.find(QStringLiteral("blur"));
     if (blurIt != decoSettingsMap.end()) {
         m_blur = blurIt.value().toBool();
     }
     auto recBorderSizeIt = decoSettingsMap.find(QStringLiteral("recommendedBorderSize"));
     if (recBorderSizeIt != decoSettingsMap.end()) {
         m_recommendedBorderSize = recBorderSizeIt.value().toString();
     }
     findTheme(decoSettingsMap);
 
     Q_EMIT metaDataLoaded();
 }
 
 void DecorationBridge::findTheme(const QVariantMap &map)
 {
     auto it = map.find(QStringLiteral("themes"));
     if (it == map.end()) {
         return;
     }
     if (!it.value().toBool()) {
         return;
     }
     it = map.find(QStringLiteral("defaultTheme"));
     m_defaultTheme = it != map.end() ? it.value().toString() : QString();
     m_theme = readTheme();
 }
 
 std::unique_ptr<KDecoration2::DecoratedClientPrivate> DecorationBridge::createClient(KDecoration2::DecoratedClient *client, KDecoration2::Decoration *decoration)
 {
     return std::unique_ptr<DecoratedClientImpl>(new DecoratedClientImpl(static_cast<AbstractClient*>(decoration->parent()), client, decoration));
 }
 
 std::unique_ptr<KDecoration2::DecorationSettingsPrivate> DecorationBridge::settings(KDecoration2::DecorationSettings *parent)
 {
     return std::unique_ptr<SettingsImpl>(new SettingsImpl(parent));
 }
 
 void DecorationBridge::update(KDecoration2::Decoration *decoration, const QRect &geometry)
 {
     // TODO: remove check once all compositors implement it
     if (AbstractClient *c = Workspace::self()->findAbstractClient([decoration] (const AbstractClient *client) { return client->decoration() == decoration; })) {
         if (Renderer *renderer = c->decoratedClient()->renderer()) {
             renderer->schedule(geometry);
         }
     }
 }
 
 KDecoration2::Decoration *DecorationBridge::createDecoration(AbstractClient *client)
 {
     if (m_noPlugin) {
         return nullptr;
     }
     if (!m_factory) {
         return nullptr;
     }
     QVariantMap args({ {QStringLiteral("bridge"), QVariant::fromValue(this)} });
 
     if (!m_theme.isEmpty()) {
         args.insert(QStringLiteral("theme"), m_theme);
     }
     auto deco = m_factory->create<KDecoration2::Decoration>(client, QVariantList({args}));
     deco->setSettings(m_settings);
     deco->init();
     return deco;
 }
 
 static
 QString settingsProperty(const QVariant &variant)
 {
     if (QLatin1String(variant.typeName()) == QLatin1String("KDecoration2::BorderSize")) {
         return QString::number(variant.toInt());
     } else if (QLatin1String(variant.typeName()) == QLatin1String("QVector<KDecoration2::DecorationButtonType>")) {
         const auto &b = variant.value<QVector<KDecoration2::DecorationButtonType>>();
         QString buffer;
         for (auto it = b.begin(); it != b.end(); ++it) {
             if (it != b.begin()) {
                 buffer.append(QStringLiteral(", "));
             }
             buffer.append(QString::number(int(*it)));
         }
         return buffer;
     }
     return variant.toString();
 }
 
 QString DecorationBridge::supportInformation() const
 {
     QString b;
     if (m_noPlugin) {
         b.append(QStringLiteral("Decorations are disabled"));
     } else {
         b.append(QStringLiteral("Plugin: %1\n").arg(m_plugin));
         b.append(QStringLiteral("Theme: %1\n").arg(m_theme));
         b.append(QStringLiteral("Plugin recommends border size: %1\n").arg(m_recommendedBorderSize.isNull() ? "No" : m_recommendedBorderSize));
         b.append(QStringLiteral("Blur: %1\n").arg(m_blur));
         const QMetaObject *metaOptions = m_settings->metaObject();
         for (int i=0; i<metaOptions->propertyCount(); ++i) {
             const QMetaProperty property = metaOptions->property(i);
             if (QLatin1String(property.name()) == QLatin1String("objectName")) {
                 continue;
             }
             b.append(QStringLiteral("%1: %2\n").arg(property.name()).arg(settingsProperty(m_settings->property(property.name()))));
         }
     }
     return b;
 }
 
 } // Decoration
 } // KWin
diff --git a/effects.cpp b/effects.cpp
index c9173f61a..40a2bb564 100644
--- a/effects.cpp
+++ b/effects.cpp
@@ -1,2421 +1,2421 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "effects.h"
 
 #include "effectsadaptor.h"
 #include "effectloader.h"
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "deleted.h"
 #include "x11client.h"
 #include "cursor.h"
 #include "group.h"
 #include "internal_client.h"
 #include "osd.h"
 #include "pointer_input.h"
 #include "unmanaged.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "screenedge.h"
 #include "scripting/scriptedeffect.h"
 #include "screens.h"
 #include "screenlockerwatcher.h"
 #include "thumbnailitem.h"
 #include "virtualdesktops.h"
 #include "window_property_notify_x11_filter.h"
 #include "workspace.h"
 #include "kwinglutils.h"
 #include "kwineffectquickview.h"
 
 #include <QDebug>
 
 #include <Plasma/Theme>
 
 #include "composite.h"
 #include "xcbutils.h"
 #include "platform.h"
 #include "xdgshellclient.h"
 #include "wayland_server.h"
 
 #include "decorations/decorationbridge.h"
 #include <KDecoration2/DecorationSettings>
 
 namespace KWin
 {
 //---------------------
 // Static
 
 static QByteArray readWindowProperty(xcb_window_t win, xcb_atom_t atom, xcb_atom_t type, int format)
 {
     if (win == XCB_WINDOW_NONE) {
         return QByteArray();
     }
     uint32_t len = 32768;
     for (;;) {
         Xcb::Property prop(false, win, atom, XCB_ATOM_ANY, 0, len);
         if (prop.isNull()) {
             // get property failed
             return QByteArray();
         }
         if (prop->bytes_after > 0) {
             len *= 2;
             continue;
         }
         return prop.toByteArray(format, type);
     }
 }
 
 static void deleteWindowProperty(Window win, long int atom)
 {
     if (win == XCB_WINDOW_NONE) {
         return;
     }
     xcb_delete_property(kwinApp()->x11Connection(), win, atom);
 }
 
 static xcb_atom_t registerSupportProperty(const QByteArray &propertyName)
 {
     auto c = kwinApp()->x11Connection();
     if (!c) {
         return XCB_ATOM_NONE;
     }
     // get the atom for the propertyName
     ScopedCPointer<xcb_intern_atom_reply_t> atomReply(xcb_intern_atom_reply(c,
         xcb_intern_atom_unchecked(c, false, propertyName.size(), propertyName.constData()),
         nullptr));
     if (atomReply.isNull()) {
         return XCB_ATOM_NONE;
     }
     // announce property on root window
     unsigned char dummy = 0;
     xcb_change_property(c, XCB_PROP_MODE_REPLACE, kwinApp()->x11RootWindow(), atomReply->atom, atomReply->atom, 8, 1, &dummy);
     // TODO: add to _NET_SUPPORTED
     return atomReply->atom;
 }
 
 //---------------------
 
 EffectsHandlerImpl::EffectsHandlerImpl(Compositor *compositor, Scene *scene)
     : EffectsHandler(scene->compositingType())
     , keyboard_grab_effect(nullptr)
     , fullscreen_effect(nullptr)
     , next_window_quad_type(EFFECT_QUAD_TYPE_START)
     , m_compositor(compositor)
     , m_scene(scene)
     , m_desktopRendering(false)
     , m_currentRenderedDesktop(0)
     , m_effectLoader(new EffectLoader(this))
     , m_trackingCursorChanges(0)
 {
     qRegisterMetaType<QVector<KWin::EffectWindow*>>();
     connect(m_effectLoader, &AbstractEffectLoader::effectLoaded, this,
         [this](Effect *effect, const QString &name) {
             effect_order.insert(effect->requestedEffectChainPosition(), EffectPair(name, effect));
             loaded_effects << EffectPair(name, effect);
             effectsChanged();
         }
     );
     m_effectLoader->setConfig(kwinApp()->config());
     new EffectsAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Effects"), this);
     // init is important, otherwise causes crashes when quads are build before the first painting pass start
     m_currentBuildQuadsIterator = m_activeEffects.constEnd();
 
     Workspace *ws = Workspace::self();
     VirtualDesktopManager *vds = VirtualDesktopManager::self();
     connect(ws, &Workspace::showingDesktopChanged,
             this, &EffectsHandlerImpl::showingDesktopChanged);
     connect(ws, &Workspace::currentDesktopChanged, this,
         [this](int old, AbstractClient *c) {
             const int newDesktop = VirtualDesktopManager::self()->current();
             if (old != 0 && newDesktop != old) {
                 emit desktopChanged(old, newDesktop, c ? c->effectWindow() : nullptr);
                 // TODO: remove in 4.10
                 emit desktopChanged(old, newDesktop);
             }
         }
     );
     connect(ws, &Workspace::desktopPresenceChanged, this,
         [this](AbstractClient *c, int old) {
             if (!c->effectWindow()) {
                 return;
             }
             emit desktopPresenceChanged(c->effectWindow(), old, c->desktop());
         }
     );
     connect(ws, &Workspace::clientAdded, this,
         [this](X11Client *c) {
             if (c->readyForPainting())
                 slotClientShown(c);
             else
                 connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotClientShown);
         }
     );
     connect(ws, &Workspace::unmanagedAdded, this,
         [this](Unmanaged *u) {
             // it's never initially ready but has synthetic 50ms delay
             connect(u, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotUnmanagedShown);
         }
     );
     connect(ws, &Workspace::internalClientAdded, this,
         [this](InternalClient *client) {
             setupAbstractClientConnections(client);
             emit windowAdded(client->effectWindow());
         }
     );
     connect(ws, &Workspace::clientActivated, this,
         [this](KWin::AbstractClient *c) {
             emit windowActivated(c ? c->effectWindow() : nullptr);
         }
     );
     connect(ws, &Workspace::deletedRemoved, this,
         [this](KWin::Deleted *d) {
             emit windowDeleted(d->effectWindow());
             elevated_windows.removeAll(d->effectWindow());
         }
     );
     connect(ws->sessionManager(), &SessionManager::stateChanged, this,
             &KWin::EffectsHandler::sessionStateChanged);
     connect(vds, &VirtualDesktopManager::countChanged, this, &EffectsHandler::numberDesktopsChanged);
     connect(Cursors::self()->mouse(), &Cursor::mouseChanged, this, &EffectsHandler::mouseChanged);
     connect(screens(), &Screens::countChanged,    this, &EffectsHandler::numberScreensChanged);
     connect(screens(), &Screens::sizeChanged,     this, &EffectsHandler::virtualScreenSizeChanged);
     connect(screens(), &Screens::geometryChanged, this, &EffectsHandler::virtualScreenGeometryChanged);
 #ifdef KWIN_BUILD_ACTIVITIES
     if (Activities *activities = Activities::self()) {
         connect(activities, &Activities::added,          this, &EffectsHandler::activityAdded);
         connect(activities, &Activities::removed,        this, &EffectsHandler::activityRemoved);
         connect(activities, &Activities::currentChanged, this, &EffectsHandler::currentActivityChanged);
     }
 #endif
     connect(ws, &Workspace::stackingOrderChanged, this, &EffectsHandler::stackingOrderChanged);
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     connect(tabBox, &TabBox::TabBox::tabBoxAdded,    this, &EffectsHandler::tabBoxAdded);
     connect(tabBox, &TabBox::TabBox::tabBoxUpdated,  this, &EffectsHandler::tabBoxUpdated);
     connect(tabBox, &TabBox::TabBox::tabBoxClosed,   this, &EffectsHandler::tabBoxClosed);
     connect(tabBox, &TabBox::TabBox::tabBoxKeyEvent, this, &EffectsHandler::tabBoxKeyEvent);
 #endif
     connect(ScreenEdges::self(), &ScreenEdges::approaching, this, &EffectsHandler::screenEdgeApproaching);
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked, this, &EffectsHandler::screenLockingChanged);
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::aboutToLock, this, &EffectsHandler::screenAboutToLock);
 
     connect(kwinApp(), &Application::x11ConnectionChanged, this,
         [this] {
             registered_atoms.clear();
             for (auto it = m_propertiesForEffects.keyBegin(); it != m_propertiesForEffects.keyEnd(); it++) {
                 const auto atom = registerSupportProperty(*it);
                 if (atom == XCB_ATOM_NONE) {
                     continue;
                 }
                 m_compositor->keepSupportProperty(atom);
                 m_managedProperties.insert(*it, atom);
                 registerPropertyType(atom, true);
             }
             if (kwinApp()->x11Connection()) {
                 m_x11WindowPropertyNotify = std::make_unique<WindowPropertyNotifyX11Filter>(this);
             } else {
                 m_x11WindowPropertyNotify.reset();
             }
             emit xcbConnectionChanged();
         }
     );
 
     if (kwinApp()->x11Connection()) {
         m_x11WindowPropertyNotify = std::make_unique<WindowPropertyNotifyX11Filter>(this);
     }
 
     // connect all clients
     for (X11Client *c : ws->clientList()) {
         setupClientConnections(c);
     }
     for (Unmanaged *u : ws->unmanagedList()) {
         setupUnmanagedConnections(u);
     }
     for (InternalClient *client : ws->internalClients()) {
         setupAbstractClientConnections(client);
     }
     if (auto w = waylandServer()) {
         connect(w, &WaylandServer::shellClientAdded, this, [this](AbstractClient *c) {
             if (c->readyForPainting())
                 slotWaylandClientShown(c);
             else
                 connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotWaylandClientShown);
         });
         const auto clients = waylandServer()->clients();
         for (AbstractClient *c : clients) {
             if (c->readyForPainting()) {
                 setupAbstractClientConnections(c);
             } else {
                 connect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotWaylandClientShown);
             }
         }
     }
     reconfigure();
 }
 
 EffectsHandlerImpl::~EffectsHandlerImpl()
 {
     unloadAllEffects();
 }
 
 void EffectsHandlerImpl::unloadAllEffects()
 {
     for (const EffectPair &pair : loaded_effects) {
         destroyEffect(pair.second);
     }
 
     effect_order.clear();
     m_effectLoader->clear();
 
     effectsChanged();
 }
 
 void EffectsHandlerImpl::setupAbstractClientConnections(AbstractClient* c)
 {
     connect(c, &AbstractClient::windowClosed, this, &EffectsHandlerImpl::slotWindowClosed);
     connect(c, static_cast<void (AbstractClient::*)(KWin::AbstractClient*, MaximizeMode)>(&AbstractClient::clientMaximizedStateChanged),
             this, &EffectsHandlerImpl::slotClientMaximized);
     connect(c, &AbstractClient::clientStartUserMovedResized, this,
         [this](AbstractClient *c) {
             emit windowStartUserMovedResized(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::clientStepUserMovedResized, this,
         [this](AbstractClient *c, const QRect &geometry) {
             emit windowStepUserMovedResized(c->effectWindow(), geometry);
         }
     );
     connect(c, &AbstractClient::clientFinishUserMovedResized, this,
         [this](AbstractClient *c) {
             emit windowFinishUserMovedResized(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::opacityChanged, this, &EffectsHandlerImpl::slotOpacityChanged);
     connect(c, &AbstractClient::clientMinimized, this,
         [this](AbstractClient *c, bool animate) {
             // TODO: notify effects even if it should not animate?
             if (animate) {
                 emit windowMinimized(c->effectWindow());
             }
         }
     );
     connect(c, &AbstractClient::clientUnminimized, this,
         [this](AbstractClient* c, bool animate) {
             // TODO: notify effects even if it should not animate?
             if (animate) {
                 emit windowUnminimized(c->effectWindow());
             }
         }
     );
     connect(c, &AbstractClient::modalChanged,         this, &EffectsHandlerImpl::slotClientModalityChanged);
     connect(c, &AbstractClient::geometryShapeChanged, this, &EffectsHandlerImpl::slotGeometryShapeChanged);
     connect(c, &AbstractClient::frameGeometryChanged, this, &EffectsHandlerImpl::slotFrameGeometryChanged);
     connect(c, &AbstractClient::damaged,              this, &EffectsHandlerImpl::slotWindowDamaged);
     connect(c, &AbstractClient::unresponsiveChanged, this,
         [this, c](bool unresponsive) {
             emit windowUnresponsiveChanged(c->effectWindow(), unresponsive);
         }
     );
     connect(c, &AbstractClient::windowShown, this,
         [this](Toplevel *c) {
             emit windowShown(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::windowHidden, this,
         [this](Toplevel *c) {
             emit windowHidden(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::keepAboveChanged, this,
         [this, c](bool above) {
             Q_UNUSED(above)
             emit windowKeepAboveChanged(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::keepBelowChanged, this,
         [this, c](bool below) {
             Q_UNUSED(below)
             emit windowKeepBelowChanged(c->effectWindow());
         }
     );
     connect(c, &AbstractClient::fullScreenChanged, this,
         [this, c]() {
             emit windowFullScreenChanged(c->effectWindow());
         }
     );
 }
 
 void EffectsHandlerImpl::setupClientConnections(X11Client *c)
 {
     setupAbstractClientConnections(c);
     connect(c, &X11Client::paddingChanged,       this, &EffectsHandlerImpl::slotPaddingChanged);
 }
 
 void EffectsHandlerImpl::setupUnmanagedConnections(Unmanaged* u)
 {
     connect(u, &Unmanaged::windowClosed,         this, &EffectsHandlerImpl::slotWindowClosed);
     connect(u, &Unmanaged::opacityChanged,       this, &EffectsHandlerImpl::slotOpacityChanged);
     connect(u, &Unmanaged::geometryShapeChanged, this, &EffectsHandlerImpl::slotGeometryShapeChanged);
     connect(u, &Unmanaged::frameGeometryChanged, this, &EffectsHandlerImpl::slotFrameGeometryChanged);
     connect(u, &Unmanaged::paddingChanged,       this, &EffectsHandlerImpl::slotPaddingChanged);
     connect(u, &Unmanaged::damaged,              this, &EffectsHandlerImpl::slotWindowDamaged);
 }
 
 void EffectsHandlerImpl::reconfigure()
 {
     m_effectLoader->queryAndLoadAll();
 }
 
 // the idea is that effects call this function again which calls the next one
 void EffectsHandlerImpl::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->prePaintScreen(data, time);
         --m_currentPaintScreenIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::paintScreen(int mask, const QRegion &region, ScreenPaintData& data)
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->paintScreen(mask, region, data);
         --m_currentPaintScreenIterator;
     } else
         m_scene->finalPaintScreen(mask, region, data);
 }
 
 void EffectsHandlerImpl::paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData &data)
 {
     if (desktop < 1 || desktop > numberOfDesktops()) {
         return;
     }
     m_currentRenderedDesktop = desktop;
     m_desktopRendering = true;
     // save the paint screen iterator
     EffectsIterator savedIterator = m_currentPaintScreenIterator;
     m_currentPaintScreenIterator = m_activeEffects.constBegin();
     effects->paintScreen(mask, region, data);
     // restore the saved iterator
     m_currentPaintScreenIterator = savedIterator;
     m_desktopRendering = false;
 }
 
 void EffectsHandlerImpl::postPaintScreen()
 {
     if (m_currentPaintScreenIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintScreenIterator++)->postPaintScreen();
         --m_currentPaintScreenIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->prePaintWindow(w, data, time);
         --m_currentPaintWindowIterator;
     }
     // no special final code
 }
 
 void EffectsHandlerImpl::paintWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->paintWindow(w, mask, region, data);
         --m_currentPaintWindowIterator;
     } else
         m_scene->finalPaintWindow(static_cast<EffectWindowImpl*>(w), mask, region, data);
 }
 
 void EffectsHandlerImpl::paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity)
 {
     if (m_currentPaintEffectFrameIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintEffectFrameIterator++)->paintEffectFrame(frame, region, opacity, frameOpacity);
         --m_currentPaintEffectFrameIterator;
     } else {
         const EffectFrameImpl* frameImpl = static_cast<const EffectFrameImpl*>(frame);
         frameImpl->finalRender(region, opacity, frameOpacity);
     }
 }
 
 void EffectsHandlerImpl::postPaintWindow(EffectWindow* w)
 {
     if (m_currentPaintWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentPaintWindowIterator++)->postPaintWindow(w);
         --m_currentPaintWindowIterator;
     }
     // no special final code
 }
 
 Effect *EffectsHandlerImpl::provides(Effect::Feature ef)
 {
     for (int i = 0; i < loaded_effects.size(); ++i)
         if (loaded_effects.at(i).second->provides(ef))
             return loaded_effects.at(i).second;
     return nullptr;
 }
 
 void EffectsHandlerImpl::drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (m_currentDrawWindowIterator != m_activeEffects.constEnd()) {
         (*m_currentDrawWindowIterator++)->drawWindow(w, mask, region, data);
         --m_currentDrawWindowIterator;
     } else
         m_scene->finalDrawWindow(static_cast<EffectWindowImpl*>(w), mask, region, data);
 }
 
 void EffectsHandlerImpl::buildQuads(EffectWindow* w, WindowQuadList& quadList)
 {
     static bool initIterator = true;
     if (initIterator) {
         m_currentBuildQuadsIterator = m_activeEffects.constBegin();
         initIterator = false;
     }
     if (m_currentBuildQuadsIterator != m_activeEffects.constEnd()) {
         (*m_currentBuildQuadsIterator++)->buildQuads(w, quadList);
         --m_currentBuildQuadsIterator;
     }
     if (m_currentBuildQuadsIterator == m_activeEffects.constBegin())
         initIterator = true;
 }
 
 bool EffectsHandlerImpl::hasDecorationShadows() const
 {
     return false;
 }
 
 bool EffectsHandlerImpl::decorationsHaveAlpha() const
 {
     return true;
 }
 
 bool EffectsHandlerImpl::decorationSupportsBlurBehind() const
 {
     return Decoration::DecorationBridge::self()->needsBlur();
 }
 
 // start another painting pass
 void EffectsHandlerImpl::startPaint()
 {
     m_activeEffects.clear();
     m_activeEffects.reserve(loaded_effects.count());
     for(QVector< KWin::EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->isActive()) {
             m_activeEffects << it->second;
         }
     }
     m_currentDrawWindowIterator = m_activeEffects.constBegin();
     m_currentPaintWindowIterator = m_activeEffects.constBegin();
     m_currentPaintScreenIterator = m_activeEffects.constBegin();
     m_currentPaintEffectFrameIterator = m_activeEffects.constBegin();
 }
 
 void EffectsHandlerImpl::slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode)
 {
     bool horizontal = false;
     bool vertical = false;
     switch (maxMode) {
     case MaximizeHorizontal:
         horizontal = true;
         break;
     case MaximizeVertical:
         vertical = true;
         break;
     case MaximizeFull:
         horizontal = true;
         vertical = true;
         break;
     case MaximizeRestore: // fall through
     default:
         // default - nothing to do
         break;
     }
     if (EffectWindowImpl *w = c->effectWindow()) {
         emit windowMaximizedStateChanged(w, horizontal, vertical);
     }
 }
 
 void EffectsHandlerImpl::slotOpacityChanged(Toplevel *t, qreal oldOpacity)
 {
     if (t->opacity() == oldOpacity || !t->effectWindow()) {
         return;
     }
     emit windowOpacityChanged(t->effectWindow(), oldOpacity, (qreal)t->opacity());
 }
 
 void EffectsHandlerImpl::slotClientShown(KWin::Toplevel *t)
 {
     Q_ASSERT(qobject_cast<X11Client *>(t));
     X11Client *c = static_cast<X11Client *>(t);
     disconnect(c, &Toplevel::windowShown, this, &EffectsHandlerImpl::slotClientShown);
     setupClientConnections(c);
     emit windowAdded(c->effectWindow());
 }
 
 void EffectsHandlerImpl::slotWaylandClientShown(Toplevel *toplevel)
 {
     AbstractClient *client = static_cast<AbstractClient *>(toplevel);
     setupAbstractClientConnections(client);
     emit windowAdded(toplevel->effectWindow());
 }
 
 void EffectsHandlerImpl::slotUnmanagedShown(KWin::Toplevel *t)
 {   // regardless, unmanaged windows are -yet?- not synced anyway
     Q_ASSERT(qobject_cast<Unmanaged *>(t));
     Unmanaged *u = static_cast<Unmanaged*>(t);
     setupUnmanagedConnections(u);
     emit windowAdded(u->effectWindow());
 }
 
 void EffectsHandlerImpl::slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d)
 {
     c->disconnect(this);
     if (d) {
         emit windowClosed(c->effectWindow());
     }
 }
 
 void EffectsHandlerImpl::slotClientModalityChanged()
 {
     emit windowModalityChanged(static_cast<X11Client *>(sender())->effectWindow());
 }
 
 void EffectsHandlerImpl::slotCurrentTabAboutToChange(EffectWindow *from, EffectWindow *to)
 {
     emit currentTabAboutToChange(from, to);
 }
 
 void EffectsHandlerImpl::slotTabAdded(EffectWindow* w, EffectWindow* to)
 {
     emit tabAdded(w, to);
 }
 
 void EffectsHandlerImpl::slotTabRemoved(EffectWindow *w, EffectWindow* leaderOfFormerGroup)
 {
     emit tabRemoved(w, leaderOfFormerGroup);
 }
 
 void EffectsHandlerImpl::slotWindowDamaged(Toplevel* t, const QRect& r)
 {
     if (!t->effectWindow()) {
         // can happen during tear down of window
         return;
     }
     emit windowDamaged(t->effectWindow(), r);
 }
 
 void EffectsHandlerImpl::slotGeometryShapeChanged(Toplevel* t, const QRect& old)
 {
     // during late cleanup effectWindow() may be already NULL
     // in some functions that may still call this
     if (t == nullptr || t->effectWindow() == nullptr)
         return;
     emit windowGeometryShapeChanged(t->effectWindow(), old);
 }
 
 void EffectsHandlerImpl::slotFrameGeometryChanged(Toplevel *toplevel, const QRect &oldGeometry)
 {
     // effectWindow() might be nullptr during tear down of the client.
     if (toplevel->effectWindow()) {
         emit windowFrameGeometryChanged(toplevel->effectWindow(), oldGeometry);
     }
 }
 
 void EffectsHandlerImpl::slotPaddingChanged(Toplevel* t, const QRect& old)
 {
     // during late cleanup effectWindow() may be already NULL
     // in some functions that may still call this
     if (t == nullptr || t->effectWindow() == nullptr)
         return;
     emit windowPaddingChanged(t->effectWindow(), old);
 }
 
 void EffectsHandlerImpl::setActiveFullScreenEffect(Effect* e)
 {
     if (fullscreen_effect == e) {
         return;
     }
     const bool activeChanged = (e == nullptr || fullscreen_effect == nullptr);
     fullscreen_effect = e;
     emit activeFullScreenEffectChanged();
     if (activeChanged) {
         emit hasActiveFullScreenEffectChanged();
     }
 }
 
 Effect* EffectsHandlerImpl::activeFullScreenEffect() const
 {
     return fullscreen_effect;
 }
 
 bool EffectsHandlerImpl::hasActiveFullScreenEffect() const
 {
     return fullscreen_effect;
 }
 
 bool EffectsHandlerImpl::grabKeyboard(Effect* effect)
 {
     if (keyboard_grab_effect != nullptr)
         return false;
     if (!doGrabKeyboard()) {
         return false;
     }
     keyboard_grab_effect = effect;
     return true;
 }
 
 bool EffectsHandlerImpl::doGrabKeyboard()
 {
     return true;
 }
 
 void EffectsHandlerImpl::ungrabKeyboard()
 {
     Q_ASSERT(keyboard_grab_effect != nullptr);
     doUngrabKeyboard();
     keyboard_grab_effect = nullptr;
 }
 
 void EffectsHandlerImpl::doUngrabKeyboard()
 {
 }
 
 void EffectsHandlerImpl::grabbedKeyboardEvent(QKeyEvent* e)
 {
     if (keyboard_grab_effect != nullptr)
         keyboard_grab_effect->grabbedKeyboardEvent(e);
 }
 
 void EffectsHandlerImpl::startMouseInterception(Effect *effect, Qt::CursorShape shape)
 {
     if (m_grabbedMouseEffects.contains(effect)) {
         return;
     }
     m_grabbedMouseEffects.append(effect);
     if (m_grabbedMouseEffects.size() != 1) {
         return;
     }
     doStartMouseInterception(shape);
 }
 
 void EffectsHandlerImpl::doStartMouseInterception(Qt::CursorShape shape)
 {
     input()->pointer()->setEffectsOverrideCursor(shape);
 }
 
 void EffectsHandlerImpl::stopMouseInterception(Effect *effect)
 {
     if (!m_grabbedMouseEffects.contains(effect)) {
         return;
     }
     m_grabbedMouseEffects.removeAll(effect);
     if (m_grabbedMouseEffects.isEmpty()) {
         doStopMouseInterception();
     }
 }
 
 void EffectsHandlerImpl::doStopMouseInterception()
 {
     input()->pointer()->removeEffectsOverrideCursor();
 }
 
 bool EffectsHandlerImpl::isMouseInterception() const
 {
     return m_grabbedMouseEffects.count() > 0;
 }
 
 
 bool EffectsHandlerImpl::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchDown(id, pos, time)) {
             return true;
         }
     }
     return false;
 }
 
 bool EffectsHandlerImpl::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchMotion(id, pos, time)) {
             return true;
         }
     }
     return false;
 }
 
 bool EffectsHandlerImpl::touchUp(qint32 id, quint32 time)
 {
     // TODO: reverse call order?
     for (auto it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if (it->second->touchUp(id, time)) {
             return true;
         }
     }
     return false;
 }
 
 void EffectsHandlerImpl::registerGlobalShortcut(const QKeySequence &shortcut, QAction *action)
 {
     input()->registerShortcut(shortcut, action);
 }
 
 void EffectsHandlerImpl::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
 {
     input()->registerPointerShortcut(modifiers, pointerButtons, action);
 }
 
 void EffectsHandlerImpl::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
 {
     input()->registerAxisShortcut(modifiers, axis, action);
 }
 
 void EffectsHandlerImpl::registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action)
 {
     input()->registerTouchpadSwipeShortcut(direction, action);
 }
 
 void* EffectsHandlerImpl::getProxy(QString name)
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name)
             return (*it).second->proxy();
 
     return nullptr;
 }
 
 void EffectsHandlerImpl::startMousePolling()
 {
     if (Cursors::self()->mouse())
         Cursors::self()->mouse()->startMousePolling();
 }
 
 void EffectsHandlerImpl::stopMousePolling()
 {
     if (Cursors::self()->mouse())
         Cursors::self()->mouse()->stopMousePolling();
 }
 
 bool EffectsHandlerImpl::hasKeyboardGrab() const
 {
     return keyboard_grab_effect != nullptr;
 }
 
 void EffectsHandlerImpl::desktopResized(const QSize &size)
 {
     m_scene->screenGeometryChanged(size);
     emit screenGeometryChanged(size);
 }
 
 void EffectsHandlerImpl::registerPropertyType(long atom, bool reg)
 {
     if (reg)
         ++registered_atoms[ atom ]; // initialized to 0 if not present yet
     else {
         if (--registered_atoms[ atom ] == 0)
             registered_atoms.remove(atom);
     }
 }
 
 xcb_atom_t EffectsHandlerImpl::announceSupportProperty(const QByteArray &propertyName, Effect *effect)
 {
     PropertyEffectMap::iterator it = m_propertiesForEffects.find(propertyName);
     if (it != m_propertiesForEffects.end()) {
         // property has already been registered for an effect
         // just append Effect and return the atom stored in m_managedProperties
         if (!it.value().contains(effect)) {
             it.value().append(effect);
         }
         return m_managedProperties.value(propertyName, XCB_ATOM_NONE);
     }
     m_propertiesForEffects.insert(propertyName, QList<Effect*>() << effect);
     const auto atom = registerSupportProperty(propertyName);
     if (atom == XCB_ATOM_NONE) {
         return atom;
     }
     m_compositor->keepSupportProperty(atom);
     m_managedProperties.insert(propertyName, atom);
     registerPropertyType(atom, true);
     return atom;
 }
 
 void EffectsHandlerImpl::removeSupportProperty(const QByteArray &propertyName, Effect *effect)
 {
     PropertyEffectMap::iterator it = m_propertiesForEffects.find(propertyName);
     if (it == m_propertiesForEffects.end()) {
         // property is not registered - nothing to do
         return;
     }
     if (!it.value().contains(effect)) {
         // property is not registered for given effect - nothing to do
         return;
     }
     it.value().removeAll(effect);
     if (!it.value().isEmpty()) {
         // property still registered for another effect - nothing further to do
         return;
     }
     const xcb_atom_t atom = m_managedProperties.take(propertyName);
     registerPropertyType(atom, false);
     m_propertiesForEffects.remove(propertyName);
     m_compositor->removeSupportProperty(atom); // delayed removal
 }
 
 QByteArray EffectsHandlerImpl::readRootProperty(long atom, long type, int format) const
 {
     if (!kwinApp()->x11Connection()) {
         return QByteArray();
     }
     return readWindowProperty(kwinApp()->x11RootWindow(), atom, type, format);
 }
 
 void EffectsHandlerImpl::activateWindow(EffectWindow* c)
 {
     if (auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(c)->window())) {
         Workspace::self()->activateClient(cl, true);
     }
 }
 
 EffectWindow* EffectsHandlerImpl::activeWindow() const
 {
     return Workspace::self()->activeClient() ? Workspace::self()->activeClient()->effectWindow() : nullptr;
 }
 
 void EffectsHandlerImpl::moveWindow(EffectWindow* w, const QPoint& pos, bool snap, double snapAdjust)
 {
     auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window());
     if (!cl || !cl->isMovable())
         return;
 
     if (snap)
         cl->move(Workspace::self()->adjustClientPosition(cl, pos, true, snapAdjust));
     else
         cl->move(pos);
 }
 
 void EffectsHandlerImpl::windowToDesktop(EffectWindow* w, int desktop)
 {
     auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window());
     if (cl && !cl->isDesktop() && !cl->isDock()) {
         Workspace::self()->sendClientToDesktop(cl, desktop, true);
     }
 }
 
 void EffectsHandlerImpl::windowToDesktops(EffectWindow *w, const QVector<uint> &desktopIds)
 {
     AbstractClient* cl = qobject_cast< AbstractClient* >(static_cast<EffectWindowImpl*>(w)->window());
     if (!cl || cl->isDesktop() || cl->isDock()) {
         return;
     }
     QVector<VirtualDesktop*> desktops;
     desktops.reserve(desktopIds.count());
     for (uint x11Id: desktopIds) {
         if (x11Id > VirtualDesktopManager::self()->count()) {
             continue;
         }
         VirtualDesktop *d = VirtualDesktopManager::self()->desktopForX11Id(x11Id);
         Q_ASSERT(d);
         if (desktops.contains(d)) {
             continue;
         }
         desktops << d;
     }
     cl->setDesktops(desktops);
 }
 
 void EffectsHandlerImpl::windowToScreen(EffectWindow* w, int screen)
 {
     auto cl = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window());
     if (cl && !cl->isDesktop() && !cl->isDock())
         Workspace::self()->sendClientToScreen(cl, screen);
 }
 
 void EffectsHandlerImpl::setShowingDesktop(bool showing)
 {
     Workspace::self()->setShowingDesktop(showing);
 }
 
 QString EffectsHandlerImpl::currentActivity() const
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return QString();
     }
     return Activities::self()->current();
 #else
     return QString();
 #endif
 }
 
 int EffectsHandlerImpl::currentDesktop() const
 {
     return VirtualDesktopManager::self()->current();
 }
 
 int EffectsHandlerImpl::numberOfDesktops() const
 {
     return VirtualDesktopManager::self()->count();
 }
 
 void EffectsHandlerImpl::setCurrentDesktop(int desktop)
 {
     VirtualDesktopManager::self()->setCurrent(desktop);
 }
 
 void EffectsHandlerImpl::setNumberOfDesktops(int desktops)
 {
     VirtualDesktopManager::self()->setCount(desktops);
 }
 
 QSize EffectsHandlerImpl::desktopGridSize() const
 {
     return VirtualDesktopManager::self()->grid().size();
 }
 
 int EffectsHandlerImpl::desktopGridWidth() const
 {
     return desktopGridSize().width();
 }
 
 int EffectsHandlerImpl::desktopGridHeight() const
 {
     return desktopGridSize().height();
 }
 
 int EffectsHandlerImpl::workspaceWidth() const
 {
     return desktopGridWidth() * screens()->size().width();
 }
 
 int EffectsHandlerImpl::workspaceHeight() const
 {
     return desktopGridHeight() * screens()->size().height();
 }
 
 int EffectsHandlerImpl::desktopAtCoords(QPoint coords) const
 {
     if (auto vd = VirtualDesktopManager::self()->grid().at(coords)) {
         return vd->x11DesktopNumber();
     }
     return 0;
 }
 
 QPoint EffectsHandlerImpl::desktopGridCoords(int id) const
 {
     return VirtualDesktopManager::self()->grid().gridCoords(id);
 }
 
 QPoint EffectsHandlerImpl::desktopCoords(int id) const
 {
     QPoint coords = VirtualDesktopManager::self()->grid().gridCoords(id);
     if (coords.x() == -1)
         return QPoint(-1, -1);
     const QSize displaySize = screens()->size();
     return QPoint(coords.x() * displaySize.width(), coords.y() * displaySize.height());
 }
 
 int EffectsHandlerImpl::desktopAbove(int desktop, bool wrap) const
 {
     return getDesktop<DesktopAbove>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopToRight(int desktop, bool wrap) const
 {
     return getDesktop<DesktopRight>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopBelow(int desktop, bool wrap) const
 {
     return getDesktop<DesktopBelow>(desktop, wrap);
 }
 
 int EffectsHandlerImpl::desktopToLeft(int desktop, bool wrap) const
 {
     return getDesktop<DesktopLeft>(desktop, wrap);
 }
 
 QString EffectsHandlerImpl::desktopName(int desktop) const
 {
     return VirtualDesktopManager::self()->name(desktop);
 }
 
 bool EffectsHandlerImpl::optionRollOverDesktops() const
 {
     return options->isRollOverDesktops();
 }
 
 double EffectsHandlerImpl::animationTimeFactor() const
 {
     return options->animationTimeFactor();
 }
 
 WindowQuadType EffectsHandlerImpl::newWindowQuadType()
 {
     return WindowQuadType(next_window_quad_type++);
 }
 
 EffectWindow* EffectsHandlerImpl::findWindow(WId id) const
 {
     if (X11Client *w = Workspace::self()->findClient(Predicate::WindowMatch, id))
         return w->effectWindow();
     if (Unmanaged* w = Workspace::self()->findUnmanaged(id))
         return w->effectWindow();
     if (waylandServer()) {
         if (AbstractClient *w = waylandServer()->findClient(id)) {
             return w->effectWindow();
         }
     }
     return nullptr;
 }
 
-EffectWindow* EffectsHandlerImpl::findWindow(KWayland::Server::SurfaceInterface *surf) const
+EffectWindow* EffectsHandlerImpl::findWindow(KWaylandServer::SurfaceInterface *surf) const
 {
     if (waylandServer()) {
         if (AbstractClient *w = waylandServer()->findClient(surf)) {
             return w->effectWindow();
         }
     }
     return nullptr;
 }
 
 EffectWindow *EffectsHandlerImpl::findWindow(QWindow *w) const
 {
     if (Toplevel *toplevel = workspace()->findInternal(w)) {
         return toplevel->effectWindow();
     }
     return nullptr;
 }
 
 EffectWindow *EffectsHandlerImpl::findWindow(const QUuid &id) const
 {
     if (const auto client = workspace()->findAbstractClient([&id] (const AbstractClient *c) { return c->internalId() == id; })) {
         return client->effectWindow();
     }
     if (const auto unmanaged = workspace()->findUnmanaged([&id] (const Unmanaged *c) { return c->internalId() == id; })) {
         return unmanaged->effectWindow();
     }
     return nullptr;
 }
 
 EffectWindowList EffectsHandlerImpl::stackingOrder() const
 {
     QList<Toplevel *> list = Workspace::self()->xStackingOrder();
     EffectWindowList ret;
     for (Toplevel *t : list) {
         if (EffectWindow *w = effectWindow(t))
             ret.append(w);
     }
     return ret;
 }
 
 void EffectsHandlerImpl::setElevatedWindow(KWin::EffectWindow* w, bool set)
 {
     elevated_windows.removeAll(w);
     if (set)
         elevated_windows.append(w);
 }
 
 void EffectsHandlerImpl::setTabBoxWindow(EffectWindow* w)
 {
 #ifdef KWIN_BUILD_TABBOX
     if (auto c = qobject_cast<AbstractClient *>(static_cast<EffectWindowImpl *>(w)->window())) {
         TabBox::TabBox::self()->setCurrentClient(c);
     }
 #else
     Q_UNUSED(w)
 #endif
 }
 
 void EffectsHandlerImpl::setTabBoxDesktop(int desktop)
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->setCurrentDesktop(desktop);
 #else
     Q_UNUSED(desktop)
 #endif
 }
 
 EffectWindowList EffectsHandlerImpl::currentTabBoxWindowList() const
 {
 #ifdef KWIN_BUILD_TABBOX
     const auto clients = TabBox::TabBox::self()->currentClientList();
     EffectWindowList ret;
     ret.reserve(clients.size());
     std::transform(std::cbegin(clients), std::cend(clients),
         std::back_inserter(ret),
         [](auto client) { return client->effectWindow(); });
     return ret;
 #else
     return EffectWindowList();
 #endif
 }
 
 void EffectsHandlerImpl::refTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->reference();
 #endif
 }
 
 void EffectsHandlerImpl::unrefTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->unreference();
 #endif
 }
 
 void EffectsHandlerImpl::closeTabBox()
 {
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox::self()->close();
 #endif
 }
 
 QList< int > EffectsHandlerImpl::currentTabBoxDesktopList() const
 {
 #ifdef KWIN_BUILD_TABBOX
     return TabBox::TabBox::self()->currentDesktopList();
 #else
     return QList< int >();
 #endif
 }
 
 int EffectsHandlerImpl::currentTabBoxDesktop() const
 {
 #ifdef KWIN_BUILD_TABBOX
     return TabBox::TabBox::self()->currentDesktop();
 #else
     return -1;
 #endif
 }
 
 EffectWindow* EffectsHandlerImpl::currentTabBoxWindow() const
 {
 #ifdef KWIN_BUILD_TABBOX
     if (auto c = TabBox::TabBox::self()->currentClient())
         return c->effectWindow();
 #endif
     return nullptr;
 }
 
 void EffectsHandlerImpl::addRepaintFull()
 {
     m_compositor->addRepaintFull();
 }
 
 void EffectsHandlerImpl::addRepaint(const QRect& r)
 {
     m_compositor->addRepaint(r);
 }
 
 void EffectsHandlerImpl::addRepaint(const QRegion& r)
 {
     m_compositor->addRepaint(r);
 }
 
 void EffectsHandlerImpl::addRepaint(int x, int y, int w, int h)
 {
     m_compositor->addRepaint(x, y, w, h);
 }
 
 int EffectsHandlerImpl::activeScreen() const
 {
     return screens()->current();
 }
 
 int EffectsHandlerImpl::numScreens() const
 {
     return screens()->count();
 }
 
 int EffectsHandlerImpl::screenNumber(const QPoint& pos) const
 {
     return screens()->number(pos);
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, int screen, int desktop) const
 {
     return Workspace::self()->clientArea(opt, screen, desktop);
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, const EffectWindow* c) const
 {
     const Toplevel* t = static_cast< const EffectWindowImpl* >(c)->window();
     if (const auto *cl = qobject_cast<const AbstractClient *>(t)) {
         return Workspace::self()->clientArea(opt, cl);
     } else {
         return Workspace::self()->clientArea(opt, t->frameGeometry().center(), VirtualDesktopManager::self()->current());
     }
 }
 
 QRect EffectsHandlerImpl::clientArea(clientAreaOption opt, const QPoint& p, int desktop) const
 {
     return Workspace::self()->clientArea(opt, p, desktop);
 }
 
 QRect EffectsHandlerImpl::virtualScreenGeometry() const
 {
     return screens()->geometry();
 }
 
 QSize EffectsHandlerImpl::virtualScreenSize() const
 {
     return screens()->size();
 }
 
 void EffectsHandlerImpl::defineCursor(Qt::CursorShape shape)
 {
     input()->pointer()->setEffectsOverrideCursor(shape);
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(QMouseEvent *e)
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return false;
     }
     foreach (Effect *effect, m_grabbedMouseEffects) {
         effect->windowInputMouseEvent(e);
     }
     return true;
 }
 
 bool EffectsHandlerImpl::checkInputWindowEvent(QWheelEvent *e)
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return false;
     }
     foreach (Effect *effect, m_grabbedMouseEffects) {
         effect->windowInputMouseEvent(e);
     }
     return true;
 }
 
 void EffectsHandlerImpl::connectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&EffectsHandler::cursorShapeChanged)) {
         if (!m_trackingCursorChanges) {
             connect(Cursors::self()->mouse(), &Cursor::cursorChanged, this, &EffectsHandler::cursorShapeChanged);
             Cursors::self()->mouse()->startCursorTracking();
         }
         ++m_trackingCursorChanges;
     }
     EffectsHandler::connectNotify(signal);
 }
 
 void EffectsHandlerImpl::disconnectNotify(const QMetaMethod &signal)
 {
     if (signal == QMetaMethod::fromSignal(&EffectsHandler::cursorShapeChanged)) {
         Q_ASSERT(m_trackingCursorChanges > 0);
         if (!--m_trackingCursorChanges) {
             Cursors::self()->mouse()->stopCursorTracking();
             disconnect(Cursors::self()->mouse(), &Cursor::cursorChanged, this, &EffectsHandler::cursorShapeChanged);
         }
     }
     EffectsHandler::disconnectNotify(signal);
 }
 
 
 void EffectsHandlerImpl::checkInputWindowStacking()
 {
     if (m_grabbedMouseEffects.isEmpty()) {
         return;
     }
     doCheckInputWindowStacking();
 }
 
 void EffectsHandlerImpl::doCheckInputWindowStacking()
 {
 }
 
 QPoint EffectsHandlerImpl::cursorPos() const
 {
     return Cursors::self()->mouse()->pos();
 }
 
 void EffectsHandlerImpl::reserveElectricBorder(ElectricBorder border, Effect *effect)
 {
     ScreenEdges::self()->reserve(border, effect, "borderActivated");
 }
 
 void EffectsHandlerImpl::unreserveElectricBorder(ElectricBorder border, Effect *effect)
 {
     ScreenEdges::self()->unreserve(border, effect);
 }
 
 void EffectsHandlerImpl::registerTouchBorder(ElectricBorder border, QAction *action)
 {
     ScreenEdges::self()->reserveTouch(border, action);
 }
 
 void EffectsHandlerImpl::unregisterTouchBorder(ElectricBorder border, QAction *action)
 {
     ScreenEdges::self()->unreserveTouch(border, action);
 }
 
 unsigned long EffectsHandlerImpl::xrenderBufferPicture()
 {
     return m_scene->xrenderBufferPicture();
 }
 
 QPainter *EffectsHandlerImpl::scenePainter()
 {
     return m_scene->scenePainter();
 }
 
 void EffectsHandlerImpl::toggleEffect(const QString& name)
 {
     if (isEffectLoaded(name))
         unloadEffect(name);
     else
         loadEffect(name);
 }
 
 QStringList EffectsHandlerImpl::loadedEffects() const
 {
     QStringList listModules;
     listModules.reserve(loaded_effects.count());
     std::transform(loaded_effects.constBegin(), loaded_effects.constEnd(),
         std::back_inserter(listModules),
         [](const EffectPair &pair) { return pair.first; });
     return listModules;
 }
 
 QStringList EffectsHandlerImpl::listOfEffects() const
 {
     return m_effectLoader->listOfKnownEffects();
 }
 
 bool EffectsHandlerImpl::loadEffect(const QString& name)
 {
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     return m_effectLoader->loadEffect(name);
 }
 
 void EffectsHandlerImpl::unloadEffect(const QString& name)
 {
     auto it = std::find_if(effect_order.begin(), effect_order.end(),
         [name](EffectPair &pair) {
             return pair.first == name;
         }
     );
     if (it == effect_order.end()) {
         qCDebug(KWIN_CORE) << "EffectsHandler::unloadEffect : Effect not loaded :" << name;
         return;
     }
 
     qCDebug(KWIN_CORE) << "EffectsHandler::unloadEffect : Unloading Effect :" << name;
     destroyEffect((*it).second);
     effect_order.erase(it);
     effectsChanged();
 
     m_compositor->addRepaintFull();
 }
 
 void EffectsHandlerImpl::destroyEffect(Effect *effect)
 {
     makeOpenGLContextCurrent();
 
     if (fullscreen_effect == effect) {
         setActiveFullScreenEffect(nullptr);
     }
 
     if (keyboard_grab_effect == effect) {
         ungrabKeyboard();
     }
 
     stopMouseInterception(effect);
 
     const QList<QByteArray> properties = m_propertiesForEffects.keys();
     for (const QByteArray &property : properties) {
         removeSupportProperty(property, effect);
     }
 
     delete effect;
 }
 
 void EffectsHandlerImpl::reconfigureEffect(const QString& name)
 {
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it)
         if ((*it).first == name) {
             kwinApp()->config()->reparseConfiguration();
             makeOpenGLContextCurrent();
             (*it).second->reconfigure(Effect::ReconfigureAll);
             return;
         }
 }
 
 bool EffectsHandlerImpl::isEffectLoaded(const QString& name) const
 {
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(),
         [&name](const EffectPair &pair) { return pair.first == name; });
     return it != loaded_effects.constEnd();
 }
 
 bool EffectsHandlerImpl::isEffectSupported(const QString &name)
 {
     // If the effect is loaded, it is obviously supported.
     if (isEffectLoaded(name)) {
         return true;
     }
 
     // next checks might require a context
     makeOpenGLContextCurrent();
     m_compositor->addRepaintFull();
 
     return m_effectLoader->isEffectSupported(name);
 
 }
 
 QList<bool> EffectsHandlerImpl::areEffectsSupported(const QStringList &names)
 {
     QList<bool> retList;
     retList.reserve(names.count());
     std::transform(names.constBegin(), names.constEnd(),
         std::back_inserter(retList),
         [this](const QString &name) {
             return isEffectSupported(name);
         });
     return retList;
 }
 
 void EffectsHandlerImpl::reloadEffect(Effect *effect)
 {
     QString effectName;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).second == effect) {
             effectName = (*it).first;
             break;
         }
     }
     if (!effectName.isNull()) {
         unloadEffect(effectName);
         m_effectLoader->loadEffect(effectName);
     }
 }
 
 void EffectsHandlerImpl::effectsChanged()
 {
     loaded_effects.clear();
     m_activeEffects.clear(); // it's possible to have a reconfigure and a quad rebuild between two paint cycles - bug #308201
 
     loaded_effects.reserve(effect_order.count());
     std::copy(effect_order.constBegin(), effect_order.constEnd(),
         std::back_inserter(loaded_effects));
 
     m_activeEffects.reserve(loaded_effects.count());
 }
 
 QStringList EffectsHandlerImpl::activeEffects() const
 {
     QStringList ret;
     for(QVector< KWin::EffectPair >::const_iterator it = loaded_effects.constBegin(),
                                                     end = loaded_effects.constEnd(); it != end; ++it) {
             if (it->second->isActive()) {
                 ret << it->first;
             }
         }
     return ret;
 }
 
-KWayland::Server::Display *EffectsHandlerImpl::waylandDisplay() const
+KWaylandServer::Display *EffectsHandlerImpl::waylandDisplay() const
 {
     if (waylandServer()) {
         return waylandServer()->display();
     }
     return nullptr;
 }
 
 EffectFrame* EffectsHandlerImpl::effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const
 {
     return new EffectFrameImpl(style, staticSize, position, alignment);
 }
 
 
 QVariant EffectsHandlerImpl::kwinOption(KWinOption kwopt)
 {
     switch (kwopt) {
     case CloseButtonCorner:
         // TODO: this could become per window and be derived from the actual position in the deco
         return Decoration::DecorationBridge::self()->settings()->decorationButtonsLeft().contains(KDecoration2::DecorationButtonType::Close) ? Qt::TopLeftCorner : Qt::TopRightCorner;
     case SwitchDesktopOnScreenEdge:
         return ScreenEdges::self()->isDesktopSwitching();
     case SwitchDesktopOnScreenEdgeMovingWindows:
         return ScreenEdges::self()->isDesktopSwitchingMovingClients();
     default:
         return QVariant(); // an invalid one
     }
 }
 
 QString EffectsHandlerImpl::supportInformation(const QString &name) const
 {
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(),
         [name](const EffectPair &pair) { return pair.first == name; });
     if (it == loaded_effects.constEnd()) {
         return QString();
     }
 
     QString support((*it).first + QLatin1String(":\n"));
     const QMetaObject *metaOptions = (*it).second->metaObject();
     for (int i=0; i<metaOptions->propertyCount(); ++i) {
         const QMetaProperty property = metaOptions->property(i);
         if (qstrcmp(property.name(), "objectName") == 0) {
             continue;
         }
         support += QString::fromUtf8(property.name()) + QLatin1String(": ") + (*it).second->property(property.name()).toString() + QLatin1Char('\n');
     }
 
     return support;
 }
 
 
 bool EffectsHandlerImpl::isScreenLocked() const
 {
     return ScreenLockerWatcher::self()->isLocked();
 }
 
 QString EffectsHandlerImpl::debug(const QString& name, const QString& parameter) const
 {
     QString internalName = name.toLower();;
     for (QVector< EffectPair >::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
         if ((*it).first == internalName) {
             return it->second->debug(parameter);
         }
     }
     return QString();
 }
 
 bool EffectsHandlerImpl::makeOpenGLContextCurrent()
 {
     return m_scene->makeOpenGLContextCurrent();
 }
 
 void EffectsHandlerImpl::doneOpenGLContextCurrent()
 {
     m_scene->doneOpenGLContextCurrent();
 }
 
 bool EffectsHandlerImpl::animationsSupported() const
 {
     static const QByteArray forceEnvVar = qgetenv("KWIN_EFFECTS_FORCE_ANIMATIONS");
     if (!forceEnvVar.isEmpty()) {
         static const int forceValue = forceEnvVar.toInt();
         return forceValue == 1;
     }
     return m_scene->animationsSupported();
 }
 
 void EffectsHandlerImpl::highlightWindows(const QVector<EffectWindow *> &windows)
 {
     Effect *e = provides(Effect::HighlightWindows);
     if (!e) {
         return;
     }
     e->perform(Effect::HighlightWindows, QVariantList{QVariant::fromValue(windows)});
 }
 
 PlatformCursorImage EffectsHandlerImpl::cursorImage() const
 {
     return kwinApp()->platform()->cursorImage();
 }
 
 void EffectsHandlerImpl::hideCursor()
 {
     kwinApp()->platform()->hideCursor();
 }
 
 void EffectsHandlerImpl::showCursor()
 {
     kwinApp()->platform()->showCursor();
 }
 
 void EffectsHandlerImpl::startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback)
 {
     kwinApp()->platform()->startInteractiveWindowSelection(
         [callback] (KWin::Toplevel *t) {
             if (t && t->effectWindow()) {
                 callback(t->effectWindow());
             } else {
                 callback(nullptr);
             }
         }
     );
 }
 
 void EffectsHandlerImpl::startInteractivePositionSelection(std::function<void(const QPoint&)> callback)
 {
     kwinApp()->platform()->startInteractivePositionSelection(callback);
 }
 
 void EffectsHandlerImpl::showOnScreenMessage(const QString &message, const QString &iconName)
 {
     OSD::show(message, iconName);
 }
 
 void EffectsHandlerImpl::hideOnScreenMessage(OnScreenMessageHideFlags flags)
 {
     OSD::HideFlags osdFlags;
     if (flags.testFlag(OnScreenMessageHideFlag::SkipsCloseAnimation)) {
         osdFlags |= OSD::HideFlag::SkipCloseAnimation;
     }
     OSD::hide(osdFlags);
 }
 
 KSharedConfigPtr EffectsHandlerImpl::config() const
 {
     return kwinApp()->config();
 }
 
 KSharedConfigPtr EffectsHandlerImpl::inputConfig() const
 {
     return kwinApp()->inputConfig();
 }
 
 Effect *EffectsHandlerImpl::findEffect(const QString &name) const
 {
     auto it = std::find_if(loaded_effects.constBegin(), loaded_effects.constEnd(),
         [name] (const EffectPair &pair) {
             return pair.first == name;
         }
     );
     if (it == loaded_effects.constEnd()) {
         return nullptr;
     }
     return (*it).second;
 }
 
 void EffectsHandlerImpl::renderEffectQuickView(EffectQuickView *w) const
 {
     if (!w->isVisible()) {
         return;
     }
     scene()->paintEffectQuickView(w);
 }
 
 SessionState EffectsHandlerImpl::sessionState() const
 {
     return Workspace::self()->sessionManager()->state();
 }
 
 //****************************************
 // EffectWindowImpl
 //****************************************
 
 EffectWindowImpl::EffectWindowImpl(Toplevel *toplevel)
     : EffectWindow(toplevel)
     , toplevel(toplevel)
     , sw(nullptr)
 {
     // Deleted windows are not managed. So, when windowClosed signal is
     // emitted, effects can't distinguish managed windows from unmanaged
     // windows(e.g. combo box popups, popup menus, etc). Save value of the
     // managed property during construction of EffectWindow. At that time,
     // parent can be Client, XdgShellClient, or Unmanaged. So, later on, when
     // an instance of Deleted becomes parent of the EffectWindow, effects
     // can still figure out whether it is/was a managed window.
     managed = toplevel->isClient();
 
     waylandClient = qobject_cast<KWin::XdgShellClient *>(toplevel) != nullptr;
     x11Client = qobject_cast<KWin::X11Client *>(toplevel) != nullptr ||
         qobject_cast<KWin::Unmanaged *>(toplevel) != nullptr;
 }
 
 EffectWindowImpl::~EffectWindowImpl()
 {
     QVariant cachedTextureVariant = data(LanczosCacheRole);
     if (cachedTextureVariant.isValid()) {
         GLTexture *cachedTexture = static_cast< GLTexture*>(cachedTextureVariant.value<void*>());
         delete cachedTexture;
     }
 }
 
 bool EffectWindowImpl::isPaintingEnabled()
 {
     return sceneWindow()->isPaintingEnabled();
 }
 
 void EffectWindowImpl::enablePainting(int reason)
 {
     sceneWindow()->enablePainting(reason);
 }
 
 void EffectWindowImpl::disablePainting(int reason)
 {
     sceneWindow()->disablePainting(reason);
 }
 
 void EffectWindowImpl::addRepaint(const QRect &r)
 {
     toplevel->addRepaint(r);
 }
 
 void EffectWindowImpl::addRepaint(int x, int y, int w, int h)
 {
     toplevel->addRepaint(x, y, w, h);
 }
 
 void EffectWindowImpl::addRepaintFull()
 {
     toplevel->addRepaintFull();
 }
 
 void EffectWindowImpl::addLayerRepaint(const QRect &r)
 {
     toplevel->addLayerRepaint(r);
 }
 
 void EffectWindowImpl::addLayerRepaint(int x, int y, int w, int h)
 {
     toplevel->addLayerRepaint(x, y, w, h);
 }
 
 const EffectWindowGroup* EffectWindowImpl::group() const
 {
     if (auto c = qobject_cast<X11Client *>(toplevel)) {
         return c->group()->effectGroup();
     }
     return nullptr; // TODO
 }
 
 void EffectWindowImpl::refWindow()
 {
     if (auto d = qobject_cast<Deleted *>(toplevel)) {
         return d->refWindow();
     }
     abort(); // TODO
 }
 
 void EffectWindowImpl::unrefWindow()
 {
     if (auto d = qobject_cast<Deleted *>(toplevel)) {
         return d->unrefWindow();   // delays deletion in case
     }
     abort(); // TODO
 }
 
 #define TOPLEVEL_HELPER( rettype, prototype, toplevelPrototype) \
     rettype EffectWindowImpl::prototype ( ) const \
     { \
         return toplevel->toplevelPrototype(); \
     }
 
 TOPLEVEL_HELPER(double, opacity, opacity)
 TOPLEVEL_HELPER(bool, hasAlpha, hasAlpha)
 TOPLEVEL_HELPER(int, x, x)
 TOPLEVEL_HELPER(int, y, y)
 TOPLEVEL_HELPER(int, width, width)
 TOPLEVEL_HELPER(int, height, height)
 TOPLEVEL_HELPER(QPoint, pos, pos)
 TOPLEVEL_HELPER(QSize, size, size)
 TOPLEVEL_HELPER(int, screen, screen)
 TOPLEVEL_HELPER(QRect, geometry, frameGeometry)
 TOPLEVEL_HELPER(QRect, frameGeometry, frameGeometry)
 TOPLEVEL_HELPER(QRect, bufferGeometry, bufferGeometry)
 TOPLEVEL_HELPER(QRect, expandedGeometry, visibleRect)
 TOPLEVEL_HELPER(QRect, rect, rect)
 TOPLEVEL_HELPER(int, desktop, desktop)
 TOPLEVEL_HELPER(bool, isDesktop, isDesktop)
 TOPLEVEL_HELPER(bool, isDock, isDock)
 TOPLEVEL_HELPER(bool, isToolbar, isToolbar)
 TOPLEVEL_HELPER(bool, isMenu, isMenu)
 TOPLEVEL_HELPER(bool, isNormalWindow, isNormalWindow)
 TOPLEVEL_HELPER(bool, isDialog, isDialog)
 TOPLEVEL_HELPER(bool, isSplash, isSplash)
 TOPLEVEL_HELPER(bool, isUtility, isUtility)
 TOPLEVEL_HELPER(bool, isDropdownMenu, isDropdownMenu)
 TOPLEVEL_HELPER(bool, isPopupMenu, isPopupMenu)
 TOPLEVEL_HELPER(bool, isTooltip, isTooltip)
 TOPLEVEL_HELPER(bool, isNotification, isNotification)
 TOPLEVEL_HELPER(bool, isCriticalNotification, isCriticalNotification)
 TOPLEVEL_HELPER(bool, isOnScreenDisplay, isOnScreenDisplay)
 TOPLEVEL_HELPER(bool, isComboBox, isComboBox)
 TOPLEVEL_HELPER(bool, isDNDIcon, isDNDIcon)
 TOPLEVEL_HELPER(bool, isDeleted, isDeleted)
 TOPLEVEL_HELPER(bool, hasOwnShape, shape)
 TOPLEVEL_HELPER(QString, windowRole, windowRole)
 TOPLEVEL_HELPER(QStringList, activities, activities)
 TOPLEVEL_HELPER(bool, skipsCloseAnimation, skipsCloseAnimation)
-TOPLEVEL_HELPER(KWayland::Server::SurfaceInterface *, surface, surface)
+TOPLEVEL_HELPER(KWaylandServer::SurfaceInterface *, surface, surface)
 TOPLEVEL_HELPER(bool, isPopupWindow, isPopupWindow)
 TOPLEVEL_HELPER(bool, isOutline, isOutline)
 TOPLEVEL_HELPER(pid_t, pid, pid)
 
 #undef TOPLEVEL_HELPER
 
 #define CLIENT_HELPER_WITH_DELETED( rettype, prototype, propertyname, defaultValue ) \
     rettype EffectWindowImpl::prototype ( ) const \
     { \
         auto client = qobject_cast<AbstractClient *>(toplevel); \
         if (client) { \
             return client->propertyname(); \
         } \
         auto deleted = qobject_cast<Deleted *>(toplevel); \
         if (deleted) { \
             return deleted->propertyname(); \
         } \
         return defaultValue; \
     }
 
 CLIENT_HELPER_WITH_DELETED(bool, isMinimized, isMinimized, false)
 CLIENT_HELPER_WITH_DELETED(bool, isModal, isModal, false)
 CLIENT_HELPER_WITH_DELETED(bool, isFullScreen, isFullScreen, false)
 CLIENT_HELPER_WITH_DELETED(bool, keepAbove, keepAbove, false)
 CLIENT_HELPER_WITH_DELETED(bool, keepBelow, keepBelow, false)
 CLIENT_HELPER_WITH_DELETED(QString, caption, caption, QString());
 CLIENT_HELPER_WITH_DELETED(QVector<uint>, desktops, x11DesktopIds, QVector<uint>());
 
 #undef CLIENT_HELPER_WITH_DELETED
 
 // legacy from tab groups, can be removed when no effects use this any more.
 bool EffectWindowImpl::isCurrentTab() const
 {
     return true;
 }
 
 QString EffectWindowImpl::windowClass() const
 {
     return toplevel->resourceName() + QLatin1Char(' ') + toplevel->resourceClass();
 }
 
 QRect EffectWindowImpl::contentsRect() const
 {
     return QRect(toplevel->clientPos(), toplevel->clientSize());
 }
 
 NET::WindowType EffectWindowImpl::windowType() const
 {
     return toplevel->windowType();
 }
 
 #define CLIENT_HELPER( rettype, prototype, propertyname, defaultValue ) \
     rettype EffectWindowImpl::prototype ( ) const \
     { \
         auto client = qobject_cast<AbstractClient *>(toplevel); \
         if (client) { \
             return client->propertyname(); \
         } \
         return defaultValue; \
     }
 
 CLIENT_HELPER(bool, isMovable, isMovable, false)
 CLIENT_HELPER(bool, isMovableAcrossScreens, isMovableAcrossScreens, false)
 CLIENT_HELPER(bool, isUserMove, isMove, false)
 CLIENT_HELPER(bool, isUserResize, isResize, false)
 CLIENT_HELPER(QRect, iconGeometry, iconGeometry, QRect())
 CLIENT_HELPER(bool, isSpecialWindow, isSpecialWindow, true)
 CLIENT_HELPER(bool, acceptsFocus, wantsInput, true) // We don't actually know...
 CLIENT_HELPER(QIcon, icon, icon, QIcon())
 CLIENT_HELPER(bool, isSkipSwitcher, skipSwitcher, false)
 CLIENT_HELPER(bool, decorationHasAlpha, decorationHasAlpha, false)
 CLIENT_HELPER(bool, isUnresponsive, unresponsive, false)
 
 #undef CLIENT_HELPER
 
 QSize EffectWindowImpl::basicUnit() const
 {
     if (auto client = qobject_cast<X11Client *>(toplevel)){
         return client->basicUnit();
     }
     return QSize(1,1);
 }
 
 void EffectWindowImpl::setWindow(Toplevel* w)
 {
     toplevel = w;
     setParent(w);
 }
 
 void EffectWindowImpl::setSceneWindow(Scene::Window* w)
 {
     sw = w;
 }
 
 QRegion EffectWindowImpl::shape() const
 {
     if (isX11Client() && sceneWindow()) {
         return sceneWindow()->bufferShape();
     }
     return toplevel->rect();
 }
 
 QRect EffectWindowImpl::decorationInnerRect() const
 {
     auto client = qobject_cast<X11Client *>(toplevel);
     return client ? client->transparentRect() : contentsRect();
 }
 
 QByteArray EffectWindowImpl::readProperty(long atom, long type, int format) const
 {
     if (!kwinApp()->x11Connection()) {
         return QByteArray();
     }
     return readWindowProperty(window()->window(), atom, type, format);
 }
 
 void EffectWindowImpl::deleteProperty(long int atom) const
 {
     if (kwinApp()->x11Connection()) {
         deleteWindowProperty(window()->window(), atom);
     }
 }
 
 EffectWindow* EffectWindowImpl::findModal()
 {
     auto client = qobject_cast<AbstractClient *>(toplevel);
     if (!client) {
         return nullptr;
     }
 
     AbstractClient *modal = client->findModal();
     if (modal) {
         return modal->effectWindow();
     }
 
     return nullptr;
 }
 
 QWindow *EffectWindowImpl::internalWindow() const
 {
     auto client = qobject_cast<InternalClient *>(toplevel);
     if (!client) {
         return nullptr;
     }
     return client->internalWindow();
 }
 
 template <typename T>
 EffectWindowList getMainWindows(T *c)
 {
     const auto mainclients = c->mainClients();
     EffectWindowList ret;
     ret.reserve(mainclients.size());
     std::transform(std::cbegin(mainclients), std::cend(mainclients),
         std::back_inserter(ret),
         [](auto client) { return client->effectWindow(); });
     return ret;
 }
 
 EffectWindowList EffectWindowImpl::mainWindows() const
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         return getMainWindows(client);
     }
     if (auto deleted = qobject_cast<Deleted *>(toplevel)) {
         return getMainWindows(deleted);
     }
     return {};
 }
 
 WindowQuadList EffectWindowImpl::buildQuads(bool force) const
 {
     return sceneWindow()->buildQuads(force);
 }
 
 void EffectWindowImpl::setData(int role, const QVariant &data)
 {
     if (!data.isNull())
         dataMap[ role ] = data;
     else
         dataMap.remove(role);
     emit effects->windowDataChanged(this, role);
 }
 
 QVariant EffectWindowImpl::data(int role) const
 {
     return dataMap.value(role);
 }
 
 EffectWindow* effectWindow(Toplevel* w)
 {
     EffectWindowImpl* ret = w->effectWindow();
     return ret;
 }
 
 EffectWindow* effectWindow(Scene::Window* w)
 {
     EffectWindowImpl* ret = w->window()->effectWindow();
     ret->setSceneWindow(w);
     return ret;
 }
 
 void EffectWindowImpl::elevate(bool elevate)
 {
     effects->setElevatedWindow(this, elevate);
 }
 
 void EffectWindowImpl::registerThumbnail(AbstractThumbnailItem *item)
 {
     if (WindowThumbnailItem *thumb = qobject_cast<WindowThumbnailItem*>(item)) {
         insertThumbnail(thumb);
         connect(thumb, SIGNAL(destroyed(QObject*)), SLOT(thumbnailDestroyed(QObject*)));
         connect(thumb, &WindowThumbnailItem::wIdChanged, this, &EffectWindowImpl::thumbnailTargetChanged);
     } else if (DesktopThumbnailItem *desktopThumb = qobject_cast<DesktopThumbnailItem*>(item)) {
         m_desktopThumbnails.append(desktopThumb);
         connect(desktopThumb, SIGNAL(destroyed(QObject*)), SLOT(desktopThumbnailDestroyed(QObject*)));
     }
 }
 
 void EffectWindowImpl::thumbnailDestroyed(QObject *object)
 {
     // we know it is a ThumbnailItem
     m_thumbnails.remove(static_cast<WindowThumbnailItem*>(object));
 }
 
 void EffectWindowImpl::thumbnailTargetChanged()
 {
     if (WindowThumbnailItem *item = qobject_cast<WindowThumbnailItem*>(sender())) {
         insertThumbnail(item);
     }
 }
 
 void EffectWindowImpl::insertThumbnail(WindowThumbnailItem *item)
 {
     EffectWindow *w = effects->findWindow(item->wId());
     if (w) {
         m_thumbnails.insert(item, QPointer<EffectWindowImpl>(static_cast<EffectWindowImpl*>(w)));
     } else {
         m_thumbnails.insert(item, QPointer<EffectWindowImpl>());
     }
 }
 
 void EffectWindowImpl::desktopThumbnailDestroyed(QObject *object)
 {
     // we know it is a DesktopThumbnailItem
     m_desktopThumbnails.removeAll(static_cast<DesktopThumbnailItem*>(object));
 }
 
 void EffectWindowImpl::minimize()
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         client->minimize();
     }
 }
 
 void EffectWindowImpl::unminimize()
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         client->unminimize();
     }
 }
 
 void EffectWindowImpl::closeWindow()
 {
     if (auto client = qobject_cast<AbstractClient *>(toplevel)) {
         client->closeWindow();
     }
 }
 
 void EffectWindowImpl::referencePreviousWindowPixmap()
 {
     if (sw) {
         sw->referencePreviousPixmap();
     }
 }
 
 void EffectWindowImpl::unreferencePreviousWindowPixmap()
 {
     if (sw) {
         sw->unreferencePreviousPixmap();
     }
 }
 
 bool EffectWindowImpl::isManaged() const
 {
     return managed;
 }
 
 bool EffectWindowImpl::isWaylandClient() const
 {
     return waylandClient;
 }
 
 bool EffectWindowImpl::isX11Client() const
 {
     return x11Client;
 }
 
 
 //****************************************
 // EffectWindowGroupImpl
 //****************************************
 
 
 EffectWindowList EffectWindowGroupImpl::members() const
 {
     const auto memberList = group->members();
     EffectWindowList ret;
     ret.reserve(memberList.size());
     std::transform(std::cbegin(memberList), std::cend(memberList),
         std::back_inserter(ret),
         [](auto toplevel) { return toplevel->effectWindow(); });
     return ret;
 }
 
 //****************************************
 // EffectFrameImpl
 //****************************************
 
 EffectFrameImpl::EffectFrameImpl(EffectFrameStyle style, bool staticSize, QPoint position, Qt::Alignment alignment)
     : QObject(nullptr)
     , EffectFrame()
     , m_style(style)
     , m_static(staticSize)
     , m_point(position)
     , m_alignment(alignment)
     , m_shader(nullptr)
     , m_theme(new Plasma::Theme(this))
 {
     if (m_style == EffectFrameStyled) {
         m_frame.setImagePath(QStringLiteral("widgets/background"));
         m_frame.setCacheAllRenderedFrames(true);
         connect(m_theme, SIGNAL(themeChanged()), this, SLOT(plasmaThemeChanged()));
     }
     m_selection.setImagePath(QStringLiteral("widgets/viewitem"));
     m_selection.setElementPrefix(QStringLiteral("hover"));
     m_selection.setCacheAllRenderedFrames(true);
     m_selection.setEnabledBorders(Plasma::FrameSvg::AllBorders);
 
     m_sceneFrame = Compositor::self()->scene()->createEffectFrame(this);
 }
 
 EffectFrameImpl::~EffectFrameImpl()
 {
     delete m_sceneFrame;
 }
 
 const QFont& EffectFrameImpl::font() const
 {
     return m_font;
 }
 
 void EffectFrameImpl::setFont(const QFont& font)
 {
     if (m_font == font) {
         return;
     }
     m_font = font;
     QRect oldGeom = m_geometry;
     if (!m_text.isEmpty()) {
         autoResize();
     }
     if (oldGeom == m_geometry) {
         // Wasn't updated in autoResize()
         m_sceneFrame->freeTextFrame();
     }
 }
 
 void EffectFrameImpl::free()
 {
     m_sceneFrame->free();
 }
 
 const QRect& EffectFrameImpl::geometry() const
 {
     return m_geometry;
 }
 
 void EffectFrameImpl::setGeometry(const QRect& geometry, bool force)
 {
     QRect oldGeom = m_geometry;
     m_geometry = geometry;
     if (m_geometry == oldGeom && !force) {
         return;
     }
     effects->addRepaint(oldGeom);
     effects->addRepaint(m_geometry);
     if (m_geometry.size() == oldGeom.size() && !force) {
         return;
     }
 
     if (m_style == EffectFrameStyled) {
         qreal left, top, right, bottom;
         m_frame.getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
         m_frame.resizeFrame(m_geometry.adjusted(-left, -top, right, bottom).size());
     }
 
     free();
 }
 
 const QIcon& EffectFrameImpl::icon() const
 {
     return m_icon;
 }
 
 void EffectFrameImpl::setIcon(const QIcon& icon)
 {
     m_icon = icon;
     if (isCrossFade()) {
         m_sceneFrame->crossFadeIcon();
     }
     if (m_iconSize.isEmpty() && !m_icon.availableSizes().isEmpty()) { // Set a size if we don't already have one
         setIconSize(m_icon.availableSizes().first());
     }
     m_sceneFrame->freeIconFrame();
 }
 
 const QSize& EffectFrameImpl::iconSize() const
 {
     return m_iconSize;
 }
 
 void EffectFrameImpl::setIconSize(const QSize& size)
 {
     if (m_iconSize == size) {
         return;
     }
     m_iconSize = size;
     autoResize();
     m_sceneFrame->freeIconFrame();
 }
 
 void EffectFrameImpl::plasmaThemeChanged()
 {
     free();
 }
 
 void EffectFrameImpl::render(const QRegion &region, double opacity, double frameOpacity)
 {
     if (m_geometry.isEmpty()) {
         return; // Nothing to display
     }
     m_shader = nullptr;
     setScreenProjectionMatrix(static_cast<EffectsHandlerImpl*>(effects)->scene()->screenProjectionMatrix());
     effects->paintEffectFrame(this, region, opacity, frameOpacity);
 }
 
 void EffectFrameImpl::finalRender(QRegion region, double opacity, double frameOpacity) const
 {
     region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
 
     m_sceneFrame->render(region, opacity, frameOpacity);
 }
 
 Qt::Alignment EffectFrameImpl::alignment() const
 {
     return m_alignment;
 }
 
 
 void
 EffectFrameImpl::align(QRect &geometry)
 {
     if (m_alignment & Qt::AlignLeft)
         geometry.moveLeft(m_point.x());
     else if (m_alignment & Qt::AlignRight)
         geometry.moveLeft(m_point.x() - geometry.width());
     else
         geometry.moveLeft(m_point.x() - geometry.width() / 2);
     if (m_alignment & Qt::AlignTop)
         geometry.moveTop(m_point.y());
     else if (m_alignment & Qt::AlignBottom)
         geometry.moveTop(m_point.y() - geometry.height());
     else
         geometry.moveTop(m_point.y() - geometry.height() / 2);
 }
 
 
 void EffectFrameImpl::setAlignment(Qt::Alignment alignment)
 {
     m_alignment = alignment;
     align(m_geometry);
     setGeometry(m_geometry);
 }
 
 void EffectFrameImpl::setPosition(const QPoint& point)
 {
     m_point = point;
     QRect geometry = m_geometry; // this is important, setGeometry need call repaint for old & new geometry
     align(geometry);
     setGeometry(geometry);
 }
 
 const QString& EffectFrameImpl::text() const
 {
     return m_text;
 }
 
 void EffectFrameImpl::setText(const QString& text)
 {
     if (m_text == text) {
         return;
     }
     if (isCrossFade()) {
         m_sceneFrame->crossFadeText();
     }
     m_text = text;
     QRect oldGeom = m_geometry;
     autoResize();
     if (oldGeom == m_geometry) {
         // Wasn't updated in autoResize()
         m_sceneFrame->freeTextFrame();
     }
 }
 
 void EffectFrameImpl::setSelection(const QRect& selection)
 {
     if (selection == m_selectionGeometry) {
         return;
     }
     m_selectionGeometry = selection;
     if (m_selectionGeometry.size() != m_selection.frameSize().toSize()) {
         m_selection.resizeFrame(m_selectionGeometry.size());
     }
     // TODO; optimize to only recreate when resizing
     m_sceneFrame->freeSelection();
 }
 
 void EffectFrameImpl::autoResize()
 {
     if (m_static)
         return; // Not automatically resizing
 
     QRect geometry;
     // Set size
     if (!m_text.isEmpty()) {
         QFontMetrics metrics(m_font);
         geometry.setSize(metrics.size(0, m_text));
     }
     if (!m_icon.isNull() && !m_iconSize.isEmpty()) {
         geometry.setLeft(-m_iconSize.width());
         if (m_iconSize.height() > geometry.height())
             geometry.setHeight(m_iconSize.height());
     }
 
     align(geometry);
     setGeometry(geometry);
 }
 
 QColor EffectFrameImpl::styledTextColor()
 {
     return m_theme->color(Plasma::Theme::TextColor);
 }
 
 } // namespace
diff --git a/effects.h b/effects.h
index 71299571d..107fd052d 100644
--- a/effects.h
+++ b/effects.h
@@ -1,679 +1,676 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_EFFECTSIMPL_H
 #define KWIN_EFFECTSIMPL_H
 
 #include "kwineffects.h"
 
 #include "scene.h"
 
 #include <QHash>
 #include <Plasma/FrameSvg>
 
 #include <memory>
 
 namespace Plasma {
 class Theme;
 }
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class Display;
 }
-}
 
 class QDBusPendingCallWatcher;
 class QDBusServiceWatcher;
 
 
 namespace KWin
 {
 
 class AbstractThumbnailItem;
 class DesktopThumbnailItem;
 class WindowThumbnailItem;
 
 class AbstractClient;
 class Compositor;
 class Deleted;
 class EffectLoader;
 class Group;
 class Toplevel;
 class Unmanaged;
 class WindowPropertyNotifyX11Filter;
 class X11Client;
 
 class KWIN_EXPORT EffectsHandlerImpl : public EffectsHandler
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.kwin.Effects")
     Q_PROPERTY(QStringList activeEffects READ activeEffects)
     Q_PROPERTY(QStringList loadedEffects READ loadedEffects)
     Q_PROPERTY(QStringList listOfEffects READ listOfEffects)
 public:
     EffectsHandlerImpl(Compositor *compositor, Scene *scene);
     ~EffectsHandlerImpl() override;
     void prePaintScreen(ScreenPrePaintData& data, int time) override;
     void paintScreen(int mask, const QRegion &region, ScreenPaintData& data) override;
     /**
      * Special hook to perform a paintScreen but just with the windows on @p desktop.
      */
     void paintDesktop(int desktop, int mask, QRegion region, ScreenPaintData& data);
     void postPaintScreen() override;
     void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
     void paintWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) override;
     void postPaintWindow(EffectWindow* w) override;
     void paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity) override;
 
     Effect *provides(Effect::Feature ef);
 
     void drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) override;
 
     void buildQuads(EffectWindow* w, WindowQuadList& quadList) override;
 
     void activateWindow(EffectWindow* c) override;
     EffectWindow* activeWindow() const override;
     void moveWindow(EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) override;
     void windowToDesktop(EffectWindow* w, int desktop) override;
     void windowToScreen(EffectWindow* w, int screen) override;
     void setShowingDesktop(bool showing) override;
 
     QString currentActivity() const override;
     int currentDesktop() const override;
     int numberOfDesktops() const override;
     void setCurrentDesktop(int desktop) override;
     void setNumberOfDesktops(int desktops) override;
     QSize desktopGridSize() const override;
     int desktopGridWidth() const override;
     int desktopGridHeight() const override;
     int workspaceWidth() const override;
     int workspaceHeight() const override;
     int desktopAtCoords(QPoint coords) const override;
     QPoint desktopGridCoords(int id) const override;
     QPoint desktopCoords(int id) const override;
     int desktopAbove(int desktop = 0, bool wrap = true) const override;
     int desktopToRight(int desktop = 0, bool wrap = true) const override;
     int desktopBelow(int desktop = 0, bool wrap = true) const override;
     int desktopToLeft(int desktop = 0, bool wrap = true) const override;
     QString desktopName(int desktop) const override;
     bool optionRollOverDesktops() const override;
 
     QPoint cursorPos() const override;
     bool grabKeyboard(Effect* effect) override;
     void ungrabKeyboard() override;
     // not performing XGrabPointer
     void startMouseInterception(Effect *effect, Qt::CursorShape shape) override;
     void stopMouseInterception(Effect *effect) override;
     bool isMouseInterception() const;
     void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) override;
     void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) override;
     void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) override;
     void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action) override;
     void* getProxy(QString name) override;
     void startMousePolling() override;
     void stopMousePolling() override;
     EffectWindow* findWindow(WId id) const override;
-    EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const override;
+    EffectWindow* findWindow(KWaylandServer::SurfaceInterface *surf) const override;
     EffectWindow *findWindow(QWindow *w) const override;
     EffectWindow *findWindow(const QUuid &id) const override;
     EffectWindowList stackingOrder() const override;
     void setElevatedWindow(KWin::EffectWindow* w, bool set) override;
 
     void setTabBoxWindow(EffectWindow*) override;
     void setTabBoxDesktop(int) override;
     EffectWindowList currentTabBoxWindowList() const override;
     void refTabBox() override;
     void unrefTabBox() override;
     void closeTabBox() override;
     QList< int > currentTabBoxDesktopList() const override;
     int currentTabBoxDesktop() const override;
     EffectWindow* currentTabBoxWindow() const override;
 
     void setActiveFullScreenEffect(Effect* e) override;
     Effect* activeFullScreenEffect() const override;
     bool hasActiveFullScreenEffect() const override;
 
     void addRepaintFull() override;
     void addRepaint(const QRect& r) override;
     void addRepaint(const QRegion& r) override;
     void addRepaint(int x, int y, int w, int h) override;
     int activeScreen() const override;
     int numScreens() const override;
     int screenNumber(const QPoint& pos) const override;
     QRect clientArea(clientAreaOption, int screen, int desktop) const override;
     QRect clientArea(clientAreaOption, const EffectWindow* c) const override;
     QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const override;
     QSize virtualScreenSize() const override;
     QRect virtualScreenGeometry() const override;
     double animationTimeFactor() const override;
     WindowQuadType newWindowQuadType() override;
 
     void defineCursor(Qt::CursorShape shape) override;
     bool checkInputWindowEvent(QMouseEvent *e);
     bool checkInputWindowEvent(QWheelEvent *e);
     void checkInputWindowStacking();
 
     void reserveElectricBorder(ElectricBorder border, Effect *effect) override;
     void unreserveElectricBorder(ElectricBorder border, Effect *effect) override;
 
     void registerTouchBorder(ElectricBorder border, QAction *action) override;
     void unregisterTouchBorder(ElectricBorder border, QAction *action) override;
 
     unsigned long xrenderBufferPicture() override;
     QPainter* scenePainter() override;
     void reconfigure() override;
     QByteArray readRootProperty(long atom, long type, int format) const override;
     xcb_atom_t announceSupportProperty(const QByteArray& propertyName, Effect* effect) override;
     void removeSupportProperty(const QByteArray& propertyName, Effect* effect) override;
 
     bool hasDecorationShadows() const override;
 
     bool decorationsHaveAlpha() const override;
 
     bool decorationSupportsBlurBehind() const override;
 
     EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize, const QPoint& position, Qt::Alignment alignment) const override;
 
     QVariant kwinOption(KWinOption kwopt) override;
     bool isScreenLocked() const override;
 
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
 
     xcb_connection_t *xcbConnection() const override;
     xcb_window_t x11RootWindow() const override;
 
     // internal (used by kwin core or compositing code)
     void startPaint();
     void grabbedKeyboardEvent(QKeyEvent* e);
     bool hasKeyboardGrab() const;
     void desktopResized(const QSize &size);
 
     void reloadEffect(Effect *effect) override;
     QStringList loadedEffects() const;
     QStringList listOfEffects() const;
     void unloadAllEffects();
 
     QList<EffectWindow*> elevatedWindows() const;
     QStringList activeEffects() const;
 
     /**
      * @returns Whether we are currently in a desktop rendering process triggered by paintDesktop hook
      */
     bool isDesktopRendering() const {
         return m_desktopRendering;
     }
     /**
      * @returns the desktop currently being rendered in the paintDesktop hook.
      */
     int currentRenderedDesktop() const {
         return m_currentRenderedDesktop;
     }
 
-    KWayland::Server::Display *waylandDisplay() const override;
+    KWaylandServer::Display *waylandDisplay() const override;
 
     bool animationsSupported() const override;
 
     PlatformCursorImage cursorImage() const override;
 
     void hideCursor() override;
     void showCursor() override;
 
     void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) override;
     void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) override;
 
     void showOnScreenMessage(const QString &message, const QString &iconName = QString()) override;
     void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags()) override;
 
     KSharedConfigPtr config() const override;
     KSharedConfigPtr inputConfig() const override;
 
     Scene *scene() const {
         return m_scene;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time);
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time);
     bool touchUp(qint32 id, quint32 time);
 
     void highlightWindows(const QVector<EffectWindow *> &windows);
 
     bool isPropertyTypeRegistered(xcb_atom_t atom) const {
         return registered_atoms.contains(atom);
     }
 
     void windowToDesktops(EffectWindow *w, const QVector<uint> &desktops) override;
 
     /**
      * Finds an effect with the given name.
      *
      * @param name The name of the effect.
      * @returns The effect with the given name @p name, or nullptr if there
      *     is no such effect loaded.
      */
     Effect *findEffect(const QString &name) const;
 
     void renderEffectQuickView(EffectQuickView *effectQuickView) const override;
 
     SessionState sessionState() const override;
 
 public Q_SLOTS:
     void slotCurrentTabAboutToChange(EffectWindow* from, EffectWindow* to);
     void slotTabAdded(EffectWindow* from, EffectWindow* to);
     void slotTabRemoved(EffectWindow* c, EffectWindow* newActiveWindow);
 
     // slots for D-Bus interface
     Q_SCRIPTABLE void reconfigureEffect(const QString& name);
     Q_SCRIPTABLE bool loadEffect(const QString& name);
     Q_SCRIPTABLE void toggleEffect(const QString& name);
     Q_SCRIPTABLE void unloadEffect(const QString& name);
     Q_SCRIPTABLE bool isEffectLoaded(const QString& name) const;
     Q_SCRIPTABLE bool isEffectSupported(const QString& name);
     Q_SCRIPTABLE QList<bool> areEffectsSupported(const QStringList &names);
     Q_SCRIPTABLE QString supportInformation(const QString& name) const;
     Q_SCRIPTABLE QString debug(const QString& name, const QString& parameter = QString()) const;
 
 protected Q_SLOTS:
     void slotClientShown(KWin::Toplevel*);
     void slotWaylandClientShown(KWin::Toplevel*);
     void slotUnmanagedShown(KWin::Toplevel*);
     void slotWindowClosed(KWin::Toplevel *c, KWin::Deleted *d);
     void slotClientMaximized(KWin::AbstractClient *c, MaximizeMode maxMode);
     void slotOpacityChanged(KWin::Toplevel *t, qreal oldOpacity);
     void slotClientModalityChanged();
     void slotGeometryShapeChanged(KWin::Toplevel *t, const QRect &old);
     void slotFrameGeometryChanged(Toplevel *toplevel, const QRect &oldGeometry);
     void slotPaddingChanged(KWin::Toplevel *t, const QRect &old);
     void slotWindowDamaged(KWin::Toplevel *t, const QRect& r);
 
 protected:
     void connectNotify(const QMetaMethod &signal) override;
     void disconnectNotify(const QMetaMethod &signal) override;
     void effectsChanged();
     void setupAbstractClientConnections(KWin::AbstractClient *c);
     void setupClientConnections(KWin::X11Client *c);
     void setupUnmanagedConnections(KWin::Unmanaged *u);
 
     /**
      * Default implementation does nothing and returns @c true.
      */
     virtual bool doGrabKeyboard();
     /**
      * Default implementation does nothing.
      */
     virtual void doUngrabKeyboard();
 
     /**
      * Default implementation sets Effects override cursor on the PointerInputRedirection.
      */
     virtual void doStartMouseInterception(Qt::CursorShape shape);
 
     /**
      * Default implementation removes the Effects override cursor on the PointerInputRedirection.
      */
     virtual void doStopMouseInterception();
 
     /**
      * Default implementation does nothing
      */
     virtual void doCheckInputWindowStacking();
 
     Effect* keyboard_grab_effect;
     Effect* fullscreen_effect;
     QList<EffectWindow*> elevated_windows;
     QMultiMap< int, EffectPair > effect_order;
     QHash< long, int > registered_atoms;
     int next_window_quad_type;
 
 private:
     void registerPropertyType(long atom, bool reg);
     void destroyEffect(Effect *effect);
 
     typedef QVector< Effect*> EffectsList;
     typedef EffectsList::const_iterator EffectsIterator;
     EffectsList m_activeEffects;
     EffectsIterator m_currentDrawWindowIterator;
     EffectsIterator m_currentPaintWindowIterator;
     EffectsIterator m_currentPaintEffectFrameIterator;
     EffectsIterator m_currentPaintScreenIterator;
     EffectsIterator m_currentBuildQuadsIterator;
     typedef QHash< QByteArray, QList< Effect*> > PropertyEffectMap;
     PropertyEffectMap m_propertiesForEffects;
     QHash<QByteArray, qulonglong> m_managedProperties;
     Compositor *m_compositor;
     Scene *m_scene;
     bool m_desktopRendering;
     int m_currentRenderedDesktop;
     QList<Effect*> m_grabbedMouseEffects;
     EffectLoader *m_effectLoader;
     int m_trackingCursorChanges;
     std::unique_ptr<WindowPropertyNotifyX11Filter> m_x11WindowPropertyNotify;
 };
 
 class EffectWindowImpl : public EffectWindow
 {
     Q_OBJECT
 public:
     explicit EffectWindowImpl(Toplevel *toplevel);
     ~EffectWindowImpl() override;
 
     void enablePainting(int reason) override;
     void disablePainting(int reason) override;
     bool isPaintingEnabled() override;
 
     void addRepaint(const QRect &r) override;
     void addRepaint(int x, int y, int w, int h) override;
     void addRepaintFull() override;
     void addLayerRepaint(const QRect &r) override;
     void addLayerRepaint(int x, int y, int w, int h) override;
 
     void refWindow() override;
     void unrefWindow() override;
 
     const EffectWindowGroup* group() const override;
 
     bool isDeleted() const override;
     bool isMinimized() const override;
     double opacity() const override;
     bool hasAlpha() const override;
 
     QStringList activities() const override;
     int desktop() const override;
     QVector<uint> desktops() const override;
     int x() const override;
     int y() const override;
     int width() const override;
     int height() const override;
 
     QSize basicUnit() const override;
     QRect geometry() const override;
     QRect frameGeometry() const override;
     QRect bufferGeometry() const override;
 
     QString caption() const override;
 
     QRect expandedGeometry() const override;
     QRegion shape() const override;
     int screen() const override;
     bool hasOwnShape() const override; // only for shadow effect, for now
     QPoint pos() const override;
     QSize size() const override;
     QRect rect() const override;
 
     bool isMovable() const override;
     bool isMovableAcrossScreens() const override;
     bool isUserMove() const override;
     bool isUserResize() const override;
     QRect iconGeometry() const override;
 
     bool isDesktop() const override;
     bool isDock() const override;
     bool isToolbar() const override;
     bool isMenu() const override;
     bool isNormalWindow() const override;
     bool isSpecialWindow() const override;
     bool isDialog() const override;
     bool isSplash() const override;
     bool isUtility() const override;
     bool isDropdownMenu() const override;
     bool isPopupMenu() const override;
     bool isTooltip() const override;
     bool isNotification() const override;
     bool isCriticalNotification() const override;
     bool isOnScreenDisplay() const override;
     bool isComboBox() const override;
     bool isDNDIcon() const override;
     bool skipsCloseAnimation() const override;
 
     bool acceptsFocus() const override;
     bool keepAbove() const override;
     bool keepBelow() const override;
     bool isModal() const override;
     bool isPopupWindow() const override;
     bool isOutline() const override;
 
-    KWayland::Server::SurfaceInterface *surface() const override;
+    KWaylandServer::SurfaceInterface *surface() const override;
     bool isFullScreen() const override;
     bool isUnresponsive() const override;
 
     QRect contentsRect() const override;
     bool decorationHasAlpha() const override;
     QIcon icon() const override;
     QString windowClass() const override;
     NET::WindowType windowType() const override;
     bool isSkipSwitcher() const override;
     bool isCurrentTab() const override;
     QString windowRole() const override;
 
     bool isManaged() const override;
     bool isWaylandClient() const override;
     bool isX11Client() const override;
 
     pid_t pid() const override;
 
     QRect decorationInnerRect() const override;
     QByteArray readProperty(long atom, long type, int format) const override;
     void deleteProperty(long atom) const override;
 
     EffectWindow* findModal() override;
     EffectWindowList mainWindows() const override;
 
     WindowQuadList buildQuads(bool force = false) const override;
 
     void minimize() override;
     void unminimize() override;
     void closeWindow() override;
 
     void referencePreviousWindowPixmap() override;
     void unreferencePreviousWindowPixmap() override;
 
     QWindow *internalWindow() const override;
 
     const Toplevel* window() const;
     Toplevel* window();
 
     void setWindow(Toplevel* w);   // internal
     void setSceneWindow(Scene::Window* w);   // internal
     const Scene::Window* sceneWindow() const; // internal
     Scene::Window* sceneWindow(); // internal
 
     void elevate(bool elevate);
 
     void setData(int role, const QVariant &data) override;
     QVariant data(int role) const override;
 
     void registerThumbnail(AbstractThumbnailItem *item);
     QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> > const &thumbnails() const {
         return m_thumbnails;
     }
     QList<DesktopThumbnailItem*> const &desktopThumbnails() const {
         return m_desktopThumbnails;
     }
 
 private Q_SLOTS:
     void thumbnailDestroyed(QObject *object);
     void thumbnailTargetChanged();
     void desktopThumbnailDestroyed(QObject *object);
 private:
     void insertThumbnail(WindowThumbnailItem *item);
     Toplevel* toplevel;
     Scene::Window* sw; // This one is used only during paint pass.
     QHash<int, QVariant> dataMap;
     QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> > m_thumbnails;
     QList<DesktopThumbnailItem*> m_desktopThumbnails;
     bool managed = false;
     bool waylandClient;
     bool x11Client;
 };
 
 class EffectWindowGroupImpl
     : public EffectWindowGroup
 {
 public:
     explicit EffectWindowGroupImpl(Group* g);
     EffectWindowList members() const override;
 private:
     Group* group;
 };
 
 class KWIN_EXPORT EffectFrameImpl
     : public QObject, public EffectFrame
 {
     Q_OBJECT
 public:
     explicit EffectFrameImpl(EffectFrameStyle style, bool staticSize = true, QPoint position = QPoint(-1, -1),
                              Qt::Alignment alignment = Qt::AlignCenter);
     ~EffectFrameImpl() override;
 
     void free() override;
     void render(const QRegion &region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) override;
     Qt::Alignment alignment() const override;
     void setAlignment(Qt::Alignment alignment) override;
     const QFont& font() const override;
     void setFont(const QFont& font) override;
     const QRect& geometry() const override;
     void setGeometry(const QRect& geometry, bool force = false) override;
     const QIcon& icon() const override;
     void setIcon(const QIcon& icon) override;
     const QSize& iconSize() const override;
     void setIconSize(const QSize& size) override;
     void setPosition(const QPoint& point) override;
     const QString& text() const override;
     void setText(const QString& text) override;
     EffectFrameStyle style() const override {
         return m_style;
     };
     Plasma::FrameSvg& frame() {
         return m_frame;
     }
     bool isStatic() const {
         return m_static;
     };
     void finalRender(QRegion region, double opacity, double frameOpacity) const;
     void setShader(GLShader* shader) override {
         m_shader = shader;
     }
     GLShader* shader() const override {
         return m_shader;
     }
     void setSelection(const QRect& selection) override;
     const QRect& selection() const {
         return m_selectionGeometry;
     }
     Plasma::FrameSvg& selectionFrame() {
         return m_selection;
     }
     /**
      * The foreground text color as specified by the default Plasma theme.
      */
     QColor styledTextColor();
 
 private Q_SLOTS:
     void plasmaThemeChanged();
 
 private:
     Q_DISABLE_COPY(EffectFrameImpl)   // As we need to use Qt slots we cannot copy this class
     void align(QRect &geometry);   // positions geometry around m_point respecting m_alignment
     void autoResize(); // Auto-resize if not a static size
 
     EffectFrameStyle m_style;
     Plasma::FrameSvg m_frame; // TODO: share between all EffectFrames
     Plasma::FrameSvg m_selection;
 
     // Position
     bool m_static;
     QPoint m_point;
     Qt::Alignment m_alignment;
     QRect m_geometry;
 
     // Contents
     QString m_text;
     QFont m_font;
     QIcon m_icon;
     QSize m_iconSize;
     QRect m_selectionGeometry;
 
     Scene::EffectFrame* m_sceneFrame;
     GLShader* m_shader;
 
     Plasma::Theme *m_theme;
 };
 
 inline
 QList<EffectWindow*> EffectsHandlerImpl::elevatedWindows() const
 {
     if (isScreenLocked())
         return QList<EffectWindow*>();
     return elevated_windows;
 }
 
 inline
 xcb_window_t EffectsHandlerImpl::x11RootWindow() const
 {
     return rootWindow();
 }
 
 inline
 xcb_connection_t *EffectsHandlerImpl::xcbConnection() const
 {
     return connection();
 }
 
 inline
 EffectWindowGroupImpl::EffectWindowGroupImpl(Group* g)
     : group(g)
 {
 }
 
 EffectWindow* effectWindow(Toplevel* w);
 EffectWindow* effectWindow(Scene::Window* w);
 
 inline
 const Scene::Window* EffectWindowImpl::sceneWindow() const
 {
     return sw;
 }
 
 inline
 Scene::Window* EffectWindowImpl::sceneWindow()
 {
     return sw;
 }
 
 inline
 const Toplevel* EffectWindowImpl::window() const
 {
     return toplevel;
 }
 
 inline
 Toplevel* EffectWindowImpl::window()
 {
     return toplevel;
 }
 
 
 } // namespace
 
 #endif
diff --git a/effects/backgroundcontrast/contrast.cpp b/effects/backgroundcontrast/contrast.cpp
index ff1abb1b5..027a28324 100644
--- a/effects/backgroundcontrast/contrast.cpp
+++ b/effects/backgroundcontrast/contrast.cpp
@@ -1,529 +1,529 @@
 /*
  *   Copyright © 2010 Fredrik Höglund <fredrik@kde.org>
  *   Copyright © 2011 Philipp Knechtges <philipp-dev@knechtges.com>
  *   Copyright 2014 Marco Martin <mart@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; see the file COPYING.  if not, write to
  *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *   Boston, MA 02110-1301, USA.
  */
 
 #include "contrast.h"
 #include "contrastshader.h"
 // KConfigSkeleton
 
 #include <QMatrix4x4>
 #include <QWindow>
 
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/contrast_interface.h>
-#include <KWayland/Server/display.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/contrast_interface.h>
+#include <KWaylandServer/display.h>
 
 namespace KWin
 {
 
 static const QByteArray s_contrastAtomName = QByteArrayLiteral("_KDE_NET_WM_BACKGROUND_CONTRAST_REGION");
 
 ContrastEffect::ContrastEffect()
 {
     shader = ContrastShader::create();
 
     reconfigure(ReconfigureAll);
 
     // ### Hackish way to announce support.
     //     Should be included in _NET_SUPPORTED instead.
     if (shader && shader->isValid()) {
         net_wm_contrast_region = effects->announceSupportProperty(s_contrastAtomName, this);
-        KWayland::Server::Display *display = effects->waylandDisplay();
+        KWaylandServer::Display *display = effects->waylandDisplay();
         if (display) {
             m_contrastManager = display->createContrastManager(this);
             m_contrastManager->create();
         }
     } else {
         net_wm_contrast_region = 0;
     }
 
     connect(effects, &EffectsHandler::windowAdded, this, &ContrastEffect::slotWindowAdded);
     connect(effects, &EffectsHandler::windowDeleted, this, &ContrastEffect::slotWindowDeleted);
     connect(effects, &EffectsHandler::propertyNotify, this, &ContrastEffect::slotPropertyNotify);
     connect(effects, &EffectsHandler::screenGeometryChanged, this, &ContrastEffect::slotScreenGeometryChanged);
     connect(effects, &EffectsHandler::xcbConnectionChanged, this,
         [this] {
             if (shader && shader->isValid()) {
                 net_wm_contrast_region = effects->announceSupportProperty(s_contrastAtomName, this);
             }
         }
     );
 
     // Fetch the contrast regions for all windows
     for (EffectWindow *window: effects->stackingOrder()) {
         updateContrastRegion(window);
     }
 }
 
 ContrastEffect::~ContrastEffect()
 {
     delete shader;
 }
 
 void ContrastEffect::slotScreenGeometryChanged()
 {
     effects->makeOpenGLContextCurrent();
     if (!supported()) {
         effects->reloadEffect(this);
         return;
     }
     for (EffectWindow *window: effects->stackingOrder()) {
         updateContrastRegion(window);
     }
 }
 
 void ContrastEffect::reconfigure(ReconfigureFlags flags)
 {
     Q_UNUSED(flags)
 
     if (shader)
         shader->init();
 
     if (!shader || !shader->isValid()) {
         effects->removeSupportProperty(s_contrastAtomName, this);
         delete m_contrastManager;
         m_contrastManager = nullptr;
     }
 }
 
 void ContrastEffect::updateContrastRegion(EffectWindow *w)
 {
     QRegion region;
     float colorTransform[16];
     QByteArray value;
 
     if (net_wm_contrast_region != XCB_ATOM_NONE) {
         value = w->readProperty(net_wm_contrast_region, net_wm_contrast_region, 32);
 
         if (value.size() > 0 && !((value.size() - (16 * sizeof(uint32_t))) % ((4 * sizeof(uint32_t))))) {
             const uint32_t *cardinals = reinterpret_cast<const uint32_t*>(value.constData());
             const float *floatCardinals = reinterpret_cast<const float*>(value.constData());
             unsigned int i = 0;
             for (; i < ((value.size() - (16 * sizeof(uint32_t)))) / sizeof(uint32_t);) {
                 int x = cardinals[i++];
                 int y = cardinals[i++];
                 int w = cardinals[i++];
                 int h = cardinals[i++];
                 region += QRect(x, y, w, h);
             }
 
             for (unsigned int j = 0; j < 16; ++j) {
                 colorTransform[j] = floatCardinals[i + j];
             }
 
             QMatrix4x4 colorMatrix(colorTransform);
             m_colorMatrices[w] = colorMatrix;
         }
     }
 
-    KWayland::Server::SurfaceInterface *surf = w->surface();
+    KWaylandServer::SurfaceInterface *surf = w->surface();
 
     if (surf && surf->contrast()) {
         region = surf->contrast()->region();
         m_colorMatrices[w] = colorMatrix(surf->contrast()->contrast(), surf->contrast()->intensity(), surf->contrast()->saturation());
     }
 
     if (auto internal = w->internalWindow()) {
         const auto property = internal->property("kwin_background_region");
         if (property.isValid()) {
             region = property.value<QRegion>();
             bool ok = false;
             qreal contrast = internal->property("kwin_background_contrast").toReal(&ok);
             if (!ok) {
                 contrast = 1.0;
             }
             qreal intensity = internal->property("kwin_background_intensity").toReal(&ok);
             if (!ok) {
                 intensity = 1.0;
             }
             qreal saturation = internal->property("kwin_background_saturation").toReal(&ok);
             if (!ok) {
                 saturation = 1.0;
             }
             m_colorMatrices[w] = colorMatrix(contrast, intensity, saturation);
         }
     }
 
     //!value.isNull() full window in X11 case, surf->contrast()
     //valid, full window in wayland case
     if (region.isEmpty() && (!value.isNull() || (surf && surf->contrast()))) {
         // Set the data to a dummy value.
         // This is needed to be able to distinguish between the value not
         // being set, and being set to an empty region.
         w->setData(WindowBackgroundContrastRole, 1);
     } else
         w->setData(WindowBackgroundContrastRole, region);
 }
 
 void ContrastEffect::slotWindowAdded(EffectWindow *w)
 {
-    KWayland::Server::SurfaceInterface *surf = w->surface();
+    KWaylandServer::SurfaceInterface *surf = w->surface();
 
     if (surf) {
-        m_contrastChangedConnections[w] = connect(surf, &KWayland::Server::SurfaceInterface::contrastChanged, this, [this, w] () {
+        m_contrastChangedConnections[w] = connect(surf, &KWaylandServer::SurfaceInterface::contrastChanged, this, [this, w] () {
 
             if (w) {
                 updateContrastRegion(w);
             }
         });
     }
 
     if (auto internal = w->internalWindow()) {
         internal->installEventFilter(this);
     }
 
     updateContrastRegion(w);
 }
 
 bool ContrastEffect::eventFilter(QObject *watched, QEvent *event)
 {
     auto internal = qobject_cast<QWindow*>(watched);
     if (internal && event->type() == QEvent::DynamicPropertyChange) {
         QDynamicPropertyChangeEvent *pe = static_cast<QDynamicPropertyChangeEvent*>(event);
         if (pe->propertyName() == "kwin_background_region" ||
             pe->propertyName() == "kwin_background_contrast" ||
             pe->propertyName() == "kwin_background_intensity" ||
             pe->propertyName() == "kwin_background_saturation") {
             if (auto w = effects->findWindow(internal)) {
                 updateContrastRegion(w);
             }
         }
     }
     return false;
 }
 
 void ContrastEffect::slotWindowDeleted(EffectWindow *w)
 {
     if (m_contrastChangedConnections.contains(w)) {
         disconnect(m_contrastChangedConnections[w]);
         m_contrastChangedConnections.remove(w);
         m_colorMatrices.remove(w);
     }
 }
 
 void ContrastEffect::slotPropertyNotify(EffectWindow *w, long atom)
 {
     if (w && atom == net_wm_contrast_region && net_wm_contrast_region != XCB_ATOM_NONE) {
         updateContrastRegion(w);
     }
 }
 
 QMatrix4x4 ContrastEffect::colorMatrix(qreal contrast, qreal intensity, qreal saturation)
 {
     QMatrix4x4 satMatrix; //saturation
     QMatrix4x4 intMatrix; //intensity
     QMatrix4x4 contMatrix; //contrast
 
     //Saturation matrix
     if (!qFuzzyCompare(saturation, 1.0)) {
         const qreal rval = (1.0 - saturation) * .2126;
         const qreal gval = (1.0 - saturation) * .7152;
         const qreal bval = (1.0 - saturation) * .0722;
 
         satMatrix = QMatrix4x4(rval + saturation, rval,     rval,     0.0,
             gval,     gval + saturation, gval,     0.0,
             bval,     bval,     bval + saturation, 0.0,
             0,        0,        0,        1.0);
     }
 
     //IntensityMatrix
     if (!qFuzzyCompare(intensity, 1.0)) {
         intMatrix.scale(intensity, intensity, intensity);
     }
 
     //Contrast Matrix
     if (!qFuzzyCompare(contrast, 1.0)) {
         const float transl = (1.0 - contrast) / 2.0;
 
         contMatrix = QMatrix4x4(contrast, 0,        0,        0.0,
             0,        contrast, 0,        0.0,
             0,        0,        contrast, 0.0,
             transl,   transl,   transl,   1.0);
     }
 
     QMatrix4x4 colorMatrix = contMatrix * satMatrix * intMatrix;
     //colorMatrix = colorMatrix.transposed();
 
     return colorMatrix;
 }
 
 bool ContrastEffect::enabledByDefault()
 {
     GLPlatform *gl = GLPlatform::instance();
 
     if (gl->isIntel() && gl->chipClass() < SandyBridge)
         return false;
     if (gl->isSoftwareEmulation()) {
         return false;
     }
 
     return true;
 }
 
 bool ContrastEffect::supported()
 {
     bool supported = effects->isOpenGLCompositing() && GLRenderTarget::supported();
 
     if (supported) {
         int maxTexSize;
         glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
 
         const QSize screenSize = effects->virtualScreenSize();
         if (screenSize.width() > maxTexSize || screenSize.height() > maxTexSize)
             supported = false;
     }
     return supported;
 }
 
 QRegion ContrastEffect::contrastRegion(const EffectWindow *w) const
 {
     QRegion region;
 
     const QVariant value = w->data(WindowBackgroundContrastRole);
     if (value.isValid()) {
         const QRegion appRegion = qvariant_cast<QRegion>(value);
         if (!appRegion.isEmpty()) {
             region |= appRegion.translated(w->contentsRect().topLeft()) &
                       w->decorationInnerRect();
         } else {
             // An empty region means that the blur effect should be enabled
             // for the whole window.
             region = w->decorationInnerRect();
         }
     }
 
     return region;
 }
 
 void ContrastEffect::uploadRegion(QVector2D *&map, const QRegion &region)
 {
     for (const QRect &r : region) {
         const QVector2D topLeft(r.x(), r.y());
         const QVector2D topRight(r.x() + r.width(), r.y());
         const QVector2D bottomLeft(r.x(), r.y() + r.height());
         const QVector2D bottomRight(r.x() + r.width(), r.y() + r.height());
 
         // First triangle
         *(map++) = topRight;
         *(map++) = topLeft;
         *(map++) = bottomLeft;
 
         // Second triangle
         *(map++) = bottomLeft;
         *(map++) = bottomRight;
         *(map++) = topRight;
     }
 }
 
 void ContrastEffect::uploadGeometry(GLVertexBuffer *vbo, const QRegion &region)
 {
     const int vertexCount = region.rectCount() * 6;
     if (!vertexCount)
         return;
 
     QVector2D *map = (QVector2D *) vbo->map(vertexCount * sizeof(QVector2D));
     uploadRegion(map, region);
     vbo->unmap();
 
     const GLVertexAttrib layout[] = {
         { VA_Position, 2, GL_FLOAT, 0 },
         { VA_TexCoord, 2, GL_FLOAT, 0 }
     };
 
     vbo->setAttribLayout(layout, 2, sizeof(QVector2D));
 }
 
 void ContrastEffect::prePaintScreen(ScreenPrePaintData &data, int time)
 {
     m_paintedArea = QRegion();
     m_currentContrast = QRegion();
 
     effects->prePaintScreen(data, time);
 }
 
 void ContrastEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     // this effect relies on prePaintWindow being called in the bottom to top order
 
     effects->prePaintWindow(w, data, time);
 
     if (!w->isPaintingEnabled()) {
         return;
     }
     if (!shader || !shader->isValid()) {
         return;
     }
 
     const QRegion oldPaint = data.paint;
 
     // we don't have to blur a region we don't see
     m_currentContrast -= data.clip;
     // if we have to paint a non-opaque part of this window that intersects with the
     // currently blurred region (which is not cached) we have to redraw the whole region
     if ((data.paint-data.clip).intersects(m_currentContrast)) {
         data.paint |= m_currentContrast;
     }
 
     // in case this window has regions to be blurred
     const QRect screen = effects->virtualScreenGeometry();
     const QRegion contrastArea = contrastRegion(w).translated(w->pos()) & screen;
 
     // we are not caching the window
 
     // if this window or an window underneath the modified area is painted again we have to
     // do everything
     if (m_paintedArea.intersects(contrastArea) || data.paint.intersects(contrastArea)) {
         data.paint |= contrastArea;
 
         // we have to check again whether we do not damage a blurred area
         // of a window we do not cache
         if (contrastArea.intersects(m_currentContrast)) {
             data.paint |= m_currentContrast;
         }
     }
 
     m_currentContrast |= contrastArea;
 
 
     // m_paintedArea keep track of all repainted areas
     m_paintedArea -= data.clip;
     m_paintedArea |= data.paint;
 }
 
 bool ContrastEffect::shouldContrast(const EffectWindow *w, int mask, const WindowPaintData &data) const
 {
     if (!shader || !shader->isValid())
         return false;
 
     if (effects->activeFullScreenEffect() && !w->data(WindowForceBackgroundContrastRole).toBool())
         return false;
 
     if (w->isDesktop())
         return false;
 
     bool scaled = !qFuzzyCompare(data.xScale(), 1.0) && !qFuzzyCompare(data.yScale(), 1.0);
     bool translated = data.xTranslation() || data.yTranslation();
 
     if ((scaled || (translated || (mask & PAINT_WINDOW_TRANSFORMED))) && !w->data(WindowForceBackgroundContrastRole).toBool())
         return false;
 
     if (!w->hasAlpha())
         return false;
 
     return true;
 }
 
 void ContrastEffect::drawWindow(EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data)
 {
     const QRect screen = GLRenderTarget::virtualScreenGeometry();
     if (shouldContrast(w, mask, data)) {
         QRegion shape = region & contrastRegion(w).translated(w->pos()) & screen;
 
         // let's do the evil parts - someone wants to blur behind a transformed window
         const bool translated = data.xTranslation() || data.yTranslation();
         const bool scaled = data.xScale() != 1 || data.yScale() != 1;
         if (scaled) {
             QPoint pt = shape.boundingRect().topLeft();
             QRegion scaledShape;
             for (QRect r : shape) {
                 r.moveTo(pt.x() + (r.x() - pt.x()) * data.xScale() + data.xTranslation(),
                             pt.y() + (r.y() - pt.y()) * data.yScale() + data.yTranslation());
                 r.setWidth(r.width() * data.xScale());
                 r.setHeight(r.height() * data.yScale());
                 scaledShape |= r;
             }
             shape = scaledShape & region;
 
         //Only translated, not scaled
         } else if (translated) {
             shape = shape.translated(data.xTranslation(), data.yTranslation());
             shape = shape & region;
         }
 
         if (!shape.isEmpty()) {
             doContrast(w, shape, screen, data.opacity(), data.screenProjectionMatrix());
         }
     }
 
     // Draw the window over the contrast area
     effects->drawWindow(w, mask, region, data);
 }
 
 void ContrastEffect::paintEffectFrame(EffectFrame *frame, const QRegion &region, double opacity, double frameOpacity)
 {
     //FIXME: this is a no-op for now, it should figure out the right contrast, intensity, saturation
     effects->paintEffectFrame(frame, region, opacity, frameOpacity);
 }
 
 void ContrastEffect::doContrast(EffectWindow *w, const QRegion& shape, const QRect& screen, const float opacity, const QMatrix4x4 &screenProjection)
 {
     const QRegion actualShape = shape & screen;
     const QRect r = actualShape.boundingRect();
 
     qreal scale = GLRenderTarget::virtualScreenScale();
 
     // Upload geometry for the horizontal and vertical passes
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
     uploadGeometry(vbo, actualShape);
     vbo->bindArrays();
 
     // Create a scratch texture and copy the area in the back buffer that we're
     // going to blur into it
     GLTexture scratch(GL_RGBA8, r.width() * scale, r.height() * scale);
     scratch.setFilter(GL_LINEAR);
     scratch.setWrapMode(GL_CLAMP_TO_EDGE);
     scratch.bind();
 
     const QRect sg = GLRenderTarget::virtualScreenGeometry();
     glCopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, (r.x() - sg.x()) * scale, (sg.height() - (r.y() - sg.y() + r.height())) * scale,
                         scratch.width(), scratch.height());
 
     // Draw the texture on the offscreen framebuffer object, while blurring it horizontally
 
     shader->setColorMatrix(m_colorMatrices.value(w));
     shader->bind();
 
 
     shader->setOpacity(opacity);
     // Set up the texture matrix to transform from screen coordinates
     // to texture coordinates.
     QMatrix4x4 textureMatrix;
     textureMatrix.scale(1.0 / r.width(), -1.0 / r.height(), 1);
     textureMatrix.translate(-r.x(), -r.height() - r.y(), 0);
     shader->setTextureMatrix(textureMatrix);
     shader->setModelViewProjectionMatrix(screenProjection);
 
     vbo->draw(GL_TRIANGLES, 0, actualShape.rectCount() * 6);
 
     scratch.unbind();
     scratch.discard();
 
     vbo->unbindArrays();
 
     if (opacity < 1.0) {
         glDisable(GL_BLEND);
     }
 
     shader->unbind();
 }
 
 } // namespace KWin
 
diff --git a/effects/backgroundcontrast/contrast.h b/effects/backgroundcontrast/contrast.h
index 4efd2e793..e85b32949 100644
--- a/effects/backgroundcontrast/contrast.h
+++ b/effects/backgroundcontrast/contrast.h
@@ -1,106 +1,103 @@
 /*
  *   Copyright © 2010 Fredrik Höglund <fredrik@kde.org>
  *   Copyright 2014 Marco Martin <mart@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; see the file COPYING.  if not, write to
  *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *   Boston, MA 02110-1301, USA.
  */
 
 #ifndef CONTRAST_H
 #define CONTRAST_H
 
 #include <kwineffects.h>
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 
 #include <QVector>
 #include <QVector2D>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class ContrastManagerInterface;
 }
-}
 
 namespace KWin
 {
 
 class ContrastShader;
 
 class ContrastEffect : public KWin::Effect
 {
     Q_OBJECT
 public:
     ContrastEffect();
     ~ContrastEffect() override;
 
     static bool supported();
     static bool enabledByDefault();
 
     static QMatrix4x4 colorMatrix(qreal contrast, qreal intensity, qreal saturation);
     void reconfigure(ReconfigureFlags flags) override;
     void prePaintScreen(ScreenPrePaintData &data, int time) override;
     void prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time) override;
     void drawWindow(EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data) override;
     void paintEffectFrame(EffectFrame *frame, const QRegion &region, double opacity, double frameOpacity) override;
 
     bool provides(Feature feature) override;
 
     int requestedEffectChainPosition() const override {
         return 76;
     }
 
     bool eventFilter(QObject *watched, QEvent *event) override;
 
 public Q_SLOTS:
     void slotWindowAdded(KWin::EffectWindow *w);
     void slotWindowDeleted(KWin::EffectWindow *w);
     void slotPropertyNotify(KWin::EffectWindow *w, long atom);
     void slotScreenGeometryChanged();
 
 private:
     QRegion contrastRegion(const EffectWindow *w) const;
     bool shouldContrast(const EffectWindow *w, int mask, const WindowPaintData &data) const;
     void updateContrastRegion(EffectWindow *w);
     void doContrast(EffectWindow *w, const QRegion &shape, const QRect &screen, const float opacity, const QMatrix4x4 &screenProjection);
     void uploadRegion(QVector2D *&map, const QRegion &region);
     void uploadGeometry(GLVertexBuffer *vbo, const QRegion &region);
 
 private:
     ContrastShader *shader;
     long net_wm_contrast_region;
     QRegion m_paintedArea; // actually painted area which is greater than m_damagedArea
     QRegion m_currentContrast; // keeps track of the currently contrasted area of non-caching windows(from bottom to top)
     QHash< const EffectWindow*, QMatrix4x4> m_colorMatrices;
     QHash< const EffectWindow*, QMetaObject::Connection > m_contrastChangedConnections; // used only in Wayland to keep track of effect changed
-    KWayland::Server::ContrastManagerInterface *m_contrastManager = nullptr;
+    KWaylandServer::ContrastManagerInterface *m_contrastManager = nullptr;
 };
 
 inline
 bool ContrastEffect::provides(Effect::Feature feature)
 {
     if (feature == Contrast) {
         return true;
     }
     return KWin::Effect::provides(feature);
 }
 
 
 } // namespace KWin
 
 #endif
 
diff --git a/effects/blur/blur.cpp b/effects/blur/blur.cpp
index 589050ee7..27af34e6a 100644
--- a/effects/blur/blur.cpp
+++ b/effects/blur/blur.cpp
@@ -1,835 +1,835 @@
 /*
  *   Copyright © 2010 Fredrik Höglund <fredrik@kde.org>
  *   Copyright © 2011 Philipp Knechtges <philipp-dev@knechtges.com>
  *   Copyright © 2018 Alex Nemeth <alex.nemeth329@gmail.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *   General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; see the file COPYING.  if not, write to
  *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *   Boston, MA 02110-1301, USA.
  */
 
 #include "blur.h"
 #include "blurshader.h"
 // KConfigSkeleton
 #include "blurconfig.h"
 
 #include <QGuiApplication>
 #include <QMatrix4x4>
 #include <QScreen> // for QGuiApplication
 #include <QTime>
 #include <QWindow>
 #include <cmath> // for ceil()
 
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/blur_interface.h>
-#include <KWayland/Server/shadow_interface.h>
-#include <KWayland/Server/display.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/blur_interface.h>
+#include <KWaylandServer/shadow_interface.h>
+#include <KWaylandServer/display.h>
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 namespace KWin
 {
 
 static const QByteArray s_blurAtomName = QByteArrayLiteral("_KDE_NET_WM_BLUR_BEHIND_REGION");
 
 BlurEffect::BlurEffect()
 {
     initConfig<BlurConfig>();
     m_shader = new BlurShader(this);
 
     initBlurStrengthValues();
     reconfigure(ReconfigureAll);
 
     // ### Hackish way to announce support.
     //     Should be included in _NET_SUPPORTED instead.
     if (m_shader && m_shader->isValid() && m_renderTargetsValid) {
         net_wm_blur_region = effects->announceSupportProperty(s_blurAtomName, this);
-        KWayland::Server::Display *display = effects->waylandDisplay();
+        KWaylandServer::Display *display = effects->waylandDisplay();
         if (display) {
             m_blurManager = display->createBlurManager(this);
             m_blurManager->create();
         }
     } else {
         net_wm_blur_region = 0;
     }
 
     connect(effects, &EffectsHandler::windowAdded, this, &BlurEffect::slotWindowAdded);
     connect(effects, &EffectsHandler::windowDeleted, this, &BlurEffect::slotWindowDeleted);
     connect(effects, &EffectsHandler::propertyNotify, this, &BlurEffect::slotPropertyNotify);
     connect(effects, &EffectsHandler::screenGeometryChanged, this, &BlurEffect::slotScreenGeometryChanged);
     connect(effects, &EffectsHandler::xcbConnectionChanged, this,
         [this] {
             if (m_shader && m_shader->isValid() && m_renderTargetsValid) {
                 net_wm_blur_region = effects->announceSupportProperty(s_blurAtomName, this);
             }
         }
     );
 
     // Fetch the blur regions for all windows
     foreach (EffectWindow *window, effects->stackingOrder())
         updateBlurRegion(window);
 }
 
 BlurEffect::~BlurEffect()
 {
     deleteFBOs();
 }
 
 void BlurEffect::slotScreenGeometryChanged()
 {
     effects->makeOpenGLContextCurrent();
     updateTexture();
 
     // Fetch the blur regions for all windows
     foreach (EffectWindow *window, effects->stackingOrder())
         updateBlurRegion(window);
     effects->doneOpenGLContextCurrent();
 }
 
 bool BlurEffect::renderTargetsValid() const
 {
     return !m_renderTargets.isEmpty() && std::find_if(m_renderTargets.cbegin(), m_renderTargets.cend(),
         [](const GLRenderTarget *target) {
             return !target->valid();
         }) == m_renderTargets.cend();
 }
 
 void BlurEffect::deleteFBOs()
 {
     qDeleteAll(m_renderTargets);
 
     m_renderTargets.clear();
     m_renderTextures.clear();
 }
 
 void BlurEffect::updateTexture()
 {
     deleteFBOs();
 
     /* Reserve memory for:
      *  - The original sized texture (1)
      *  - The downsized textures (m_downSampleIterations)
      *  - The helper texture (1)
      */
     m_renderTargets.reserve(m_downSampleIterations + 2);
     m_renderTextures.reserve(m_downSampleIterations + 2);
 
     GLenum textureFormat = GL_RGBA8;
 
     // Check the color encoding of the default framebuffer
     if (!GLPlatform::instance()->isGLES()) {
         GLuint prevFbo = 0;
         glGetIntegerv(GL_DRAW_FRAMEBUFFER_BINDING, reinterpret_cast<GLint *>(&prevFbo));
 
         if (prevFbo != 0) {
             glBindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
         }
 
         GLenum colorEncoding = GL_LINEAR;
         glGetFramebufferAttachmentParameteriv(GL_DRAW_FRAMEBUFFER, GL_BACK_LEFT,
                                               GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING,
                                               reinterpret_cast<GLint *>(&colorEncoding));
 
         if (prevFbo != 0) {
             glBindFramebuffer(GL_DRAW_FRAMEBUFFER, prevFbo);
         }
 
         if (colorEncoding == GL_SRGB) {
             textureFormat = GL_SRGB8_ALPHA8;
         }
     }
 
     for (int i = 0; i <= m_downSampleIterations; i++) {
         m_renderTextures.append(GLTexture(textureFormat, effects->virtualScreenSize() / (1 << i)));
         m_renderTextures.last().setFilter(GL_LINEAR);
         m_renderTextures.last().setWrapMode(GL_CLAMP_TO_EDGE);
 
         m_renderTargets.append(new GLRenderTarget(m_renderTextures.last()));
     }
 
     // This last set is used as a temporary helper texture
     m_renderTextures.append(GLTexture(textureFormat, effects->virtualScreenSize()));
     m_renderTextures.last().setFilter(GL_LINEAR);
     m_renderTextures.last().setWrapMode(GL_CLAMP_TO_EDGE);
 
     m_renderTargets.append(new GLRenderTarget(m_renderTextures.last()));
 
     m_renderTargetsValid = renderTargetsValid();
 
     // Prepare the stack for the rendering
     m_renderTargetStack.clear();
     m_renderTargetStack.reserve(m_downSampleIterations * 2);
 
     // Upsample
     for (int i = 1; i < m_downSampleIterations; i++) {
         m_renderTargetStack.push(m_renderTargets[i]);
     }
 
     // Downsample
     for (int i = m_downSampleIterations; i > 0; i--) {
         m_renderTargetStack.push(m_renderTargets[i]);
     }
 
     // Copysample
     m_renderTargetStack.push(m_renderTargets[0]);
 
     // Generate the noise helper texture
     generateNoiseTexture();
 }
 
 void BlurEffect::initBlurStrengthValues()
 {
     // This function creates an array of blur strength values that are evenly distributed
 
     // The range of the slider on the blur settings UI
     int numOfBlurSteps = 15;
     int remainingSteps = numOfBlurSteps;
 
     /*
      * Explanation for these numbers:
      *
      * The texture blur amount depends on the downsampling iterations and the offset value.
      * By changing the offset we can alter the blur amount without relying on further downsampling.
      * But there is a minimum and maximum value of offset per downsample iteration before we
      * get artifacts.
      *
      * The minOffset variable is the minimum offset value for an iteration before we
      * get blocky artifacts because of the downsampling.
      *
      * The maxOffset value is the maximum offset value for an iteration before we
      * get diagonal line artifacts because of the nature of the dual kawase blur algorithm.
      *
      * The expandSize value is the minimum value for an iteration before we reach the end
      * of a texture in the shader and sample outside of the area that was copied into the
      * texture from the screen.
      */
 
     // {minOffset, maxOffset, expandSize}
     blurOffsets.append({1.0, 2.0, 10});     // Down sample size / 2
     blurOffsets.append({2.0, 3.0, 20});     // Down sample size / 4
     blurOffsets.append({2.0, 5.0, 50});     // Down sample size / 8
     blurOffsets.append({3.0, 8.0, 150});    // Down sample size / 16
     //blurOffsets.append({5.0, 10.0, 400}); // Down sample size / 32
     //blurOffsets.append({7.0, ?.0});       // Down sample size / 64
 
     float offsetSum = 0;
 
     for (int i = 0; i < blurOffsets.size(); i++) {
         offsetSum += blurOffsets[i].maxOffset - blurOffsets[i].minOffset;
     }
 
     for (int i = 0; i < blurOffsets.size(); i++) {
         int iterationNumber = std::ceil((blurOffsets[i].maxOffset - blurOffsets[i].minOffset) / offsetSum * numOfBlurSteps);
         remainingSteps -= iterationNumber;
 
         if (remainingSteps < 0) {
             iterationNumber += remainingSteps;
         }
 
         float offsetDifference = blurOffsets[i].maxOffset - blurOffsets[i].minOffset;
 
         for (int j = 1; j <= iterationNumber; j++) {
             // {iteration, offset}
             blurStrengthValues.append({i + 1, blurOffsets[i].minOffset + (offsetDifference / iterationNumber) * j});
         }
     }
 }
 
 void BlurEffect::reconfigure(ReconfigureFlags flags)
 {
     Q_UNUSED(flags)
 
     BlurConfig::self()->read();
 
     int blurStrength = BlurConfig::blurStrength() - 1;
     m_downSampleIterations = blurStrengthValues[blurStrength].iteration;
     m_offset = blurStrengthValues[blurStrength].offset;
     m_expandSize = blurOffsets[m_downSampleIterations - 1].expandSize;
     m_noiseStrength = BlurConfig::noiseStrength();
 
     m_scalingFactor = qMax(1.0, QGuiApplication::primaryScreen()->logicalDotsPerInch() / 96.0);
 
     updateTexture();
 
     if (!m_shader || !m_shader->isValid()) {
         effects->removeSupportProperty(s_blurAtomName, this);
         delete m_blurManager;
         m_blurManager = nullptr;
     }
 
     // Update all windows for the blur to take effect
     effects->addRepaintFull();
 }
 
 void BlurEffect::updateBlurRegion(EffectWindow *w) const
 {
     QRegion region;
     QByteArray value;
 
     if (net_wm_blur_region != XCB_ATOM_NONE) {
         value = w->readProperty(net_wm_blur_region, XCB_ATOM_CARDINAL, 32);
         if (value.size() > 0 && !(value.size() % (4 * sizeof(uint32_t)))) {
             const uint32_t *cardinals = reinterpret_cast<const uint32_t*>(value.constData());
             for (unsigned int i = 0; i < value.size() / sizeof(uint32_t);) {
                 int x = cardinals[i++];
                 int y = cardinals[i++];
                 int w = cardinals[i++];
                 int h = cardinals[i++];
                 region += QRect(x, y, w, h);
             }
         }
     }
 
-    KWayland::Server::SurfaceInterface *surf = w->surface();
+    KWaylandServer::SurfaceInterface *surf = w->surface();
 
     if (surf && surf->blur()) {
         region = surf->blur()->region();
     }
 
     if (auto internal = w->internalWindow()) {
         const auto property = internal->property("kwin_blur");
         if (property.isValid()) {
             region = property.value<QRegion>();
         }
     }
 
     //!value.isNull() full window in X11 case, surf->blur()
     //valid, full window in wayland case
     if (region.isEmpty() && (!value.isNull() || (surf && surf->blur()))) {
         // Set the data to a dummy value.
         // This is needed to be able to distinguish between the value not
         // being set, and being set to an empty region.
         w->setData(WindowBlurBehindRole, 1);
     } else
         w->setData(WindowBlurBehindRole, region);
 }
 
 void BlurEffect::slotWindowAdded(EffectWindow *w)
 {
-    KWayland::Server::SurfaceInterface *surf = w->surface();
+    KWaylandServer::SurfaceInterface *surf = w->surface();
 
     if (surf) {
-        windowBlurChangedConnections[w] = connect(surf, &KWayland::Server::SurfaceInterface::blurChanged, this, [this, w] () {
+        windowBlurChangedConnections[w] = connect(surf, &KWaylandServer::SurfaceInterface::blurChanged, this, [this, w] () {
             if (w) {
                 updateBlurRegion(w);
             }
         });
     }
     if (auto internal = w->internalWindow()) {
         internal->installEventFilter(this);
     }
 
     updateBlurRegion(w);
 }
 
 void BlurEffect::slotWindowDeleted(EffectWindow *w)
 {
     auto it = windowBlurChangedConnections.find(w);
     if (it == windowBlurChangedConnections.end()) {
         return;
     }
     disconnect(*it);
     windowBlurChangedConnections.erase(it);
 }
 
 void BlurEffect::slotPropertyNotify(EffectWindow *w, long atom)
 {
     if (w && atom == net_wm_blur_region && net_wm_blur_region != XCB_ATOM_NONE) {
         updateBlurRegion(w);
     }
 }
 
 bool BlurEffect::eventFilter(QObject *watched, QEvent *event)
 {
     auto internal = qobject_cast<QWindow*>(watched);
     if (internal && event->type() == QEvent::DynamicPropertyChange) {
         QDynamicPropertyChangeEvent *pe = static_cast<QDynamicPropertyChangeEvent*>(event);
         if (pe->propertyName() == "kwin_blur") {
             if (auto w = effects->findWindow(internal)) {
                 updateBlurRegion(w);
             }
         }
     }
     return false;
 }
 
 bool BlurEffect::enabledByDefault()
 {
     GLPlatform *gl = GLPlatform::instance();
 
     if (gl->isIntel() && gl->chipClass() < SandyBridge)
         return false;
     if (gl->isSoftwareEmulation()) {
         return false;
     }
 
     return true;
 }
 
 bool BlurEffect::supported()
 {
     bool supported = effects->isOpenGLCompositing() && GLRenderTarget::supported() && GLRenderTarget::blitSupported();
 
     if (supported) {
         int maxTexSize;
         glGetIntegerv(GL_MAX_TEXTURE_SIZE, &maxTexSize);
 
         const QSize screenSize = effects->virtualScreenSize();
         if (screenSize.width() > maxTexSize || screenSize.height() > maxTexSize)
             supported = false;
     }
     return supported;
 }
 
 QRect BlurEffect::expand(const QRect &rect) const
 {
     return rect.adjusted(-m_expandSize, -m_expandSize, m_expandSize, m_expandSize);
 }
 
 QRegion BlurEffect::expand(const QRegion &region) const
 {
     QRegion expanded;
 
     for (const QRect &rect : region) {
         expanded += expand(rect);
     }
 
     return expanded;
 }
 
 QRegion BlurEffect::blurRegion(const EffectWindow *w) const
 {
     QRegion region;
 
     const QVariant value = w->data(WindowBlurBehindRole);
     if (value.isValid()) {
         const QRegion appRegion = qvariant_cast<QRegion>(value);
         if (!appRegion.isEmpty()) {
             if (w->decorationHasAlpha() && effects->decorationSupportsBlurBehind()) {
                 region = w->shape();
                 region -= w->decorationInnerRect();
             }
             region |= appRegion.translated(w->contentsRect().topLeft()) &
                       w->decorationInnerRect();
         } else {
             // An empty region means that the blur effect should be enabled
             // for the whole window.
             region = w->shape();
         }
     } else if (w->decorationHasAlpha() && effects->decorationSupportsBlurBehind()) {
         // If the client hasn't specified a blur region, we'll only enable
         // the effect behind the decoration.
         region = w->shape();
         region -= w->decorationInnerRect();
     }
 
     return region;
 }
 
 void BlurEffect::uploadRegion(QVector2D *&map, const QRegion &region, const int downSampleIterations)
 {
     for (int i = 0; i <= downSampleIterations; i++) {
         const int divisionRatio = (1 << i);
 
         for (const QRect &r : region) {
             const QVector2D topLeft(     r.x() / divisionRatio,               r.y() / divisionRatio);
             const QVector2D topRight(   (r.x() + r.width()) / divisionRatio,  r.y() / divisionRatio);
             const QVector2D bottomLeft(  r.x() / divisionRatio,              (r.y() + r.height()) / divisionRatio);
             const QVector2D bottomRight((r.x() + r.width()) / divisionRatio, (r.y() + r.height()) / divisionRatio);
 
             // First triangle
             *(map++) = topRight;
             *(map++) = topLeft;
             *(map++) = bottomLeft;
 
             // Second triangle
             *(map++) = bottomLeft;
             *(map++) = bottomRight;
             *(map++) = topRight;
         }
     }
 }
 
 void BlurEffect::uploadGeometry(GLVertexBuffer *vbo, const QRegion &blurRegion, const QRegion &windowRegion)
 {
     const int vertexCount = ((blurRegion.rectCount() * (m_downSampleIterations + 1)) + windowRegion.rectCount()) * 6;
 
     if (!vertexCount)
         return;
 
     QVector2D *map = (QVector2D *) vbo->map(vertexCount * sizeof(QVector2D));
 
     uploadRegion(map, blurRegion, m_downSampleIterations);
     uploadRegion(map, windowRegion, 0);
 
     vbo->unmap();
 
     const GLVertexAttrib layout[] = {
         { VA_Position, 2, GL_FLOAT, 0 },
         { VA_TexCoord, 2, GL_FLOAT, 0 }
     };
 
     vbo->setAttribLayout(layout, 2, sizeof(QVector2D));
 }
 
 void BlurEffect::prePaintScreen(ScreenPrePaintData &data, int time)
 {
     m_damagedArea = QRegion();
     m_paintedArea = QRegion();
     m_currentBlur = QRegion();
 
     effects->prePaintScreen(data, time);
 }
 
 void BlurEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     // this effect relies on prePaintWindow being called in the bottom to top order
 
     effects->prePaintWindow(w, data, time);
 
     if (!w->isPaintingEnabled()) {
         return;
     }
     if (!m_shader || !m_shader->isValid()) {
         return;
     }
 
     // to blur an area partially we have to shrink the opaque area of a window
     QRegion newClip;
     const QRegion oldClip = data.clip;
     for (const QRect &rect : data.clip) {
         newClip |= rect.adjusted(m_expandSize, m_expandSize, -m_expandSize, -m_expandSize);
     }
     data.clip = newClip;
 
     const QRegion oldPaint = data.paint;
 
     // we don't have to blur a region we don't see
     m_currentBlur -= newClip;
     // if we have to paint a non-opaque part of this window that intersects with the
     // currently blurred region we have to redraw the whole region
     if ((data.paint - oldClip).intersects(m_currentBlur)) {
         data.paint |= m_currentBlur;
     }
 
     // in case this window has regions to be blurred
     const QRect screen = effects->virtualScreenGeometry();
     const QRegion blurArea = blurRegion(w).translated(w->pos()) & screen;
     const QRegion expandedBlur = (w->isDock() ? blurArea : expand(blurArea)) & screen;
 
     // if this window or a window underneath the blurred area is painted again we have to
     // blur everything
     if (m_paintedArea.intersects(expandedBlur) || data.paint.intersects(blurArea)) {
         data.paint |= expandedBlur;
         // we keep track of the "damage propagation"
         m_damagedArea |=  (w->isDock() ? (expandedBlur & m_damagedArea) : expand(expandedBlur & m_damagedArea)) & blurArea;
         // we have to check again whether we do not damage a blurred area
         // of a window
         if (expandedBlur.intersects(m_currentBlur)) {
             data.paint |= m_currentBlur;
         }
     }
 
     m_currentBlur |= expandedBlur;
 
     // we don't consider damaged areas which are occluded and are not
     // explicitly damaged by this window
     m_damagedArea -= data.clip;
     m_damagedArea |= oldPaint;
 
     // in contrast to m_damagedArea does m_paintedArea keep track of all repainted areas
     m_paintedArea -= data.clip;
     m_paintedArea |= data.paint;
 }
 
 bool BlurEffect::shouldBlur(const EffectWindow *w, int mask, const WindowPaintData &data) const
 {
     if (!m_renderTargetsValid || !m_shader || !m_shader->isValid())
         return false;
 
     if (effects->activeFullScreenEffect() && !w->data(WindowForceBlurRole).toBool())
         return false;
 
     if (w->isDesktop())
         return false;
 
     bool scaled = !qFuzzyCompare(data.xScale(), 1.0) && !qFuzzyCompare(data.yScale(), 1.0);
     bool translated = data.xTranslation() || data.yTranslation();
 
     if ((scaled || (translated || (mask & PAINT_WINDOW_TRANSFORMED))) && !w->data(WindowForceBlurRole).toBool())
         return false;
 
     bool blurBehindDecos = effects->decorationsHaveAlpha() &&
                 effects->decorationSupportsBlurBehind();
 
     if (!w->hasAlpha() && w->opacity() >= 1.0 && !(blurBehindDecos && w->hasDecoration()))
         return false;
 
     return true;
 }
 
 void BlurEffect::drawWindow(EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data)
 {
     const QRect screen = GLRenderTarget::virtualScreenGeometry();
     if (shouldBlur(w, mask, data)) {
         QRegion shape = region & blurRegion(w).translated(w->pos()) & screen;
 
         // let's do the evil parts - someone wants to blur behind a transformed window
         const bool translated = data.xTranslation() || data.yTranslation();
         const bool scaled = data.xScale() != 1 || data.yScale() != 1;
         if (scaled) {
             QPoint pt = shape.boundingRect().topLeft();
             QRegion scaledShape;
             for (QRect r : shape) {
                 r.moveTo(pt.x() + (r.x() - pt.x()) * data.xScale() + data.xTranslation(),
                             pt.y() + (r.y() - pt.y()) * data.yScale() + data.yTranslation());
                 r.setWidth(r.width() * data.xScale());
                 r.setHeight(r.height() * data.yScale());
                 scaledShape |= r;
             }
             shape = scaledShape & region;
 
         //Only translated, not scaled
         } else if (translated) {
             shape = shape.translated(data.xTranslation(), data.yTranslation());
             shape = shape & region;
         }
 
         if (!shape.isEmpty()) {
             doBlur(shape, screen, data.opacity(), data.screenProjectionMatrix(), w->isDock(), w->geometry());
         }
     }
 
     // Draw the window over the blurred area
     effects->drawWindow(w, mask, region, data);
 }
 
 void BlurEffect::paintEffectFrame(EffectFrame *frame, const QRegion &region, double opacity, double frameOpacity)
 {
     const QRect screen = effects->virtualScreenGeometry();
     bool valid = m_renderTargetsValid && m_shader && m_shader->isValid();
 
     QRegion shape = frame->geometry().adjusted(-borderSize, -borderSize, borderSize, borderSize) & screen;
 
     if (valid && !shape.isEmpty() && region.intersects(shape.boundingRect()) && frame->style() != EffectFrameNone) {
         doBlur(shape, screen, opacity * frameOpacity, frame->screenProjectionMatrix(), false, frame->geometry());
     }
     effects->paintEffectFrame(frame, region, opacity, frameOpacity);
 }
 
 void BlurEffect::generateNoiseTexture()
 {
     if (m_noiseStrength == 0) {
         return;
     }
 
     // Init randomness based on time
     qsrand((uint)QTime::currentTime().msec());
 
     QImage noiseImage(QSize(256, 256), QImage::Format_Grayscale8);
 
     for (int y = 0; y < noiseImage.height(); y++) {
         uint8_t *noiseImageLine = (uint8_t *) noiseImage.scanLine(y);
 
         for (int x = 0; x < noiseImage.width(); x++) {
             noiseImageLine[x] = qrand() % m_noiseStrength + (128 - m_noiseStrength / 2);
         }
     }
 
     // The noise texture looks distorted when not scaled with integer
     noiseImage = noiseImage.scaled(noiseImage.size() * m_scalingFactor);
 
     m_noiseTexture = GLTexture(noiseImage);
     m_noiseTexture.setFilter(GL_NEAREST);
     m_noiseTexture.setWrapMode(GL_REPEAT);
 }
 
 void BlurEffect::doBlur(const QRegion& shape, const QRect& screen, const float opacity, const QMatrix4x4 &screenProjection, bool isDock, QRect windowRect)
 {
     // Blur would not render correctly on a secondary monitor because of wrong coordinates
     // BUG: 393723
     const int xTranslate = -screen.x();
     const int yTranslate = effects->virtualScreenSize().height() - screen.height() - screen.y();
 
     const QRegion expandedBlurRegion = expand(shape) & expand(screen);
 
     const bool useSRGB = m_renderTextures.first().internalFormat() == GL_SRGB8_ALPHA8;
 
     // Upload geometry for the down and upsample iterations
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
 
     uploadGeometry(vbo, expandedBlurRegion.translated(xTranslate, yTranslate), shape);
     vbo->bindArrays();
 
     const QRect sourceRect = expandedBlurRegion.boundingRect() & screen;
     const QRect destRect = sourceRect.translated(xTranslate, yTranslate);
 
     GLRenderTarget::pushRenderTargets(m_renderTargetStack);
     int blurRectCount = expandedBlurRegion.rectCount() * 6;
 
     /*
      * If the window is a dock or panel we avoid the "extended blur" effect.
      * Extended blur is when windows that are not under the blurred area affect
      * the final blur result.
      * We want to avoid this on panels, because it looks really weird and ugly
      * when maximized windows or windows near the panel affect the dock blur.
      */
     if (isDock) {
         m_renderTargets.last()->blitFromFramebuffer(sourceRect, destRect);
 
         if (useSRGB) {
             glEnable(GL_FRAMEBUFFER_SRGB);
         }
 
         copyScreenSampleTexture(vbo, blurRectCount, shape.translated(xTranslate, yTranslate), screenProjection);
     } else {
         m_renderTargets.first()->blitFromFramebuffer(sourceRect, destRect);
 
         if (useSRGB) {
             glEnable(GL_FRAMEBUFFER_SRGB);
         }
 
         // Remove the m_renderTargets[0] from the top of the stack that we will not use
         GLRenderTarget::popRenderTarget();
     }
 
     downSampleTexture(vbo, blurRectCount);
     upSampleTexture(vbo, blurRectCount);
 
     // Modulate the blurred texture with the window opacity if the window isn't opaque
     if (opacity < 1.0) {
         glEnable(GL_BLEND);
 #if 1 // bow shape, always above y = x
         float o = 1.0f-opacity;
         o = 1.0f - o*o;
 #else // sigmoid shape, above y = x for x > 0.5, below y = x for x < 0.5
         float o = 2.0f*opacity - 1.0f;
         o = 0.5f + o / (1.0f + qAbs(o));
 #endif
         glBlendColor(0, 0, 0, o);
         glBlendFunc(GL_CONSTANT_ALPHA, GL_ONE_MINUS_CONSTANT_ALPHA);
     }
 
     upscaleRenderToScreen(vbo, blurRectCount * (m_downSampleIterations + 1), shape.rectCount() * 6, screenProjection, windowRect.topLeft());
 
     if (useSRGB) {
         glDisable(GL_FRAMEBUFFER_SRGB);
     }
 
     if (opacity < 1.0) {
         glDisable(GL_BLEND);
     }
 
     vbo->unbindArrays();
 }
 
 void BlurEffect::upscaleRenderToScreen(GLVertexBuffer *vbo, int vboStart, int blurRectCount, QMatrix4x4 screenProjection, QPoint windowPosition)
 {
     glActiveTexture(GL_TEXTURE0);
     m_renderTextures[1].bind();
 
     if (m_noiseStrength > 0) {
         m_shader->bind(BlurShader::NoiseSampleType);
         m_shader->setTargetTextureSize(m_renderTextures[0].size() * GLRenderTarget::virtualScreenScale());
         m_shader->setNoiseTextureSize(m_noiseTexture.size() * GLRenderTarget::virtualScreenScale());
         m_shader->setTexturePosition(windowPosition * GLRenderTarget::virtualScreenScale());
 
         glActiveTexture(GL_TEXTURE1);
         m_noiseTexture.bind();
     } else {
         m_shader->bind(BlurShader::UpSampleType);
         m_shader->setTargetTextureSize(m_renderTextures[0].size() * GLRenderTarget::virtualScreenScale());
     }
 
     m_shader->setOffset(m_offset);
     m_shader->setModelViewProjectionMatrix(screenProjection);
 
     //Render to the screen
     vbo->draw(GL_TRIANGLES, vboStart, blurRectCount);
 
     glActiveTexture(GL_TEXTURE0);
     m_shader->unbind();
 }
 
 void BlurEffect::downSampleTexture(GLVertexBuffer *vbo, int blurRectCount)
 {
     QMatrix4x4 modelViewProjectionMatrix;
 
     m_shader->bind(BlurShader::DownSampleType);
     m_shader->setOffset(m_offset);
 
     for (int i = 1; i <= m_downSampleIterations; i++) {
         modelViewProjectionMatrix.setToIdentity();
         modelViewProjectionMatrix.ortho(0, m_renderTextures[i].width(), m_renderTextures[i].height(), 0 , 0, 65535);
 
         m_shader->setModelViewProjectionMatrix(modelViewProjectionMatrix);
         m_shader->setTargetTextureSize(m_renderTextures[i].size());
 
         //Copy the image from this texture
         m_renderTextures[i - 1].bind();
 
         vbo->draw(GL_TRIANGLES, blurRectCount * i, blurRectCount);
         GLRenderTarget::popRenderTarget();
     }
 
     m_shader->unbind();
 }
 
 void BlurEffect::upSampleTexture(GLVertexBuffer *vbo, int blurRectCount)
 {
     QMatrix4x4 modelViewProjectionMatrix;
 
     m_shader->bind(BlurShader::UpSampleType);
     m_shader->setOffset(m_offset);
 
     for (int i = m_downSampleIterations - 1; i >= 1; i--) {
         modelViewProjectionMatrix.setToIdentity();
         modelViewProjectionMatrix.ortho(0, m_renderTextures[i].width(), m_renderTextures[i].height(), 0 , 0, 65535);
 
         m_shader->setModelViewProjectionMatrix(modelViewProjectionMatrix);
         m_shader->setTargetTextureSize(m_renderTextures[i].size());
 
         //Copy the image from this texture
         m_renderTextures[i + 1].bind();
 
         vbo->draw(GL_TRIANGLES, blurRectCount * i, blurRectCount);
         GLRenderTarget::popRenderTarget();
     }
 
     m_shader->unbind();
 }
 
 void BlurEffect::copyScreenSampleTexture(GLVertexBuffer *vbo, int blurRectCount, QRegion blurShape, QMatrix4x4 screenProjection)
 {
     m_shader->bind(BlurShader::CopySampleType);
 
     m_shader->setModelViewProjectionMatrix(screenProjection);
     m_shader->setTargetTextureSize(effects->virtualScreenSize());
 
     /*
      * This '1' sized adjustment is necessary do avoid windows affecting the blur that are
      * right next to this window.
      */
     m_shader->setBlurRect(blurShape.boundingRect().adjusted(1, 1, -1, -1), effects->virtualScreenSize());
     m_renderTextures.last().bind();
 
     vbo->draw(GL_TRIANGLES, 0, blurRectCount);
     GLRenderTarget::popRenderTarget();
 
     m_shader->unbind();
 }
 
 } // namespace KWin
 
diff --git a/effects/blur/blur.h b/effects/blur/blur.h
index 53db214fa..250b0a21d 100644
--- a/effects/blur/blur.h
+++ b/effects/blur/blur.h
@@ -1,150 +1,147 @@
 /*
  *   Copyright © 2010 Fredrik Höglund <fredrik@kde.org>
  *   Copyright © 2018 Alex Nemeth <alex.nemeth329@gmail.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *   General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program; see the file COPYING.  if not, write to
  *   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  *   Boston, MA 02110-1301, USA.
  */
 
 #ifndef BLUR_H
 #define BLUR_H
 
 #include <kwineffects.h>
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 
 #include <QVector>
 #include <QVector2D>
 #include <QStack>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class BlurManagerInterface;
 }
-}
 
 namespace KWin
 {
 
 static const int borderSize = 5;
 
 class BlurShader;
 
 class BlurEffect : public KWin::Effect
 {
     Q_OBJECT
 
 public:
     BlurEffect();
     ~BlurEffect() override;
 
     static bool supported();
     static bool enabledByDefault();
 
     void reconfigure(ReconfigureFlags flags) override;
     void prePaintScreen(ScreenPrePaintData &data, int time) override;
     void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) override;
     void drawWindow(EffectWindow *w, int mask, const QRegion &region, WindowPaintData &data) override;
     void paintEffectFrame(EffectFrame *frame, const QRegion &region, double opacity, double frameOpacity) override;
 
     bool provides(Feature feature) override;
 
     int requestedEffectChainPosition() const override {
         return 75;
     }
 
     bool eventFilter(QObject *watched, QEvent *event) override;
 
 public Q_SLOTS:
     void slotWindowAdded(KWin::EffectWindow *w);
     void slotWindowDeleted(KWin::EffectWindow *w);
     void slotPropertyNotify(KWin::EffectWindow *w, long atom);
     void slotScreenGeometryChanged();
 
 private:
     QRect expand(const QRect &rect) const;
     QRegion expand(const QRegion &region) const;
     bool renderTargetsValid() const;
     void deleteFBOs();
     void initBlurStrengthValues();
     void updateTexture();
     QRegion blurRegion(const EffectWindow *w) const;
     bool shouldBlur(const EffectWindow *w, int mask, const WindowPaintData &data) const;
     void updateBlurRegion(EffectWindow *w) const;
     void doBlur(const QRegion &shape, const QRect &screen, const float opacity, const QMatrix4x4 &screenProjection, bool isDock, QRect windowRect);
     void uploadRegion(QVector2D *&map, const QRegion &region, const int downSampleIterations);
     void uploadGeometry(GLVertexBuffer *vbo, const QRegion &blurRegion, const QRegion &windowRegion);
     void generateNoiseTexture();
 
     void upscaleRenderToScreen(GLVertexBuffer *vbo, int vboStart, int blurRectCount, QMatrix4x4 screenProjection, QPoint windowPosition);
     void downSampleTexture(GLVertexBuffer *vbo, int blurRectCount);
     void upSampleTexture(GLVertexBuffer *vbo, int blurRectCount);
     void copyScreenSampleTexture(GLVertexBuffer *vbo, int blurRectCount, QRegion blurShape, QMatrix4x4 screenProjection);
 
 private:
     BlurShader *m_shader;
     QVector <GLRenderTarget*> m_renderTargets;
     QVector <GLTexture> m_renderTextures;
     QStack <GLRenderTarget*> m_renderTargetStack;
 
     GLTexture m_noiseTexture;
 
     bool m_renderTargetsValid;
     long net_wm_blur_region;
     QRegion m_damagedArea; // keeps track of the area which has been damaged (from bottom to top)
     QRegion m_paintedArea; // actually painted area which is greater than m_damagedArea
     QRegion m_currentBlur; // keeps track of the currently blured area of the windows(from bottom to top)
 
     int m_downSampleIterations; // number of times the texture will be downsized to half size
     int m_offset;
     int m_expandSize;
     int m_noiseStrength;
     int m_scalingFactor;
 
     struct OffsetStruct {
         float minOffset;
         float maxOffset;
         int expandSize;
     };
 
     QVector <OffsetStruct> blurOffsets;
 
     struct BlurValuesStruct {
         int iteration;
         float offset;
     };
 
     QVector <BlurValuesStruct> blurStrengthValues;
 
     QMap <EffectWindow*, QMetaObject::Connection> windowBlurChangedConnections;
-    KWayland::Server::BlurManagerInterface *m_blurManager = nullptr;
+    KWaylandServer::BlurManagerInterface *m_blurManager = nullptr;
 };
 
 inline
 bool BlurEffect::provides(Effect::Feature feature)
 {
     if (feature == Blur) {
         return true;
     }
     return KWin::Effect::provides(feature);
 }
 
 
 } // namespace KWin
 
 #endif
 
diff --git a/effects/desktopgrid/desktopgrid.cpp b/effects/desktopgrid/desktopgrid.cpp
index 3f9343b82..ac6443204 100644
--- a/effects/desktopgrid/desktopgrid.cpp
+++ b/effects/desktopgrid/desktopgrid.cpp
@@ -1,1425 +1,1425 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2008 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2009 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "desktopgrid.h"
 // KConfigSkeleton
 #include "desktopgridconfig.h"
 
 #include "../presentwindows/presentwindows_proxy.h"
 #include "../effect_builtins.h"
 
 #include <QAction>
 #include <QApplication>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <netwm_def.h>
 #include <QEvent>
 #include <QMouseEvent>
 #include <QTimer>
 #include <QVector2D>
 #include <QMatrix4x4>
 
 #include <QQuickItem>
 #include <QQmlContext>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <cmath>
 
 namespace KWin
 {
 
 // WARNING, TODO: This effect relies on the desktop layout being EWMH-compliant.
 
 DesktopGridEffect::DesktopGridEffect()
     : activated(false)
     , timeline()
     , keyboardGrab(false)
     , wasWindowMove(false)
     , wasWindowCopy(false)
     , wasDesktopMove(false)
     , isValidMove(false)
     , windowMove(nullptr)
     , windowMoveDiff()
     , gridSize()
     , orientation(Qt::Horizontal)
     , activeCell(1, 1)
     , scale()
     , unscaledBorder()
     , scaledSize()
     , scaledOffset()
     , m_proxy(nullptr)
     , m_activateAction(new QAction(this))
 {
     initConfig<DesktopGridConfig>();
     // Load shortcuts
     QAction* a = m_activateAction;
     a->setObjectName(QStringLiteral("ShowDesktopGrid"));
     a->setText(i18n("Show Desktop Grid"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F8);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::CTRL + Qt::Key_F8);
     shortcut = KGlobalAccel::self()->shortcut(a);
     effects->registerGlobalShortcut(Qt::CTRL + Qt::Key_F8, a);
     effects->registerTouchpadSwipeShortcut(SwipeDirection::Up, a);
     connect(a, &QAction::triggered, this, &DesktopGridEffect::toggle);
     connect(KGlobalAccel::self(), &KGlobalAccel::globalShortcutChanged, this, &DesktopGridEffect::globalShortcutChanged);
     connect(effects, &EffectsHandler::windowAdded, this, &DesktopGridEffect::slotWindowAdded);
     connect(effects, &EffectsHandler::windowClosed, this, &DesktopGridEffect::slotWindowClosed);
     connect(effects, &EffectsHandler::windowDeleted, this, &DesktopGridEffect::slotWindowDeleted);
     connect(effects, &EffectsHandler::numberDesktopsChanged, this, &DesktopGridEffect::slotNumberDesktopsChanged);
     connect(effects, &EffectsHandler::windowFrameGeometryChanged, this, &DesktopGridEffect::slotWindowFrameGeometryChanged);
     connect(effects, &EffectsHandler::numberScreensChanged, this, &DesktopGridEffect::setup);
 
     connect(effects, &EffectsHandler::screenAboutToLock, this, [this]() {
         setActive(false);
         if (keyboardGrab) {
             effects->ungrabKeyboard();
             keyboardGrab = false;
         }
     });
 
     // Load all other configuration details
     reconfigure(ReconfigureAll);
 }
 
 DesktopGridEffect::~DesktopGridEffect()
 {
 }
 
 void DesktopGridEffect::reconfigure(ReconfigureFlags)
 {
     DesktopGridConfig::self()->read();
 
     foreach (ElectricBorder border, borderActivate) {
         effects->unreserveElectricBorder(border, this);
     }
     borderActivate.clear();
     foreach (int i, DesktopGridConfig::borderActivate()) {
         borderActivate.append(ElectricBorder(i));
         effects->reserveElectricBorder(ElectricBorder(i), this);
     }
 
     // TODO: rename zoomDuration to duration
     zoomDuration = animationTime(DesktopGridConfig::zoomDuration() != 0 ? DesktopGridConfig::zoomDuration() : 300);
     timeline.setCurveShape(QTimeLine::EaseInOutCurve);
     timeline.setDuration(zoomDuration);
 
     border = DesktopGridConfig::borderWidth();
     desktopNameAlignment = Qt::Alignment(DesktopGridConfig::desktopNameAlignment());
     layoutMode = DesktopGridConfig::layoutMode();
     customLayoutRows = DesktopGridConfig::customLayoutRows();
     m_usePresentWindows = DesktopGridConfig::presentWindows();
 
     // deactivate and activate all touch border
     const QVector<ElectricBorder> relevantBorders{ElectricLeft, ElectricTop, ElectricRight, ElectricBottom};
     for (auto e : relevantBorders) {
         effects->unregisterTouchBorder(e, m_activateAction);
     }
     const auto touchBorders = DesktopGridConfig::touchBorderActivate();
     for (int i : touchBorders) {
         if (!relevantBorders.contains(ElectricBorder(i))) {
             continue;
         }
         effects->registerTouchBorder(ElectricBorder(i), m_activateAction);
     }
 }
 
 //-----------------------------------------------------------------------------
 // Screen painting
 
 void DesktopGridEffect::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     if (timeline.currentValue() != 0 || activated || (isUsingPresentWindows() && isMotionManagerMovingWindows())) {
         if (activated)
             timeline.setCurrentTime(timeline.currentTime() + time);
         else
             timeline.setCurrentTime(timeline.currentTime() - time);
         for (int i = 0; i < effects->numberOfDesktops(); i++) {
             if (i == highlightedDesktop - 1)
                 hoverTimeline[i]->setCurrentTime(hoverTimeline[i]->currentTime() + time);
             else
                 hoverTimeline[i]->setCurrentTime(hoverTimeline[i]->currentTime() - time);
         }
         if (isUsingPresentWindows()) {
             QList<WindowMotionManager>::iterator i;
             for (i = m_managers.begin(); i != m_managers.end(); ++i)
                 (*i).calculate(time);
         }
         // PAINT_SCREEN_BACKGROUND_FIRST is needed because screen will be actually painted more than once,
         // so with normal screen painting second screen paint would erase parts of the first paint
         if (timeline.currentValue() != 0 || (isUsingPresentWindows() && isMotionManagerMovingWindows()))
             data.mask |= PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_BACKGROUND_FIRST;
         if (!activated && timeline.currentValue() == 0 && !(isUsingPresentWindows() && isMotionManagerMovingWindows()))
             finish();
     }
 
     for (auto const &w : effects->stackingOrder()) {
         w->setData(WindowForceBlurRole, QVariant(true));
     }
 
     effects->prePaintScreen(data, time);
 }
 
 void DesktopGridEffect::paintScreen(int mask, const QRegion &region, ScreenPaintData& data)
 {
     if (timeline.currentValue() == 0 && !isUsingPresentWindows()) {
         effects->paintScreen(mask, region, data);
         return;
     }
     for (int desktop = 1; desktop <= effects->numberOfDesktops(); desktop++) {
         ScreenPaintData d = data;
         paintingDesktop = desktop;
         effects->paintScreen(mask, region, d);
     }
 
     // paint the add desktop button
     for (EffectQuickScene *view : m_desktopButtons) {
         view->rootItem()->setOpacity(timeline.currentValue());
         effects->renderEffectQuickView(view);
     }
 
     if (isUsingPresentWindows() && windowMove && wasWindowMove) {
         // the moving window has to be painted on top of all desktops
         QPoint diff = cursorPos() - m_windowMoveStartPoint;
         QRect geo = m_windowMoveGeometry.translated(diff);
         WindowPaintData d(windowMove, data.projectionMatrix());
         d *= QVector2D((qreal)geo.width() / (qreal)windowMove->width(), (qreal)geo.height() / (qreal)windowMove->height());
         d += QPoint(geo.left() - windowMove->x(), geo.top() - windowMove->y());
         effects->drawWindow(windowMove, PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_LANCZOS, infiniteRegion(), d);
     }
 
     if (desktopNameAlignment) {
         for (int screen = 0; screen < effects->numScreens(); screen++) {
             QRect screenGeom = effects->clientArea(ScreenArea, screen, 0);
             int desktop = 1;
             foreach (EffectFrame * frame, desktopNames) {
                 QPointF posTL(scalePos(screenGeom.topLeft(), desktop, screen));
                 QPointF posBR(scalePos(screenGeom.bottomRight(), desktop, screen));
                 QRect textArea(posTL.x(), posTL.y(), posBR.x() - posTL.x(), posBR.y() - posTL.y());
                 textArea.adjust(textArea.width() / 10, textArea.height() / 10,
                                 -textArea.width() / 10, -textArea.height() / 10);
                 int x, y;
                 if (desktopNameAlignment & Qt::AlignLeft)
                     x = textArea.x();
                 else if (desktopNameAlignment & Qt::AlignRight)
                     x = textArea.right();
                 else
                     x = textArea.center().x();
                 if (desktopNameAlignment & Qt::AlignTop)
                     y = textArea.y();
                 else if (desktopNameAlignment & Qt::AlignBottom)
                     y = textArea.bottom();
                 else
                     y = textArea.center().y();
                 frame->setPosition(QPoint(x, y));
                 frame->render(region, timeline.currentValue(), 0.7);
                 ++desktop;
             }
         }
     }
 }
 
 void DesktopGridEffect::postPaintScreen()
 {
     if (activated ? timeline.currentValue() != 1 : timeline.currentValue() != 0)
         effects->addRepaintFull(); // Repaint during zoom
     if (isUsingPresentWindows() && isMotionManagerMovingWindows())
         effects->addRepaintFull();
     if (activated) {
         for (int i = 0; i < effects->numberOfDesktops(); i++) {
             if (hoverTimeline[i]->currentValue() != 0.0 && hoverTimeline[i]->currentValue() != 1.0) {
                 // Repaint during soft highlighting
                 effects->addRepaintFull();
                 break;
             }
         }
     }
 
     for (auto &w : effects->stackingOrder()) {
         w->setData(WindowForceBlurRole, QVariant());
     }
 
     effects->postPaintScreen();
 }
 
 //-----------------------------------------------------------------------------
 // Window painting
 
 void DesktopGridEffect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     if (timeline.currentValue() != 0 || (isUsingPresentWindows() && isMotionManagerMovingWindows())) {
         if (w->isOnDesktop(paintingDesktop)) {
             w->enablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
             if (w->isMinimized() && isUsingPresentWindows())
                 w->enablePainting(EffectWindow::PAINT_DISABLED_BY_MINIMIZE);
             data.mask |= PAINT_WINDOW_TRANSFORMED;
 
             // Split windows at screen edges
             for (int screen = 0; screen < effects->numScreens(); screen++) {
                 QRect screenGeom = effects->clientArea(ScreenArea, screen, 0);
                 if (w->x() < screenGeom.x())
                     data.quads = data.quads.splitAtX(screenGeom.x() - w->x());
                 if (w->x() + w->width() > screenGeom.x() + screenGeom.width())
                     data.quads = data.quads.splitAtX(screenGeom.x() + screenGeom.width() - w->x());
                 if (w->y() < screenGeom.y())
                     data.quads = data.quads.splitAtY(screenGeom.y() - w->y());
                 if (w->y() + w->height() > screenGeom.y() + screenGeom.height())
                     data.quads = data.quads.splitAtY(screenGeom.y() + screenGeom.height() - w->y());
             }
             if (windowMove && wasWindowMove && windowMove->findModal() == w)
                 w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
         } else
             w->disablePainting(EffectWindow::PAINT_DISABLED_BY_DESKTOP);
     }
     effects->prePaintWindow(w, data, time);
 }
 
 void DesktopGridEffect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
 {
     if (timeline.currentValue() != 0 || (isUsingPresentWindows() && isMotionManagerMovingWindows())) {
         if (isUsingPresentWindows() && w == windowMove && wasWindowMove &&
             ((!wasWindowCopy && sourceDesktop == paintingDesktop) ||
              (sourceDesktop != highlightedDesktop && highlightedDesktop == paintingDesktop))) {
             return; // will be painted on top of all other windows
         }
 
         qreal xScale = data.xScale();
         qreal yScale = data.yScale();
 
         data.multiplyBrightness(1.0 - (0.3 * (1.0 - hoverTimeline[paintingDesktop - 1]->currentValue())));
 
         for (int screen = 0; screen < effects->numScreens(); screen++) {
             QRect screenGeom = effects->clientArea(ScreenArea, screen, 0);
 
             QRectF transformedGeo = w->geometry();
             // Display all quads on the same screen on the same pass
             WindowQuadList screenQuads;
             bool quadsAdded = false;
             if (isUsingPresentWindows()) {
                 WindowMotionManager& manager = m_managers[(paintingDesktop-1)*(effects->numScreens())+screen ];
                 if (manager.isManaging(w)) {
                     foreach (const WindowQuad & quad, data.quads)
                         screenQuads.append(quad);
                     transformedGeo = manager.transformedGeometry(w);
                     quadsAdded = true;
                     if (!manager.areWindowsMoving() && timeline.currentValue() == 1.0)
                         mask |= PAINT_WINDOW_LANCZOS;
                 } else if (w->screen() != screen)
                     quadsAdded = true; // we don't want parts of overlapping windows on the other screen
                 if (w->isDesktop())
                     quadsAdded = false;
             }
             if (!quadsAdded) {
                 foreach (const WindowQuad & quad, data.quads) {
                     QRect quadRect(
                         w->x() + quad.left(), w->y() + quad.top(),
                         quad.right() - quad.left(), quad.bottom() - quad.top()
                     );
                     if (quadRect.intersects(screenGeom))
                         screenQuads.append(quad);
                 }
             }
             if (screenQuads.isEmpty())
                 continue; // Nothing is being displayed, don't bother
             WindowPaintData d = data;
             d.quads = screenQuads;
 
             QPointF newPos = scalePos(transformedGeo.topLeft().toPoint(), paintingDesktop, screen);
             double progress = timeline.currentValue();
             d.setXScale(interpolate(1, xScale * scale[screen] * (float)transformedGeo.width() / (float)w->geometry().width(), progress));
             d.setYScale(interpolate(1, yScale * scale[screen] * (float)transformedGeo.height() / (float)w->geometry().height(), progress));
             d += QPoint(qRound(newPos.x() - w->x()), qRound(newPos.y() - w->y()));
 
             if (isUsingPresentWindows() && (w->isDock() || w->isSkipSwitcher())) {
                 // fade out panels if present windows is used
                 d.multiplyOpacity((1.0 - timeline.currentValue()));
             }
             if (isUsingPresentWindows() && w->isMinimized()) {
                 d.multiplyOpacity(timeline.currentValue());
             }
 
             if (effects->compositingType() == XRenderCompositing) {
                 // More exact clipping as XRender displays the entire window instead of just the quad
                 QPointF screenPosF = scalePos(screenGeom.topLeft(), paintingDesktop).toPoint();
                 QPoint screenPos(
                     qRound(screenPosF.x()),
                     qRound(screenPosF.y())
                 );
                 QSize screenSize(
                     qRound(interpolate(screenGeom.width(), scaledSize[screen].width(), progress)),
                     qRound(interpolate(screenGeom.height(), scaledSize[screen].height(), progress))
                 );
                 PaintClipper pc(effects->clientArea(ScreenArea, screen, 0) & QRect(screenPos, screenSize));
                 effects->paintWindow(w, mask, region, d);
             } else {
                 if (w->isDesktop() && timeline.currentValue() == 1.0) {
                     // desktop windows are not in a motion manager and can always be rendered with
                     // lanczos sampling except for animations
                     mask |= PAINT_WINDOW_LANCZOS;
                 }
                 effects->paintWindow(w, mask, effects->clientArea(ScreenArea, screen, 0), d);
             }
         }
     } else
         effects->paintWindow(w, mask, region, data);
 }
 
 //-----------------------------------------------------------------------------
 // User interaction
 
 void DesktopGridEffect::slotWindowAdded(EffectWindow* w)
 {
     if (!activated)
         return;
     if (isUsingPresentWindows()) {
         if (!isRelevantWithPresentWindows(w))
             return; // don't add
         foreach (const int i, desktopList(w)) {
             WindowMotionManager& manager = m_managers[ i*effects->numScreens()+w->screen()];
             manager.manage(w);
             m_proxy->calculateWindowTransformations(manager.managedWindows(), w->screen(), manager);
         }
     }
     effects->addRepaintFull();
 }
 
 void DesktopGridEffect::slotWindowClosed(EffectWindow* w)
 {
     if (!activated && timeline.currentValue() == 0)
         return;
     if (w == windowMove) {
         effects->setElevatedWindow(windowMove, false);
         windowMove = nullptr;
     }
     if (isUsingPresentWindows()) {
         foreach (const int i, desktopList(w)) {
             WindowMotionManager& manager = m_managers[i*effects->numScreens()+w->screen()];
             manager.unmanage(w);
             m_proxy->calculateWindowTransformations(manager.managedWindows(), w->screen(), manager);
         }
     }
     effects->addRepaintFull();
 }
 
 void DesktopGridEffect::slotWindowDeleted(EffectWindow* w)
 {
     if (w == windowMove)
         windowMove = nullptr;
     if (isUsingPresentWindows()) {
         for (QList<WindowMotionManager>::iterator it = m_managers.begin(),
                                                  end = m_managers.end(); it != end; ++it) {
             it->unmanage(w);
         }
     }
 }
 
 void DesktopGridEffect::slotWindowFrameGeometryChanged(EffectWindow* w, const QRect& old)
 {
     Q_UNUSED(old)
     if (!activated)
         return;
     if (w == windowMove && wasWindowMove)
         return;
     if (isUsingPresentWindows()) {
         foreach (const int i, desktopList(w)) {
             WindowMotionManager& manager = m_managers[i*effects->numScreens()+w->screen()];
             m_proxy->calculateWindowTransformations(manager.managedWindows(), w->screen(), manager);
         }
     }
 }
 
 void DesktopGridEffect::windowInputMouseEvent(QEvent* e)
 {
     if ((e->type() != QEvent::MouseMove
             && e->type() != QEvent::MouseButtonPress
             && e->type() != QEvent::MouseButtonRelease)
             || timeline.currentValue() != 1)  // Block user input during animations
         return;
     QMouseEvent* me = static_cast< QMouseEvent* >(e);
     if (!(wasWindowMove || wasDesktopMove)) {
         for (EffectQuickScene *view : m_desktopButtons) {
             view->forwardMouseEvent(me);
             if (e->isAccepted()) {
                 return;
             }
         }
     }
 
     if (e->type() == QEvent::MouseMove) {
         int d = posToDesktop(me->pos());
         if (windowMove != nullptr &&
                 (me->pos() - dragStartPos).manhattanLength() > QApplication::startDragDistance()) {
             // Handle window moving
             if (!wasWindowMove) { // Activate on move
                 if (isUsingPresentWindows()) {
                     foreach (const int i, desktopList(windowMove)) {
                         WindowMotionManager& manager = m_managers[(i)*(effects->numScreens()) + windowMove->screen()];
                         if ((i + 1) == sourceDesktop) {
                             const QRectF transformedGeo = manager.transformedGeometry(windowMove);
                             const QPointF pos = scalePos(transformedGeo.topLeft().toPoint(), sourceDesktop, windowMove->screen());
                             const QSize size(scale[windowMove->screen()] *(float)transformedGeo.width(),
                                              scale[windowMove->screen()] *(float)transformedGeo.height());
                             m_windowMoveGeometry = QRect(pos.toPoint(), size);
                             m_windowMoveStartPoint = me->pos();
                         }
                         manager.unmanage(windowMove);
                         if (EffectWindow* modal = windowMove->findModal()) {
                             if (manager.isManaging(modal))
                                 manager.unmanage(modal);
                         }
                         m_proxy->calculateWindowTransformations(manager.managedWindows(), windowMove->screen(), manager);
                     }
                     wasWindowMove = true;
                 }
             }
             if (windowMove->isMovable() && !isUsingPresentWindows()) {
                 wasWindowMove = true;
                 int screen = effects->screenNumber(me->pos());
                 effects->moveWindow(windowMove, unscalePos(me->pos(), nullptr) + windowMoveDiff, true, 1.0 / scale[screen]);
             }
             if (wasWindowMove) {
                 if (effects->waylandDisplay() && (me->modifiers() & Qt::ControlModifier)) {
                     wasWindowCopy = true;
                     effects->defineCursor(Qt::DragCopyCursor);
                 } else {
                     wasWindowCopy = false;
                     effects->defineCursor(Qt::ClosedHandCursor);
                 }
                 if (d != highlightedDesktop) {
                     auto desktops = windowMove->desktops();
                     if (!desktops.contains(d)) {
                         desktops.append(d);
                     }
                     if (highlightedDesktop != sourceDesktop || !wasWindowCopy) {
                         desktops.removeOne(highlightedDesktop);
                     }
                     effects->windowToDesktops(windowMove, desktops);
                     const int screen = effects->screenNumber(me->pos());
                     if (screen != windowMove->screen())
                         effects->windowToScreen(windowMove, screen);
                 }
                 effects->addRepaintFull();
             }
         } else if ((me->buttons() & Qt::LeftButton) && !wasDesktopMove &&
                   (me->pos() - dragStartPos).manhattanLength() > QApplication::startDragDistance()) {
             wasDesktopMove = true;
             effects->defineCursor(Qt::ClosedHandCursor);
         }
         if (d != highlightedDesktop) { // Highlight desktop
             if ((me->buttons() & Qt::LeftButton) && isValidMove && !wasWindowMove && d <= effects->numberOfDesktops()) {
                 EffectWindowList windows = effects->stackingOrder();
                 EffectWindowList stack[3];
                 for (EffectWindowList::const_iterator it = windows.constBegin(),
                                                       end = windows.constEnd(); it != end; ++it) {
                     EffectWindow *w = const_cast<EffectWindow*>(*it); // we're not really touching it here but below
                     if (w->isOnAllDesktops())
                         continue;
                     if (w->isOnDesktop(highlightedDesktop))
                         stack[0] << w;
                     if (w->isOnDesktop(d))
                         stack[1] << w;
                     if (w->isOnDesktop(m_originalMovingDesktop))
                         stack[2] << w;
                 }
                 const int desks[4] = {highlightedDesktop, d, m_originalMovingDesktop, highlightedDesktop};
                 for (int i = 0; i < 3; ++i ) {
                     if (desks[i] == desks[i+1])
                         continue;
                     foreach (EffectWindow *w, stack[i]) {
                         auto desktops = w->desktops();
                         desktops.removeOne(desks[i]);
                         desktops.append(desks[i+1]);
                         effects->windowToDesktops(w, desktops);
 
                         if (isUsingPresentWindows()) {
                             m_managers[(desks[i]-1)*(effects->numScreens()) + w->screen()].unmanage(w);
                             m_managers[(desks[i+1]-1)*(effects->numScreens()) + w->screen()].manage(w);
                         }
                     }
                 }
                 if (isUsingPresentWindows()) {
                     for (int i = 0; i < effects->numScreens(); i++) {
                         for (int j = 0; j < 3; ++j) {
                             WindowMotionManager& manager = m_managers[(desks[j]-1)*(effects->numScreens()) + i ];
                             m_proxy->calculateWindowTransformations(manager.managedWindows(), i, manager);
                         }
                     }
                     effects->addRepaintFull();
                 }
             }
             setHighlightedDesktop(d);
         }
     }
     if (e->type() == QEvent::MouseButtonPress) {
         if (me->buttons() == Qt::LeftButton) {
             isValidMove = true;
             dragStartPos = me->pos();
             sourceDesktop = posToDesktop(me->pos());
             bool isDesktop = (me->modifiers() & Qt::ShiftModifier);
             EffectWindow* w = isDesktop ? nullptr : windowAt(me->pos());
             if (w != nullptr)
                 isDesktop = w->isDesktop();
             if (isDesktop)
                 m_originalMovingDesktop = posToDesktop(me->pos());
             else
                 m_originalMovingDesktop = 0;
             if (w != nullptr && !w->isDesktop() && (w->isMovable() || w->isMovableAcrossScreens() || isUsingPresentWindows())) {
                 // Prepare it for moving
                 windowMoveDiff = w->pos() - unscalePos(me->pos(), nullptr);
                 windowMove = w;
                 effects->setElevatedWindow(windowMove, true);
             }
         } else if ((me->buttons() == Qt::MidButton || me->buttons() == Qt::RightButton) && windowMove == nullptr) {
             EffectWindow* w = windowAt(me->pos());
             if (w && w->isDesktop()) {
                 w = nullptr;
             }
             if (w != nullptr) {
                 const int desktop = posToDesktop(me->pos());
                 if (w->isOnAllDesktops()) {
                     effects->windowToDesktop(w, desktop);
                 } else {
                     effects->windowToDesktop(w, NET::OnAllDesktops);
                 }
                 const bool isOnAllDesktops = w->isOnAllDesktops();
                 if (isUsingPresentWindows()) {
                     for (int i = 0; i < effects->numberOfDesktops(); i++) {
                         if (i != desktop - 1) {
                             WindowMotionManager& manager = m_managers[ i*effects->numScreens() + w->screen()];
                             if (isOnAllDesktops)
                                 manager.manage(w);
                             else
                                 manager.unmanage(w);
                             m_proxy->calculateWindowTransformations(manager.managedWindows(), w->screen(), manager);
                         }
                     }
                 }
                 effects->addRepaintFull();
             }
         }
     }
     if (e->type() == QEvent::MouseButtonRelease && me->button() == Qt::LeftButton) {
         isValidMove = false;
         if (windowMove)
             effects->activateWindow(windowMove);
         if (wasWindowMove || wasDesktopMove) { // reset pointer
             effects->defineCursor(Qt::PointingHandCursor);
         } else { // click -> exit
             const int desk = posToDesktop(me->pos());
             if (desk > effects->numberOfDesktops())
                 return; // don't quit when missing desktop
             setCurrentDesktop(desk);
             setActive(false);
         }
         if (windowMove) {
             if (wasWindowMove && isUsingPresentWindows()) {
                 const int targetDesktop = posToDesktop(cursorPos());
                 foreach (const int i, desktopList(windowMove)) {
                     WindowMotionManager& manager = m_managers[(i)*(effects->numScreens()) + windowMove->screen()];
                     manager.manage(windowMove);
                     if (EffectWindow* modal = windowMove->findModal())
                         manager.manage(modal);
                     if (i + 1 == targetDesktop) {
                         // for the desktop the window is dropped on, we use the current geometry
                         manager.setTransformedGeometry(windowMove, moveGeometryToDesktop(targetDesktop));
                     }
                     m_proxy->calculateWindowTransformations(manager.managedWindows(), windowMove->screen(), manager);
                 }
                 effects->addRepaintFull();
             }
             effects->setElevatedWindow(windowMove, false);
             windowMove = nullptr;
         }
         wasWindowMove = false;
         wasWindowCopy = false;
         wasDesktopMove = false;
     }
 }
 
 void DesktopGridEffect::grabbedKeyboardEvent(QKeyEvent* e)
 {
     if (timeline.currentValue() != 1)   // Block user input during animations
         return;
     if (windowMove != nullptr)
         return;
     if (e->type() == QEvent::KeyPress) {
         // check for global shortcuts
         // HACK: keyboard grab disables the global shortcuts so we have to check for global shortcut (bug 156155)
         if (shortcut.contains(e->key() + e->modifiers())) {
             toggle();
             return;
         }
 
         int desktop = -1;
         // switch by F<number> or just <number>
         if (e->key() >= Qt::Key_F1 && e->key() <= Qt::Key_F35)
             desktop = e->key() - Qt::Key_F1 + 1;
         else if (e->key() >= Qt::Key_0 && e->key() <= Qt::Key_9)
             desktop = e->key() == Qt::Key_0 ? 10 : e->key() - Qt::Key_0;
         if (desktop != -1) {
             if (desktop <= effects->numberOfDesktops()) {
                 setHighlightedDesktop(desktop);
                 setCurrentDesktop(desktop);
                 setActive(false);
             }
             return;
         }
         switch(e->key()) {
             // Wrap only on autorepeat
         case Qt::Key_Left:
             setHighlightedDesktop(desktopToLeft(highlightedDesktop, !e->isAutoRepeat()));
             break;
         case Qt::Key_Right:
             setHighlightedDesktop(desktopToRight(highlightedDesktop, !e->isAutoRepeat()));
             break;
         case Qt::Key_Up:
             setHighlightedDesktop(desktopUp(highlightedDesktop, !e->isAutoRepeat()));
             break;
         case Qt::Key_Down:
             setHighlightedDesktop(desktopDown(highlightedDesktop, !e->isAutoRepeat()));
             break;
         case Qt::Key_Escape:
             setActive(false);
             return;
         case Qt::Key_Enter:
         case Qt::Key_Return:
         case Qt::Key_Space:
             setCurrentDesktop(highlightedDesktop);
             setActive(false);
             return;
         case Qt::Key_Plus:
             slotAddDesktop();
             break;
         case Qt::Key_Minus:
             slotRemoveDesktop();
             break;
         default:
             break;
         }
     }
 }
 
 bool DesktopGridEffect::borderActivated(ElectricBorder border)
 {
     if (!borderActivate.contains(border))
         return false;
     if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)
         return true;
     toggle();
     return true;
 }
 
 //-----------------------------------------------------------------------------
 // Helper functions
 
 // Transform a point to its position on the scaled grid
 QPointF DesktopGridEffect::scalePos(const QPoint& pos, int desktop, int screen) const
 {
     if (screen == -1)
         screen = effects->screenNumber(pos);
     QRect screenGeom = effects->clientArea(ScreenArea, screen, 0);
     QPoint desktopCell;
     if (orientation == Qt::Horizontal) {
         desktopCell.setX((desktop - 1) % gridSize.width() + 1);
         desktopCell.setY((desktop - 1) / gridSize.width() + 1);
     } else {
         desktopCell.setX((desktop - 1) / gridSize.height() + 1);
         desktopCell.setY((desktop - 1) % gridSize.height() + 1);
     }
 
     double progress = timeline.currentValue();
     QPointF point(
         interpolate(
             (
                 (screenGeom.width() + unscaledBorder[screen]) *(desktopCell.x() - 1)
                 - (screenGeom.width() + unscaledBorder[screen]) *(activeCell.x() - 1)
             ) + pos.x(),
             (
                 (scaledSize[screen].width() + border) *(desktopCell.x() - 1)
                 + scaledOffset[screen].x()
                 + (pos.x() - screenGeom.x()) * scale[screen]
             ),
             progress),
         interpolate(
             (
                 (screenGeom.height() + unscaledBorder[screen]) *(desktopCell.y() - 1)
                 - (screenGeom.height() + unscaledBorder[screen]) *(activeCell.y() - 1)
             ) + pos.y(),
             (
                 (scaledSize[screen].height() + border) *(desktopCell.y() - 1)
                 + scaledOffset[screen].y()
                 + (pos.y() - screenGeom.y()) * scale[screen]
             ),
             progress)
     );
 
     return point;
 }
 
 // Detransform a point to its position on the full grid
 // TODO: Doesn't correctly interpolate (Final position is correct though), don't forget to copy to posToDesktop()
 QPoint DesktopGridEffect::unscalePos(const QPoint& pos, int* desktop) const
 {
     int screen = effects->screenNumber(pos);
     QRect screenGeom = effects->clientArea(ScreenArea, screen, 0);
 
     //double progress = timeline.currentValue();
     double scaledX = /*interpolate(
         ( pos.x() - screenGeom.x() + unscaledBorder[screen] / 2.0 ) / ( screenGeom.width() + unscaledBorder[screen] ) + activeCell.x() - 1,*/
         (pos.x() - scaledOffset[screen].x() + double(border) / 2.0) / (scaledSize[screen].width() + border)/*,
         progress )*/;
     double scaledY = /*interpolate(
         ( pos.y() - screenGeom.y() + unscaledBorder[screen] / 2.0 ) / ( screenGeom.height() + unscaledBorder[screen] ) + activeCell.y() - 1,*/
         (pos.y() - scaledOffset[screen].y() + double(border) / 2.0) / (scaledSize[screen].height() + border)/*,
         progress )*/;
     int gx = qBound(0, int(scaledX), gridSize.width() - 1);     // Zero-based
     int gy = qBound(0, int(scaledY), gridSize.height() - 1);
     scaledX -= gx;
     scaledY -= gy;
     if (desktop != nullptr) {
         if (orientation == Qt::Horizontal)
             *desktop = gy * gridSize.width() + gx + 1;
         else
             *desktop = gx * gridSize.height() + gy + 1;
     }
 
     return QPoint(
                qBound(
                    screenGeom.x(),
                    qRound(
                        scaledX * (screenGeom.width() + unscaledBorder[screen])
                        - unscaledBorder[screen] / 2.0
                        + screenGeom.x()
                    ),
                    screenGeom.right()
                ),
                qBound(
                    screenGeom.y(),
                    qRound(
                        scaledY * (screenGeom.height() + unscaledBorder[screen])
                        - unscaledBorder[screen] / 2.0
                        + screenGeom.y()
                    ),
                    screenGeom.bottom()
                )
            );
 }
 
 int DesktopGridEffect::posToDesktop(const QPoint& pos) const
 {
     // Copied from unscalePos()
     int screen = effects->screenNumber(pos);
 
     double scaledX = (pos.x() - scaledOffset[screen].x() + double(border) / 2.0) / (scaledSize[screen].width() + border);
     double scaledY = (pos.y() - scaledOffset[screen].y() + double(border) / 2.0) / (scaledSize[screen].height() + border);
     int gx = qBound(0, int(scaledX), gridSize.width() - 1);     // Zero-based
     int gy = qBound(0, int(scaledY), gridSize.height() - 1);
     if (orientation == Qt::Horizontal)
         return gy * gridSize.width() + gx + 1;
     return gx * gridSize.height() + gy + 1;
 }
 
 EffectWindow* DesktopGridEffect::windowAt(QPoint pos) const
 {
     // Get stacking order top first
     EffectWindowList windows = effects->stackingOrder();
     EffectWindowList::Iterator begin = windows.begin();
     EffectWindowList::Iterator end = windows.end();
     --end;
     while (begin < end)
         qSwap(*begin++, *end--);
 
     int desktop;
     pos = unscalePos(pos, &desktop);
     if (desktop > effects->numberOfDesktops())
         return nullptr;
     if (isUsingPresentWindows()) {
         const int screen = effects->screenNumber(pos);
         EffectWindow *w =
             m_managers.at((desktop - 1) * (effects->numScreens()) + screen).windowAtPoint(pos, false);
         if (w)
             return w;
         foreach (EffectWindow * w, windows) {
             if (w->isOnDesktop(desktop) && w->isDesktop() && w->geometry().contains(pos))
                 return w;
         }
     } else {
         foreach (EffectWindow * w, windows) {
             if (w->isOnDesktop(desktop) && w->isOnCurrentActivity() && !w->isMinimized() && w->geometry().contains(pos))
                 return w;
         }
     }
     return nullptr;
 }
 
 void DesktopGridEffect::setCurrentDesktop(int desktop)
 {
     if (orientation == Qt::Horizontal) {
         activeCell.setX((desktop - 1) % gridSize.width() + 1);
         activeCell.setY((desktop - 1) / gridSize.width() + 1);
     } else {
         activeCell.setX((desktop - 1) / gridSize.height() + 1);
         activeCell.setY((desktop - 1) % gridSize.height() + 1);
     }
     if (effects->currentDesktop() != desktop)
         effects->setCurrentDesktop(desktop);
 }
 
 void DesktopGridEffect::setHighlightedDesktop(int d)
 {
     if (d == highlightedDesktop || d <= 0 || d > effects->numberOfDesktops())
         return;
     if (highlightedDesktop > 0 && highlightedDesktop <= hoverTimeline.count())
         hoverTimeline[highlightedDesktop-1]->setCurrentTime(qMin(hoverTimeline[highlightedDesktop-1]->currentTime(),
                                                                  hoverTimeline[highlightedDesktop-1]->duration()));
     highlightedDesktop = d;
     if (highlightedDesktop <= hoverTimeline.count())
         hoverTimeline[highlightedDesktop-1]->setCurrentTime(qMax(hoverTimeline[highlightedDesktop-1]->currentTime(), 0));
     effects->addRepaintFull();
 }
 
 int DesktopGridEffect::desktopToRight(int desktop, bool wrap) const
 {
     // Copied from Workspace::desktopToRight()
     int dt = desktop - 1;
     if (orientation == Qt::Vertical) {
         dt += gridSize.height();
         if (dt >= effects->numberOfDesktops()) {
             if (wrap)
                 dt -= effects->numberOfDesktops();
             else
                 return desktop;
         }
     } else {
         int d = (dt % gridSize.width()) + 1;
         if (d >= gridSize.width()) {
             if (wrap)
                 d -= gridSize.width();
             else
                 return desktop;
         }
         dt = dt - (dt % gridSize.width()) + d;
     }
     return dt + 1;
 }
 
 int DesktopGridEffect::desktopToLeft(int desktop, bool wrap) const
 {
     // Copied from Workspace::desktopToLeft()
     int dt = desktop - 1;
     if (orientation == Qt::Vertical) {
         dt -= gridSize.height();
         if (dt < 0) {
             if (wrap)
                 dt += effects->numberOfDesktops();
             else
                 return desktop;
         }
     } else {
         int d = (dt % gridSize.width()) - 1;
         if (d < 0) {
             if (wrap)
                 d += gridSize.width();
             else
                 return desktop;
         }
         dt = dt - (dt % gridSize.width()) + d;
     }
     return dt + 1;
 }
 
 int DesktopGridEffect::desktopUp(int desktop, bool wrap) const
 {
     // Copied from Workspace::desktopUp()
     int dt = desktop - 1;
     if (orientation == Qt::Horizontal) {
         dt -= gridSize.width();
         if (dt < 0) {
             if (wrap)
                 dt += effects->numberOfDesktops();
             else
                 return desktop;
         }
     } else {
         int d = (dt % gridSize.height()) - 1;
         if (d < 0) {
             if (wrap)
                 d += gridSize.height();
             else
                 return desktop;
         }
         dt = dt - (dt % gridSize.height()) + d;
     }
     return dt + 1;
 }
 
 int DesktopGridEffect::desktopDown(int desktop, bool wrap) const
 {
     // Copied from Workspace::desktopDown()
     int dt = desktop - 1;
     if (orientation == Qt::Horizontal) {
         dt += gridSize.width();
         if (dt >= effects->numberOfDesktops()) {
             if (wrap)
                 dt -= effects->numberOfDesktops();
             else
                 return desktop;
         }
     } else {
         int d = (dt % gridSize.height()) + 1;
         if (d >= gridSize.height()) {
             if (wrap)
                 d -= gridSize.height();
             else
                 return desktop;
         }
         dt = dt - (dt % gridSize.height()) + d;
     }
     return dt + 1;
 }
 
 //-----------------------------------------------------------------------------
 // Activation
 
 void DesktopGridEffect::toggle()
 {
     setActive(!activated);
 }
 
 void DesktopGridEffect::setActive(bool active)
 {
     if (effects->activeFullScreenEffect() && effects->activeFullScreenEffect() != this)
         return; // Only one fullscreen effect at a time thanks
     if (active && isMotionManagerMovingWindows())
         return; // Still moving windows from last usage - don't activate
     if (activated == active)
         return; // Already in that state
 
     activated = active;
     if (activated) {
         effects->setShowingDesktop(false);
         if (timeline.currentValue() == 0)
             setup();
     } else {
         if (isUsingPresentWindows()) {
             QList<WindowMotionManager>::iterator it;
             for (it = m_managers.begin(); it != m_managers.end(); ++it) {
                 foreach (EffectWindow * w, (*it).managedWindows()) {
                     (*it).moveWindow(w, w->geometry());
                 }
             }
         }
         QTimer::singleShot(zoomDuration + 1, this,
             [this] {
                 if (activated)
                     return;
                 for (EffectQuickScene *view : m_desktopButtons) {
                     view->hide();
                 }
             }
         );
         setHighlightedDesktop(effects->currentDesktop());   // Ensure selected desktop is highlighted
     }
     effects->addRepaintFull();
 }
 
 void DesktopGridEffect::setup()
 {
     if (!isActive())
         return;
     if (!keyboardGrab) {
         keyboardGrab = effects->grabKeyboard(this);
         effects->startMouseInterception(this, Qt::PointingHandCursor);
         effects->setActiveFullScreenEffect(this);
     }
     setHighlightedDesktop(effects->currentDesktop());
 
     // Soft highlighting
     qDeleteAll(hoverTimeline);
     hoverTimeline.clear();
     for (int i = 0; i < effects->numberOfDesktops(); i++) {
         QTimeLine *newTimeline = new QTimeLine(zoomDuration, this);
         newTimeline->setCurveShape(QTimeLine::EaseInOutCurve);
         hoverTimeline.append(newTimeline);
     }
     hoverTimeline[effects->currentDesktop() - 1]->setCurrentTime(hoverTimeline[effects->currentDesktop() - 1]->duration());
 
     // Create desktop name textures if enabled
     if (desktopNameAlignment) {
         QFont font;
         font.setBold(true);
         font.setPointSize(12);
         for (int i = 0; i < effects->numberOfDesktops(); i++) {
             EffectFrame* frame = effects->effectFrame(EffectFrameUnstyled, false);
             frame->setFont(font);
             frame->setText(effects->desktopName(i + 1));
             frame->setAlignment(desktopNameAlignment);
             desktopNames.append(frame);
         }
     }
     setupGrid();
     setCurrentDesktop(effects->currentDesktop());
 
     // setup the motion managers
     if (m_usePresentWindows)
         m_proxy = static_cast<PresentWindowsEffectProxy*>(effects->getProxy(BuiltInEffects::nameForEffect(BuiltInEffect::PresentWindows)));
     if (isUsingPresentWindows()) {
         m_proxy->reCreateGrids(); // revalidation on multiscreen, bug #351724
         for (int i = 1; i <= effects->numberOfDesktops(); i++) {
             for (int j = 0; j < effects->numScreens(); j++) {
                 WindowMotionManager manager;
                 foreach (EffectWindow * w, effects->stackingOrder()) {
                     if (w->isOnDesktop(i) && w->screen() == j &&isRelevantWithPresentWindows(w)) {
                         manager.manage(w);
                     }
                 }
                 m_proxy->calculateWindowTransformations(manager.managedWindows(), j, manager);
                 m_managers.append(manager);
             }
         }
     }
 
     auto it = m_desktopButtons.begin();
     const int n = DesktopGridConfig::showAddRemove() ? effects->numScreens() : 0;
     for (int i = 0; i < n; ++i) {
         EffectQuickScene *view;
         QSize size;
         if (it == m_desktopButtons.end()) {
             view = new EffectQuickScene(this);
 
             connect(view, &EffectQuickView::repaintNeeded, this, []() {
                 effects->addRepaintFull();
             });
 
             view->rootContext()->setContextProperty("effects", effects);
             view->setSource(QUrl(QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("kwin/effects/desktopgrid/main.qml"))));
 
             QQuickItem *rootItem = view->rootItem();
             if (!rootItem) {
                 delete view;
                 continue;
             }
 
             m_desktopButtons.append(view);
             it = m_desktopButtons.end(); // changed through insert!
 
             size = QSize(rootItem->implicitWidth(), rootItem->implicitHeight());
         } else {
             view = *it;
             ++it;
             size = view->size();
         }
         const QRect screenRect = effects->clientArea(FullScreenArea, i, 1);
         view->show(); // pseudo show must happen before geometry changes
         const QPoint position(screenRect.right() - border/3 - size.width(),
                               screenRect.bottom() - border/3 - size.height());
         view->setGeometry(QRect(position, size));
     }
     while (it != m_desktopButtons.end()) {
         (*it)->deleteLater();
         it = m_desktopButtons.erase(it);
     }
 }
 
 void DesktopGridEffect::setupGrid()
 {
     // We need these variables for every paint so lets cache them
     int x, y;
     int numDesktops = effects->numberOfDesktops();
     switch(layoutMode) {
     default:
     case LayoutPager:
         orientation = Qt::Horizontal;
         gridSize = effects->desktopGridSize();
         // sanity check: pager may report incorrect size in case of one desktop
         if (numDesktops == 1) {
             gridSize = QSize(1, 1);
         }
         break;
     case LayoutAutomatic:
         y = sqrt(float(numDesktops)) + 0.5;
         x = float(numDesktops) / float(y) + 0.5;
         if (x * y < numDesktops)
             x++;
         orientation = Qt::Horizontal;
         gridSize.setWidth(x);
         gridSize.setHeight(y);
         break;
     case LayoutCustom:
         orientation = Qt::Horizontal;
         gridSize.setWidth(ceil(effects->numberOfDesktops() / double(customLayoutRows)));
         gridSize.setHeight(customLayoutRows);
         break;
     }
     scale.clear();
     unscaledBorder.clear();
     scaledSize.clear();
     scaledOffset.clear();
     for (int i = 0; i < effects->numScreens(); i++) {
         QRect geom = effects->clientArea(ScreenArea, i, 0);
         double sScale;
         if (gridSize.width() > gridSize.height())
             sScale = (geom.width() - border * (gridSize.width() + 1)) / double(geom.width() * gridSize.width());
         else
             sScale = (geom.height() - border * (gridSize.height() + 1)) / double(geom.height() * gridSize.height());
         double sBorder = border / sScale;
         QSizeF size(
             double(geom.width()) * sScale,
             double(geom.height()) * sScale
         );
         QPointF offset(
             geom.x() + (geom.width() - size.width() * gridSize.width() - border *(gridSize.width() - 1)) / 2.0,
             geom.y() + (geom.height() - size.height() * gridSize.height() - border *(gridSize.height() - 1)) / 2.0
         );
         scale.append(sScale);
         unscaledBorder.append(sBorder);
         scaledSize.append(size);
         scaledOffset.append(offset);
     }
 }
 
 void DesktopGridEffect::finish()
 {
     if (desktopNameAlignment) {
         qDeleteAll(desktopNames);
         desktopNames.clear();
     }
 
     if (keyboardGrab)
         effects->ungrabKeyboard();
     keyboardGrab = false;
     effects->stopMouseInterception(this);
     effects->setActiveFullScreenEffect(nullptr);
     if (isUsingPresentWindows()) {
         while (!m_managers.isEmpty()) {
             m_managers.first().unmanageAll();
             m_managers.removeFirst();
         }
         m_proxy = nullptr;
     }
 }
 
 void DesktopGridEffect::globalShortcutChanged(QAction *action, const QKeySequence& seq)
 {
     if (action->objectName() != QStringLiteral("ShowDesktopGrid")) {
         return;
     }
     shortcut.clear();
     shortcut.append(seq);
 }
 
 bool DesktopGridEffect::isMotionManagerMovingWindows() const
 {
     if (isUsingPresentWindows()) {
         QList<WindowMotionManager>::const_iterator it;
         for (it = m_managers.begin(); it != m_managers.end(); ++it) {
             if ((*it).areWindowsMoving())
                 return true;
         }
     }
     return false;
 }
 
 bool DesktopGridEffect::isUsingPresentWindows() const
 {
     return (m_proxy != nullptr);
 }
 
 // transforms the geometry of the moved window to a geometry on the desktop
 // internal method only used when a window is dropped onto a desktop
 QRectF DesktopGridEffect::moveGeometryToDesktop(int desktop) const
 {
     QPointF point = unscalePos(m_windowMoveGeometry.topLeft() + cursorPos() - m_windowMoveStartPoint);
     const double scaleFactor = scale[ windowMove->screen()];
     if (posToDesktop(m_windowMoveGeometry.topLeft() + cursorPos() - m_windowMoveStartPoint) != desktop) {
         // topLeft is not on the desktop - check other corners
         // if all corners are not on the desktop the window is bigger than the desktop - no matter what it will look strange
         if (posToDesktop(m_windowMoveGeometry.topRight() + cursorPos() - m_windowMoveStartPoint) == desktop) {
             point = unscalePos(m_windowMoveGeometry.topRight() + cursorPos() - m_windowMoveStartPoint) -
                     QPointF(m_windowMoveGeometry.width(), 0) / scaleFactor;
         } else if (posToDesktop(m_windowMoveGeometry.bottomLeft() + cursorPos() - m_windowMoveStartPoint) == desktop) {
             point = unscalePos(m_windowMoveGeometry.bottomLeft() + cursorPos() - m_windowMoveStartPoint) -
                     QPointF(0, m_windowMoveGeometry.height()) / scaleFactor;
         } else if (posToDesktop(m_windowMoveGeometry.bottomRight() + cursorPos() - m_windowMoveStartPoint) == desktop) {
             point = unscalePos(m_windowMoveGeometry.bottomRight() + cursorPos() - m_windowMoveStartPoint) -
                     QPointF(m_windowMoveGeometry.width(), m_windowMoveGeometry.height()) / scaleFactor;
         }
     }
     return QRectF(point, m_windowMoveGeometry.size() / scaleFactor);
 }
 
 void DesktopGridEffect::slotAddDesktop()
 {
     effects->setNumberOfDesktops(effects->numberOfDesktops() + 1);
 }
 
 void DesktopGridEffect::slotRemoveDesktop()
 {
     effects->setNumberOfDesktops(effects->numberOfDesktops() - 1);
 }
 
 void DesktopGridEffect::slotNumberDesktopsChanged(uint old)
 {
     if (!activated)
         return;
     const uint desktop = effects->numberOfDesktops();
     if (old < desktop)
         desktopsAdded(old);
     else
         desktopsRemoved(old);
 }
 
 void DesktopGridEffect::desktopsAdded(int old)
 {
     const int desktop = effects->numberOfDesktops();
     for (int i = old; i <= effects->numberOfDesktops(); i++) {
         // add a timeline for the new desktop
         QTimeLine *newTimeline = new QTimeLine(zoomDuration, this);
         newTimeline->setCurveShape(QTimeLine::EaseInOutCurve);
         hoverTimeline.append(newTimeline);
     }
 
     // Create desktop name textures if enabled
     if (desktopNameAlignment) {
         QFont font;
         font.setBold(true);
         font.setPointSize(12);
         for (int i = old; i < desktop; i++) {
             EffectFrame* frame = effects->effectFrame(EffectFrameUnstyled, false);
             frame->setFont(font);
             frame->setText(effects->desktopName(i + 1));
             frame->setAlignment(desktopNameAlignment);
             desktopNames.append(frame);
         }
     }
 
     if (isUsingPresentWindows()) {
         for (int i = old+1; i <= effects->numberOfDesktops(); ++i) {
             for (int j = 0; j < effects->numScreens(); ++j) {
                 WindowMotionManager manager;
                 foreach (EffectWindow * w, effects->stackingOrder()) {
                     if (w->isOnDesktop(i) && w->screen() == j &&isRelevantWithPresentWindows(w)) {
                         manager.manage(w);
                     }
                 }
                 m_proxy->calculateWindowTransformations(manager.managedWindows(), j, manager);
                 m_managers.append(manager);
             }
         }
     }
 
     setupGrid();
 
     // and repaint
     effects->addRepaintFull();
 }
 
 void DesktopGridEffect::desktopsRemoved(int old)
 {
     const int desktop = effects->numberOfDesktops();
     for (int i = desktop; i < old; i++) {
         delete hoverTimeline.takeLast();
         if (desktopNameAlignment) {
             delete desktopNames.last();
             desktopNames.removeLast();
         }
         if (isUsingPresentWindows()) {
             for (int j = 0; j < effects->numScreens(); ++j) {
                 WindowMotionManager& manager = m_managers.last();
                 manager.unmanageAll();
                 m_managers.removeLast();
             }
         }
     }
     // add removed windows to the last desktop
     if (isUsingPresentWindows()) {
         for (int j = 0; j < effects->numScreens(); ++j) {
             WindowMotionManager& manager = m_managers[(desktop-1)*(effects->numScreens())+j ];
             foreach (EffectWindow * w, effects->stackingOrder()) {
                 if (manager.isManaging(w))
                     continue;
                 if (w->isOnDesktop(desktop) && w->screen() == j && isRelevantWithPresentWindows(w)) {
                     manager.manage(w);
                 }
             }
             m_proxy->calculateWindowTransformations(manager.managedWindows(), j, manager);
         }
     }
 
     setupGrid();
 
     // and repaint
     effects->addRepaintFull();
 }
 //TODO: kill this function? or at least keep a consistent numeration with desktops starting from 1
 QVector<int> DesktopGridEffect::desktopList(const EffectWindow *w) const
 {
     if (w->isOnAllDesktops()) {
         static QVector<int> allDesktops;
         if (allDesktops.count() != effects->numberOfDesktops()) {
             allDesktops.resize(effects->numberOfDesktops());
             for (int i = 0; i < effects->numberOfDesktops(); ++i)
                 allDesktops[i] = i;
         }
         return allDesktops;
     }
 
     QVector<int> desks;
     desks.resize(w->desktops().count());
     int i = 0;
     for (const int desk : w->desktops()) {
         desks[i++] = desk-1;
     }
     return desks;
 }
 
 bool DesktopGridEffect::isActive() const
 {
     return (timeline.currentValue() != 0 || activated || (isUsingPresentWindows() && isMotionManagerMovingWindows())) && !effects->isScreenLocked();
 }
 
 bool DesktopGridEffect::isRelevantWithPresentWindows(EffectWindow *w) const
 {
     if (w->isSpecialWindow() || w->isUtility()) {
         return false;
     }
 
     if (w->isSkipSwitcher()) {
         return false;
     }
 
     if (w->isDeleted()) {
         return false;
     }
 
     if (!w->acceptsFocus()) {
         return false;
     }
 
     if (!w->isOnCurrentActivity()) {
         return false;
     }
 
     return true;
 }
 
 } // namespace
 
diff --git a/effects/slidingpopups/slidingpopups.cpp b/effects/slidingpopups/slidingpopups.cpp
index fc66b4925..1e3b5fd59 100644
--- a/effects/slidingpopups/slidingpopups.cpp
+++ b/effects/slidingpopups/slidingpopups.cpp
@@ -1,544 +1,544 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Marco Martin notmart@gmail.com
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "slidingpopups.h"
 #include "slidingpopupsconfig.h"
 
 #include <QApplication>
 #include <QFontMetrics>
 #include <QWindow>
 
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/slide_interface.h>
-#include <KWayland/Server/display.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/slide_interface.h>
+#include <KWaylandServer/display.h>
 
 #include <KWindowEffects>
 
 Q_DECLARE_METATYPE(KWindowEffects::SlideFromLocation)
 
 namespace KWin
 {
 
 SlidingPopupsEffect::SlidingPopupsEffect()
 {
     initConfig<SlidingPopupsConfig>();
-    KWayland::Server::Display *display = effects->waylandDisplay();
+    KWaylandServer::Display *display = effects->waylandDisplay();
     if (display) {
         display->createSlideManager(this)->create();
     }
 
     m_slideLength = QFontMetrics(qApp->font()).height() * 8;
 
     m_atom = effects->announceSupportProperty("_KDE_SLIDE", this);
     connect(effects, &EffectsHandler::windowAdded, this, &SlidingPopupsEffect::slotWindowAdded);
     connect(effects, &EffectsHandler::windowClosed, this, &SlidingPopupsEffect::slideOut);
     connect(effects, &EffectsHandler::windowDeleted, this, &SlidingPopupsEffect::slotWindowDeleted);
     connect(effects, &EffectsHandler::propertyNotify, this, &SlidingPopupsEffect::slotPropertyNotify);
     connect(effects, &EffectsHandler::windowShown, this, &SlidingPopupsEffect::slideIn);
     connect(effects, &EffectsHandler::windowHidden, this, &SlidingPopupsEffect::slideOut);
     connect(effects, &EffectsHandler::xcbConnectionChanged, this,
         [this] {
             m_atom = effects->announceSupportProperty(QByteArrayLiteral("_KDE_SLIDE"), this);
         }
     );
     connect(effects, qOverload<int, int, EffectWindow *>(&EffectsHandler::desktopChanged),
             this, &SlidingPopupsEffect::stopAnimations);
     connect(effects, &EffectsHandler::activeFullScreenEffectChanged,
             this, &SlidingPopupsEffect::stopAnimations);
 
     reconfigure(ReconfigureAll);
 }
 
 SlidingPopupsEffect::~SlidingPopupsEffect()
 {
 }
 
 bool SlidingPopupsEffect::supported()
 {
      return effects->animationsSupported();
 }
 
 void SlidingPopupsEffect::reconfigure(ReconfigureFlags flags)
 {
     Q_UNUSED(flags)
     SlidingPopupsConfig::self()->read();
     m_slideInDuration = std::chrono::milliseconds(
         static_cast<int>(animationTime(SlidingPopupsConfig::slideInTime() != 0 ? SlidingPopupsConfig::slideInTime() : 150)));
     m_slideOutDuration = std::chrono::milliseconds(
         static_cast<int>(animationTime(SlidingPopupsConfig::slideOutTime() != 0 ? SlidingPopupsConfig::slideOutTime() : 250)));
 
     auto animationIt = m_animations.begin();
     while (animationIt != m_animations.end()) {
         const auto duration = ((*animationIt).kind == AnimationKind::In)
             ? m_slideInDuration
             : m_slideOutDuration;
         (*animationIt).timeLine.setDuration(duration);
         ++animationIt;
     }
 
     auto dataIt = m_animationsData.begin();
     while (dataIt != m_animationsData.end()) {
         (*dataIt).slideInDuration = m_slideInDuration;
         (*dataIt).slideOutDuration = m_slideOutDuration;
         ++dataIt;
     }
 }
 
 void SlidingPopupsEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, int time)
 {
     auto animationIt = m_animations.find(w);
     if (animationIt == m_animations.end()) {
         effects->prePaintWindow(w, data, time);
         return;
     }
 
     (*animationIt).timeLine.update(std::chrono::milliseconds(time));
     data.setTransformed();
     w->enablePainting(EffectWindow::PAINT_DISABLED | EffectWindow::PAINT_DISABLED_BY_DELETE);
 
     effects->prePaintWindow(w, data, time);
 }
 
 void SlidingPopupsEffect::paintWindow(EffectWindow *w, int mask, QRegion region, WindowPaintData &data)
 {
     auto animationIt = m_animations.constFind(w);
     if (animationIt == m_animations.constEnd()) {
         effects->paintWindow(w, mask, region, data);
         return;
     }
 
     const AnimationData &animData = m_animationsData[w];
     const int slideLength = (animData.slideLength > 0) ? animData.slideLength : m_slideLength;
 
     const QRect screenRect = effects->clientArea(FullScreenArea, w->screen(), effects->currentDesktop());
     int splitPoint = 0;
     const QRect geo = w->expandedGeometry();
     const qreal t = (*animationIt).timeLine.value();
 
     switch (animData.location) {
     case Location::Left:
         if (slideLength < geo.width()) {
             data.multiplyOpacity(t);
         }
         data.translate(-interpolate(qMin(geo.width(), slideLength), 0.0, t));
         splitPoint = geo.width() - (geo.x() + geo.width() - screenRect.x() - animData.offset);
         region = QRegion(geo.x() + splitPoint, geo.y(), geo.width() - splitPoint, geo.height());
         break;
     case Location::Top:
         if (slideLength < geo.height()) {
             data.multiplyOpacity(t);
         }
         data.translate(0.0, -interpolate(qMin(geo.height(), slideLength), 0.0, t));
         splitPoint = geo.height() - (geo.y() + geo.height() - screenRect.y() - animData.offset);
         region = QRegion(geo.x(), geo.y() + splitPoint, geo.width(), geo.height() - splitPoint);
         break;
     case Location::Right:
         if (slideLength < geo.width()) {
             data.multiplyOpacity(t);
         }
         data.translate(interpolate(qMin(geo.width(), slideLength), 0.0, t));
         splitPoint = screenRect.x() + screenRect.width() - geo.x() - animData.offset;
         region = QRegion(geo.x(), geo.y(), splitPoint, geo.height());
         break;
     case Location::Bottom:
     default:
         if (slideLength < geo.height()) {
             data.multiplyOpacity(t);
         }
         data.translate(0.0, interpolate(qMin(geo.height(), slideLength), 0.0, t));
         splitPoint = screenRect.y() + screenRect.height() - geo.y() - animData.offset;
         region = QRegion(geo.x(), geo.y(), geo.width(), splitPoint);
     }
 
     effects->paintWindow(w, mask, region, data);
 }
 
 void SlidingPopupsEffect::postPaintWindow(EffectWindow *w)
 {
     auto animationIt = m_animations.find(w);
     if (animationIt != m_animations.end()) {
         if ((*animationIt).timeLine.done()) {
             if (w->isDeleted()) {
                 w->unrefWindow();
             } else {
                 w->setData(WindowForceBackgroundContrastRole, QVariant());
                 w->setData(WindowForceBlurRole, QVariant());
             }
             m_animations.erase(animationIt);
         }
         w->addRepaintFull();
     }
 
     effects->postPaintWindow(w);
 }
 
 void SlidingPopupsEffect::slotWindowAdded(EffectWindow *w)
 {
     //X11
     if (m_atom != XCB_ATOM_NONE) {
         slotPropertyNotify(w, m_atom);
     }
 
     //Wayland
     if (auto surf = w->surface()) {
         slotWaylandSlideOnShowChanged(w);
-        connect(surf, &KWayland::Server::SurfaceInterface::slideOnShowHideChanged, this, [this, surf] {
+        connect(surf, &KWaylandServer::SurfaceInterface::slideOnShowHideChanged, this, [this, surf] {
             slotWaylandSlideOnShowChanged(effects->findWindow(surf));
         });
     }
 
     if (auto internal = w->internalWindow()) {
         internal->installEventFilter(this);
         setupInternalWindowSlide(w);
     }
 
     slideIn(w);
 }
 
 void SlidingPopupsEffect::slotWindowDeleted(EffectWindow *w)
 {
     m_animations.remove(w);
     m_animationsData.remove(w);
 }
 
 void SlidingPopupsEffect::slotPropertyNotify(EffectWindow *w, long atom)
 {
     if (!w || atom != m_atom || m_atom == XCB_ATOM_NONE) {
         return;
     }
 
     // _KDE_SLIDE atom format(each field is an uint32_t):
     // <offset> <location> [<slide in duration>] [<slide out duration>] [<slide length>]
     //
     // If offset is equal to -1, this effect will decide what offset to use
     // given edge of the screen, from which the window has to slide.
     //
     // If slide in duration is equal to 0 milliseconds, the default slide in
     // duration will be used. Same with the slide out duration.
     //
     // NOTE: If only slide in duration has been provided, then it will be
     // also used as slide out duration. I.e. if you provided only slide in
     // duration, then slide in duration == slide out duration.
 
     const QByteArray rawAtomData = w->readProperty(m_atom, m_atom, 32);
 
     if (rawAtomData.isEmpty()) {
         // Property was removed, thus also remove the effect for window
         if (w->data(WindowClosedGrabRole).value<void *>() == this) {
             w->setData(WindowClosedGrabRole, QVariant());
         }
         m_animations.remove(w);
         m_animationsData.remove(w);
         return;
     }
 
     // Offset and location are required.
     if (static_cast<size_t>(rawAtomData.size()) < sizeof(uint32_t) * 2) {
         return;
     }
 
     const auto *atomData = reinterpret_cast<const uint32_t *>(rawAtomData.data());
     AnimationData &animData = m_animationsData[w];
     animData.offset = atomData[0];
 
     switch (atomData[1]) {
     case 0: // West
         animData.location = Location::Left;
         break;
     case 1: // North
         animData.location = Location::Top;
         break;
     case 2: // East
         animData.location = Location::Right;
         break;
     case 3: // South
     default:
         animData.location = Location::Bottom;
         break;
     }
 
     if (static_cast<size_t>(rawAtomData.size()) >= sizeof(uint32_t) * 3) {
         animData.slideInDuration = std::chrono::milliseconds(atomData[2]);
         if (static_cast<size_t>(rawAtomData.size()) >= sizeof(uint32_t) * 4) {
             animData.slideOutDuration = std::chrono::milliseconds(atomData[3]);
         } else {
             animData.slideOutDuration = animData.slideInDuration;
         }
     } else {
         animData.slideInDuration = m_slideInDuration;
         animData.slideOutDuration = m_slideOutDuration;
     }
 
     if (static_cast<size_t>(rawAtomData.size()) >= sizeof(uint32_t) * 5) {
         animData.slideLength = atomData[4];
     } else {
         animData.slideLength = 0;
     }
 
     setupAnimData(w);
 }
 
 void SlidingPopupsEffect::setupAnimData(EffectWindow *w)
 {
     const QRect screenRect = effects->clientArea(FullScreenArea, w->screen(), effects->currentDesktop());
     const QRect windowGeo = w->geometry();
     AnimationData &animData = m_animationsData[w];
 
     if (animData.offset == -1) {
         switch (animData.location) {
         case Location::Left:
             animData.offset = qMax(windowGeo.left() - screenRect.left(), 0);
             break;
         case Location::Top:
             animData.offset = qMax(windowGeo.top() - screenRect.top(), 0);
             break;
         case Location::Right:
             animData.offset = qMax(screenRect.right() - windowGeo.right(), 0);
             break;
         case Location::Bottom:
         default:
             animData.offset = qMax(screenRect.bottom() - windowGeo.bottom(), 0);
             break;
         }
     }
     // sanitize
     switch (animData.location) {
     case Location::Left:
         animData.offset = qMax(windowGeo.left() - screenRect.left(), animData.offset);
         break;
     case Location::Top:
         animData.offset = qMax(windowGeo.top() - screenRect.top(), animData.offset);
         break;
     case Location::Right:
         animData.offset = qMax(screenRect.right() - windowGeo.right(), animData.offset);
         break;
     case Location::Bottom:
     default:
         animData.offset = qMax(screenRect.bottom() - windowGeo.bottom(), animData.offset);
         break;
     }
 
     animData.slideInDuration = (animData.slideInDuration.count() != 0)
         ? animData.slideInDuration
         : m_slideInDuration;
 
     animData.slideOutDuration = (animData.slideOutDuration.count() != 0)
         ? animData.slideOutDuration
         : m_slideOutDuration;
 
     // Grab the window, so other windowClosed effects will ignore it
     w->setData(WindowClosedGrabRole, QVariant::fromValue(static_cast<void*>(this)));
 }
 
 void SlidingPopupsEffect::slotWaylandSlideOnShowChanged(EffectWindow* w)
 {
     if (!w) {
         return;
     }
 
-    KWayland::Server::SurfaceInterface *surf = w->surface();
+    KWaylandServer::SurfaceInterface *surf = w->surface();
     if (!surf) {
         return;
     }
 
     if (surf->slideOnShowHide()) {
         AnimationData &animData = m_animationsData[w];
 
         animData.offset = surf->slideOnShowHide()->offset();
 
         switch (surf->slideOnShowHide()->location()) {
-        case KWayland::Server::SlideInterface::Location::Top:
+        case KWaylandServer::SlideInterface::Location::Top:
             animData.location = Location::Top;
             break;
-        case KWayland::Server::SlideInterface::Location::Left:
+        case KWaylandServer::SlideInterface::Location::Left:
             animData.location = Location::Left;
             break;
-        case KWayland::Server::SlideInterface::Location::Right:
+        case KWaylandServer::SlideInterface::Location::Right:
             animData.location = Location::Right;
             break;
-        case KWayland::Server::SlideInterface::Location::Bottom:
+        case KWaylandServer::SlideInterface::Location::Bottom:
         default:
             animData.location = Location::Bottom;
             break;
         }
         animData.slideLength = 0;
         animData.slideInDuration = m_slideInDuration;
         animData.slideOutDuration = m_slideOutDuration;
 
         setupAnimData(w);
     }
 }
 
 void SlidingPopupsEffect::setupInternalWindowSlide(EffectWindow *w)
 {
     if (!w) {
         return;
     }
     auto internal = w->internalWindow();
     if (!internal) {
         return;
     }
     const QVariant slideProperty = internal->property("kwin_slide");
     if (!slideProperty.isValid()) {
         return;
     }
     Location location;
     switch (slideProperty.value<KWindowEffects::SlideFromLocation>()) {
     case KWindowEffects::BottomEdge:
         location = Location::Bottom;
         break;
     case KWindowEffects::TopEdge:
         location = Location::Top;
         break;
     case KWindowEffects::RightEdge:
         location = Location::Right;
         break;
     case KWindowEffects::LeftEdge:
         location = Location::Left;
         break;
     default:
         return;
     }
     AnimationData &animData = m_animationsData[w];
     animData.location = location;
     bool intOk = false;
     animData.offset = internal->property("kwin_slide_offset").toInt(&intOk);
     if (!intOk) {
         animData.offset = -1;
     }
     animData.slideLength = 0;
     animData.slideInDuration = m_slideInDuration;
     animData.slideOutDuration = m_slideOutDuration;
 
     setupAnimData(w);
 }
 
 bool SlidingPopupsEffect::eventFilter(QObject *watched, QEvent *event)
 {
     auto internal = qobject_cast<QWindow*>(watched);
     if (internal && event->type() == QEvent::DynamicPropertyChange) {
         QDynamicPropertyChangeEvent *pe = static_cast<QDynamicPropertyChangeEvent*>(event);
         if (pe->propertyName() == "kwin_slide" || pe->propertyName() == "kwin_slide_offset") {
             if (auto w = effects->findWindow(internal)) {
                 setupInternalWindowSlide(w);
             }
         }
     }
     return false;
 }
 
 void SlidingPopupsEffect::slideIn(EffectWindow *w)
 {
     if (effects->activeFullScreenEffect()) {
         return;
     }
 
     if (!w->isVisible()) {
         return;
     }
 
     auto dataIt = m_animationsData.constFind(w);
     if (dataIt == m_animationsData.constEnd()) {
         return;
     }
 
     Animation &animation = m_animations[w];
     animation.kind = AnimationKind::In;
     animation.timeLine.setDirection(TimeLine::Forward);
     animation.timeLine.setDuration((*dataIt).slideInDuration);
     animation.timeLine.setEasingCurve(QEasingCurve::OutCubic);
 
     // If the opposite animation (Out) was active and it had shorter duration,
     // at this point, the timeline can end up in the "done" state. Thus, we have
     // to reset it.
     if (animation.timeLine.done()) {
         animation.timeLine.reset();
     }
 
     w->setData(WindowAddedGrabRole, QVariant::fromValue(static_cast<void*>(this)));
     w->setData(WindowForceBackgroundContrastRole, QVariant(true));
     w->setData(WindowForceBlurRole, QVariant(true));
 
     w->addRepaintFull();
 }
 
 void SlidingPopupsEffect::slideOut(EffectWindow *w)
 {
     if (effects->activeFullScreenEffect()) {
         return;
     }
 
     if (!w->isVisible()) {
         return;
     }
 
     auto dataIt = m_animationsData.constFind(w);
     if (dataIt == m_animationsData.constEnd()) {
         return;
     }
 
     if (w->isDeleted()) {
         w->refWindow();
     }
 
     Animation &animation = m_animations[w];
     animation.kind = AnimationKind::Out;
     animation.timeLine.setDirection(TimeLine::Backward);
     animation.timeLine.setDuration((*dataIt).slideOutDuration);
     // this is effectively InCubic because the direction is reversed
     animation.timeLine.setEasingCurve(QEasingCurve::OutCubic);
 
     // If the opposite animation (In) was active and it had shorter duration,
     // at this point, the timeline can end up in the "done" state. Thus, we have
     // to reset it.
     if (animation.timeLine.done()) {
         animation.timeLine.reset();
     }
 
     w->setData(WindowClosedGrabRole, QVariant::fromValue(static_cast<void*>(this)));
     w->setData(WindowForceBackgroundContrastRole, QVariant(true));
     w->setData(WindowForceBlurRole, QVariant(true));
 
     w->addRepaintFull();
 }
 
 void SlidingPopupsEffect::stopAnimations()
 {
     for (auto it = m_animations.constBegin(); it != m_animations.constEnd(); ++it) {
         EffectWindow *w = it.key();
 
         if (w->isDeleted()) {
             w->unrefWindow();
         } else {
             w->setData(WindowForceBackgroundContrastRole, QVariant());
             w->setData(WindowForceBlurRole, QVariant());
         }
     }
 
     m_animations.clear();
 }
 
 bool SlidingPopupsEffect::isActive() const
 {
     return !m_animations.isEmpty();
 }
 
 } // namespace
diff --git a/events.cpp b/events.cpp
index 63d9c2fc2..480571398 100644
--- a/events.cpp
+++ b/events.cpp
@@ -1,1356 +1,1356 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 1999, 2000 Matthias Ettrich <ettrich@kde.org>
 Copyright (C) 2003 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 /*
 
  This file contains things relevant to handling incoming events.
 
 */
 
 #include "x11client.h"
 #include "cursor.h"
 #include "focuschain.h"
 #include "netinfo.h"
 #include "workspace.h"
 #include "atoms.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "group.h"
 #include "rules.h"
 #include "unmanaged.h"
 #include "useractions.h"
 #include "effects.h"
 #include "screens.h"
 #include "xcbutils.h"
 
 #include <KDecoration2/Decoration>
 
 #include <QApplication>
 #include <QDebug>
 #include <QHoverEvent>
 #include <QKeyEvent>
 #include <QMouseEvent>
 #include <QStyleHints>
 #include <QWheelEvent>
 
 #include <kkeyserver.h>
 
 #include <xcb/sync.h>
 #ifdef XCB_ICCCM_FOUND
 #include <xcb/xcb_icccm.h>
 #endif
 
 #include "composite.h"
 #include "x11eventfilter.h"
 
 #include "wayland_server.h"
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #ifndef XCB_GE_GENERIC
 #define XCB_GE_GENERIC 35
 typedef struct xcb_ge_generic_event_t {
     uint8_t  response_type; /**<  */
     uint8_t  extension; /**<  */
     uint16_t sequence; /**<  */
     uint32_t length; /**<  */
     uint16_t event_type; /**<  */
     uint8_t  pad0[22]; /**<  */
     uint32_t full_sequence; /**<  */
 } xcb_ge_generic_event_t;
 #endif
 
 namespace KWin
 {
 
 // ****************************************
 // Workspace
 // ****************************************
 
 static xcb_window_t findEventWindow(xcb_generic_event_t *event)
 {
     const uint8_t eventType = event->response_type & ~0x80;
     switch(eventType) {
     case XCB_KEY_PRESS:
     case XCB_KEY_RELEASE:
         return reinterpret_cast<xcb_key_press_event_t*>(event)->event;
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE:
         return reinterpret_cast<xcb_button_press_event_t*>(event)->event;
     case XCB_MOTION_NOTIFY:
         return reinterpret_cast<xcb_motion_notify_event_t*>(event)->event;
     case XCB_ENTER_NOTIFY:
     case XCB_LEAVE_NOTIFY:
         return reinterpret_cast<xcb_enter_notify_event_t*>(event)->event;
     case XCB_FOCUS_IN:
     case XCB_FOCUS_OUT:
         return reinterpret_cast<xcb_focus_in_event_t*>(event)->event;
     case XCB_EXPOSE:
         return reinterpret_cast<xcb_expose_event_t*>(event)->window;
     case XCB_GRAPHICS_EXPOSURE:
         return reinterpret_cast<xcb_graphics_exposure_event_t*>(event)->drawable;
     case XCB_NO_EXPOSURE:
         return reinterpret_cast<xcb_no_exposure_event_t*>(event)->drawable;
     case XCB_VISIBILITY_NOTIFY:
         return reinterpret_cast<xcb_visibility_notify_event_t*>(event)->window;
     case XCB_CREATE_NOTIFY:
         return reinterpret_cast<xcb_create_notify_event_t*>(event)->window;
     case XCB_DESTROY_NOTIFY:
         return reinterpret_cast<xcb_destroy_notify_event_t*>(event)->window;
     case XCB_UNMAP_NOTIFY:
         return reinterpret_cast<xcb_unmap_notify_event_t*>(event)->window;
     case XCB_MAP_NOTIFY:
         return reinterpret_cast<xcb_map_notify_event_t*>(event)->window;
     case XCB_MAP_REQUEST:
         return reinterpret_cast<xcb_map_request_event_t*>(event)->window;
     case XCB_REPARENT_NOTIFY:
         return reinterpret_cast<xcb_reparent_notify_event_t*>(event)->window;
     case XCB_CONFIGURE_NOTIFY:
         return reinterpret_cast<xcb_configure_notify_event_t*>(event)->window;
     case XCB_CONFIGURE_REQUEST:
         return reinterpret_cast<xcb_configure_request_event_t*>(event)->window;
     case XCB_GRAVITY_NOTIFY:
         return reinterpret_cast<xcb_gravity_notify_event_t*>(event)->window;
     case XCB_RESIZE_REQUEST:
         return reinterpret_cast<xcb_resize_request_event_t*>(event)->window;
     case XCB_CIRCULATE_NOTIFY:
     case XCB_CIRCULATE_REQUEST:
         return reinterpret_cast<xcb_circulate_notify_event_t*>(event)->window;
     case XCB_PROPERTY_NOTIFY:
         return reinterpret_cast<xcb_property_notify_event_t*>(event)->window;
     case XCB_COLORMAP_NOTIFY:
         return reinterpret_cast<xcb_colormap_notify_event_t*>(event)->window;
     case XCB_CLIENT_MESSAGE:
         return reinterpret_cast<xcb_client_message_event_t*>(event)->window;
     default:
         // extension handling
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
             return reinterpret_cast<xcb_shape_notify_event_t*>(event)->affected_window;
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent()) {
             return reinterpret_cast<xcb_damage_notify_event_t*>(event)->drawable;
         }
         return XCB_WINDOW_NONE;
     }
 }
 
 QVector<QByteArray> s_xcbEerrors({
     QByteArrayLiteral("Success"),
     QByteArrayLiteral("BadRequest"),
     QByteArrayLiteral("BadValue"),
     QByteArrayLiteral("BadWindow"),
     QByteArrayLiteral("BadPixmap"),
     QByteArrayLiteral("BadAtom"),
     QByteArrayLiteral("BadCursor"),
     QByteArrayLiteral("BadFont"),
     QByteArrayLiteral("BadMatch"),
     QByteArrayLiteral("BadDrawable"),
     QByteArrayLiteral("BadAccess"),
     QByteArrayLiteral("BadAlloc"),
     QByteArrayLiteral("BadColor"),
     QByteArrayLiteral("BadGC"),
     QByteArrayLiteral("BadIDChoice"),
     QByteArrayLiteral("BadName"),
     QByteArrayLiteral("BadLength"),
     QByteArrayLiteral("BadImplementation"),
     QByteArrayLiteral("Unknown")});
 
 
 void Workspace::registerEventFilter(X11EventFilter *filter)
 {
     if (filter->isGenericEvent())
         m_genericEventFilters.append(filter);
     else
         m_eventFilters.append(filter);
 }
 
 void Workspace::unregisterEventFilter(X11EventFilter *filter)
 {
     if (filter->isGenericEvent())
         m_genericEventFilters.removeOne(filter);
     else
         m_eventFilters.removeOne(filter);
 }
 
 
 /**
  * Handles workspace specific XCB event
  */
 bool Workspace::workspaceEvent(xcb_generic_event_t *e)
 {
     const uint8_t eventType = e->response_type & ~0x80;
     if (!eventType) {
         // let's check whether it's an error from one of the extensions KWin uses
         xcb_generic_error_t *error = reinterpret_cast<xcb_generic_error_t*>(e);
         const QVector<Xcb::ExtensionData> extensions = Xcb::Extensions::self()->extensions();
         for (const auto &extension : extensions) {
             if (error->major_code == extension.majorOpcode) {
                 QByteArray errorName;
                 if (error->error_code < s_xcbEerrors.size()) {
                     errorName = s_xcbEerrors.at(error->error_code);
                 } else if (error->error_code >= extension.errorBase) {
                     const int index = error->error_code - extension.errorBase;
                     if (index >= 0 && index < extension.errorCodes.size()) {
                         errorName = extension.errorCodes.at(index);
                     }
                 }
                 if (errorName.isEmpty()) {
                     errorName = QByteArrayLiteral("Unknown");
                 }
                 qCWarning(KWIN_CORE, "XCB error: %d (%s), sequence: %d, resource id: %d, major code: %d (%s), minor code: %d (%s)",
                          int(error->error_code), errorName.constData(),
                          int(error->sequence), int(error->resource_id),
                          int(error->major_code), extension.name.constData(),
                          int(error->minor_code),
                          extension.opCodes.size() > error->minor_code ? extension.opCodes.at(error->minor_code).constData() : "Unknown");
                 return true;
             }
         }
         return false;
     }
 
     if (eventType == XCB_GE_GENERIC) {
         xcb_ge_generic_event_t *ge = reinterpret_cast<xcb_ge_generic_event_t *>(e);
 
         foreach (X11EventFilter *filter, m_genericEventFilters) {
             if (filter->extension() == ge->extension && filter->genericEventTypes().contains(ge->event_type) && filter->event(e)) {
                 return true;
             }
         }
     } else {
         foreach (X11EventFilter *filter, m_eventFilters) {
             if (filter->eventTypes().contains(eventType) && filter->event(e)) {
                 return true;
             }
         }
     }
 
     if (effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()
             && (eventType == XCB_KEY_PRESS || eventType == XCB_KEY_RELEASE))
         return false; // let Qt process it, it'll be intercepted again in eventFilter()
 
     // events that should be handled before Clients can get them
     switch (eventType) {
     case XCB_CONFIGURE_NOTIFY:
         if (reinterpret_cast<xcb_configure_notify_event_t*>(e)->event == rootWindow())
             markXStackingOrderAsDirty();
         break;
     };
 
     const xcb_window_t eventWindow = findEventWindow(e);
     if (eventWindow != XCB_WINDOW_NONE) {
         if (X11Client *c = findClient(Predicate::WindowMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (X11Client *c = findClient(Predicate::WrapperIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (X11Client *c = findClient(Predicate::FrameIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (X11Client *c = findClient(Predicate::InputIdMatch, eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         } else if (Unmanaged* c = findUnmanaged(eventWindow)) {
             if (c->windowEvent(e))
                 return true;
         }
     }
 
     switch (eventType) {
     case XCB_CREATE_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_create_notify_event_t*>(e);
         if (event->parent == rootWindow() &&
                 !QWidget::find(event->window) &&
                 !event->override_redirect) {
             // see comments for allowClientActivation()
             updateXTime();
             const xcb_timestamp_t t = xTime();
             xcb_change_property(connection(), XCB_PROP_MODE_REPLACE, event->window, atoms->kde_net_wm_user_creation_time, XCB_ATOM_CARDINAL, 32, 1, &t);
         }
         break;
     }
     case XCB_UNMAP_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_unmap_notify_event_t*>(e);
         return (event->event != event->window);   // hide wm typical event from Qt
     }
     case XCB_REPARENT_NOTIFY: {
         //do not confuse Qt with these events. After all, _we_ are the
         //window manager who does the reparenting.
         return true;
     }
     case XCB_MAP_REQUEST: {
         updateXTime();
 
         const auto *event = reinterpret_cast<xcb_map_request_event_t*>(e);
         if (X11Client *c = findClient(Predicate::WindowMatch, event->window)) {
             // e->xmaprequest.window is different from e->xany.window
             // TODO this shouldn't be necessary now
             c->windowEvent(e);
             FocusChain::self()->update(c, FocusChain::Update);
         } else if ( true /*|| e->xmaprequest.parent != root */ ) {
             // NOTICE don't check for the parent being the root window, this breaks when some app unmaps
             // a window, changes something and immediately maps it back, without giving KWin
             // a chance to reparent it back to root
             // since KWin can get MapRequest only for root window children and
             // children of WindowWrapper (=clients), the check is AFAIK useless anyway
             // NOTICE: The save-set support in X11Client::mapRequestEvent() actually requires that
             // this code doesn't check the parent to be root.
             if (!createClient(event->window, false)) {
                 xcb_map_window(connection(), event->window);
                 const uint32_t values[] = { XCB_STACK_MODE_ABOVE };
                 xcb_configure_window(connection(), event->window, XCB_CONFIG_WINDOW_STACK_MODE, values);
             }
         }
         return true;
     }
     case XCB_MAP_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_map_notify_event_t*>(e);
         if (event->override_redirect) {
             Unmanaged* c = findUnmanaged(event->window);
             if (c == nullptr)
                 c = createUnmanaged(event->window);
             if (c) {
                 // if hasScheduledRelease is true, it means a unamp and map sequence has occurred. 
                 // since release is scheduled after map notify, this old Unmanaged will get released
                 // before KWIN has chance to remanage it again. so release it right now.
                 if (c->hasScheduledRelease()) {
                     c->release();
                     c = createUnmanaged(event->window);
                 }
                 if (c)
                     return c->windowEvent(e);
             }
         }
         return (event->event != event->window);   // hide wm typical event from Qt
     }
 
     case XCB_CONFIGURE_REQUEST: {
         const auto *event = reinterpret_cast<xcb_configure_request_event_t*>(e);
         if (event->parent == rootWindow()) {
             uint32_t values[5] = { 0, 0, 0, 0, 0};
             const uint32_t value_mask = event->value_mask
                                         & (XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_BORDER_WIDTH);
             int i = 0;
             if (value_mask & XCB_CONFIG_WINDOW_X) {
                 values[i++] = event->x;
             }
             if (value_mask & XCB_CONFIG_WINDOW_Y) {
                 values[i++] = event->y;
             }
             if (value_mask & XCB_CONFIG_WINDOW_WIDTH) {
                 values[i++] = event->width;
             }
             if (value_mask & XCB_CONFIG_WINDOW_HEIGHT) {
                 values[i++] = event->height;
             }
             if (value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
                 values[i++] = event->border_width;
             }
             xcb_configure_window(connection(), event->window, value_mask, values);
             return true;
         }
         break;
     }
     case XCB_FOCUS_IN: {
         const auto *event = reinterpret_cast<xcb_focus_in_event_t*>(e);
         if (event->event == rootWindow()
                 && (event->detail == XCB_NOTIFY_DETAIL_NONE || event->detail == XCB_NOTIFY_DETAIL_POINTER_ROOT || event->detail == XCB_NOTIFY_DETAIL_INFERIOR)) {
             Xcb::CurrentInput currentInput;
             updateXTime(); // focusToNull() uses xTime(), which is old now (FocusIn has no timestamp)
             // it seems we can "loose" focus reversions when the closing client hold a grab
             // => catch the typical pattern (though we don't want the focus on the root anyway) #348935
             const bool lostFocusPointerToRoot = currentInput->focus == rootWindow() && event->detail == XCB_NOTIFY_DETAIL_INFERIOR;
             if (!currentInput.isNull() && (currentInput->focus == XCB_WINDOW_NONE || currentInput->focus == XCB_INPUT_FOCUS_POINTER_ROOT || lostFocusPointerToRoot)) {
                 //kWarning( 1212 ) << "X focus set to None/PointerRoot, reseting focus" ;
                 AbstractClient *c = mostRecentlyActivatedClient();
                 if (c != nullptr)
                     requestFocus(c, true);
                 else if (activateNextClient(nullptr))
                     ; // ok, activated
                 else
                     focusToNull();
             }
         }
     }
         // fall through
     case XCB_FOCUS_OUT:
         return true; // always eat these, they would tell Qt that KWin is the active app
     default:
         break;
     }
     return false;
 }
 
 // Used only to filter events that need to be processed by Qt first
 // (e.g. keyboard input to be composed), otherwise events are
 // handle by the XEvent filter above
 bool Workspace::workspaceEvent(QEvent* e)
 {
     if ((e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease || e->type() == QEvent::ShortcutOverride)
             && effects && static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
         static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(static_cast< QKeyEvent* >(e));
         return true;
     }
     return false;
 }
 
 // ****************************************
 // Client
 // ****************************************
 
 /**
  * General handler for XEvents concerning the client window
  */
 bool X11Client::windowEvent(xcb_generic_event_t *e)
 {
     if (findEventWindow(e) == window()) { // avoid doing stuff on frame or wrapper
         NET::Properties dirtyProperties;
         NET::Properties2 dirtyProperties2;
         double old_opacity = opacity();
         info->event(e, &dirtyProperties, &dirtyProperties2);   // pass through the NET stuff
 
         if ((dirtyProperties & NET::WMName) != 0)
             fetchName();
         if ((dirtyProperties & NET::WMIconName) != 0)
             fetchIconicName();
         if ((dirtyProperties & NET::WMStrut) != 0
                 || (dirtyProperties2 & NET::WM2ExtendedStrut) != 0) {
             workspace()->updateClientArea();
         }
         if ((dirtyProperties & NET::WMIcon) != 0)
             getIcons();
         // Note there's a difference between userTime() and info->userTime()
         // info->userTime() is the value of the property, userTime() also includes
         // updates of the time done by KWin (ButtonPress on windowrapper etc.).
         if ((dirtyProperties2 & NET::WM2UserTime) != 0) {
             workspace()->setWasUserInteraction();
             updateUserTime(info->userTime());
         }
         if ((dirtyProperties2 & NET::WM2StartupId) != 0)
             startupIdChanged();
         if (dirtyProperties2 & NET::WM2Opacity) {
             if (compositing()) {
                 addRepaintFull();
                 emit opacityChanged(this, old_opacity);
             } else {
                 // forward to the frame if there's possibly another compositing manager running
                 NETWinInfo i(connection(), frameId(), rootWindow(), NET::Properties(), NET::Properties2());
                 i.setOpacity(info->opacity());
             }
         }
         if (dirtyProperties2 & NET::WM2FrameOverlap) {
             // ### Inform the decoration
         }
         if (dirtyProperties2.testFlag(NET::WM2WindowRole)) {
             emit windowRoleChanged();
         }
         if (dirtyProperties2.testFlag(NET::WM2WindowClass)) {
             getResourceClass();
         }
         if (dirtyProperties2.testFlag(NET::WM2BlockCompositing)) {
             setBlockingCompositing(info->isBlockingCompositing());
         }
         if (dirtyProperties2.testFlag(NET::WM2GroupLeader)) {
             checkGroup();
             updateAllowedActions(); // Group affects isMinimizable()
         }
         if (dirtyProperties2.testFlag(NET::WM2Urgency)) {
             updateUrgency();
         }
         if (dirtyProperties2 & NET::WM2OpaqueRegion) {
             getWmOpaqueRegion();
         }
         if (dirtyProperties2 & NET::WM2DesktopFileName) {
             setDesktopFileName(QByteArray(info->desktopFileName()));
         }
         if (dirtyProperties2 & NET::WM2GTKFrameExtents) {
             setClientFrameExtents(info->gtkFrameExtents());
         }
     }
 
     const uint8_t eventType = e->response_type & ~0x80;
     switch(eventType) {
     case XCB_UNMAP_NOTIFY:
         unmapNotifyEvent(reinterpret_cast<xcb_unmap_notify_event_t*>(e));
         break;
     case XCB_DESTROY_NOTIFY:
         destroyNotifyEvent(reinterpret_cast<xcb_destroy_notify_event_t*>(e));
         break;
     case XCB_MAP_REQUEST:
         // this one may pass the event to workspace
         return mapRequestEvent(reinterpret_cast<xcb_map_request_event_t*>(e));
     case XCB_CONFIGURE_REQUEST:
         configureRequestEvent(reinterpret_cast<xcb_configure_request_event_t*>(e));
         break;
     case XCB_PROPERTY_NOTIFY:
         propertyNotifyEvent(reinterpret_cast<xcb_property_notify_event_t*>(e));
         break;
     case XCB_KEY_PRESS:
         updateUserTime(reinterpret_cast<xcb_key_press_event_t*>(e)->time);
         break;
     case XCB_BUTTON_PRESS: {
         const auto *event = reinterpret_cast<xcb_button_press_event_t*>(e);
         updateUserTime(event->time);
         buttonPressEvent(event->event, event->detail, event->state,
                          event->event_x, event->event_y, event->root_x, event->root_y, event->time);
         break;
     }
     case XCB_KEY_RELEASE:
         // don't update user time on releases
         // e.g. if the user presses Alt+F2, the Alt release
         // would appear as user input to the currently active window
         break;
     case XCB_BUTTON_RELEASE: {
         const auto *event = reinterpret_cast<xcb_button_release_event_t*>(e);
         // don't update user time on releases
         // e.g. if the user presses Alt+F2, the Alt release
         // would appear as user input to the currently active window
         buttonReleaseEvent(event->event, event->detail, event->state,
                            event->event_x, event->event_y, event->root_x, event->root_y);
         break;
     }
     case XCB_MOTION_NOTIFY: {
         const auto *event = reinterpret_cast<xcb_motion_notify_event_t*>(e);
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         workspace()->updateFocusMousePosition(QPoint(event->root_x, event->root_y));
         break;
     }
     case XCB_ENTER_NOTIFY: {
         auto *event = reinterpret_cast<xcb_enter_notify_event_t*>(e);
         enterNotifyEvent(event);
         // MotionNotify is guaranteed to be generated only if the mouse
         // move start and ends in the window; for cases when it only
         // starts or only ends there, Enter/LeaveNotify are generated.
         // Fake a MotionEvent in such cases to make handle of mouse
         // events simpler (Qt does that too).
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         workspace()->updateFocusMousePosition(QPoint(event->root_x, event->root_y));
         break;
     }
     case XCB_LEAVE_NOTIFY: {
         auto *event = reinterpret_cast<xcb_leave_notify_event_t*>(e);
         motionNotifyEvent(event->event, event->state,
                           event->event_x, event->event_y, event->root_x, event->root_y);
         leaveNotifyEvent(event);
         // not here, it'd break following enter notify handling
         // workspace()->updateFocusMousePosition( QPoint( e->xcrossing.x_root, e->xcrossing.y_root ));
         break;
     }
     case XCB_FOCUS_IN:
         focusInEvent(reinterpret_cast<xcb_focus_in_event_t*>(e));
         break;
     case XCB_FOCUS_OUT:
         focusOutEvent(reinterpret_cast<xcb_focus_out_event_t*>(e));
         break;
     case XCB_REPARENT_NOTIFY:
         break;
     case XCB_CLIENT_MESSAGE:
         clientMessageEvent(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     case XCB_EXPOSE: {
         xcb_expose_event_t *event = reinterpret_cast<xcb_expose_event_t*>(e);
         if (event->window == frameId() && !Compositor::self()->isActive()) {
             // TODO: only repaint required areas
             triggerDecorationRepaint();
         }
         break;
     }
     default:
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent() && reinterpret_cast<xcb_shape_notify_event_t*>(e)->affected_window == window()) {
             detectShape(window());  // workaround for #19644
             updateShape();
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent() && reinterpret_cast<xcb_damage_notify_event_t*>(e)->drawable == frameId())
             damageNotifyEvent();
         break;
     }
     return true; // eat all events
 }
 
 /**
  * Handles map requests of the client window
  */
 bool X11Client::mapRequestEvent(xcb_map_request_event_t *e)
 {
     if (e->window != window()) {
         // Special support for the save-set feature, which is a bit broken.
         // If there's a window from one client embedded in another one,
         // e.g. using XEMBED, and the embedder suddenly loses its X connection,
         // save-set will reparent the embedded window to its closest ancestor
         // that will remains. Unfortunately, with reparenting window managers,
         // this is not the root window, but the frame (or in KWin's case,
         // it's the wrapper for the client window). In this case,
         // the wrapper will get ReparentNotify for a window it won't know,
         // which will be ignored, and then it gets MapRequest, as save-set
         // always maps. Returning true here means that Workspace::workspaceEvent()
         // will handle this MapRequest and manage this window (i.e. act as if
         // it was reparented to root window).
         if (e->parent == wrapperId())
             return false;
         return true; // no messing with frame etc.
     }
     // also copied in clientMessage()
     if (isMinimized())
         unminimize();
     if (isShade())
         setShade(ShadeNone);
     if (!isOnCurrentDesktop()) {
         if (workspace()->allowClientActivation(this))
             workspace()->activateClient(this);
         else
             demandAttention();
     }
     return true;
 }
 
 /**
  * Handles unmap notify events of the client window
  */
 void X11Client::unmapNotifyEvent(xcb_unmap_notify_event_t *e)
 {
     if (e->window != window())
         return;
     if (e->event != wrapperId()) {
         // most probably event from root window when initially reparenting
         bool ignore = true;
         if (e->event == rootWindow() && (e->response_type & 0x80))
             ignore = false; // XWithdrawWindow()
         if (ignore)
             return;
     }
 
     // check whether this is result of an XReparentWindow - client then won't be parented by wrapper
     // in this case do not release the client (causes reparent to root, removal from saveSet and what not)
     // but just destroy the client
     Xcb::Tree tree(m_client);
     xcb_window_t daddy = tree.parent();
     if (daddy == m_wrapper) {
         releaseWindow(); // unmapped from a regular client state
     } else {
         destroyClient(); // the client was moved to some other parent
     }
 }
 
 void X11Client::destroyNotifyEvent(xcb_destroy_notify_event_t *e)
 {
     if (e->window != window())
         return;
     destroyClient();
 }
 
 
 /**
  * Handles client messages for the client window
  */
 void X11Client::clientMessageEvent(xcb_client_message_event_t *e)
 {
     Toplevel::clientMessageEvent(e);
     if (e->window != window())
         return; // ignore frame/wrapper
     // WM_STATE
     if (e->type == atoms->wm_change_state) {
         if (e->data.data32[0] == XCB_ICCCM_WM_STATE_ICONIC)
             minimize();
         return;
     }
 }
 
 
 /**
  * Handles configure  requests of the client window
  */
 void X11Client::configureRequestEvent(xcb_configure_request_event_t *e)
 {
     if (e->window != window())
         return; // ignore frame/wrapper
     if (isResize() || isMove())
         return; // we have better things to do right now
 
     if (m_fullscreenMode == FullScreenNormal) { // refuse resizing of fullscreen windows
         // but allow resizing fullscreen hacks in order to let them cancel fullscreen mode
         sendSyntheticConfigureNotify();
         return;
     }
     if (isSplash()) {  // no manipulations with splashscreens either
         sendSyntheticConfigureNotify();
         return;
     }
 
     if (e->value_mask & XCB_CONFIG_WINDOW_BORDER_WIDTH) {
         // first, get rid of a window border
         m_client.setBorderWidth(0);
     }
 
     if (e->value_mask & (XCB_CONFIG_WINDOW_X | XCB_CONFIG_WINDOW_Y | XCB_CONFIG_WINDOW_HEIGHT | XCB_CONFIG_WINDOW_WIDTH))
         configureRequest(e->value_mask, e->x, e->y, e->width, e->height, 0, false);
 
     if (e->value_mask & XCB_CONFIG_WINDOW_STACK_MODE)
         restackWindow(e->sibling, e->stack_mode, NET::FromApplication, userTime(), false);
 
     // Sending a synthetic configure notify always is fine, even in cases where
     // the ICCCM doesn't require this - it can be though of as 'the WM decided to move
     // the window later'. The client should not cause that many configure request,
     // so this should not have any significant impact. With user moving/resizing
     // the it should be optimized though (see also X11Client::setGeometry()/plainResize()/move()).
     sendSyntheticConfigureNotify();
 
     // SELI TODO accept configure requests for isDesktop windows (because kdesktop
     // may get XRANDR resize event before kwin), but check it's still at the bottom?
 }
 
 
 /**
  * Handles property changes of the client window
  */
 void X11Client::propertyNotifyEvent(xcb_property_notify_event_t *e)
 {
     Toplevel::propertyNotifyEvent(e);
     if (e->window != window())
         return; // ignore frame/wrapper
     switch(e->atom) {
     case XCB_ATOM_WM_NORMAL_HINTS:
         getWmNormalHints();
         break;
     case XCB_ATOM_WM_NAME:
         fetchName();
         break;
     case XCB_ATOM_WM_ICON_NAME:
         fetchIconicName();
         break;
     case XCB_ATOM_WM_TRANSIENT_FOR:
         readTransient();
         break;
     case XCB_ATOM_WM_HINTS:
         getIcons(); // because KWin::icon() uses WMHints as fallback
         break;
     default:
         if (e->atom == atoms->motif_wm_hints) {
             getMotifHints();
         } else if (e->atom == atoms->net_wm_sync_request_counter)
             getSyncCounter();
         else if (e->atom == atoms->activities)
             checkActivities();
         else if (e->atom == atoms->kde_first_in_window_list)
             updateFirstInTabBox();
         else if (e->atom == atoms->kde_color_sheme)
             updateColorScheme();
         else if (e->atom == atoms->kde_screen_edge_show)
             updateShowOnScreenEdge();
         else if (e->atom == atoms->kde_net_wm_appmenu_service_name)
             checkApplicationMenuServiceName();
         else if (e->atom == atoms->kde_net_wm_appmenu_object_path)
             checkApplicationMenuObjectPath();
         break;
     }
 }
 
 
 void X11Client::enterNotifyEvent(xcb_enter_notify_event_t *e)
 {
     if (e->event != frameId())
         return; // care only about entering the whole frame
 
 #define MOUSE_DRIVEN_FOCUS (!options->focusPolicyIsReasonable() || \
                             (options->focusPolicy() == Options::FocusFollowsMouse && options->isNextFocusPrefersMouse()))
     if (e->mode == XCB_NOTIFY_MODE_NORMAL || (e->mode == XCB_NOTIFY_MODE_UNGRAB && MOUSE_DRIVEN_FOCUS)) {
 
         if (options->isShadeHover()) {
             cancelShadeHoverTimer();
             if (isShade()) {
                 shadeHoverTimer = new QTimer(this);
                 connect(shadeHoverTimer, SIGNAL(timeout()), this, SLOT(shadeHover()));
                 shadeHoverTimer->setSingleShot(true);
                 shadeHoverTimer->start(options->shadeHoverInterval());
             }
         }
 #undef MOUSE_DRIVEN_FOCUS
 
         enterEvent(QPoint(e->root_x, e->root_y));
         return;
     }
 }
 
 void X11Client::leaveNotifyEvent(xcb_leave_notify_event_t *e)
 {
     if (e->event != frameId())
         return; // care only about leaving the whole frame
     if (e->mode == XCB_NOTIFY_MODE_NORMAL) {
         if (!isMoveResizePointerButtonDown()) {
             setMoveResizePointerMode(PositionCenter);
             updateCursor();
         }
         bool lostMouse = !rect().contains(QPoint(e->event_x, e->event_y));
         // 'lostMouse' wouldn't work with e.g. B2 or Keramik, which have non-rectangular decorations
         // (i.e. the LeaveNotify event comes before leaving the rect and no LeaveNotify event
         // comes after leaving the rect) - so lets check if the pointer is really outside the window
 
         // TODO this still sucks if a window appears above this one - it should lose the mouse
         // if this window is another client, but not if it's a popup ... maybe after KDE3.1 :(
         // (repeat after me 'AARGHL!')
         if (!lostMouse && e->detail != XCB_NOTIFY_DETAIL_INFERIOR) {
             Xcb::Pointer pointer(frameId());
             if (!pointer || !pointer->same_screen || pointer->child == XCB_WINDOW_NONE) {
                 // really lost the mouse
                 lostMouse = true;
             }
         }
         if (lostMouse) {
             leaveEvent();
             cancelShadeHoverTimer();
             if (shade_mode == ShadeHover && !isMoveResize() && !isMoveResizePointerButtonDown()) {
                 shadeHoverTimer = new QTimer(this);
                 connect(shadeHoverTimer, SIGNAL(timeout()), this, SLOT(shadeUnhover()));
                 shadeHoverTimer->setSingleShot(true);
                 shadeHoverTimer->start(options->shadeHoverInterval());
             }
             if (isDecorated()) {
                 // sending a move instead of a leave. With leave we need to send proper coords, with move it's handled internally
                 QHoverEvent leaveEvent(QEvent::HoverMove, QPointF(-1, -1), QPointF(-1, -1), Qt::NoModifier);
                 QCoreApplication::sendEvent(decoration(), &leaveEvent);
             }
         }
         if (options->focusPolicy() == Options::FocusStrictlyUnderMouse && isActive() && lostMouse) {
             workspace()->requestDelayFocus(nullptr);
         }
         return;
     }
 }
 
 #define XCapL KKeyServer::modXLock()
 #define XNumL KKeyServer::modXNumLock()
 #define XScrL KKeyServer::modXScrollLock()
 void X11Client::grabButton(int modifier)
 {
     unsigned int mods[ 8 ] = {
         0, XCapL, XNumL, XNumL | XCapL,
         XScrL, XScrL | XCapL,
         XScrL | XNumL, XScrL | XNumL | XCapL
     };
     for (int i = 0;
             i < 8;
             ++i)
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC, modifier | mods[ i ]);
 }
 
 void X11Client::ungrabButton(int modifier)
 {
     unsigned int mods[ 8 ] = {
         0, XCapL, XNumL, XNumL | XCapL,
         XScrL, XScrL | XCapL,
         XScrL | XNumL, XScrL | XNumL | XCapL
     };
     for (int i = 0;
             i < 8;
             ++i)
         m_wrapper.ungrabButton(modifier | mods[ i ]);
 }
 #undef XCapL
 #undef XNumL
 #undef XScrL
 
 /**
  * Releases the passive grab for some modifier combinations when a
  * window becomes active. This helps broken X programs that
  * missinterpret LeaveNotify events in grab mode to work properly
  * (Motif, AWT, Tk, ...)
  */
 void X11Client::updateMouseGrab()
 {
     if (workspace()->globalShortcutsDisabled()) {
         m_wrapper.ungrabButton();
         // keep grab for the simple click without modifiers if needed (see below)
         bool not_obscured = workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
         if (!(!options->isClickRaise() || not_obscured))
             grabButton(XCB_NONE);
         return;
     }
     if (isActive() && !TabBox::TabBox::self()->forcedGlobalMouseGrab()) { // see TabBox::establishTabBoxGrab()
         // first grab all modifier combinations
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
         // remove the grab for no modifiers only if the window
         // is unobscured or if the user doesn't want click raise
         // (it is unobscured if it the topmost in the unconstrained stacking order, i.e. it is
         // the most recently raised window)
         bool not_obscured = workspace()->topClientOnDesktop(VirtualDesktopManager::self()->current(), -1, true, false) == this;
         if (!options->isClickRaise() || not_obscured)
             ungrabButton(XCB_NONE);
         else
             grabButton(XCB_NONE);
         ungrabButton(XCB_MOD_MASK_SHIFT);
         ungrabButton(XCB_MOD_MASK_CONTROL);
         ungrabButton(XCB_MOD_MASK_CONTROL | XCB_MOD_MASK_SHIFT);
     } else {
         m_wrapper.ungrabButton();
         // simply grab all modifier combinations
         m_wrapper.grabButton(XCB_GRAB_MODE_SYNC, XCB_GRAB_MODE_ASYNC);
     }
 }
 
 static bool modKeyDown(int state) {
     const uint keyModX = (options->keyCmdAllModKey() == Qt::Key_Meta) ?
                                                     KKeyServer::modXMeta() : KKeyServer::modXAlt();
     return keyModX  && (state & KKeyServer::accelModMaskX()) == keyModX;
 }
 
 
 // return value matters only when filtering events before decoration gets them
 bool X11Client::buttonPressEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root, xcb_timestamp_t time)
 {
     if (isMoveResizePointerButtonDown()) {
         if (w == wrapperId())
             xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
 
     if (w == wrapperId() || w == frameId() || w == inputId()) {
         // FRAME neco s tohohle by se melo zpracovat, nez to dostane dekorace
         updateUserTime(time);
         const bool bModKeyHeld = modKeyDown(state);
 
         if (isSplash()
                 && button == XCB_BUTTON_INDEX_1 && !bModKeyHeld) {
             // hide splashwindow if the user clicks on it
             hideClient(true);
             if (w == wrapperId())
                 xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
             return true;
         }
 
         Options::MouseCommand com = Options::MouseNothing;
         bool was_action = false;
         if (bModKeyHeld) {
             was_action = true;
             switch(button) {
             case XCB_BUTTON_INDEX_1:
                 com = options->commandAll1();
                 break;
             case XCB_BUTTON_INDEX_2:
                 com = options->commandAll2();
                 break;
             case XCB_BUTTON_INDEX_3:
                 com = options->commandAll3();
                 break;
             case XCB_BUTTON_INDEX_4:
             case XCB_BUTTON_INDEX_5:
                 com = options->operationWindowMouseWheel(button == XCB_BUTTON_INDEX_4 ? 120 : -120);
                 break;
             }
         } else {
             if (w == wrapperId()) {
                 if (button < 4) {
                     com = getMouseCommand(x11ToQtMouseButton(button), &was_action);
                 } else if (button < 6) {
                     com = getWheelCommand(Qt::Vertical, &was_action);
                 }
             }
         }
         if (was_action) {
             bool replay = performMouseCommand(com, QPoint(x_root, y_root));
 
             if (isSpecialWindow())
                 replay = true;
 
             if (w == wrapperId())  // these can come only from a grab
                 xcb_allow_events(connection(), replay ? XCB_ALLOW_REPLAY_POINTER : XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
             return true;
         }
     }
 
     if (w == wrapperId()) { // these can come only from a grab
         xcb_allow_events(connection(), XCB_ALLOW_REPLAY_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
     if (w == inputId()) {
         x = x_root - frameGeometry().x();
         y = y_root - frameGeometry().y();
         // New API processes core events FIRST and only passes unused ones to the decoration
         QMouseEvent ev(QMouseEvent::MouseButtonPress, QPoint(x, y), QPoint(x_root, y_root),
                        x11ToQtMouseButton(button), x11ToQtMouseButtons(state), Qt::KeyboardModifiers());
         return processDecorationButtonPress(&ev, true);
     }
     if (w == frameId() && isDecorated()) {
         if (button >= 4 && button <= 7) {
             const Qt::KeyboardModifiers modifiers = x11ToQtKeyboardModifiers(state);
             // Logic borrowed from qapplication_x11.cpp
             const int delta = 120 * ((button == 4 || button == 6) ? 1 : -1);
             const bool hor = (((button == 4 || button == 5) && (modifiers & Qt::AltModifier))
                              || (button == 6 || button == 7));
 
             const QPoint angle = hor ? QPoint(delta, 0) : QPoint(0, delta);
             QWheelEvent event(QPointF(x, y),
                               QPointF(x_root, y_root),
                               QPoint(),
                               angle,
                               delta,
                               hor ? Qt::Horizontal : Qt::Vertical,
                               x11ToQtMouseButtons(state),
                               modifiers);
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (!event.isAccepted() && !hor) {
                 if (titlebarPositionUnderMouse()) {
                     performMouseCommand(options->operationTitlebarMouseWheel(delta), QPoint(x_root, y_root));
                 }
             }
         } else {
             QMouseEvent event(QEvent::MouseButtonPress, QPointF(x, y), QPointF(x_root, y_root),
                             x11ToQtMouseButton(button), x11ToQtMouseButtons(state), x11ToQtKeyboardModifiers(state));
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (!event.isAccepted()) {
                 processDecorationButtonPress(&event);
             }
         }
         return true;
     }
     return true;
 }
 
 // return value matters only when filtering events before decoration gets them
 bool X11Client::buttonReleaseEvent(xcb_window_t w, int button, int state, int x, int y, int x_root, int y_root)
 {
     if (w == frameId() && isDecorated()) {
         // wheel handled on buttonPress
         if (button < 4 || button > 7) {
             QMouseEvent event(QEvent::MouseButtonRelease,
                               QPointF(x, y),
                               QPointF(x_root, y_root),
                               x11ToQtMouseButton(button),
                               x11ToQtMouseButtons(state) & ~x11ToQtMouseButton(button),
                               x11ToQtKeyboardModifiers(state));
             event.setAccepted(false);
             QCoreApplication::sendEvent(decoration(), &event);
             if (event.isAccepted() || !titlebarPositionUnderMouse()) {
                 invalidateDecorationDoubleClickTimer(); // click was for the deco and shall not init a doubleclick
             }
         }
     }
     if (w == wrapperId()) {
         xcb_allow_events(connection(), XCB_ALLOW_SYNC_POINTER, XCB_TIME_CURRENT_TIME);  //xTime());
         return true;
     }
     if (w != frameId() && w != inputId() && w != moveResizeGrabWindow())
         return true;
     if (w == frameId() && workspace()->userActionsMenu() && workspace()->userActionsMenu()->isShown()) {
         const_cast<UserActionsMenu*>(workspace()->userActionsMenu())->grabInput();
     }
     x = this->x(); // translate from grab window to local coords
     y = this->y();
 
     // Check whether other buttons are still left pressed
     int buttonMask = XCB_BUTTON_MASK_1 | XCB_BUTTON_MASK_2 | XCB_BUTTON_MASK_3;
     if (button == XCB_BUTTON_INDEX_1)
         buttonMask &= ~XCB_BUTTON_MASK_1;
     else if (button == XCB_BUTTON_INDEX_2)
         buttonMask &= ~XCB_BUTTON_MASK_2;
     else if (button == XCB_BUTTON_INDEX_3)
         buttonMask &= ~XCB_BUTTON_MASK_3;
 
     if ((state & buttonMask) == 0) {
         endMoveResize();
     }
     return true;
 }
 
 // return value matters only when filtering events before decoration gets them
 bool X11Client::motionNotifyEvent(xcb_window_t w, int state, int x, int y, int x_root, int y_root)
 {
     if (w == frameId() && isDecorated() && !isMinimized()) {
         // TODO Mouse move event dependent on state
         QHoverEvent event(QEvent::HoverMove, QPointF(x, y), QPointF(x, y));
         QCoreApplication::instance()->sendEvent(decoration(), &event);
     }
     if (w != frameId() && w != inputId() && w != moveResizeGrabWindow())
         return true; // care only about the whole frame
     if (!isMoveResizePointerButtonDown()) {
         if (w == inputId()) {
             int x = x_root - frameGeometry().x();// + padding_left;
             int y = y_root - frameGeometry().y();// + padding_top;
 
             if (isDecorated()) {
                 QHoverEvent event(QEvent::HoverMove, QPointF(x, y), QPointF(x, y));
                 QCoreApplication::instance()->sendEvent(decoration(), &event);
             }
         }
         Position newmode = modKeyDown(state) ? PositionCenter : mousePosition();
         if (newmode != moveResizePointerMode()) {
             setMoveResizePointerMode(newmode);
             updateCursor();
         }
         return false;
     }
     if (w == moveResizeGrabWindow()) {
         x = this->x(); // translate from grab window to local coords
         y = this->y();
     }
 
     handleMoveResize(QPoint(x, y), QPoint(x_root, y_root));
     return true;
 }
 
 void X11Client::focusInEvent(xcb_focus_in_event_t *e)
 {
     if (e->event != window())
         return; // only window gets focus
     if (e->mode == XCB_NOTIFY_MODE_UNGRAB)
         return; // we don't care
     if (e->detail == XCB_NOTIFY_DETAIL_POINTER)
         return;  // we don't care
     if (!isShown(false) || !isOnCurrentDesktop())    // we unmapped it, but it got focus meanwhile ->
         return;            // activateNextClient() already transferred focus elsewhere
     workspace()->forEachClient([](X11Client *client) {
         client->cancelFocusOutTimer();
     });
     // check if this client is in should_get_focus list or if activation is allowed
     bool activate =  workspace()->allowClientActivation(this, -1U, true);
     workspace()->gotFocusIn(this);   // remove from should_get_focus list
     if (activate)
         setActive(true);
     else {
         workspace()->restoreFocus();
         demandAttention();
     }
 }
 
 void X11Client::focusOutEvent(xcb_focus_out_event_t *e)
 {
     if (e->event != window())
         return; // only window gets focus
     if (e->mode == XCB_NOTIFY_MODE_GRAB)
         return; // we don't care
     if (isShade())
         return; // here neither
     if (e->detail != XCB_NOTIFY_DETAIL_NONLINEAR
             && e->detail != XCB_NOTIFY_DETAIL_NONLINEAR_VIRTUAL)
         // SELI check all this
         return; // hack for motif apps like netscape
     if (QApplication::activePopupWidget())
         return;
 
     // When a client loses focus, FocusOut events are usually immediatelly
     // followed by FocusIn events for another client that gains the focus
     // (unless the focus goes to another screen, or to the nofocus widget).
     // Without this check, the former focused client would have to be
     // deactivated, and after that, the new one would be activated, with
     // a short time when there would be no active client. This can cause
     // flicker sometimes, e.g. when a fullscreen is shown, and focus is transferred
     // from it to its transient, the fullscreen would be kept in the Active layer
     // at the beginning and at the end, but not in the middle, when the active
     // client would be temporarily none (see X11Client::belongToLayer() ).
     // Therefore the setActive(false) call is moved to the end of the current
     // event queue. If there is a matching FocusIn event in the current queue
     // this will be processed before the setActive(false) call and the activation
     // of the Client which gained FocusIn will automatically deactivate the
     // previously active client.
     if (!m_focusOutTimer) {
         m_focusOutTimer = new QTimer(this);
         m_focusOutTimer->setSingleShot(true);
         m_focusOutTimer->setInterval(0);
         connect(m_focusOutTimer, &QTimer::timeout, [this]() {
             setActive(false);
         });
     }
     m_focusOutTimer->start();
 }
 
 // performs _NET_WM_MOVERESIZE
 void X11Client::NETMoveResize(int x_root, int y_root, NET::Direction direction)
 {
     if (direction == NET::Move) {
         // move cursor to the provided position to prevent the window jumping there on first movement
         // the expectation is that the cursor is already at the provided position,
         // thus it's more a safety measurement
         Cursors::self()->mouse()->setPos(QPoint(x_root, y_root));
         performMouseCommand(Options::MouseMove, QPoint(x_root, y_root));
     } else if (isMoveResize() && direction == NET::MoveResizeCancel) {
         finishMoveResize(true);
         setMoveResizePointerButtonDown(false);
         updateCursor();
     } else if (direction >= NET::TopLeft && direction <= NET::Left) {
         static const Position convert[] = {
             PositionTopLeft,
             PositionTop,
             PositionTopRight,
             PositionRight,
             PositionBottomRight,
             PositionBottom,
             PositionBottomLeft,
             PositionLeft
         };
         if (!isResizable() || isShade())
             return;
         if (isMoveResize())
             finishMoveResize(false);
         setMoveResizePointerButtonDown(true);
         setMoveOffset(QPoint(x_root - x(), y_root - y()));  // map from global
         setInvertedMoveOffset(rect().bottomRight() - moveOffset());
         setUnrestrictedMoveResize(false);
         setMoveResizePointerMode(convert[ direction ]);
         if (!startMoveResize())
             setMoveResizePointerButtonDown(false);
         updateCursor();
     } else if (direction == NET::KeyboardMove) {
         // ignore mouse coordinates given in the message, mouse position is used by the moving algorithm
         Cursors::self()->mouse()->setPos(frameGeometry().center());
         performMouseCommand(Options::MouseUnrestrictedMove, frameGeometry().center());
     } else if (direction == NET::KeyboardSize) {
         // ignore mouse coordinates given in the message, mouse position is used by the resizing algorithm
         Cursors::self()->mouse()->setPos(frameGeometry().bottomRight());
         performMouseCommand(Options::MouseUnrestrictedResize, frameGeometry().bottomRight());
     }
 }
 
 void X11Client::keyPressEvent(uint key_code, xcb_timestamp_t time)
 {
     updateUserTime(time);
     AbstractClient::keyPressEvent(key_code);
 }
 
 // ****************************************
 // Unmanaged
 // ****************************************
 
 bool Unmanaged::windowEvent(xcb_generic_event_t *e)
 {
     double old_opacity = opacity();
     NET::Properties dirtyProperties;
     NET::Properties2 dirtyProperties2;
     info->event(e, &dirtyProperties, &dirtyProperties2);   // pass through the NET stuff
     if (dirtyProperties2 & NET::WM2Opacity) {
         if (compositing()) {
             addRepaintFull();
             emit opacityChanged(this, old_opacity);
         }
     }
     if (dirtyProperties2 & NET::WM2OpaqueRegion) {
         getWmOpaqueRegion();
     }
     if (dirtyProperties2.testFlag(NET::WM2WindowRole)) {
         emit windowRoleChanged();
     }
     if (dirtyProperties2.testFlag(NET::WM2WindowClass)) {
         getResourceClass();
     }
     const uint8_t eventType = e->response_type & ~0x80;
     switch (eventType) {
     case XCB_DESTROY_NOTIFY:
         release(ReleaseReason::Destroyed);
         break;
     case XCB_UNMAP_NOTIFY:{
         workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
 
         // unmap notify might have been emitted due to a destroy notify
         // but unmap notify gets emitted before the destroy notify, nevertheless at this
         // point the window is already destroyed. This means any XCB request with the window
         // will cause an error.
         // To not run into these errors we try to wait for the destroy notify. For this we
         // generate a round trip to the X server and wait a very short time span before
         // handling the release.
         updateXTime();
         // using 1 msec to not just move it at the end of the event loop but add an very short
         // timespan to cover cases like unmap() followed by destroy(). The only other way to
         // ensure that the window is not destroyed when we do the release handling is to grab
         // the XServer which we do not want to do for an Unmanaged. The timespan of 1 msec is
         // short enough to not cause problems in the close window animations.
         // It's of course still possible that we miss the destroy in which case non-fatal
         // X errors are reported to the event loop and logged by Qt.
         m_scheduledRelease = true;
         QTimer::singleShot(1, this, SLOT(release()));
         break;
     }
     case XCB_CONFIGURE_NOTIFY:
         configureNotifyEvent(reinterpret_cast<xcb_configure_notify_event_t*>(e));
         break;
     case XCB_PROPERTY_NOTIFY:
         propertyNotifyEvent(reinterpret_cast<xcb_property_notify_event_t*>(e));
         break;
     case XCB_CLIENT_MESSAGE:
         clientMessageEvent(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     default: {
         if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
             detectShape(window());
             addRepaintFull();
             addWorkspaceRepaint(frameGeometry());  // in case shape change removes part of this window
             emit geometryShapeChanged(this, frameGeometry());
         }
         if (eventType == Xcb::Extensions::self()->damageNotifyEvent())
             damageNotifyEvent();
         break;
     }
     }
     return false; // don't eat events, even our own unmanaged widgets are tracked
 }
 
 void Unmanaged::configureNotifyEvent(xcb_configure_notify_event_t *e)
 {
     if (effects)
         static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowStacking(); // keep them on top
     QRect newgeom(e->x, e->y, e->width, e->height);
     if (newgeom != m_frameGeometry) {
         addWorkspaceRepaint(visibleRect());  // damage old area
         QRect old = m_frameGeometry;
         m_frameGeometry = newgeom;
         emit frameGeometryChanged(this, old); // update shadow region
         addRepaintFull();
         if (old.size() != m_frameGeometry.size())
             discardWindowPixmap();
         emit geometryShapeChanged(this, old);
     }
 }
 
 // ****************************************
 // Toplevel
 // ****************************************
 
 void Toplevel::propertyNotifyEvent(xcb_property_notify_event_t *e)
 {
     if (e->window != window())
         return; // ignore frame/wrapper
     switch(e->atom) {
     default:
         if (e->atom == atoms->wm_client_leader)
             getWmClientLeader();
         else if (e->atom == atoms->kde_net_wm_shadow)
             updateShadow();
         else if (e->atom == atoms->kde_skip_close_animation)
             getSkipCloseAnimation();
         break;
     }
 }
 
 void Toplevel::clientMessageEvent(xcb_client_message_event_t *e)
 {
     if (e->type == atoms->wl_surface_id) {
         m_surfaceId = e->data.data32[0];
         if (auto w = waylandServer()) {
-            if (auto s = KWayland::Server::SurfaceInterface::get(m_surfaceId, w->xWaylandConnection())) {
+            if (auto s = KWaylandServer::SurfaceInterface::get(m_surfaceId, w->xWaylandConnection())) {
                 setSurface(s);
             }
         }
         emit surfaceIdChanged(m_surfaceId);
     }
 }
 
 } // namespace
diff --git a/idle_inhibition.cpp b/idle_inhibition.cpp
index 662c430b0..f2acd88ae 100644
--- a/idle_inhibition.cpp
+++ b/idle_inhibition.cpp
@@ -1,121 +1,121 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "idle_inhibition.h"
 #include "abstract_client.h"
 #include "deleted.h"
 #include "workspace.h"
 
-#include <KWayland/Server/idle_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/idle_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <algorithm>
 #include <functional>
 
-using KWayland::Server::SurfaceInterface;
+using KWaylandServer::SurfaceInterface;
 
 namespace KWin
 {
 
 IdleInhibition::IdleInhibition(IdleInterface *idle)
     : QObject(idle)
     , m_idle(idle)
 {
     // Workspace is created after the wayland server is initialized.
     connect(kwinApp(), &Application::workspaceCreated, this, &IdleInhibition::slotWorkspaceCreated);
 }
 
 IdleInhibition::~IdleInhibition() = default;
 
 void IdleInhibition::registerClient(AbstractClient *client)
 {
     auto updateInhibit = [this, client] {
         update(client);
     };
 
     m_connections[client] = connect(client->surface(), &SurfaceInterface::inhibitsIdleChanged, this, updateInhibit);
     connect(client, &AbstractClient::desktopChanged, this, updateInhibit);
     connect(client, &AbstractClient::clientMinimized, this, updateInhibit);
     connect(client, &AbstractClient::clientUnminimized, this, updateInhibit);
     connect(client, &AbstractClient::windowHidden, this, updateInhibit);
     connect(client, &AbstractClient::windowShown, this, updateInhibit);
     connect(client, &AbstractClient::windowClosed, this,
         [this, client] {
             uninhibit(client);
             auto it = m_connections.find(client);
             if (it != m_connections.end()) {
                 disconnect(it.value());
                 m_connections.erase(it);
             }
         }
     );
 
     updateInhibit();
 }
 
 void IdleInhibition::inhibit(AbstractClient *client)
 {
     if (isInhibited(client)) {
         // already inhibited
         return;
     }
     m_idleInhibitors << client;
     m_idle->inhibit();
     // TODO: notify powerdevil?
 }
 
 void IdleInhibition::uninhibit(AbstractClient *client)
 {
     auto it = std::find(m_idleInhibitors.begin(), m_idleInhibitors.end(), client);
     if (it == m_idleInhibitors.end()) {
         // not inhibited
         return;
     }
     m_idleInhibitors.erase(it);
     m_idle->uninhibit();
 }
 
 void IdleInhibition::update(AbstractClient *client)
 {
     if (client->isInternal()) {
         return;
     }
 
     // TODO: Don't honor the idle inhibitor object if the shell client is not
     // on the current activity (currently, activities are not supported).
     const bool visible = client->isShown(true) && client->isOnCurrentDesktop();
     if (visible && client->surface() && client->surface()->inhibitsIdle()) {
         inhibit(client);
     } else {
         uninhibit(client);
     }
 }
 
 void IdleInhibition::slotWorkspaceCreated()
 {
     connect(workspace(), &Workspace::currentDesktopChanged, this, &IdleInhibition::slotDesktopChanged);
 }
 
 void IdleInhibition::slotDesktopChanged()
 {
     workspace()->forEachAbstractClient([this] (AbstractClient *c) { update(c); });
 }
 
 }
diff --git a/idle_inhibition.h b/idle_inhibition.h
index aefa487de..eb870fc9c 100644
--- a/idle_inhibition.h
+++ b/idle_inhibition.h
@@ -1,70 +1,67 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2017 Martin Flöser <mgraesslin@kde.org>
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #pragma once
 
 #include <QObject>
 #include <QVector>
 #include <QMap>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class IdleInterface;
 }
-}
 
-using KWayland::Server::IdleInterface;
+using KWaylandServer::IdleInterface;
 
 namespace KWin
 {
 class AbstractClient;
 
 class IdleInhibition : public QObject
 {
     Q_OBJECT
 public:
     explicit IdleInhibition(IdleInterface *idle);
     ~IdleInhibition() override;
 
     void registerClient(AbstractClient *client);
 
     bool isInhibited() const {
         return !m_idleInhibitors.isEmpty();
     }
     bool isInhibited(AbstractClient *client) const {
         return m_idleInhibitors.contains(client);
     }
 
 private Q_SLOTS:
     void slotWorkspaceCreated();
     void slotDesktopChanged();
 
 private:
     void inhibit(AbstractClient *client);
     void uninhibit(AbstractClient *client);
     void update(AbstractClient *client);
 
     IdleInterface *m_idle;
     QVector<AbstractClient *> m_idleInhibitors;
     QMap<AbstractClient *, QMetaObject::Connection> m_connections;
 };
 }
diff --git a/input.cpp b/input.cpp
index 41155fd40..a0ba034ce 100644
--- a/input.cpp
+++ b/input.cpp
@@ -1,2751 +1,2751 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "input.h"
 #include "effects.h"
 #include "gestures.h"
 #include "globalshortcuts.h"
 #include "input_event.h"
 #include "input_event_spy.h"
 #include "keyboard_input.h"
 #include "logind.h"
 #include "main.h"
 #include "pointer_input.h"
 #include "tablet_input.h"
 #include "touch_hide_cursor_spy.h"
 #include "touch_input.h"
 #include "x11client.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox/tabbox.h"
 #endif
 #include "internal_client.h"
 #include "libinput/connection.h"
 #include "libinput/device.h"
 #include "platform.h"
 #include "popup_input_filter.h"
 #include "screenedge.h"
 #include "screens.h"
 #include "unmanaged.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xdgshellclient.h"
 #include "xwl/xwayland_interface.h"
 #include "cursor.h"
 #include <KDecoration2/Decoration>
 #include <KGlobalAccel>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/fakeinput_interface.h>
-#include <KWayland/Server/relativepointer_interface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/tablet_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/fakeinput_interface.h>
+#include <KWaylandServer/relativepointer_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/tablet_interface.h>
 #include <decorations/decoratedclient.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 // Qt
 #include <QKeyEvent>
 
 #include <xkbcommon/xkbcommon.h>
 
 namespace KWin
 {
 
 InputEventFilter::InputEventFilter() = default;
 
 InputEventFilter::~InputEventFilter()
 {
     if (input()) {
         input()->uninstallInputEventFilter(this);
     }
 }
 
 bool InputEventFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(event)
     Q_UNUSED(nativeButton)
     return false;
 }
 
 bool InputEventFilter::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::keyEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::touchDown(qint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::touchMotion(qint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::touchUp(qint32 id, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(scale)
     Q_UNUSED(angleDelta)
     Q_UNUSED(delta)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::pinchGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(delta)
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::swipeGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
     return false;
 }
 
 bool InputEventFilter::switchEvent(SwitchEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::tabletToolEvent(TabletEvent *event)
 {
     Q_UNUSED(event)
     return false;
 }
 
 bool InputEventFilter::tabletToolButtonEvent(const QSet<uint> &pressedButtons)
 {
     Q_UNUSED(pressedButtons)
     return false;
 }
 
 bool InputEventFilter::tabletPadButtonEvent(const QSet<uint> &pressedButtons)
 {
     Q_UNUSED(pressedButtons)
     return false;
 }
 
 bool InputEventFilter::tabletPadStripEvent(int number, int position, bool isFinger)
 {
     Q_UNUSED(number)
     Q_UNUSED(position)
     Q_UNUSED(isFinger)
     return false;
 }
 
 bool InputEventFilter::tabletPadRingEvent(int number, int position, bool isFinger)
 {
     Q_UNUSED(number)
     Q_UNUSED(position)
     Q_UNUSED(isFinger)
     return false;
 }
 
 void InputEventFilter::passToWaylandServer(QKeyEvent *event)
 {
     Q_ASSERT(waylandServer());
     if (event->isAutoRepeat()) {
         return;
     }
     switch (event->type()) {
     case QEvent::KeyPress:
         waylandServer()->seat()->keyPressed(event->nativeScanCode());
         break;
     case QEvent::KeyRelease:
         waylandServer()->seat()->keyReleased(event->nativeScanCode());
         break;
     default:
         break;
     }
 }
 
 class VirtualTerminalFilter : public InputEventFilter {
 public:
     bool keyEvent(QKeyEvent *event) override {
         // really on press and not on release? X11 switches on press.
         if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
             const xkb_keysym_t keysym = event->nativeVirtualKey();
             if (keysym >= XKB_KEY_XF86Switch_VT_1 && keysym <= XKB_KEY_XF86Switch_VT_12) {
                 LogindIntegration::self()->switchVirtualTerminal(keysym - XKB_KEY_XF86Switch_VT_1 + 1);
                 return true;
             }
         }
         return false;
     }
 };
 
 class TerminateServerFilter : public InputEventFilter {
 public:
     bool keyEvent(QKeyEvent *event) override {
         if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
             if (event->nativeVirtualKey() == XKB_KEY_Terminate_Server) {
                 qCWarning(KWIN_CORE) << "Request to terminate server";
                 QMetaObject::invokeMethod(qApp, "quit", Qt::QueuedConnection);
                 return true;
             }
         }
         return false;
     }
 };
 
 class LockScreenFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         if (event->type() == QEvent::MouseMove) {
             if (pointerSurfaceAllowed()) {
                 // TODO: should the pointer position always stay in sync, i.e. not do the check?
                 seat->setPointerPos(event->screenPos().toPoint());
             }
         } else if (event->type() == QEvent::MouseButtonPress || event->type() == QEvent::MouseButtonRelease) {
             if (pointerSurfaceAllowed()) {
                 // TODO: can we leak presses/releases here when we move the mouse in between from an allowed surface to
                 //       disallowed one or vice versa?
                 event->type() == QEvent::MouseButtonPress ? seat->pointerButtonPressed(nativeButton) : seat->pointerButtonReleased(nativeButton);
             }
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         if (pointerSurfaceAllowed()) {
             seat->setTimestamp(event->timestamp());
             const Qt::Orientation orientation = event->angleDelta().x() == 0 ? Qt::Vertical : Qt::Horizontal;
             seat->pointerAxis(orientation, orientation == Qt::Horizontal ? event->angleDelta().x() : event->angleDelta().y());
         }
         return true;
     }
     bool keyEvent(QKeyEvent * event) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         if (event->isAutoRepeat()) {
             // wayland client takes care of it
             return true;
         }
         // send event to KSldApp for global accel
         // if event is set to accepted it means a whitelisted shortcut was triggered
         // in that case we filter it out and don't process it further
         event->setAccepted(false);
         QCoreApplication::sendEvent(ScreenLocker::KSldApp::self(), event);
         if (event->isAccepted()) {
             return true;
         }
 
         // continue normal processing
         input()->keyboard()->update();
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         if (!keyboardSurfaceAllowed()) {
             // don't pass event to seat
             return true;
         }
         switch (event->type()) {
         case QEvent::KeyPress:
             seat->keyPressed(event->nativeScanCode());
             break;
         case QEvent::KeyRelease:
             seat->keyReleased(event->nativeScanCode());
             break;
         default:
             break;
         }
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             input()->touch()->insertId(id, seat->touchDown(pos));
         }
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             const qint32 kwaylandId = input()->touch()->mappedId(id);
             if (kwaylandId != -1) {
                 seat->touchMove(kwaylandId, pos);
             }
         }
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         if (!waylandServer()->isScreenLocked()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         if (touchSurfaceAllowed()) {
             const qint32 kwaylandId = input()->touch()->mappedId(id);
             if (kwaylandId != -1) {
                 seat->touchUp(kwaylandId);
                 input()->touch()->removeId(id);
             }
         }
         return true;
     }
     bool pinchGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(fingerCount)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override {
         Q_UNUSED(scale)
         Q_UNUSED(angleDelta)
         Q_UNUSED(delta)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool pinchGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
 
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(fingerCount)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         Q_UNUSED(delta)
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
     bool swipeGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         // no touchpad multi-finger gestures on lock screen
         return waylandServer()->isScreenLocked();
     }
 private:
-    bool surfaceAllowed(KWayland::Server::SurfaceInterface *(KWayland::Server::SeatInterface::*method)() const) const {
-        if (KWayland::Server::SurfaceInterface *s = (waylandServer()->seat()->*method)()) {
+    bool surfaceAllowed(KWaylandServer::SurfaceInterface *(KWaylandServer::SeatInterface::*method)() const) const {
+        if (KWaylandServer::SurfaceInterface *s = (waylandServer()->seat()->*method)()) {
             if (Toplevel *t = waylandServer()->findClient(s)) {
                 return t->isLockScreen() || t->isInputMethod();
             }
             return false;
         }
         return true;
     }
     bool pointerSurfaceAllowed() const {
-        return surfaceAllowed(&KWayland::Server::SeatInterface::focusedPointerSurface);
+        return surfaceAllowed(&KWaylandServer::SeatInterface::focusedPointerSurface);
     }
     bool keyboardSurfaceAllowed() const {
-        return surfaceAllowed(&KWayland::Server::SeatInterface::focusedKeyboardSurface);
+        return surfaceAllowed(&KWaylandServer::SeatInterface::focusedKeyboardSurface);
     }
     bool touchSurfaceAllowed() const {
-        return surfaceAllowed(&KWayland::Server::SeatInterface::focusedTouchSurface);
+        return surfaceAllowed(&KWaylandServer::SeatInterface::focusedTouchSurface);
     }
 };
 
 class EffectsFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (!effects) {
             return false;
         }
         return static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event);
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!effects) {
             return false;
         }
         return static_cast<EffectsHandlerImpl*>(effects)->checkInputWindowEvent(event);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!effects || !static_cast< EffectsHandlerImpl* >(effects)->hasKeyboardGrab()) {
             return false;
         }
         waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
         passToWaylandServer(event);
         static_cast< EffectsHandlerImpl* >(effects)->grabbedKeyboardEvent(event);
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchDown(id, pos, time);
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchMotion(id, pos, time);
     }
     bool touchUp(qint32 id, quint32 time) override {
         if (!effects) {
             return false;
         }
         return static_cast< EffectsHandlerImpl* >(effects)->touchUp(id, time);
     }
 };
 
 class MoveResizeFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         switch (event->type()) {
         case QEvent::MouseMove:
             c->updateMoveResize(event->screenPos().toPoint());
             break;
         case QEvent::MouseButtonRelease:
             if (event->buttons() == Qt::NoButton) {
                 c->endMoveResize();
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         Q_UNUSED(event)
         // filter out while moving a window
         return workspace()->moveResizeClient() != nullptr;
     }
     bool keyEvent(QKeyEvent *event) override {
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         if (event->type() == QEvent::KeyPress) {
             c->keyPressEvent(event->key() | event->modifiers());
             if (c->isMove() || c->isResize()) {
                 // only update if mode didn't end
                 c->updateMoveResize(input()->globalPointer());
             }
         }
         return true;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(id)
         Q_UNUSED(pos)
         Q_UNUSED(time)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         return true;
     }
 
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         if (!m_set) {
             m_id = id;
             m_set = true;
         }
         if (m_id == id) {
             c->updateMoveResize(pos.toPoint());
         }
         return true;
     }
 
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time)
         AbstractClient *c = workspace()->moveResizeClient();
         if (!c) {
             return false;
         }
         if (m_id == id || !m_set) {
             c->endMoveResize();
             m_set = false;
             // pass through to update decoration filter later on
             return false;
         }
         m_set = false;
         return true;
     }
 private:
     qint32 m_id = 0;
     bool m_set = false;
 };
 
 class WindowSelectorFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (!m_active) {
             return false;
         }
         switch (event->type()) {
         case QEvent::MouseButtonRelease:
             if (event->buttons() == Qt::NoButton) {
                 if (event->button() == Qt::RightButton) {
                     cancel();
                 } else {
                     accept(event->globalPos());
                 }
             }
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         Q_UNUSED(event)
         // filter out while selecting a window
         return m_active;
     }
     bool keyEvent(QKeyEvent *event) override {
         Q_UNUSED(event)
         if (!m_active) {
             return false;
         }
         waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
         passToWaylandServer(event);
 
         if (event->type() == QEvent::KeyPress) {
             // x11 variant does this on key press, so do the same
             if (event->key() == Qt::Key_Escape) {
                 cancel();
             } else if (event->key() == Qt::Key_Enter ||
                        event->key() == Qt::Key_Return ||
                        event->key() == Qt::Key_Space) {
                 accept(input()->globalPointer());
             }
             if (input()->supportsPointerWarping()) {
                 int mx = 0;
                 int my = 0;
                 if (event->key() == Qt::Key_Left) {
                     mx = -10;
                 }
                 if (event->key() == Qt::Key_Right) {
                     mx = 10;
                 }
                 if (event->key() == Qt::Key_Up) {
                     my = -10;
                 }
                 if (event->key() == Qt::Key_Down) {
                     my = 10;
                 }
                 if (event->modifiers() & Qt::ControlModifier) {
                     mx /= 10;
                     my /= 10;
                 }
                 input()->warpPointer(input()->globalPointer() + QPointF(mx, my));
             }
         }
         // filter out while selecting a window
         return true;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         if (!isActive()) {
             return false;
         }
         m_touchPoints.insert(id, pos);
         return true;
     }
 
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         if (!isActive()) {
             return false;
         }
         auto it = m_touchPoints.find(id);
         if (it != m_touchPoints.end()) {
             *it = pos;
         }
         return true;
     }
 
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time)
         if (!isActive()) {
             return false;
         }
         auto it = m_touchPoints.find(id);
         if (it != m_touchPoints.end()) {
             const auto pos = it.value();
             m_touchPoints.erase(it);
             if (m_touchPoints.isEmpty()) {
                 accept(pos);
             }
         }
         return true;
     }
 
     bool isActive() const {
         return m_active;
     }
     void start(std::function<void(KWin::Toplevel*)> callback) {
         Q_ASSERT(!m_active);
         m_active = true;
         m_callback = callback;
         input()->keyboard()->update();
         input()->cancelTouch();
     }
     void start(std::function<void(const QPoint &)> callback) {
         Q_ASSERT(!m_active);
         m_active = true;
         m_pointSelectionFallback = callback;
         input()->keyboard()->update();
         input()->cancelTouch();
     }
 private:
     void deactivate() {
         m_active = false;
         m_callback = std::function<void(KWin::Toplevel*)>();
         m_pointSelectionFallback = std::function<void(const QPoint &)>();
         input()->pointer()->removeWindowSelectionCursor();
         input()->keyboard()->update();
         m_touchPoints.clear();
     }
     void cancel() {
         if (m_callback) {
             m_callback(nullptr);
         }
         if (m_pointSelectionFallback) {
             m_pointSelectionFallback(QPoint(-1, -1));
         }
         deactivate();
     }
     void accept(const QPoint &pos) {
         if (m_callback) {
             // TODO: this ignores shaped windows
             m_callback(input()->findToplevel(pos));
         }
         if (m_pointSelectionFallback) {
             m_pointSelectionFallback(pos);
         }
         deactivate();
     }
     void accept(const QPointF &pos) {
         accept(pos.toPoint());
     }
     bool m_active = false;
     std::function<void(KWin::Toplevel*)> m_callback;
     std::function<void(const QPoint &)> m_pointSelectionFallback;
     QMap<quint32, QPointF> m_touchPoints;
 };
 
 class GlobalShortcutFilter : public InputEventFilter {
 public:
     GlobalShortcutFilter() {
         m_powerDown = new QTimer;
         m_powerDown->setSingleShot(true);
         m_powerDown->setInterval(1000);
     }
     ~GlobalShortcutFilter() {
         delete m_powerDown;
     }
 
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton);
         if (event->type() == QEvent::MouseButtonPress) {
             if (input()->shortcuts()->processPointerPressed(event->modifiers(), event->buttons())) {
                 return true;
             }
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (event->modifiers() == Qt::NoModifier) {
             return false;
         }
         PointerAxisDirection direction = PointerAxisUp;
         if (event->angleDelta().x() < 0) {
             direction = PointerAxisRight;
         } else if (event->angleDelta().x() > 0) {
             direction = PointerAxisLeft;
         } else if (event->angleDelta().y() < 0) {
             direction = PointerAxisDown;
         } else if (event->angleDelta().y() > 0) {
             direction = PointerAxisUp;
         }
         return input()->shortcuts()->processAxis(event->modifiers(), direction);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (event->key() == Qt::Key_PowerOff) {
             const auto modifiers = static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts();
             if (event->type() == QEvent::KeyPress && !event->isAutoRepeat()) {
                 QObject::connect(m_powerDown, &QTimer::timeout, input()->shortcuts(), [this, modifiers] {
                     QObject::disconnect(m_powerDown, &QTimer::timeout, input()->shortcuts(), nullptr);
                     m_powerDown->stop();
                     input()->shortcuts()->processKey(modifiers, Qt::Key_PowerDown);
                 });
                 m_powerDown->start();
                 return true;
             } else if (event->type() == QEvent::KeyRelease) {
                 const bool ret = !m_powerDown->isActive() || input()->shortcuts()->processKey(modifiers, event->key());
                 m_powerDown->stop();
                 return ret;
             }
         } else if (event->type() == QEvent::KeyPress) {
             return input()->shortcuts()->processKey(static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts(), event->key());
         }
         return false;
     }
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeStart(fingerCount);
         return false;
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeUpdate(delta);
         return false;
     }
     bool swipeGestureCancelled(quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeCancel();
         return false;
     }
     bool swipeGestureEnd(quint32 time) override {
         Q_UNUSED(time)
         input()->shortcuts()->processSwipeEnd();
         return false;
     }
 
 private:
     QTimer* m_powerDown = nullptr;
 };
 
 
 namespace {
 
 enum class MouseAction {
     ModifierOnly,
     ModifierAndWindow
 };
 std::pair<bool, bool> performClientMouseAction(QMouseEvent *event, AbstractClient *client, MouseAction action = MouseAction::ModifierOnly)
 {
     Options::MouseCommand command = Options::MouseNothing;
     bool wasAction = false;
     if (static_cast<MouseEvent*>(event)->modifiersRelevantForGlobalShortcuts() == options->commandAllModifier()) {
         if (!input()->pointer()->isConstrained() && !workspace()->globalShortcutsDisabled()) {
             wasAction = true;
             switch (event->button()) {
             case Qt::LeftButton:
                 command = options->commandAll1();
                 break;
             case Qt::MiddleButton:
                 command = options->commandAll2();
                 break;
             case Qt::RightButton:
                 command = options->commandAll3();
                 break;
             default:
                 // nothing
                 break;
             }
         }
     } else {
         if (action == MouseAction::ModifierAndWindow) {
             command = client->getMouseCommand(event->button(), &wasAction);
         }
     }
     if (wasAction) {
         return std::make_pair(wasAction, !client->performMouseCommand(command, event->globalPos()));
     }
     return std::make_pair(wasAction, false);
 }
 
 std::pair<bool, bool> performClientWheelAction(QWheelEvent *event, AbstractClient *c, MouseAction action = MouseAction::ModifierOnly)
 {
     bool wasAction = false;
     Options::MouseCommand command = Options::MouseNothing;
     if (static_cast<WheelEvent*>(event)->modifiersRelevantForGlobalShortcuts() == options->commandAllModifier()) {
         if (!input()->pointer()->isConstrained() && !workspace()->globalShortcutsDisabled()) {
             wasAction = true;
             command = options->operationWindowMouseWheel(-1 * event->angleDelta().y());
         }
     } else {
         if (action == MouseAction::ModifierAndWindow) {
             command = c->getWheelCommand(Qt::Vertical, &wasAction);
         }
     }
     if (wasAction) {
         return std::make_pair(wasAction, !c->performMouseCommand(command, event->globalPos()));
     }
     return std::make_pair(wasAction, false);
 }
 
 }
 
 class InternalWindowEventFilter : public InputEventFilter {
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         auto internal = input()->pointer()->internalWindow();
         if (!internal) {
             return false;
         }
         // find client
         switch (event->type())
         {
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease: {
             auto s = qobject_cast<InternalClient *>(workspace()->findInternal(internal));
             if (s && s->isDecorated()) {
                 // only perform mouse commands on decorated internal windows
                 const auto actionResult = performClientMouseAction(event, s);
                 if (actionResult.first) {
                     return actionResult.second;
                 }
             }
             break;
         }
         default:
             break;
         }
         QMouseEvent e(event->type(),
                         event->pos() - internal->position(),
                         event->globalPos(),
                         event->button(), event->buttons(), event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return e.isAccepted();
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto internal = input()->pointer()->internalWindow();
         if (!internal) {
             return false;
         }
         if (event->angleDelta().y() != 0) {
             auto s = qobject_cast<InternalClient *>(workspace()->findInternal(internal));
             if (s && s->isDecorated()) {
                 // client window action only on vertical scrolling
                 const auto actionResult = performClientWheelAction(event, s);
                 if (actionResult.first) {
                     return actionResult.second;
                 }
             }
         }
         const QPointF localPos = event->globalPosF() - QPointF(internal->x(), internal->y());
         const Qt::Orientation orientation = (event->angleDelta().x() != 0) ? Qt::Horizontal : Qt::Vertical;
         const int delta = event->angleDelta().x() != 0 ? event->angleDelta().x() : event->angleDelta().y();
         QWheelEvent e(localPos, event->globalPosF(), QPoint(),
                         event->angleDelta() * -1,
                         delta * -1,
                         orientation,
                         event->buttons(),
                         event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return e.isAccepted();
     }
     bool keyEvent(QKeyEvent *event) override {
         const QList<InternalClient *> &internalClients = workspace()->internalClients();
         if (internalClients.isEmpty()) {
             return false;
         }
         QWindow *found = nullptr;
         auto it = internalClients.end();
         do {
             it--;
             if (QWindow *w = (*it)->internalWindow()) {
                 if (!w->isVisible()) {
                     continue;
                 }
                 if (!screens()->geometry().contains(w->geometry())) {
                     continue;
                 }
                 if (w->property("_q_showWithoutActivating").toBool()) {
                     continue;
                 }
                 if (w->property("outputOnly").toBool()) {
                     continue;
                 }
                 if (w->flags().testFlag(Qt::ToolTip)) {
                     continue;
                 }
                 found = w;
                 break;
             }
         } while (it != internalClients.begin());
         if (!found) {
             return false;
         }
         auto xkb = input()->keyboard()->xkb();
         Qt::Key key = xkb->toQtKey(xkb->toKeysym(event->nativeScanCode()));
         if (key == Qt::Key_Super_L || key == Qt::Key_Super_R) {
             // workaround for QTBUG-62102
             key = Qt::Key_Meta;
         }
         QKeyEvent internalEvent(event->type(), key,
                                 event->modifiers(), event->nativeScanCode(), event->nativeVirtualKey(),
                                 event->nativeModifiers(), event->text());
         internalEvent.setAccepted(false);
         if (QCoreApplication::sendEvent(found, &internalEvent)) {
             waylandServer()->seat()->setFocusedKeyboardSurface(nullptr);
             passToWaylandServer(event);
             return true;
         }
         return false;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             // something else is getting the events
             return false;
         }
         auto touch = input()->touch();
         if (touch->internalPressId() != -1) {
             // already on internal window, ignore further touch points, but filter out
             return true;
         }
         // a new touch point
         seat->setTimestamp(time);
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         touch->setInternalPressId(id);
         // Qt's touch event API is rather complex, let's do fake mouse events instead
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - QPointF(internal->x(), internal->y());
 
         QEnterEvent enterEvent(m_lastLocalTouchPos, m_lastLocalTouchPos, pos);
         QCoreApplication::sendEvent(internal.data(), &enterEvent);
 
         QMouseEvent e(QEvent::MouseButtonPress, m_lastLocalTouchPos, pos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         auto touch = input()->touch();
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         if (touch->internalPressId() == -1) {
             return false;
         }
         waylandServer()->seat()->setTimestamp(time);
         if (touch->internalPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - QPointF(internal->x(), internal->y());
 
         QMouseEvent e(QEvent::MouseMove, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         QCoreApplication::instance()->sendEvent(internal.data(), &e);
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         auto touch = input()->touch();
         auto internal = touch->internalWindow();
         if (!internal) {
             return false;
         }
         if (touch->internalPressId() == -1) {
             return false;
         }
         waylandServer()->seat()->setTimestamp(time);
         if (touch->internalPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         // send mouse up
         QMouseEvent e(QEvent::MouseButtonRelease, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::MouseButtons(), input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(internal.data(), &e);
 
         QEvent leaveEvent(QEvent::Leave);
         QCoreApplication::sendEvent(internal.data(), &leaveEvent);
 
         m_lastGlobalTouchPos = QPointF();
         m_lastLocalTouchPos = QPointF();
         input()->touch()->setInternalPressId(-1);
         return true;
     }
 private:
     QPointF m_lastGlobalTouchPos;
     QPointF m_lastLocalTouchPos;
 };
 
 class DecorationEventFilter : public InputEventFilter {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         auto decoration = input()->pointer()->decoration();
         if (!decoration) {
             return false;
         }
         const QPointF p = event->globalPos() - decoration->client()->pos();
         switch (event->type()) {
         case QEvent::MouseMove: {
             QHoverEvent e(QEvent::HoverMove, p, p);
             QCoreApplication::instance()->sendEvent(decoration->decoration(), &e);
             decoration->client()->processDecorationMove(p.toPoint(), event->globalPos());
             return true;
         }
         case QEvent::MouseButtonPress:
         case QEvent::MouseButtonRelease: {
             const auto actionResult = performClientMouseAction(event, decoration->client());
             if (actionResult.first) {
                 return actionResult.second;
             }
             QMouseEvent e(event->type(), p, event->globalPos(), event->button(), event->buttons(), event->modifiers());
             e.setAccepted(false);
             QCoreApplication::sendEvent(decoration->decoration(), &e);
             if (!e.isAccepted() && event->type() == QEvent::MouseButtonPress) {
                 decoration->client()->processDecorationButtonPress(&e);
             }
             if (event->type() == QEvent::MouseButtonRelease) {
                 decoration->client()->processDecorationButtonRelease(&e);
             }
             return true;
         }
         default:
             break;
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto decoration = input()->pointer()->decoration();
         if (!decoration) {
             return false;
         }
         if (event->angleDelta().y() != 0) {
             // client window action only on vertical scrolling
             const auto actionResult = performClientWheelAction(event, decoration->client());
             if (actionResult.first) {
                 return actionResult.second;
             }
         }
         const QPointF localPos = event->globalPosF() - decoration->client()->pos();
         const Qt::Orientation orientation = (event->angleDelta().x() != 0) ? Qt::Horizontal : Qt::Vertical;
         const int delta = event->angleDelta().x() != 0 ? event->angleDelta().x() : event->angleDelta().y();
         QWheelEvent e(localPos, event->globalPosF(), QPoint(),
                         event->angleDelta(),
                         delta,
                         orientation,
                         event->buttons(),
                         event->modifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration.data(), &e);
         if (e.isAccepted()) {
             return true;
         }
         if ((orientation == Qt::Vertical) && decoration->client()->titlebarPositionUnderMouse()) {
             decoration->client()->performMouseCommand(options->operationTitlebarMouseWheel(delta * -1),
                                                         event->globalPosF().toPoint());
         }
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             return false;
         }
         if (input()->touch()->decorationPressId() != -1) {
             // already on a decoration, ignore further touch points, but filter out
             return true;
         }
         seat->setTimestamp(time);
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
 
         input()->touch()->setDecorationPressId(id);
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - decoration->client()->pos();
 
         QHoverEvent hoverEvent(QEvent::HoverMove, m_lastLocalTouchPos, m_lastLocalTouchPos);
         QCoreApplication::sendEvent(decoration->decoration(), &hoverEvent);
 
         QMouseEvent e(QEvent::MouseButtonPress, m_lastLocalTouchPos, pos, Qt::LeftButton, Qt::LeftButton, input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration->decoration(), &e);
         if (!e.isAccepted()) {
             decoration->client()->processDecorationButtonPress(&e);
         }
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         if (input()->touch()->decorationPressId() == -1) {
             return false;
         }
         if (input()->touch()->decorationPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
         m_lastGlobalTouchPos = pos;
         m_lastLocalTouchPos = pos - decoration->client()->pos();
 
         QHoverEvent e(QEvent::HoverMove, m_lastLocalTouchPos, m_lastLocalTouchPos);
         QCoreApplication::instance()->sendEvent(decoration->decoration(), &e);
         decoration->client()->processDecorationMove(m_lastLocalTouchPos.toPoint(), pos.toPoint());
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time);
         auto decoration = input()->touch()->decoration();
         if (!decoration) {
             return false;
         }
         if (input()->touch()->decorationPressId() == -1) {
             return false;
         }
         if (input()->touch()->decorationPressId() != qint32(id)) {
             // ignore, but filter out
             return true;
         }
 
         // send mouse up
         QMouseEvent e(QEvent::MouseButtonRelease, m_lastLocalTouchPos, m_lastGlobalTouchPos, Qt::LeftButton, Qt::MouseButtons(), input()->keyboardModifiers());
         e.setAccepted(false);
         QCoreApplication::sendEvent(decoration->decoration(), &e);
         decoration->client()->processDecorationButtonRelease(&e);
 
         QHoverEvent leaveEvent(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::sendEvent(decoration->decoration(), &leaveEvent);
 
         m_lastGlobalTouchPos = QPointF();
         m_lastLocalTouchPos = QPointF();
         input()->touch()->setDecorationPressId(-1);
         return true;
     }
 private:
     QPointF m_lastGlobalTouchPos;
     QPointF m_lastLocalTouchPos;
 };
 
 #ifdef KWIN_BUILD_TABBOX
 class TabBoxInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 button) override {
         Q_UNUSED(button)
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         return TabBox::TabBox::self()->handleMouseEvent(event);
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setFocusedKeyboardSurface(nullptr);
         input()->pointer()->setEnableConstraints(false);
         // pass the key event to the seat, so that it has a proper model of the currently hold keys
         // this is important for combinations like alt+shift to ensure that shift is not considered pressed
         passToWaylandServer(event);
 
         if (event->type() == QEvent::KeyPress) {
             TabBox::TabBox::self()->keyPress(event->modifiers() | event->key());
         } else if (static_cast<KeyEvent*>(event)->modifiersRelevantForGlobalShortcuts() == Qt::NoModifier) {
             TabBox::TabBox::self()->modifiersReleased();
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (!TabBox::TabBox::self() || !TabBox::TabBox::self()->isGrabbed()) {
             return false;
         }
         return TabBox::TabBox::self()->handleWheelEvent(event);
     }
 };
 #endif
 
 class ScreenEdgeInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         ScreenEdges::self()->isEntered(event);
         // always forward
         return false;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         // TODO: better check whether a touch sequence is in progress
         if (m_touchInProgress || waylandServer()->seat()->isTouchSequence()) {
             // cancel existing touch
             ScreenEdges::self()->gestureRecognizer()->cancelSwipeGesture();
             m_touchInProgress = false;
             m_id = 0;
             return false;
         }
         if (ScreenEdges::self()->gestureRecognizer()->startSwipeGesture(pos) > 0) {
             m_touchInProgress = true;
             m_id = id;
             m_lastPos = pos;
             return true;
         }
         return false;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(time)
         if (m_touchInProgress && m_id == id) {
             ScreenEdges::self()->gestureRecognizer()->updateSwipeGesture(QSizeF(pos.x() - m_lastPos.x(), pos.y() - m_lastPos.y()));
             m_lastPos = pos;
             return true;
         }
         return false;
     }
     bool touchUp(qint32 id, quint32 time) override {
         Q_UNUSED(time)
         if (m_touchInProgress && m_id == id) {
             ScreenEdges::self()->gestureRecognizer()->endSwipeGesture();
             m_touchInProgress = false;
             return true;
         }
         return false;
     }
 private:
     bool m_touchInProgress = false;
     qint32 m_id = 0;
     QPointF m_lastPos;
 };
 
 /**
  * This filter implements window actions. If the event should not be passed to the
  * current pointer window it will filter out the event
  */
 class WindowActionInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         Q_UNUSED(nativeButton)
         if (event->type() != QEvent::MouseButtonPress) {
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->pointer()->focus().data());
         if (!c) {
             return false;
         }
         const auto actionResult = performClientMouseAction(event, c, MouseAction::ModifierAndWindow);
         if (actionResult.first) {
             return actionResult.second;
         }
         return false;
     }
     bool wheelEvent(QWheelEvent *event) override {
         if (event->angleDelta().y() == 0) {
             // only actions on vertical scroll
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->pointer()->focus().data());
         if (!c) {
             return false;
         }
         const auto actionResult = performClientWheelAction(event, c, MouseAction::ModifierAndWindow);
         if (actionResult.first) {
             return actionResult.second;
         }
         return false;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         Q_UNUSED(id)
         Q_UNUSED(time)
         auto seat = waylandServer()->seat();
         if (seat->isTouchSequence()) {
             return false;
         }
         AbstractClient *c = dynamic_cast<AbstractClient*>(input()->touch()->focus().data());
         if (!c) {
             return false;
         }
         bool wasAction = false;
         const Options::MouseCommand command = c->getMouseCommand(Qt::LeftButton, &wasAction);
         if (wasAction) {
             return !c->performMouseCommand(command, pos.toPoint());
         }
         return false;
     }
 };
 
 /**
  * The remaining default input filter which forwards events to other windows
  */
 class ForwardInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         switch (event->type()) {
         case QEvent::MouseMove: {
             seat->setPointerPos(event->globalPos());
             MouseEvent *e = static_cast<MouseEvent*>(event);
             if (e->delta() != QSizeF()) {
                 seat->relativePointerMotion(e->delta(), e->deltaUnaccelerated(), e->timestampMicroseconds());
             }
             break;
         }
         case QEvent::MouseButtonPress:
             seat->pointerButtonPressed(nativeButton);
             break;
         case QEvent::MouseButtonRelease:
             seat->pointerButtonReleased(nativeButton);
             break;
         default:
             break;
         }
         return true;
     }
     bool wheelEvent(QWheelEvent *event) override {
         auto seat = waylandServer()->seat();
         seat->setTimestamp(event->timestamp());
         auto _event = static_cast<WheelEvent *>(event);
-        KWayland::Server::PointerAxisSource source;
+        KWaylandServer::PointerAxisSource source;
         switch (_event->axisSource()) {
         case KWin::InputRedirection::PointerAxisSourceWheel:
-            source = KWayland::Server::PointerAxisSource::Wheel;
+            source = KWaylandServer::PointerAxisSource::Wheel;
             break;
         case KWin::InputRedirection::PointerAxisSourceFinger:
-            source = KWayland::Server::PointerAxisSource::Finger;
+            source = KWaylandServer::PointerAxisSource::Finger;
             break;
         case KWin::InputRedirection::PointerAxisSourceContinuous:
-            source = KWayland::Server::PointerAxisSource::Continuous;
+            source = KWaylandServer::PointerAxisSource::Continuous;
             break;
         case KWin::InputRedirection::PointerAxisSourceWheelTilt:
-            source = KWayland::Server::PointerAxisSource::WheelTilt;
+            source = KWaylandServer::PointerAxisSource::WheelTilt;
             break;
         case KWin::InputRedirection::PointerAxisSourceUnknown:
         default:
-            source = KWayland::Server::PointerAxisSource::Unknown;
+            source = KWaylandServer::PointerAxisSource::Unknown;
             break;
         }
         seat->pointerAxisV5(_event->orientation(), _event->delta(), _event->discreteDelta(), source);
         return true;
     }
     bool keyEvent(QKeyEvent *event) override {
         if (!workspace()) {
             return false;
         }
         if (event->isAutoRepeat()) {
             // handled by Wayland client
             return false;
         }
         auto seat = waylandServer()->seat();
         input()->keyboard()->update();
         seat->setTimestamp(event->timestamp());
         passToWaylandServer(event);
         return true;
     }
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         input()->touch()->insertId(id, seat->touchDown(pos));
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchMove(kwaylandId, pos);
         }
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchUp(kwaylandId);
             input()->touch()->removeId(id);
         }
         return true;
     }
     bool pinchGestureBegin(int fingerCount, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->startPointerPinchGesture(fingerCount);
         return true;
     }
     bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->updatePointerPinchGesture(delta, scale, angleDelta);
         return true;
     }
     bool pinchGestureEnd(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->endPointerPinchGesture();
         return true;
     }
     bool pinchGestureCancelled(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->cancelPointerPinchGesture();
         return true;
     }
 
     bool swipeGestureBegin(int fingerCount, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->startPointerSwipeGesture(fingerCount);
         return true;
     }
     bool swipeGestureUpdate(const QSizeF &delta, quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->updatePointerSwipeGesture(delta);
         return true;
     }
     bool swipeGestureEnd(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->endPointerSwipeGesture();
         return true;
     }
     bool swipeGestureCancelled(quint32 time) override {
         if (!workspace()) {
             return false;
         }
         auto seat = waylandServer()->seat();
         seat->setTimestamp(time);
         seat->cancelPointerSwipeGesture();
         return true;
     }
 };
 
-static KWayland::Server::SeatInterface *findSeat()
+static KWaylandServer::SeatInterface *findSeat()
 {
     auto server = waylandServer();
     if (!server) {
         return nullptr;
     }
     return server->seat();
 }
 
 /**
  * Useful when there's no proper tablet support on the clients
  */
 class TabletInputFilter : public QObject, public InputEventFilter
 {
 public:
     TabletInputFilter()
     {
     }
 
-    static KWayland::Server::TabletSeatInterface *findTabletSeat()
+    static KWaylandServer::TabletSeatInterface *findTabletSeat()
     {
         auto server = waylandServer();
         if (!server) {
             return nullptr;
         }
-        KWayland::Server::TabletManagerInterface *manager = server->tabletManager();
+        KWaylandServer::TabletManagerInterface *manager = server->tabletManager();
         return manager->seat(findSeat());
     }
 
     void integrateDevice(LibInput::Device *device)
     {
         if (device->isTabletTool()) {
-            KWayland::Server::TabletSeatInterface *tabletSeat = findTabletSeat();
+            KWaylandServer::TabletSeatInterface *tabletSeat = findTabletSeat();
             struct udev_device *const udev_device = libinput_device_get_udev_device(device->device());
             const char *devnode = udev_device_get_devnode(udev_device);
             tabletSeat->addTablet(device->vendor(), device->product(), device->sysName(), device->name(), {QString::fromUtf8(devnode)});
         }
     }
     void removeDevice(const QString &sysname)
     {
-        KWayland::Server::TabletSeatInterface *tabletSeat = findTabletSeat();
+        KWaylandServer::TabletSeatInterface *tabletSeat = findTabletSeat();
         tabletSeat->removeTablet(sysname);
     }
 
     bool tabletToolEvent(TabletEvent *event) override
     {
         if (!workspace()) {
             return false;
         }
 
-        KWayland::Server::TabletSeatInterface *tabletSeat = findTabletSeat();
+        KWaylandServer::TabletSeatInterface *tabletSeat = findTabletSeat();
         auto tool = tabletSeat->toolByHardwareSerial(event->serialId());
         if (!tool) {
-            using namespace KWayland::Server;
+            using namespace KWaylandServer;
 
             const QVector<InputRedirection::Capability> capabilities = event->capabilities();
             const auto f = [](InputRedirection::Capability cap) {
                 switch (cap) {
                 case InputRedirection::Tilt:
                     return TabletToolInterface::Tilt;
                 case InputRedirection::Pressure:
                     return TabletToolInterface::Pressure;
                 case InputRedirection::Distance:
                     return TabletToolInterface::Distance;
                 case InputRedirection::Rotation:
                     return TabletToolInterface::Rotation;
                 case InputRedirection::Slider:
                     return TabletToolInterface::Slider;
                 case InputRedirection::Wheel:
                     return TabletToolInterface::Wheel;
                 }
                 return TabletToolInterface::Wheel;
             };
             QVector<TabletToolInterface::Capability> ifaceCapabilities;
             ifaceCapabilities.resize(capabilities.size());
             std::transform(capabilities.constBegin(), capabilities.constEnd(), ifaceCapabilities.begin(), f);
 
             TabletToolInterface::Type toolType = TabletToolInterface::Type::Pen;
             switch (event->toolType()) {
             case InputRedirection::Pen:
                 toolType = TabletToolInterface::Type::Pen;
                 break;
             case InputRedirection::Eraser:
                 toolType = TabletToolInterface::Type::Eraser;
                 break;
             case InputRedirection::Brush:
                 toolType = TabletToolInterface::Type::Brush;
                 break;
             case InputRedirection::Pencil:
                 toolType = TabletToolInterface::Type::Pencil;
                 break;
             case InputRedirection::Airbrush:
                 toolType = TabletToolInterface::Type::Airbrush;
                 break;
             case InputRedirection::Finger:
                 toolType = TabletToolInterface::Type::Finger;
                 break;
             case InputRedirection::Mouse:
                 toolType = TabletToolInterface::Type::Mouse;
                 break;
             case InputRedirection::Lens:
                 toolType = TabletToolInterface::Type::Lens;
                 break;
             case InputRedirection::Totem:
                 toolType = TabletToolInterface::Type::Totem;
                 break;
             }
             tool = tabletSeat->addTool(toolType, event->serialId(), event->uniqueId(), ifaceCapabilities);
 
             const auto cursor = new Cursor(tool);
             Cursors::self()->addCursor(cursor);
             m_cursorByTool[tool] = cursor;
 
             connect(tool, &TabletToolInterface::cursorChanged, cursor, &Cursor::cursorChanged);
             connect(tool, &TabletToolInterface::cursorChanged, cursor, [cursor] (TabletCursor* tcursor) {
                 static const auto createDefaultCursor = [] {
                     WaylandCursorImage defaultCursor;
                     WaylandCursorImage::Image ret;
                     defaultCursor.loadThemeCursor(CursorShape(Qt::CrossCursor), &ret);
                     return ret;
                 };
                 static const auto defaultCursor = createDefaultCursor();
                 if (!tcursor) {
                     cursor->updateCursor(defaultCursor.image, defaultCursor.hotspot);
                     return;
                 }
                 auto cursorSurface = tcursor->surface();
                 if (!cursorSurface) {
                     cursor->updateCursor(defaultCursor.image, defaultCursor.hotspot);
                     return;
                 }
                 auto buffer = cursorSurface->buffer();
                 if (!buffer) {
                     cursor->updateCursor(defaultCursor.image, defaultCursor.hotspot);
                     return;
                 }
 
                 QImage cursorImage;
                 cursorImage = buffer->data().copy();
                 cursorImage.setDevicePixelRatio(cursorSurface->scale());
 
                 cursor->updateCursor(cursorImage, tcursor->hotspot());
             });
             emit cursor->cursorChanged();
         }
 
-        KWayland::Server::TabletInterface *tablet = tabletSeat->tabletByName(event->tabletSysName());
+        KWaylandServer::TabletInterface *tablet = tabletSeat->tabletByName(event->tabletSysName());
 
         Toplevel *toplevel = input()->findToplevel(event->globalPos());
         if (!toplevel || !toplevel->surface()) {
             return false;
         }
 
-        KWayland::Server::SurfaceInterface *surface = toplevel->surface();
+        KWaylandServer::SurfaceInterface *surface = toplevel->surface();
         tool->setCurrentSurface(surface);
 
         if (!tool->isClientSupported() || !tablet->isSurfaceSupported(surface)) {
             return emulateTabletEvent(event);
         }
 
         switch (event->type()) {
         case QEvent::TabletMove: {
             const auto pos = event->globalPosF() - toplevel->pos();
             tool->sendMotion(pos);
             m_cursorByTool[tool]->setPos(event->globalPos());
             break;
         } case QEvent::TabletEnterProximity: {
             tool->sendProximityIn(tablet);
             break;
         } case QEvent::TabletLeaveProximity:
             tool->sendProximityOut();
             break;
         case QEvent::TabletPress:
             tool->sendDown();
             break;
         case QEvent::TabletRelease:
             tool->sendUp();
             break;
         default:
             qCWarning(KWIN_CORE) << "Unexpected tablet event type" << event;
             break;
         }
         const quint32 MAX_VAL = 65535;
         tool->sendPressure(MAX_VAL * event->pressure());
         tool->sendFrame(event->timestamp());
         waylandServer()->simulateUserActivity();
         return true;
     }
 
     bool emulateTabletEvent(TabletEvent *event)
     {
         if (!workspace()) {
             return false;
         }
 
         switch (event->type()) {
         case QEvent::TabletMove:
         case QEvent::TabletEnterProximity:
             input()->pointer()->processMotion(event->globalPosF(), event->timestamp());
             break;
         case QEvent::TabletPress:
             input()->pointer()->processButton(KWin::qtMouseButtonToButton(Qt::LeftButton),
                                               InputRedirection::PointerButtonPressed, event->timestamp());
             break;
         case QEvent::TabletRelease:
             input()->pointer()->processButton(KWin::qtMouseButtonToButton(Qt::LeftButton),
                                               InputRedirection::PointerButtonReleased, event->timestamp());
             break;
         case QEvent::TabletLeaveProximity:
             break;
         default:
             qCWarning(KWIN_CORE) << "Unexpected tablet event type" << event;
             break;
         }
         waylandServer()->simulateUserActivity();
         return true;
     }
-    QHash<KWayland::Server::TabletToolInterface*, Cursor*> m_cursorByTool;
+    QHash<KWaylandServer::TabletToolInterface*, Cursor*> m_cursorByTool;
 };
 
 class DragAndDropInputFilter : public InputEventFilter
 {
 public:
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override {
         auto seat = waylandServer()->seat();
         if (!seat->isDragPointer()) {
             return false;
         }
         if (seat->isDragTouch()) {
             return true;
         }
         seat->setTimestamp(event->timestamp());
         switch (event->type()) {
         case QEvent::MouseMove: {
             const auto pos = input()->globalPointer();
             seat->setPointerPos(pos);
 
             const auto eventPos = event->globalPos();
             // TODO: use InputDeviceHandler::at() here and check isClient()?
             Toplevel *t = input()->findManagedToplevel(eventPos);
             if (auto *xwl = xwayland()) {
                 const auto ret = xwl->dragMoveFilter(t, eventPos);
                 if (ret == Xwl::DragEventReply::Ignore) {
                     return false;
                 } else if (ret == Xwl::DragEventReply::Take) {
                     break;
                 }
             }
 
             if (t) {
                 // TODO: consider decorations
                 if (t->surface() != seat->dragSurface()) {
                     if (AbstractClient *c = qobject_cast<AbstractClient*>(t)) {
                         workspace()->activateClient(c);
                     }
                     seat->setDragTarget(t->surface(), t->inputTransformation());
                 }
             } else {
                 // no window at that place, if we have a surface we need to reset
                 seat->setDragTarget(nullptr);
             }
             break;
         }
         case QEvent::MouseButtonPress:
             seat->pointerButtonPressed(nativeButton);
             break;
         case QEvent::MouseButtonRelease:
             seat->pointerButtonReleased(nativeButton);
             break;
         default:
             break;
         }
         // TODO: should we pass through effects?
         return true;
     }
 
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isDragPointer()) {
             return true;
         }
         if (!seat->isDragTouch()) {
             return false;
         }
         if (m_touchId != id) {
             return true;
         }
         seat->setTimestamp(time);
         input()->touch()->insertId(id, seat->touchDown(pos));
         return true;
     }
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (seat->isDragPointer()) {
             return true;
         }
         if (!seat->isDragTouch()) {
             return false;
         }
         if (m_touchId < 0) {
             // We take for now the first id appearing as a move after a drag
             // started. We can optimize by specifying the id the drag is
             // associated with by implementing a key-value getter in KWayland.
             m_touchId = id;
         }
         if (m_touchId != id) {
             return true;
         }
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId == -1) {
             return true;
         }
 
         seat->touchMove(kwaylandId, pos);
 
         if (Toplevel *t = input()->findToplevel(pos.toPoint())) {
             // TODO: consider decorations
             if (t->surface() != seat->dragSurface()) {
                 if (AbstractClient *c = qobject_cast<AbstractClient*>(t)) {
                     workspace()->activateClient(c);
                 }
                 seat->setDragTarget(t->surface(), pos, t->inputTransformation());
             }
         } else {
             // no window at that place, if we have a surface we need to reset
             seat->setDragTarget(nullptr);
         }
         return true;
     }
     bool touchUp(qint32 id, quint32 time) override {
         auto seat = waylandServer()->seat();
         if (!seat->isDragTouch()) {
             return false;
         }
         seat->setTimestamp(time);
         const qint32 kwaylandId = input()->touch()->mappedId(id);
         if (kwaylandId != -1) {
             seat->touchUp(kwaylandId);
             input()->touch()->removeId(id);
         }
         if (m_touchId == id) {
             m_touchId = -1;
         }
         return true;
     }
 private:
     qint32 m_touchId = -1;
 };
 
 KWIN_SINGLETON_FACTORY(InputRedirection)
 
 static const QString s_touchpadComponent = QStringLiteral("kcm_touchpad");
 
 InputRedirection::InputRedirection(QObject *parent)
     : QObject(parent)
     , m_keyboard(new KeyboardInputRedirection(this))
     , m_pointer(new PointerInputRedirection(this))
     , m_tablet(new TabletInputRedirection(this))
     , m_touch(new TouchInputRedirection(this))
     , m_shortcuts(new GlobalShortcutsManager(this))
 {
     qRegisterMetaType<KWin::InputRedirection::KeyboardKeyState>();
     qRegisterMetaType<KWin::InputRedirection::PointerButtonState>();
     qRegisterMetaType<KWin::InputRedirection::PointerAxis>();
     if (Application::usesLibinput()) {
         if (LogindIntegration::self()->hasSessionControl()) {
             setupLibInput();
         } else {
             LibInput::Connection::createThread();
             if (LogindIntegration::self()->isConnected()) {
                 LogindIntegration::self()->takeControl();
             } else {
                 connect(LogindIntegration::self(), &LogindIntegration::connectedChanged, LogindIntegration::self(), &LogindIntegration::takeControl);
             }
             connect(LogindIntegration::self(), &LogindIntegration::hasSessionControlChanged, this,
                 [this] (bool sessionControl) {
                     if (sessionControl) {
                         setupLibInput();
                     }
                 }
             );
         }
     }
     connect(kwinApp(), &Application::workspaceCreated, this, &InputRedirection::setupWorkspace);
     reconfigure();
 }
 
 InputRedirection::~InputRedirection()
 {
     s_self = nullptr;
     qDeleteAll(m_filters);
     qDeleteAll(m_spies);
 }
 
 void InputRedirection::installInputEventFilter(InputEventFilter *filter)
 {
     Q_ASSERT(!m_filters.contains(filter));
     m_filters << filter;
 }
 
 void InputRedirection::prependInputEventFilter(InputEventFilter *filter)
 {
     Q_ASSERT(!m_filters.contains(filter));
     m_filters.prepend(filter);
 }
 
 void InputRedirection::uninstallInputEventFilter(InputEventFilter *filter)
 {
     m_filters.removeOne(filter);
 }
 
 void InputRedirection::installInputEventSpy(InputEventSpy *spy)
 {
     m_spies << spy;
 }
 
 void InputRedirection::uninstallInputEventSpy(InputEventSpy *spy)
 {
     m_spies.removeOne(spy);
 }
 
 void InputRedirection::init()
 {
     m_shortcuts->init();
 }
 
 void InputRedirection::setupWorkspace()
 {
     if (waylandServer()) {
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
         FakeInputInterface *fakeInput = waylandServer()->display()->createFakeInput(this);
         fakeInput->create();
         connect(fakeInput, &FakeInputInterface::deviceCreated, this,
             [this] (FakeInputDevice *device) {
                 connect(device, &FakeInputDevice::authenticationRequested, this,
                     [device] (const QString &application, const QString &reason) {
                         Q_UNUSED(application)
                         Q_UNUSED(reason)
                         // TODO: make secure
                         device->setAuthentication(true);
                     }
                 );
                 connect(device, &FakeInputDevice::pointerMotionRequested, this,
                     [this] (const QSizeF &delta) {
                         // TODO: Fix time
                         m_pointer->processMotion(globalPointer() + QPointF(delta.width(), delta.height()), 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                connect(device, &FakeInputDevice::pointerMotionAbsoluteRequested, this,
                     [this] (const QPointF &pos) {
                         // TODO: Fix time
                         m_pointer->processMotion(pos, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::pointerButtonPressRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_pointer->processButton(button, InputRedirection::PointerButtonPressed, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::pointerButtonReleaseRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_pointer->processButton(button, InputRedirection::PointerButtonReleased, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::pointerAxisRequested, this,
                     [this] (Qt::Orientation orientation, qreal delta) {
                         // TODO: Fix time
                         InputRedirection::PointerAxis axis;
                         switch (orientation) {
                         case Qt::Horizontal:
                             axis = InputRedirection::PointerAxisHorizontal;
                             break;
                         case Qt::Vertical:
                             axis = InputRedirection::PointerAxisVertical;
                             break;
                         default:
                             Q_UNREACHABLE();
                             break;
                         }
                         // TODO: Fix time
                         m_pointer->processAxis(axis, delta, 0, InputRedirection::PointerAxisSourceUnknown, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::touchDownRequested, this,
                    [this] (qint32 id, const QPointF &pos) {
                        // TODO: Fix time
                        m_touch->processDown(id, pos, 0);
                         waylandServer()->simulateUserActivity();
                    }
                 );
                 connect(device, &FakeInputDevice::touchMotionRequested, this,
                    [this] (qint32 id, const QPointF &pos) {
                        // TODO: Fix time
                        m_touch->processMotion(id, pos, 0);
                         waylandServer()->simulateUserActivity();
                    }
                 );
                 connect(device, &FakeInputDevice::touchUpRequested, this,
                     [this] (qint32 id) {
                         // TODO: Fix time
                         m_touch->processUp(id, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::touchCancelRequested, this,
                     [this] () {
                         m_touch->cancel();
                     }
                 );
                 connect(device, &FakeInputDevice::touchFrameRequested, this,
                    [this] () {
                        m_touch->frame();
                    }
                 );
                 connect(device, &FakeInputDevice::keyboardKeyPressRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_keyboard->processKey(button, InputRedirection::KeyboardKeyPressed, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
                 connect(device, &FakeInputDevice::keyboardKeyReleaseRequested, this,
                     [this] (quint32 button) {
                         // TODO: Fix time
                         m_keyboard->processKey(button, InputRedirection::KeyboardKeyReleased, 0);
                         waylandServer()->simulateUserActivity();
                     }
                 );
             }
         );
         connect(workspace(), &Workspace::configChanged, this, &InputRedirection::reconfigure);
 
         m_keyboard->init();
         m_pointer->init();
         m_touch->init();
         m_tablet->init();
     }
     setupInputFilters();
 }
 
 void InputRedirection::setupInputFilters()
 {
     const bool hasGlobalShortcutSupport = !waylandServer() || waylandServer()->hasGlobalShortcutSupport();
     if (LogindIntegration::self()->hasSessionControl() && hasGlobalShortcutSupport) {
         installInputEventFilter(new VirtualTerminalFilter);
     }
     if (waylandServer()) {
         installInputEventSpy(new TouchHideCursorSpy);
         if (hasGlobalShortcutSupport) {
             installInputEventFilter(new TerminateServerFilter);
         }
         installInputEventFilter(new DragAndDropInputFilter);
         installInputEventFilter(new LockScreenFilter);
         installInputEventFilter(new PopupInputFilter);
         m_windowSelector = new WindowSelectorFilter;
         installInputEventFilter(m_windowSelector);
     }
     if (hasGlobalShortcutSupport) {
         installInputEventFilter(new ScreenEdgeInputFilter);
     }
     installInputEventFilter(new EffectsFilter);
     installInputEventFilter(new MoveResizeFilter);
 #ifdef KWIN_BUILD_TABBOX
     installInputEventFilter(new TabBoxInputFilter);
 #endif
     if (hasGlobalShortcutSupport) {
         installInputEventFilter(new GlobalShortcutFilter);
     }
     installInputEventFilter(new DecorationEventFilter);
     installInputEventFilter(new InternalWindowEventFilter);
     if (waylandServer()) {
         installInputEventFilter(new WindowActionInputFilter);
         installInputEventFilter(new ForwardInputFilter);
 
         if (m_libInput) {
             m_tabletSupport = new TabletInputFilter;
             for (LibInput::Device *dev : m_libInput->devices()) {
                 m_tabletSupport->integrateDevice(dev);
             }
             connect(m_libInput, &LibInput::Connection::deviceAdded, m_tabletSupport, &TabletInputFilter::integrateDevice);
             connect(m_libInput, &LibInput::Connection::deviceRemovedSysName, m_tabletSupport, &TabletInputFilter::removeDevice);
             installInputEventFilter(m_tabletSupport);
         }
     }
 }
 
 void InputRedirection::reconfigure()
 {
     if (Application::usesLibinput()) {
         auto inputConfig = kwinApp()->inputConfig();
         inputConfig->reparseConfiguration();
         const auto config = inputConfig->group(QStringLiteral("Keyboard"));
         const int delay = config.readEntry("RepeatDelay", 660);
         const int rate = config.readEntry("RepeatRate", 25);
         const bool enabled = config.readEntry("KeyboardRepeating", 0) == 0;
 
         waylandServer()->seat()->setKeyRepeatInfo(enabled ? rate : 0, delay);
     }
 }
 
 void InputRedirection::setupLibInput()
 {
     if (!Application::usesLibinput()) {
         return;
     }
     if (m_libInput) {
         return;
     }
     LibInput::Connection *conn = LibInput::Connection::create(this);
     m_libInput = conn;
     if (conn) {
 
         if (waylandServer()) {
             // create relative pointer manager
-            waylandServer()->display()->createRelativePointerManager(KWayland::Server::RelativePointerInterfaceVersion::UnstableV1, waylandServer()->display())->create();
+            waylandServer()->display()->createRelativePointerManager(KWaylandServer::RelativePointerInterfaceVersion::UnstableV1, waylandServer()->display())->create();
         }
 
         conn->setInputConfig(kwinApp()->inputConfig());
         conn->updateLEDs(m_keyboard->xkb()->leds());
         waylandServer()->updateKeyState(m_keyboard->xkb()->leds());
         connect(m_keyboard, &KeyboardInputRedirection::ledsChanged, waylandServer(), &WaylandServer::updateKeyState);
         connect(m_keyboard, &KeyboardInputRedirection::ledsChanged, conn, &LibInput::Connection::updateLEDs);
         connect(conn, &LibInput::Connection::eventsRead, this,
             [this] {
                 m_libInput->processEvents();
             }, Qt::QueuedConnection
         );
         conn->setup();
         connect(conn, &LibInput::Connection::pointerButtonChanged, m_pointer, &PointerInputRedirection::processButton);
         connect(conn, &LibInput::Connection::pointerAxisChanged, m_pointer, &PointerInputRedirection::processAxis);
         connect(conn, &LibInput::Connection::pinchGestureBegin, m_pointer, &PointerInputRedirection::processPinchGestureBegin);
         connect(conn, &LibInput::Connection::pinchGestureUpdate, m_pointer, &PointerInputRedirection::processPinchGestureUpdate);
         connect(conn, &LibInput::Connection::pinchGestureEnd, m_pointer, &PointerInputRedirection::processPinchGestureEnd);
         connect(conn, &LibInput::Connection::pinchGestureCancelled, m_pointer, &PointerInputRedirection::processPinchGestureCancelled);
         connect(conn, &LibInput::Connection::swipeGestureBegin, m_pointer, &PointerInputRedirection::processSwipeGestureBegin);
         connect(conn, &LibInput::Connection::swipeGestureUpdate, m_pointer, &PointerInputRedirection::processSwipeGestureUpdate);
         connect(conn, &LibInput::Connection::swipeGestureEnd, m_pointer, &PointerInputRedirection::processSwipeGestureEnd);
         connect(conn, &LibInput::Connection::swipeGestureCancelled, m_pointer, &PointerInputRedirection::processSwipeGestureCancelled);
         connect(conn, &LibInput::Connection::keyChanged, m_keyboard, &KeyboardInputRedirection::processKey);
         connect(conn, &LibInput::Connection::pointerMotion, this,
             [this] (const QSizeF &delta, const QSizeF &deltaNonAccel, uint32_t time, quint64 timeMicroseconds, LibInput::Device *device) {
                 m_pointer->processMotion(m_pointer->pos() + QPointF(delta.width(), delta.height()), delta, deltaNonAccel, time, timeMicroseconds, device);
             }
         );
         connect(conn, &LibInput::Connection::pointerMotionAbsolute, this,
             [this] (QPointF orig, QPointF screen, uint32_t time, LibInput::Device *device) {
                 Q_UNUSED(orig)
                 m_pointer->processMotion(screen, time, device);
             }
         );
         connect(conn, &LibInput::Connection::touchDown, m_touch, &TouchInputRedirection::processDown);
         connect(conn, &LibInput::Connection::touchUp, m_touch, &TouchInputRedirection::processUp);
         connect(conn, &LibInput::Connection::touchMotion, m_touch, &TouchInputRedirection::processMotion);
         connect(conn, &LibInput::Connection::touchCanceled, m_touch, &TouchInputRedirection::cancel);
         connect(conn, &LibInput::Connection::touchFrame, m_touch, &TouchInputRedirection::frame);
         auto handleSwitchEvent = [this] (SwitchEvent::State state, quint32 time, quint64 timeMicroseconds, LibInput::Device *device) {
             SwitchEvent event(state, time, timeMicroseconds, device);
             processSpies(std::bind(&InputEventSpy::switchEvent, std::placeholders::_1, &event));
             processFilters(std::bind(&InputEventFilter::switchEvent, std::placeholders::_1, &event));
         };
         connect(conn, &LibInput::Connection::switchToggledOn, this,
                 std::bind(handleSwitchEvent, SwitchEvent::State::On, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
         connect(conn, &LibInput::Connection::switchToggledOff, this,
                 std::bind(handleSwitchEvent, SwitchEvent::State::Off, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
 
         connect(conn, &LibInput::Connection::tabletToolEvent,
                 m_tablet, &TabletInputRedirection::tabletToolEvent);
         connect(conn, &LibInput::Connection::tabletToolButtonEvent,
                 m_tablet, &TabletInputRedirection::tabletToolButtonEvent);
         connect(conn, &LibInput::Connection::tabletPadButtonEvent,
                 m_tablet, &TabletInputRedirection::tabletPadButtonEvent);
         connect(conn, &LibInput::Connection::tabletPadRingEvent,
                 m_tablet, &TabletInputRedirection::tabletPadRingEvent);
         connect(conn, &LibInput::Connection::tabletPadStripEvent,
                 m_tablet, &TabletInputRedirection::tabletPadStripEvent);
 
         if (screens()) {
             setupLibInputWithScreens();
         } else {
             connect(kwinApp(), &Application::screensCreated, this, &InputRedirection::setupLibInputWithScreens);
         }
         if (auto s = findSeat()) {
             // Workaround for QTBUG-54371: if there is no real keyboard Qt doesn't request virtual keyboard
             s->setHasKeyboard(true);
             s->setHasPointer(conn->hasPointer());
             s->setHasTouch(conn->hasTouch());
             connect(conn, &LibInput::Connection::hasAlphaNumericKeyboardChanged, this,
                 [this] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     // TODO: this should update the seat, only workaround for QTBUG-54371
                     emit hasAlphaNumericKeyboardChanged(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasTabletModeSwitchChanged, this,
                 [this] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     emit hasTabletModeSwitchChanged(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasPointerChanged, this,
                 [this, s] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     s->setHasPointer(set);
                 }
             );
             connect(conn, &LibInput::Connection::hasTouchChanged, this,
                 [this, s] (bool set) {
                     if (m_libInput->isSuspended()) {
                         return;
                     }
                     s->setHasTouch(set);
                 }
             );
         }
         connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, m_libInput,
             [this] (bool active) {
                 if (!active) {
                     m_libInput->deactivate();
                 }
             }
         );
     }
 
     setupTouchpadShortcuts();
 }
 
 void InputRedirection::setupTouchpadShortcuts()
 {
     if (!m_libInput) {
         return;
     }
     QAction *touchpadToggleAction = new QAction(this);
     QAction *touchpadOnAction = new QAction(this);
     QAction *touchpadOffAction = new QAction(this);
 
     touchpadToggleAction->setObjectName(QStringLiteral("Toggle Touchpad"));
     touchpadToggleAction->setProperty("componentName", s_touchpadComponent);
     touchpadOnAction->setObjectName(QStringLiteral("Enable Touchpad"));
     touchpadOnAction->setProperty("componentName", s_touchpadComponent);
     touchpadOffAction->setObjectName(QStringLiteral("Disable Touchpad"));
     touchpadOffAction->setProperty("componentName", s_touchpadComponent);
     KGlobalAccel::self()->setDefaultShortcut(touchpadToggleAction, QList<QKeySequence>{Qt::Key_TouchpadToggle});
     KGlobalAccel::self()->setShortcut(touchpadToggleAction, QList<QKeySequence>{Qt::Key_TouchpadToggle});
     KGlobalAccel::self()->setDefaultShortcut(touchpadOnAction, QList<QKeySequence>{Qt::Key_TouchpadOn});
     KGlobalAccel::self()->setShortcut(touchpadOnAction, QList<QKeySequence>{Qt::Key_TouchpadOn});
     KGlobalAccel::self()->setDefaultShortcut(touchpadOffAction, QList<QKeySequence>{Qt::Key_TouchpadOff});
     KGlobalAccel::self()->setShortcut(touchpadOffAction, QList<QKeySequence>{Qt::Key_TouchpadOff});
 #ifndef KWIN_BUILD_TESTING
     registerShortcut(Qt::Key_TouchpadToggle, touchpadToggleAction);
     registerShortcut(Qt::Key_TouchpadOn, touchpadOnAction);
     registerShortcut(Qt::Key_TouchpadOff, touchpadOffAction);
 #endif
     connect(touchpadToggleAction, &QAction::triggered, m_libInput, &LibInput::Connection::toggleTouchpads);
     connect(touchpadOnAction, &QAction::triggered, m_libInput, &LibInput::Connection::enableTouchpads);
     connect(touchpadOffAction, &QAction::triggered, m_libInput, &LibInput::Connection::disableTouchpads);
 }
 
 bool InputRedirection::hasAlphaNumericKeyboard()
 {
     if (m_libInput) {
         return m_libInput->hasAlphaNumericKeyboard();
     }
     return true;
 }
 
 bool InputRedirection::hasTabletModeSwitch()
 {
     if (m_libInput) {
         return m_libInput->hasTabletModeSwitch();
     }
     return false;
 }
 
 void InputRedirection::setupLibInputWithScreens()
 {
     if (!screens() || !m_libInput) {
         return;
     }
     m_libInput->setScreenSize(screens()->size());
     m_libInput->updateScreens();
     connect(screens(), &Screens::sizeChanged, this,
         [this] {
             m_libInput->setScreenSize(screens()->size());
         }
     );
     connect(screens(), &Screens::changed, m_libInput, &LibInput::Connection::updateScreens);
 }
 
 void InputRedirection::processPointerMotion(const QPointF &pos, uint32_t time)
 {
     m_pointer->processMotion(pos, time);
 }
 
 void InputRedirection::processPointerButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time)
 {
     m_pointer->processButton(button, state, time);
 }
 
 void InputRedirection::processPointerAxis(InputRedirection::PointerAxis axis, qreal delta, qint32 discreteDelta, PointerAxisSource source, uint32_t time)
 {
     m_pointer->processAxis(axis, delta, discreteDelta, source, time);
 }
 
 void InputRedirection::processKeyboardKey(uint32_t key, InputRedirection::KeyboardKeyState state, uint32_t time)
 {
     m_keyboard->processKey(key, state, time);
 }
 
 void InputRedirection::processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     m_keyboard->processModifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
 void InputRedirection::processKeymapChange(int fd, uint32_t size)
 {
     m_keyboard->processKeymapChange(fd, size);
 }
 
 void InputRedirection::processTouchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     m_touch->processDown(id, pos, time);
 }
 
 void InputRedirection::processTouchUp(qint32 id, quint32 time)
 {
     m_touch->processUp(id, time);
 }
 
 void InputRedirection::processTouchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     m_touch->processMotion(id, pos, time);
 }
 
 void InputRedirection::cancelTouch()
 {
     m_touch->cancel();
 }
 
 void InputRedirection::touchFrame()
 {
     m_touch->frame();
 }
 
 Qt::MouseButtons InputRedirection::qtButtonStates() const
 {
     return m_pointer->buttons();
 }
 
 static bool acceptsInput(Toplevel *t, const QPoint &pos)
 {
     const QRegion input = t->inputShape();
     if (input.isEmpty()) {
         return true;
     }
     // TODO: What about sub-surfaces sticking outside the main surface?
     const QPoint localPoint = pos - t->bufferGeometry().topLeft();
     return input.contains(localPoint);
 }
 
 Toplevel *InputRedirection::findToplevel(const QPoint &pos)
 {
     if (!Workspace::self()) {
         return nullptr;
     }
     const bool isScreenLocked = waylandServer() && waylandServer()->isScreenLocked();
     // TODO: check whether the unmanaged wants input events at all
     if (!isScreenLocked) {
         // if an effect overrides the cursor we don't have a window to focus
         if (effects && static_cast<EffectsHandlerImpl*>(effects)->isMouseInterception()) {
             return nullptr;
         }
         const QList<Unmanaged *> &unmanaged = Workspace::self()->unmanagedList();
         foreach (Unmanaged *u, unmanaged) {
             if (u->inputGeometry().contains(pos) && acceptsInput(u, pos)) {
                 return u;
             }
         }
     }
     return findManagedToplevel(pos);
 }
 
 Toplevel *InputRedirection::findManagedToplevel(const QPoint &pos)
 {
     if (!Workspace::self()) {
         return nullptr;
     }
     const bool isScreenLocked = waylandServer() && waylandServer()->isScreenLocked();
     const QList<Toplevel *> &stacking = Workspace::self()->stackingOrder();
     if (stacking.isEmpty()) {
         return nullptr;
     }
     auto it = stacking.end();
     do {
         --it;
         Toplevel *t = (*it);
         if (t->isDeleted()) {
             // a deleted window doesn't get mouse events
             continue;
         }
         if (AbstractClient *c = dynamic_cast<AbstractClient*>(t)) {
             if (!c->isOnCurrentActivity() || !c->isOnCurrentDesktop() || c->isMinimized() || c->isHiddenInternal()) {
                 continue;
             }
         }
         if (!t->readyForPainting()) {
             continue;
         }
         if (isScreenLocked) {
             if (!t->isLockScreen() && !t->isInputMethod()) {
                 continue;
             }
         }
         if (t->inputGeometry().contains(pos) && acceptsInput(t, pos)) {
             return t;
         }
     } while (it != stacking.begin());
     return nullptr;
 }
 
 Qt::KeyboardModifiers InputRedirection::keyboardModifiers() const
 {
     return m_keyboard->modifiers();
 }
 
 Qt::KeyboardModifiers InputRedirection::modifiersRelevantForGlobalShortcuts() const
 {
     return m_keyboard->modifiersRelevantForGlobalShortcuts();
 }
 
 void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action)
 {
     Q_UNUSED(shortcut)
     kwinApp()->platform()->setupActionForGlobalAccel(action);
 }
 
 void InputRedirection::registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action)
 {
     m_shortcuts->registerPointerShortcut(action, modifiers, pointerButtons);
 }
 
 void InputRedirection::registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action)
 {
     m_shortcuts->registerAxisShortcut(action, modifiers, axis);
 }
 
 void InputRedirection::registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action)
 {
     m_shortcuts->registerTouchpadSwipe(action, direction);
 }
 
 void InputRedirection::registerGlobalAccel(KGlobalAccelInterface *interface)
 {
     m_shortcuts->setKGlobalAccelInterface(interface);
 }
 
 void InputRedirection::warpPointer(const QPointF &pos)
 {
     m_pointer->warp(pos);
 }
 
 bool InputRedirection::supportsPointerWarping() const
 {
     return m_pointer->supportsWarping();
 }
 
 QPointF InputRedirection::globalPointer() const
 {
     return m_pointer->pos();
 }
 
 void InputRedirection::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (!m_windowSelector || m_windowSelector->isActive()) {
         callback(nullptr);
         return;
     }
     m_windowSelector->start(callback);
     m_pointer->setWindowSelectionCursor(cursorName);
 }
 
 void InputRedirection::startInteractivePositionSelection(std::function<void(const QPoint &)> callback)
 {
     if (!m_windowSelector || m_windowSelector->isActive()) {
         callback(QPoint(-1, -1));
         return;
     }
     m_windowSelector->start(callback);
     m_pointer->setWindowSelectionCursor(QByteArray());
 }
 
 bool InputRedirection::isSelectingWindow() const
 {
     return m_windowSelector ? m_windowSelector->isActive() : false;
 }
 
 InputDeviceHandler::InputDeviceHandler(InputRedirection *input)
     : QObject(input)
 {
 }
 
 InputDeviceHandler::~InputDeviceHandler() = default;
 
 void InputDeviceHandler::init()
 {
     connect(workspace(), &Workspace::stackingOrderChanged, this, &InputDeviceHandler::update);
     connect(workspace(), &Workspace::clientMinimizedChanged, this, &InputDeviceHandler::update);
     connect(VirtualDesktopManager::self(), &VirtualDesktopManager::currentChanged, this, &InputDeviceHandler::update);
 }
 
 bool InputDeviceHandler::setAt(Toplevel *toplevel)
 {
     if (m_at.at == toplevel) {
         return false;
     }
     auto old = m_at.at;
     disconnect(m_at.surfaceCreatedConnection);
     m_at.surfaceCreatedConnection = QMetaObject::Connection();
 
     m_at.at = toplevel;
     emit atChanged(old, toplevel);
     return true;
 }
 
 void InputDeviceHandler::setFocus(Toplevel *toplevel)
 {
     m_focus.focus = toplevel;
     //TODO: call focusUpdate?
 }
 
 void InputDeviceHandler::setDecoration(QPointer<Decoration::DecoratedClientImpl> decoration)
 {
     auto oldDeco = m_focus.decoration;
     m_focus.decoration = decoration;
     cleanupDecoration(oldDeco.data(), m_focus.decoration.data());
     emit decorationChanged();
 }
 
 void InputDeviceHandler::setInternalWindow(QWindow *window)
 {
     m_focus.internalWindow = window;
     //TODO: call internalWindowUpdate?
 }
 
 void InputDeviceHandler::updateFocus()
 {
     auto oldFocus = m_focus.focus;
 
     if (m_at.at && !m_at.at->surface()) {
         // The surface has not yet been created (special XWayland case).
         // Therefore listen for its creation.
         if (!m_at.surfaceCreatedConnection) {
             m_at.surfaceCreatedConnection = connect(m_at.at, &Toplevel::surfaceChanged,
                                                     this, &InputDeviceHandler::update);
         }
         m_focus.focus = nullptr;
     } else {
         m_focus.focus = m_at.at;
     }
 
     focusUpdate(oldFocus, m_focus.focus);
 }
 
 bool InputDeviceHandler::updateDecoration()
 {
     const auto oldDeco = m_focus.decoration;
     m_focus.decoration = nullptr;
 
     auto *ac = qobject_cast<AbstractClient*>(m_at.at);
     if (ac && ac->decoratedClient()) {
         const QRect clientRect = QRect(ac->clientPos(), ac->clientSize()).translated(ac->pos());
         if (!clientRect.contains(position().toPoint())) {
             // input device above decoration
             m_focus.decoration = ac->decoratedClient();
         }
     }
 
     if (m_focus.decoration == oldDeco) {
         // no change to decoration
         return false;
     }
     cleanupDecoration(oldDeco.data(), m_focus.decoration.data());
     emit decorationChanged();
     return true;
 }
 
 void InputDeviceHandler::updateInternalWindow(QWindow *window)
 {
     if (m_focus.internalWindow == window) {
         // no change
         return;
     }
     const auto oldInternal = m_focus.internalWindow;
     m_focus.internalWindow = window;
     cleanupInternalWindow(oldInternal, window);
 }
 
 void InputDeviceHandler::update()
 {
     if (!m_inited) {
         return;
     }
 
     Toplevel *toplevel = nullptr;
     QWindow *internalWindow = nullptr;
 
     if (!positionValid()) {
         const auto pos = position().toPoint();
         internalWindow = findInternalWindow(pos);
         if (internalWindow) {
             toplevel = workspace()->findInternal(internalWindow);
         } else {
             toplevel = input()->findToplevel(pos);
         }
     }
     // Always set the toplevel at the position of the input device.
     setAt(toplevel);
 
     if (focusUpdatesBlocked()) {
         return;
     }
 
     if (internalWindow) {
         if (m_focus.internalWindow != internalWindow) {
             // changed internal window
             updateDecoration();
             updateInternalWindow(internalWindow);
             updateFocus();
         } else if (updateDecoration()) {
             // went onto or off from decoration, update focus
             updateFocus();
         }
         return;
     }
     updateInternalWindow(nullptr);
 
     if (m_focus.focus != m_at.at) {
         // focus change
         updateDecoration();
         updateFocus();
         return;
     }
     // check if switched to/from decoration while staying on the same Toplevel
     if (updateDecoration()) {
         // went onto or off from decoration, update focus
         updateFocus();
     }
 }
 
 QWindow* InputDeviceHandler::findInternalWindow(const QPoint &pos) const
 {
     if (waylandServer()->isScreenLocked()) {
         return nullptr;
     }
 
     const QList<InternalClient *> &internalClients = workspace()->internalClients();
     if (internalClients.isEmpty()) {
         return nullptr;
     }
 
     auto it = internalClients.end();
     do {
         --it;
         QWindow *w = (*it)->internalWindow();
         if (!w || !w->isVisible()) {
             continue;
         }
         if (!(*it)->frameGeometry().contains(pos)) {
             continue;
         }
         // check input mask
         const QRegion mask = w->mask().translated(w->geometry().topLeft());
         if (!mask.isEmpty() && !mask.contains(pos)) {
             continue;
         }
         if (w->property("outputOnly").toBool()) {
             continue;
         }
         return w;
     } while (it != internalClients.begin());
 
     return nullptr;
 }
 
 } // namespace
diff --git a/keyboard_input.cpp b/keyboard_input.cpp
index a6f376265..005a82715 100644
--- a/keyboard_input.cpp
+++ b/keyboard_input.cpp
@@ -1,257 +1,257 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "keyboard_input.h"
 #include "input_event.h"
 #include "input_event_spy.h"
 #include "keyboard_layout.h"
 #include "keyboard_repeat.h"
 #include "abstract_client.h"
 #include "modifier_only_shortcuts.h"
 #include "utils.h"
 #include "screenlockerwatcher.h"
 #include "toplevel.h"
 #include "wayland_server.h"
 #include "workspace.h"
 // KWayland
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/seat_interface.h>
 //screenlocker
 #include <KScreenLocker/KsldApp>
 // Frameworks
 #include <KGlobalAccel>
 // Qt
 #include <QKeyEvent>
 
 namespace KWin
 {
 
 KeyboardInputRedirection::KeyboardInputRedirection(InputRedirection *parent)
     : QObject(parent)
     , m_input(parent)
     , m_xkb(new Xkb(parent))
 {
     connect(m_xkb.data(), &Xkb::ledsChanged, this, &KeyboardInputRedirection::ledsChanged);
     if (waylandServer()) {
         m_xkb->setSeat(waylandServer()->seat());
     }
 }
 
 KeyboardInputRedirection::~KeyboardInputRedirection() = default;
 
 class KeyStateChangedSpy : public InputEventSpy
 {
 public:
     KeyStateChangedSpy(InputRedirection *input)
         : m_input(input)
     {
     }
 
     void keyEvent(KeyEvent *event) override
     {
         if (event->isAutoRepeat()) {
             return;
         }
         emit m_input->keyStateChanged(event->nativeScanCode(), event->type() == QEvent::KeyPress ? InputRedirection::KeyboardKeyPressed : InputRedirection::KeyboardKeyReleased);
     }
 
 private:
     InputRedirection *m_input;
 };
 
 class ModifiersChangedSpy : public InputEventSpy
 {
 public:
     ModifiersChangedSpy(InputRedirection *input)
         : m_input(input)
         , m_modifiers()
     {
     }
 
     void keyEvent(KeyEvent *event) override
     {
         if (event->isAutoRepeat()) {
             return;
         }
         updateModifiers(event->modifiers());
     }
 
     void updateModifiers(Qt::KeyboardModifiers mods)
     {
         if (mods == m_modifiers) {
             return;
         }
         emit m_input->keyboardModifiersChanged(mods, m_modifiers);
         m_modifiers = mods;
     }
 
 private:
     InputRedirection *m_input;
     Qt::KeyboardModifiers m_modifiers;
 };
 
 void KeyboardInputRedirection::init()
 {
     Q_ASSERT(!m_inited);
     m_inited = true;
     const auto config = kwinApp()->kxkbConfig();
     m_xkb->setNumLockConfig(kwinApp()->inputConfig());
     m_xkb->setConfig(config);
 
     m_input->installInputEventSpy(new KeyStateChangedSpy(m_input));
     m_modifiersChangedSpy = new ModifiersChangedSpy(m_input);
     m_input->installInputEventSpy(m_modifiersChangedSpy);
     m_keyboardLayout = new KeyboardLayout(m_xkb.data());
     m_keyboardLayout->setConfig(config);
     m_keyboardLayout->init();
     m_input->installInputEventSpy(m_keyboardLayout);
 
     if (waylandServer()->hasGlobalShortcutSupport()) {
         m_input->installInputEventSpy(new ModifierOnlyShortcuts);
     }
 
     KeyboardRepeat *keyRepeatSpy = new KeyboardRepeat(m_xkb.data());
     connect(keyRepeatSpy, &KeyboardRepeat::keyRepeat, this,
         std::bind(&KeyboardInputRedirection::processKey, this, std::placeholders::_1, InputRedirection::KeyboardKeyAutoRepeat, std::placeholders::_2, nullptr));
     m_input->installInputEventSpy(keyRepeatSpy);
 
     connect(workspace(), &QObject::destroyed, this, [this] { m_inited = false; });
     connect(waylandServer(), &QObject::destroyed, this, [this] { m_inited = false; });
     connect(workspace(), &Workspace::clientActivated, this,
         [this] {
             disconnect(m_activeClientSurfaceChangedConnection);
             if (auto c = workspace()->activeClient()) {
                 m_activeClientSurfaceChangedConnection = connect(c, &Toplevel::surfaceChanged, this, &KeyboardInputRedirection::update);
             } else {
                 m_activeClientSurfaceChangedConnection = QMetaObject::Connection();
             }
             update();
         }
     );
     if (waylandServer()->hasScreenLockerIntegration()) {
         connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this, &KeyboardInputRedirection::update);
     }
 }
 
 void KeyboardInputRedirection::update()
 {
     if (!m_inited) {
         return;
     }
     auto seat = waylandServer()->seat();
     // TODO: this needs better integration
     Toplevel *found = nullptr;
     if (waylandServer()->isScreenLocked()) {
         const QList<Toplevel *> &stacking = Workspace::self()->stackingOrder();
         if (!stacking.isEmpty()) {
             auto it = stacking.end();
             do {
                 --it;
                 Toplevel *t = (*it);
                 if (t->isDeleted()) {
                     // a deleted window doesn't get mouse events
                     continue;
                 }
                 if (!t->isLockScreen()) {
                     continue;
                 }
                 if (!t->readyForPainting()) {
                     continue;
                 }
                 found = t;
                 break;
             } while (it != stacking.begin());
         }
     } else if (!input()->isSelectingWindow()) {
         found = workspace()->activeClient();
     }
     if (found && found->surface()) {
         if (found->surface() != seat->focusedKeyboardSurface()) {
             seat->setFocusedKeyboardSurface(found->surface());
         }
     } else {
         seat->setFocusedKeyboardSurface(nullptr);
     }
 }
 
 void KeyboardInputRedirection::processKey(uint32_t key, InputRedirection::KeyboardKeyState state, uint32_t time, LibInput::Device *device)
 {
     QEvent::Type type;
     bool autoRepeat = false;
     switch (state) {
     case InputRedirection::KeyboardKeyAutoRepeat:
         autoRepeat = true;
         // fall through
     case InputRedirection::KeyboardKeyPressed:
         type = QEvent::KeyPress;
         break;
     case InputRedirection::KeyboardKeyReleased:
         type = QEvent::KeyRelease;
         break;
     default:
         Q_UNREACHABLE();
     }
 
     if (!autoRepeat) {
         m_xkb->updateKey(key, state);
     }
 
     const xkb_keysym_t keySym = m_xkb->currentKeysym();
     KeyEvent event(type,
                    m_xkb->toQtKey(keySym),
                    m_xkb->modifiers(),
                    key,
                    keySym,
                    m_xkb->toString(keySym),
                    autoRepeat,
                    time,
                    device);
     event.setModifiersRelevantForGlobalShortcuts(m_xkb->modifiersRelevantForGlobalShortcuts());
 
     m_input->processSpies(std::bind(&InputEventSpy::keyEvent, std::placeholders::_1, &event));
     if (!m_inited) {
         return;
     }
     m_input->processFilters(std::bind(&InputEventFilter::keyEvent, std::placeholders::_1, &event));
 
     m_xkb->forwardModifiers();
 }
 
 void KeyboardInputRedirection::processModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     if (!m_inited) {
         return;
     }
     // TODO: send to proper Client and also send when active Client changes
     m_xkb->updateModifiers(modsDepressed, modsLatched, modsLocked, group);
     m_modifiersChangedSpy->updateModifiers(modifiers());
     m_keyboardLayout->checkLayoutChange();
 }
 
 void KeyboardInputRedirection::processKeymapChange(int fd, uint32_t size)
 {
     if (!m_inited) {
         return;
     }
     // TODO: should we pass the keymap to our Clients? Or only to the currently active one and update
     m_xkb->installKeymap(fd, size);
     m_keyboardLayout->resetLayout();
 }
 
 }
diff --git a/keyboard_repeat.cpp b/keyboard_repeat.cpp
index bdb11953e..5a4e19462 100644
--- a/keyboard_repeat.cpp
+++ b/keyboard_repeat.cpp
@@ -1,73 +1,73 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016, 2017 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "keyboard_repeat.h"
 #include "keyboard_input.h"
 #include "input_event.h"
 #include "wayland_server.h"
 
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <QTimer>
 
 namespace KWin
 {
 
 KeyboardRepeat::KeyboardRepeat(Xkb *xkb)
     : QObject()
     , m_timer(new QTimer)
     , m_xkb(xkb)
 {
     connect(m_timer, &QTimer::timeout, this, &KeyboardRepeat::handleKeyRepeat);
 }
 
 KeyboardRepeat::~KeyboardRepeat() = default;
 
 void KeyboardRepeat::handleKeyRepeat()
 {
     // TODO: don't depend on WaylandServer
     if (waylandServer()->seat()->keyRepeatRate() != 0) {
         m_timer->setInterval(1000 / waylandServer()->seat()->keyRepeatRate());
     }
     // TODO: better time
     emit keyRepeat(m_key, m_time);
 }
 
 void KeyboardRepeat::keyEvent(KeyEvent *event)
 {
     if (event->isAutoRepeat()) {
         return;
     }
     const quint32 key = event->nativeScanCode();
     if (event->type() == QEvent::KeyPress) {
         // TODO: don't get these values from WaylandServer
         if (m_xkb->shouldKeyRepeat(key) && waylandServer()->seat()->keyRepeatDelay() != 0) {
             m_timer->setInterval(waylandServer()->seat()->keyRepeatDelay());
             m_key = key;
             m_time = event->timestamp();
             m_timer->start();
         }
     } else if (event->type() == QEvent::KeyRelease) {
         if (key == m_key) {
             m_timer->stop();
         }
     }
 }
 
 }
diff --git a/libkwineffects/CMakeLists.txt b/libkwineffects/CMakeLists.txt
index 4f8b81701..2b320ad5a 100644
--- a/libkwineffects/CMakeLists.txt
+++ b/libkwineffects/CMakeLists.txt
@@ -1,127 +1,127 @@
 ########### next target ###############
 include(ECMSetupVersion)
 
 ecm_setup_version(${PROJECT_VERSION}
                   VARIABLE_PREFIX KWINEFFECTS
                   VERSION_HEADER "${CMAKE_CURRENT_BINARY_DIR}/kwineffects_version.h"
                   PACKAGE_VERSION_FILE "${CMAKE_CURRENT_BINARY_DIR}/KWinEffectsConfigVersion.cmake"
                   SOVERSION 12
 )
 
 ### xrenderutils lib ###
 set(kwin_XRENDERUTILS_SRCS
     kwinxrenderutils.cpp
     logging.cpp
 )
 
 add_library(kwinxrenderutils SHARED ${kwin_XRENDERUTILS_SRCS})
 generate_export_header(kwinxrenderutils EXPORT_FILE_NAME kwinxrenderutils_export.h)
 target_link_libraries(kwinxrenderutils
     PUBLIC
         Qt5::Core
         Qt5::Gui
 
-        KF5::WaylandServer
+        Plasma::KWaylandServer
 
         XCB::RENDER
         XCB::XCB
         XCB::XFIXES
 )
 
 set_target_properties(kwinxrenderutils PROPERTIES
     VERSION ${KWINEFFECTS_VERSION_STRING}
     SOVERSION ${KWINEFFECTS_SOVERSION}
 )
 set_target_properties(kwinxrenderutils PROPERTIES OUTPUT_NAME ${KWIN_NAME}xrenderutils)
 
 install(TARGETS kwinxrenderutils EXPORT kdeworkspaceLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 ###  effects lib  ###
 set(kwin_EFFECTSLIB_SRCS
     anidata.cpp
     kwinanimationeffect.cpp
     kwineffectquickview.cpp
     kwineffects.cpp
     logging.cpp
 )
 
 set(kwineffects_QT_LIBS
     Qt5::DBus
     Qt5::Widgets
     Qt5::Quick
 )
 
 set(kwineffects_KDE_LIBS
     KF5::ConfigCore
     KF5::CoreAddons
     KF5::WindowSystem
     KF5::Declarative
 )
 
 set(kwineffects_XCB_LIBS
     XCB::XCB
 )
 
 add_library(kwineffects SHARED ${kwin_EFFECTSLIB_SRCS})
 generate_export_header(kwineffects EXPORT_FILE_NAME kwineffects_export.h)
 target_link_libraries(kwineffects
     PUBLIC
         ${kwineffects_QT_LIBS}
         ${kwineffects_KDE_LIBS}
         ${kwineffects_XCB_LIBS}
         kwinglutils
 )
 if (KWIN_HAVE_XRENDER_COMPOSITING)
     target_link_libraries(kwineffects PRIVATE kwinxrenderutils XCB::XFIXES)
 endif()
 set_target_properties(kwineffects PROPERTIES
     VERSION ${KWINEFFECTS_VERSION_STRING}
     SOVERSION ${KWINEFFECTS_SOVERSION}
 )
 set_target_properties(kwineffects PROPERTIES OUTPUT_NAME ${KWIN_NAME}effects)
 
 install(TARGETS kwineffects EXPORT kdeworkspaceLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 # kwingl(es)utils library
 set(kwin_GLUTILSLIB_SRCS
     kwinglplatform.cpp
     kwingltexture.cpp
     kwinglutils.cpp
     kwinglutils_funcs.cpp
     logging.cpp
 )
 
 macro(KWIN4_ADD_GLUTILS_BACKEND name glinclude)
     include_directories(${glinclude})
     add_library(${name} SHARED ${kwin_GLUTILSLIB_SRCS})
     generate_export_header(${name} BASE_NAME kwinglutils EXPORT_FILE_NAME kwinglutils_export.h)
     target_link_libraries(${name} PUBLIC XCB::XCB KF5::CoreAddons KF5::ConfigCore KF5::WindowSystem)
     set_target_properties(${name} PROPERTIES
         VERSION ${KWINEFFECTS_VERSION_STRING}
         SOVERSION ${KWINEFFECTS_SOVERSION}
     )
     target_link_libraries(${name} PUBLIC ${ARGN})
 
     install(TARGETS ${name} EXPORT kdeworkspaceLibraryTargets ${INSTALL_TARGETS_DEFAULT_ARGS})
 endmacro()
 
 kwin4_add_glutils_backend(kwinglutils ${epoxy_INCLUDE_DIR} ${epoxy_LIBRARY})
 set_target_properties(kwinglutils PROPERTIES OUTPUT_NAME ${KWIN_NAME}glutils)
 
 target_link_libraries(kwinglutils PUBLIC ${epoxy_LIBRARY})
 
 install(FILES
     ${CMAKE_CURRENT_BINARY_DIR}/kwinconfig.h
     ${CMAKE_CURRENT_BINARY_DIR}/kwineffects_export.h
     ${CMAKE_CURRENT_BINARY_DIR}/kwinglutils_export.h
     ${CMAKE_CURRENT_BINARY_DIR}/kwinxrenderutils_export.h
     kwinanimationeffect.h
     kwineffectquickview.h
     kwineffects.h
     kwinglobals.h
     kwinglplatform.h
     kwingltexture.h
     kwinglutils.h
     kwinglutils_funcs.h
     kwinxrenderutils.h
     DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
diff --git a/libkwineffects/kwineffects.cpp b/libkwineffects/kwineffects.cpp
index 584891884..81aa1fa01 100644
--- a/libkwineffects/kwineffects.cpp
+++ b/libkwineffects/kwineffects.cpp
@@ -1,1951 +1,1951 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "kwineffects.h"
 
 #include "config-kwin.h"
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 #include "kwinxrenderutils.h"
 #endif
 
 #include <QVariant>
 #include <QList>
 #include <QTimeLine>
 #include <QFontMetrics>
 #include <QPainter>
 #include <QPixmap>
 #include <QVector2D>
 #include <QGraphicsRotation>
 #include <QGraphicsScale>
 #include <QtMath>
 
 #include <ksharedconfig.h>
 #include <kconfiggroup.h>
 
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 #include <xcb/xfixes.h>
 #endif
 
 #if defined(__SSE2__)
 #  include <emmintrin.h>
 #endif
 
 
 namespace KWin
 {
 
 void WindowPrePaintData::setTranslucent()
 {
     mask |= Effect::PAINT_WINDOW_TRANSLUCENT;
     mask &= ~Effect::PAINT_WINDOW_OPAQUE;
     clip = QRegion(); // cannot clip, will be transparent
 }
 
 void WindowPrePaintData::setTransformed()
 {
     mask |= Effect::PAINT_WINDOW_TRANSFORMED;
 }
 
 class PaintDataPrivate {
 public:
     QGraphicsScale scale;
     QVector3D translation;
     QGraphicsRotation rotation;
 };
 
 PaintData::PaintData()
     : d(new PaintDataPrivate())
 {
 }
 
 PaintData::~PaintData()
 {
     delete d;
 }
 
 qreal PaintData::xScale() const
 {
     return d->scale.xScale();
 }
 
 qreal PaintData::yScale() const
 {
     return d->scale.yScale();
 }
 
 qreal PaintData::zScale() const
 {
     return d->scale.zScale();
 }
 
 void PaintData::setScale(const QVector2D &scale)
 {
     d->scale.setXScale(scale.x());
     d->scale.setYScale(scale.y());
 }
 
 void PaintData::setScale(const QVector3D &scale)
 {
     d->scale.setXScale(scale.x());
     d->scale.setYScale(scale.y());
     d->scale.setZScale(scale.z());
 }
 
 void PaintData::setXScale(qreal scale)
 {
     d->scale.setXScale(scale);
 }
 
 void PaintData::setYScale(qreal scale)
 {
     d->scale.setYScale(scale);
 }
 
 void PaintData::setZScale(qreal scale)
 {
     d->scale.setZScale(scale);
 }
 
 const QGraphicsScale &PaintData::scale() const
 {
     return d->scale;
 }
 
 void PaintData::setXTranslation(qreal translate)
 {
     d->translation.setX(translate);
 }
 
 void PaintData::setYTranslation(qreal translate)
 {
     d->translation.setY(translate);
 }
 
 void PaintData::setZTranslation(qreal translate)
 {
     d->translation.setZ(translate);
 }
 
 void PaintData::translate(qreal x, qreal y, qreal z)
 {
     translate(QVector3D(x, y, z));
 }
 
 void PaintData::translate(const QVector3D &t)
 {
     d->translation += t;
 }
 
 qreal PaintData::xTranslation() const
 {
     return d->translation.x();
 }
 
 qreal PaintData::yTranslation() const
 {
     return d->translation.y();
 }
 
 qreal PaintData::zTranslation() const
 {
     return d->translation.z();
 }
 
 const QVector3D &PaintData::translation() const
 {
     return d->translation;
 }
 
 qreal PaintData::rotationAngle() const
 {
     return d->rotation.angle();
 }
 
 QVector3D PaintData::rotationAxis() const
 {
     return d->rotation.axis();
 }
 
 QVector3D PaintData::rotationOrigin() const
 {
     return d->rotation.origin();
 }
 
 void PaintData::setRotationAngle(qreal angle)
 {
     d->rotation.setAngle(angle);
 }
 
 void PaintData::setRotationAxis(Qt::Axis axis)
 {
     d->rotation.setAxis(axis);
 }
 
 void PaintData::setRotationAxis(const QVector3D &axis)
 {
     d->rotation.setAxis(axis);
 }
 
 void PaintData::setRotationOrigin(const QVector3D &origin)
 {
     d->rotation.setOrigin(origin);
 }
 
 class WindowPaintDataPrivate {
 public:
     qreal opacity;
     qreal saturation;
     qreal brightness;
     int screen;
     qreal crossFadeProgress;
     QMatrix4x4 pMatrix;
     QMatrix4x4 mvMatrix;
     QMatrix4x4 screenProjectionMatrix;
 };
 
 WindowPaintData::WindowPaintData(EffectWindow *w)
     : WindowPaintData(w, QMatrix4x4())
 {
 }
 
 WindowPaintData::WindowPaintData(EffectWindow* w, const QMatrix4x4 &screenProjectionMatrix)
     : PaintData()
     , shader(nullptr)
     , d(new WindowPaintDataPrivate())
 {
     d->screenProjectionMatrix = screenProjectionMatrix;
     quads = w->buildQuads();
     setOpacity(w->opacity());
     setSaturation(1.0);
     setBrightness(1.0);
     setScreen(0);
     setCrossFadeProgress(1.0);
 }
 
 WindowPaintData::WindowPaintData(const WindowPaintData &other)
     : PaintData()
     , quads(other.quads)
     , shader(other.shader)
     , d(new WindowPaintDataPrivate())
 {
     setXScale(other.xScale());
     setYScale(other.yScale());
     setZScale(other.zScale());
     translate(other.translation());
     setRotationOrigin(other.rotationOrigin());
     setRotationAxis(other.rotationAxis());
     setRotationAngle(other.rotationAngle());
     setOpacity(other.opacity());
     setSaturation(other.saturation());
     setBrightness(other.brightness());
     setScreen(other.screen());
     setCrossFadeProgress(other.crossFadeProgress());
     setProjectionMatrix(other.projectionMatrix());
     setModelViewMatrix(other.modelViewMatrix());
     d->screenProjectionMatrix = other.d->screenProjectionMatrix;
 }
 
 WindowPaintData::~WindowPaintData()
 {
     delete d;
 }
 
 qreal WindowPaintData::opacity() const
 {
     return d->opacity;
 }
 
 qreal WindowPaintData::saturation() const
 {
     return d->saturation;
 }
 
 qreal WindowPaintData::brightness() const
 {
     return d->brightness;
 }
 
 int WindowPaintData::screen() const
 {
     return d->screen;
 }
 
 void WindowPaintData::setOpacity(qreal opacity)
 {
     d->opacity = opacity;
 }
 
 void WindowPaintData::setSaturation(qreal saturation) const
 {
     d->saturation = saturation;
 }
 
 void WindowPaintData::setBrightness(qreal brightness)
 {
     d->brightness = brightness;
 }
 
 void WindowPaintData::setScreen(int screen) const
 {
     d->screen = screen;
 }
 
 qreal WindowPaintData::crossFadeProgress() const
 {
     return d->crossFadeProgress;
 }
 
 void WindowPaintData::setCrossFadeProgress(qreal factor)
 {
     d->crossFadeProgress = qBound(qreal(0.0), factor, qreal(1.0));
 }
 
 qreal WindowPaintData::multiplyOpacity(qreal factor)
 {
     d->opacity *= factor;
     return d->opacity;
 }
 
 qreal WindowPaintData::multiplySaturation(qreal factor)
 {
     d->saturation *= factor;
     return d->saturation;
 }
 
 qreal WindowPaintData::multiplyBrightness(qreal factor)
 {
     d->brightness *= factor;
     return d->brightness;
 }
 
 void WindowPaintData::setProjectionMatrix(const QMatrix4x4 &matrix)
 {
     d->pMatrix = matrix;
 }
 
 QMatrix4x4 WindowPaintData::projectionMatrix() const
 {
     return d->pMatrix;
 }
 
 QMatrix4x4 &WindowPaintData::rprojectionMatrix()
 {
     return d->pMatrix;
 }
 
 void WindowPaintData::setModelViewMatrix(const QMatrix4x4 &matrix)
 {
     d->mvMatrix = matrix;
 }
 
 QMatrix4x4 WindowPaintData::modelViewMatrix() const
 {
     return d->mvMatrix;
 }
 
 QMatrix4x4 &WindowPaintData::rmodelViewMatrix()
 {
     return d->mvMatrix;
 }
 
 WindowPaintData &WindowPaintData::operator*=(qreal scale)
 {
     this->setXScale(this->xScale() * scale);
     this->setYScale(this->yScale() * scale);
     this->setZScale(this->zScale() * scale);
     return *this;
 }
 
 WindowPaintData &WindowPaintData::operator*=(const QVector2D &scale)
 {
     this->setXScale(this->xScale() * scale.x());
     this->setYScale(this->yScale() * scale.y());
     return *this;
 }
 
 WindowPaintData &WindowPaintData::operator*=(const QVector3D &scale)
 {
     this->setXScale(this->xScale() * scale.x());
     this->setYScale(this->yScale() * scale.y());
     this->setZScale(this->zScale() * scale.z());
     return *this;
 }
 
 WindowPaintData &WindowPaintData::operator+=(const QPointF &translation)
 {
     return this->operator+=(QVector3D(translation));
 }
 
 WindowPaintData &WindowPaintData::operator+=(const QPoint &translation)
 {
     return this->operator+=(QVector3D(translation));
 }
 
 WindowPaintData &WindowPaintData::operator+=(const QVector2D &translation)
 {
     return this->operator+=(QVector3D(translation));
 }
 
 WindowPaintData &WindowPaintData::operator+=(const QVector3D &translation)
 {
     translate(translation);
     return *this;
 }
 
 QMatrix4x4 WindowPaintData::screenProjectionMatrix() const
 {
     return d->screenProjectionMatrix;
 }
 
 class ScreenPaintData::Private
 {
 public:
     QMatrix4x4 projectionMatrix;
     QRect outputGeometry;
     qreal screenScale;
 };
 
 ScreenPaintData::ScreenPaintData()
     : PaintData()
     , d(new Private())
 {
 }
 
 ScreenPaintData::ScreenPaintData(const QMatrix4x4 &projectionMatrix, const QRect &outputGeometry, const qreal screenScale)
     : PaintData()
     , d(new Private())
 {
     d->projectionMatrix = projectionMatrix;
     d->outputGeometry = outputGeometry;
     d->screenScale = screenScale;
 }
 
 ScreenPaintData::~ScreenPaintData() = default;
 
 ScreenPaintData::ScreenPaintData(const ScreenPaintData &other)
     : PaintData()
     , d(new Private())
 {
     translate(other.translation());
     setXScale(other.xScale());
     setYScale(other.yScale());
     setZScale(other.zScale());
     setRotationOrigin(other.rotationOrigin());
     setRotationAxis(other.rotationAxis());
     setRotationAngle(other.rotationAngle());
     d->projectionMatrix = other.d->projectionMatrix;
     d->outputGeometry = other.d->outputGeometry;
 }
 
 ScreenPaintData &ScreenPaintData::operator=(const ScreenPaintData &rhs)
 {
     setXScale(rhs.xScale());
     setYScale(rhs.yScale());
     setZScale(rhs.zScale());
     setXTranslation(rhs.xTranslation());
     setYTranslation(rhs.yTranslation());
     setZTranslation(rhs.zTranslation());
     setRotationOrigin(rhs.rotationOrigin());
     setRotationAxis(rhs.rotationAxis());
     setRotationAngle(rhs.rotationAngle());
     d->projectionMatrix = rhs.d->projectionMatrix;
     d->outputGeometry = rhs.d->outputGeometry;
     return *this;
 }
 
 ScreenPaintData &ScreenPaintData::operator*=(qreal scale)
 {
     setXScale(this->xScale() * scale);
     setYScale(this->yScale() * scale);
     setZScale(this->zScale() * scale);
     return *this;
 }
 
 ScreenPaintData &ScreenPaintData::operator*=(const QVector2D &scale)
 {
     setXScale(this->xScale() * scale.x());
     setYScale(this->yScale() * scale.y());
     return *this;
 }
 
 ScreenPaintData &ScreenPaintData::operator*=(const QVector3D &scale)
 {
     setXScale(this->xScale() * scale.x());
     setYScale(this->yScale() * scale.y());
     setZScale(this->zScale() * scale.z());
     return *this;
 }
 
 ScreenPaintData &ScreenPaintData::operator+=(const QPointF &translation)
 {
     return this->operator+=(QVector3D(translation));
 }
 
 ScreenPaintData &ScreenPaintData::operator+=(const QPoint &translation)
 {
     return this->operator+=(QVector3D(translation));
 }
 
 ScreenPaintData &ScreenPaintData::operator+=(const QVector2D &translation)
 {
     return this->operator+=(QVector3D(translation));
 }
 
 ScreenPaintData &ScreenPaintData::operator+=(const QVector3D &translation)
 {
     translate(translation);
     return *this;
 }
 
 QMatrix4x4 ScreenPaintData::projectionMatrix() const
 {
     return d->projectionMatrix;
 }
 
 QRect ScreenPaintData::outputGeometry() const
 {
     return d->outputGeometry;
 }
 
 qreal ScreenPaintData::screenScale() const
 {
     return d->screenScale;
 }
 
 //****************************************
 // Effect
 //****************************************
 
 Effect::Effect()
 {
 }
 
 Effect::~Effect()
 {
 }
 
 void Effect::reconfigure(ReconfigureFlags)
 {
 }
 
 void* Effect::proxy()
 {
     return nullptr;
 }
 
 void Effect::windowInputMouseEvent(QEvent*)
 {
 }
 
 void Effect::grabbedKeyboardEvent(QKeyEvent*)
 {
 }
 
 bool Effect::borderActivated(ElectricBorder)
 {
     return false;
 }
 
 void Effect::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     effects->prePaintScreen(data, time);
 }
 
 void Effect::paintScreen(int mask, const QRegion &region, ScreenPaintData& data)
 {
     effects->paintScreen(mask, region, data);
 }
 
 void Effect::postPaintScreen()
 {
     effects->postPaintScreen();
 }
 
 void Effect::prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time)
 {
     effects->prePaintWindow(w, data, time);
 }
 
 void Effect::paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data)
 {
     effects->paintWindow(w, mask, region, data);
 }
 
 void Effect::postPaintWindow(EffectWindow* w)
 {
     effects->postPaintWindow(w);
 }
 
 void Effect::paintEffectFrame(KWin::EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity)
 {
     effects->paintEffectFrame(frame, region, opacity, frameOpacity);
 }
 
 bool Effect::provides(Feature)
 {
     return false;
 }
 
 bool Effect::isActive() const
 {
     return true;
 }
 
 QString Effect::debug(const QString &) const
 {
     return QString();
 }
 
 void Effect::drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     effects->drawWindow(w, mask, region, data);
 }
 
 void Effect::buildQuads(EffectWindow* w, WindowQuadList& quadList)
 {
     effects->buildQuads(w, quadList);
 }
 
 void Effect::setPositionTransformations(WindowPaintData& data, QRect& region, EffectWindow* w,
                                         const QRect& r, Qt::AspectRatioMode aspect)
 {
     QSize size = w->size();
     size.scale(r.size(), aspect);
     data.setXScale(size.width() / double(w->width()));
     data.setYScale(size.height() / double(w->height()));
     int width = int(w->width() * data.xScale());
     int height = int(w->height() * data.yScale());
     int x = r.x() + (r.width() - width) / 2;
     int y = r.y() + (r.height() - height) / 2;
     region = QRect(x, y, width, height);
     data.setXTranslation(x - w->x());
     data.setYTranslation(y - w->y());
 }
 
 QPoint Effect::cursorPos()
 {
     return effects->cursorPos();
 }
 
 double Effect::animationTime(const KConfigGroup& cfg, const QString& key, int defaultTime)
 {
     int time = cfg.readEntry(key, 0);
     return time != 0 ? time : qMax(defaultTime * effects->animationTimeFactor(), 1.);
 }
 
 double Effect::animationTime(int defaultTime)
 {
     // at least 1ms, otherwise 0ms times can break some things
     return qMax(defaultTime * effects->animationTimeFactor(), 1.);
 }
 
 int Effect::requestedEffectChainPosition() const
 {
     return 0;
 }
 
 xcb_connection_t *Effect::xcbConnection() const
 {
     return effects->xcbConnection();
 }
 
 xcb_window_t Effect::x11RootWindow() const
 {
     return effects->x11RootWindow();
 }
 
 bool Effect::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(pos)
     Q_UNUSED(time)
     return false;
 }
 
 bool Effect::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(pos)
     Q_UNUSED(time)
     return false;
 }
 
 bool Effect::touchUp(qint32 id, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(time)
     return false;
 }
 
 bool Effect::perform(Feature feature, const QVariantList &arguments)
 {
     Q_UNUSED(feature)
     Q_UNUSED(arguments)
     return false;
 }
 
 //****************************************
 // EffectFactory
 //****************************************
 EffectPluginFactory::EffectPluginFactory()
 {
 }
 
 EffectPluginFactory::~EffectPluginFactory()
 {
 }
 
 bool EffectPluginFactory::enabledByDefault() const
 {
     return true;
 }
 
 bool EffectPluginFactory::isSupported() const
 {
     return true;
 }
 
 //****************************************
 // EffectsHandler
 //****************************************
 
 EffectsHandler::EffectsHandler(CompositingType type)
     : compositing_type(type)
 {
     if (compositing_type == NoCompositing)
         return;
     KWin::effects = this;
 }
 
 EffectsHandler::~EffectsHandler()
 {
     // All effects should already be unloaded by Impl dtor
     Q_ASSERT(loaded_effects.count() == 0);
     KWin::effects = nullptr;
 }
 
 CompositingType EffectsHandler::compositingType() const
 {
     return compositing_type;
 }
 
 bool EffectsHandler::isOpenGLCompositing() const
 {
     return compositing_type & OpenGLCompositing;
 }
 
 EffectsHandler* effects = nullptr;
 
 
 //****************************************
 // EffectWindow
 //****************************************
 
 class Q_DECL_HIDDEN EffectWindow::Private
 {
 public:
     Private(EffectWindow *q);
 
     EffectWindow *q;
 };
 
 EffectWindow::Private::Private(EffectWindow *q)
     : q(q)
 {
 }
 
 EffectWindow::EffectWindow(QObject *parent)
     : QObject(parent)
     , d(new Private(this))
 {
 }
 
 EffectWindow::~EffectWindow()
 {
 }
 
 bool EffectWindow::isOnActivity(const QString &activity) const
 {
     const QStringList _activities = activities();
     return _activities.isEmpty() || _activities.contains(activity);
 }
 
 bool EffectWindow::isOnAllActivities() const
 {
     return activities().isEmpty();
 }
 
 void EffectWindow::setMinimized(bool min)
 {
     if (min) {
         minimize();
     } else {
         unminimize();
     }
 }
 
 bool EffectWindow::isOnCurrentActivity() const
 {
     return isOnActivity(effects->currentActivity());
 }
 
 bool EffectWindow::isOnCurrentDesktop() const
 {
     return isOnDesktop(effects->currentDesktop());
 }
 
 bool EffectWindow::isOnDesktop(int d) const
 {
     const QVector<uint> ds = desktops();
     return ds.isEmpty() || ds.contains(d);
 }
 
 bool EffectWindow::isOnAllDesktops() const
 {
     return desktops().isEmpty();
 }
 
 bool EffectWindow::hasDecoration() const
 {
     return contentsRect() != QRect(0, 0, width(), height());
 }
 
 bool EffectWindow::isVisible() const
 {
     return !isMinimized()
            && isOnCurrentDesktop()
            && isOnCurrentActivity();
 }
 
 //****************************************
 // EffectWindowGroup
 //****************************************
 
 EffectWindowGroup::~EffectWindowGroup()
 {
 }
 
 /***************************************************************
  WindowQuad
 ***************************************************************/
 
 WindowQuad WindowQuad::makeSubQuad(double x1, double y1, double x2, double y2) const
 {
     Q_ASSERT(x1 < x2 && y1 < y2 && x1 >= left() && x2 <= right() && y1 >= top() && y2 <= bottom());
 #if !defined(QT_NO_DEBUG)
     if (isTransformed())
         qFatal("Splitting quads is allowed only in pre-paint calls!");
 #endif
     WindowQuad ret(*this);
     // vertices are clockwise starting from topleft
     ret.verts[ 0 ].px = x1;
     ret.verts[ 3 ].px = x1;
     ret.verts[ 1 ].px = x2;
     ret.verts[ 2 ].px = x2;
     ret.verts[ 0 ].py = y1;
     ret.verts[ 1 ].py = y1;
     ret.verts[ 2 ].py = y2;
     ret.verts[ 3 ].py = y2;
     // original x/y are supposed to be the same, no transforming is done here
     ret.verts[ 0 ].ox = x1;
     ret.verts[ 3 ].ox = x1;
     ret.verts[ 1 ].ox = x2;
     ret.verts[ 2 ].ox = x2;
     ret.verts[ 0 ].oy = y1;
     ret.verts[ 1 ].oy = y1;
     ret.verts[ 2 ].oy = y2;
     ret.verts[ 3 ].oy = y2;
 
     const double my_u0 = verts[0].tx;
     const double my_u1 = verts[2].tx;
     const double my_v0 = verts[0].ty;
     const double my_v1 = verts[2].ty;
 
     const double width  = right() - left();
     const double height = bottom() - top();
 
     const double texWidth  = my_u1 - my_u0;
     const double texHeight = my_v1 - my_v0;
 
     if (!uvAxisSwapped()) {
         const double u0 = (x1 - left()) / width  * texWidth  + my_u0;
         const double u1 = (x2 - left()) / width  * texWidth  + my_u0;
         const double v0 = (y1 - top())  / height * texHeight + my_v0;
         const double v1 = (y2 - top())  / height * texHeight + my_v0;
 
         ret.verts[0].tx = u0;
         ret.verts[3].tx = u0;
         ret.verts[1].tx = u1;
         ret.verts[2].tx = u1;
         ret.verts[0].ty = v0;
         ret.verts[1].ty = v0;
         ret.verts[2].ty = v1;
         ret.verts[3].ty = v1;
     } else {
         const double u0 = (y1 - top())  / height * texWidth  + my_u0;
         const double u1 = (y2 - top())  / height * texWidth  + my_u0;
         const double v0 = (x1 - left()) / width  * texHeight + my_v0;
         const double v1 = (x2 - left()) / width  * texHeight + my_v0;
 
         ret.verts[0].tx = u0;
         ret.verts[1].tx = u0;
         ret.verts[2].tx = u1;
         ret.verts[3].tx = u1;
         ret.verts[0].ty = v0;
         ret.verts[3].ty = v0;
         ret.verts[1].ty = v1;
         ret.verts[2].ty = v1;
     }
 
     ret.setUVAxisSwapped(uvAxisSwapped());
 
     return ret;
 }
 
 bool WindowQuad::smoothNeeded() const
 {
     // smoothing is needed if the width or height of the quad does not match the original size
     double width = verts[ 1 ].ox - verts[ 0 ].ox;
     double height = verts[ 2 ].oy - verts[ 1 ].oy;
     return(verts[ 1 ].px - verts[ 0 ].px != width || verts[ 2 ].px - verts[ 3 ].px != width
            || verts[ 2 ].py - verts[ 1 ].py != height || verts[ 3 ].py - verts[ 0 ].py != height);
 }
 
 /***************************************************************
  WindowQuadList
 ***************************************************************/
 
 WindowQuadList WindowQuadList::splitAtX(double x) const
 {
     WindowQuadList ret;
     foreach (const WindowQuad & quad, *this) {
 #if !defined(QT_NO_DEBUG)
         if (quad.isTransformed())
             qFatal("Splitting quads is allowed only in pre-paint calls!");
 #endif
         bool wholeleft = true;
         bool wholeright = true;
         for (int i = 0;
                 i < 4;
                 ++i) {
             if (quad[ i ].x() < x)
                 wholeright = false;
             if (quad[ i ].x() > x)
                 wholeleft = false;
         }
         if (wholeleft || wholeright) { // is whole in one split part
             ret.append(quad);
             continue;
         }
         if (quad.top() == quad.bottom() || quad.left() == quad.right()) { // quad has no size
             ret.append(quad);
             continue;
         }
         ret.append(quad.makeSubQuad(quad.left(), quad.top(), x, quad.bottom()));
         ret.append(quad.makeSubQuad(x, quad.top(), quad.right(), quad.bottom()));
     }
     return ret;
 }
 
 WindowQuadList WindowQuadList::splitAtY(double y) const
 {
     WindowQuadList ret;
     foreach (const WindowQuad & quad, *this) {
 #if !defined(QT_NO_DEBUG)
         if (quad.isTransformed())
             qFatal("Splitting quads is allowed only in pre-paint calls!");
 #endif
         bool wholetop = true;
         bool wholebottom = true;
         for (int i = 0;
                 i < 4;
                 ++i) {
             if (quad[ i ].y() < y)
                 wholebottom = false;
             if (quad[ i ].y() > y)
                 wholetop = false;
         }
         if (wholetop || wholebottom) { // is whole in one split part
             ret.append(quad);
             continue;
         }
         if (quad.top() == quad.bottom() || quad.left() == quad.right()) { // quad has no size
             ret.append(quad);
             continue;
         }
         ret.append(quad.makeSubQuad(quad.left(), quad.top(), quad.right(), y));
         ret.append(quad.makeSubQuad(quad.left(), y, quad.right(), quad.bottom()));
     }
     return ret;
 }
 
 WindowQuadList WindowQuadList::makeGrid(int maxQuadSize) const
 {
     if (empty())
         return *this;
 
     // Find the bounding rectangle
     double left   = first().left();
     double right  = first().right();
     double top    = first().top();
     double bottom = first().bottom();
 
     foreach (const WindowQuad &quad, *this) {
 #if !defined(QT_NO_DEBUG)
         if (quad.isTransformed())
             qFatal("Splitting quads is allowed only in pre-paint calls!");
 #endif
         left   = qMin(left,   quad.left());
         right  = qMax(right,  quad.right());
         top    = qMin(top,    quad.top());
         bottom = qMax(bottom, quad.bottom());
     }
 
     WindowQuadList ret;
 
     foreach (const WindowQuad &quad, *this) {
         const double quadLeft   = quad.left();
         const double quadRight  = quad.right();
         const double quadTop    = quad.top();
         const double quadBottom = quad.bottom();
 
         // sanity check, see BUG 390953
         if (quadLeft == quadRight || quadTop == quadBottom) {
             ret.append(quad);
             continue;
         }
 
         // Compute the top-left corner of the first intersecting grid cell
         const double xBegin = left + qFloor((quadLeft - left) / maxQuadSize) * maxQuadSize;
         const double yBegin = top  + qFloor((quadTop  - top)  / maxQuadSize) * maxQuadSize;
 
         // Loop over all intersecting cells and add sub-quads
         for (double y = yBegin; y < quadBottom; y += maxQuadSize) {
             const double y0 = qMax(y, quadTop);
             const double y1 = qMin(quadBottom, y + maxQuadSize);
 
             for (double x = xBegin; x < quadRight; x += maxQuadSize) {
                 const double x0 = qMax(x, quadLeft);
                 const double x1 = qMin(quadRight, x + maxQuadSize);
 
                 ret.append(quad.makeSubQuad(x0, y0, x1, y1));
             }
         }
     }
 
     return ret;
 }
 
 WindowQuadList WindowQuadList::makeRegularGrid(int xSubdivisions, int ySubdivisions) const
 {
     if (empty())
         return *this;
 
     // Find the bounding rectangle
     double left   = first().left();
     double right  = first().right();
     double top    = first().top();
     double bottom = first().bottom();
 
     foreach (const WindowQuad &quad, *this) {
 #if !defined(QT_NO_DEBUG)
         if (quad.isTransformed())
             qFatal("Splitting quads is allowed only in pre-paint calls!");
 #endif
         left   = qMin(left,   quad.left());
         right  = qMax(right,  quad.right());
         top    = qMin(top,    quad.top());
         bottom = qMax(bottom, quad.bottom());
     }
 
     double xIncrement = (right - left) / xSubdivisions;
     double yIncrement = (bottom - top) / ySubdivisions;
 
     WindowQuadList ret;
 
     foreach (const WindowQuad &quad, *this) {
         const double quadLeft   = quad.left();
         const double quadRight  = quad.right();
         const double quadTop    = quad.top();
         const double quadBottom = quad.bottom();
 
         // sanity check, see BUG 390953
         if (quadLeft == quadRight || quadTop == quadBottom) {
             ret.append(quad);
             continue;
         }
 
         // Compute the top-left corner of the first intersecting grid cell
         const double xBegin = left + qFloor((quadLeft - left) / xIncrement) * xIncrement;
         const double yBegin = top  + qFloor((quadTop  - top)  / yIncrement) * yIncrement;
 
         // Loop over all intersecting cells and add sub-quads
         for (double y = yBegin; y < quadBottom; y += yIncrement) {
             const double y0 = qMax(y, quadTop);
             const double y1 = qMin(quadBottom, y + yIncrement);
 
             for (double x = xBegin; x < quadRight; x += xIncrement) {
                 const double x0 = qMax(x, quadLeft);
                 const double x1 = qMin(quadRight, x + xIncrement);
 
                 ret.append(quad.makeSubQuad(x0, y0, x1, y1));
             }
         }
     }
 
     return ret;
 }
 
 #ifndef GL_TRIANGLES
 #  define GL_TRIANGLES      0x0004
 #endif
 
 #ifndef GL_QUADS
 #  define GL_QUADS          0x0007
 #endif
 
 void WindowQuadList::makeInterleavedArrays(unsigned int type, GLVertex2D *vertices, const QMatrix4x4 &textureMatrix) const
 {
     // Since we know that the texture matrix just scales and translates
     // we can use this information to optimize the transformation
     const QVector2D coeff(textureMatrix(0, 0), textureMatrix(1, 1));
     const QVector2D offset(textureMatrix(0, 3), textureMatrix(1, 3));
 
     GLVertex2D *vertex = vertices;
 
     Q_ASSERT(type == GL_QUADS || type == GL_TRIANGLES);
 
     switch (type)
     {
     case GL_QUADS:
 #if defined(__SSE2__)
         if (!(intptr_t(vertex) & 0xf)) {
             for (int i = 0; i < count(); i++) {
                 const WindowQuad &quad = at(i);
                 alignas(16) GLVertex2D v[4];
 
                 for (int j = 0; j < 4; j++) {
                     const WindowVertex &wv = quad[j];
 
                     v[j].position = QVector2D(wv.x(), wv.y());
                     v[j].texcoord = QVector2D(wv.u(), wv.v()) * coeff + offset;
                 }
 
                 const __m128i *srcP = reinterpret_cast<const __m128i *>(&v);
                 __m128i *dstP = reinterpret_cast<__m128i *>(vertex);
 
                 _mm_stream_si128(&dstP[0], _mm_load_si128(&srcP[0])); // Top-left
                 _mm_stream_si128(&dstP[1], _mm_load_si128(&srcP[1])); // Top-right
                 _mm_stream_si128(&dstP[2], _mm_load_si128(&srcP[2])); // Bottom-right
                 _mm_stream_si128(&dstP[3], _mm_load_si128(&srcP[3])); // Bottom-left
 
                 vertex += 4;
             }
         } else
 #endif // __SSE2__
         {
             for (int i = 0; i < count(); i++) {
                 const WindowQuad &quad = at(i);
 
                 for (int j = 0; j < 4; j++) {
                     const WindowVertex &wv = quad[j];
 
                     GLVertex2D v;
                     v.position = QVector2D(wv.x(), wv.y());
                     v.texcoord = QVector2D(wv.u(), wv.v()) * coeff + offset;
 
                     *(vertex++) = v;
                 }
             }
         }
         break;
 
     case GL_TRIANGLES:
 #if defined(__SSE2__)
         if (!(intptr_t(vertex) & 0xf)) {
             for (int i = 0; i < count(); i++) {
                 const WindowQuad &quad = at(i);
                 alignas(16) GLVertex2D v[4];
 
                 for (int j = 0; j < 4; j++) {
                     const WindowVertex &wv = quad[j];
 
                     v[j].position = QVector2D(wv.x(), wv.y());
                     v[j].texcoord = QVector2D(wv.u(), wv.v()) * coeff + offset;
                 }
 
                 const __m128i *srcP = reinterpret_cast<const __m128i *>(&v);
                 __m128i *dstP = reinterpret_cast<__m128i *>(vertex);
 
                 __m128i src[4];
                 src[0] = _mm_load_si128(&srcP[0]); // Top-left
                 src[1] = _mm_load_si128(&srcP[1]); // Top-right
                 src[2] = _mm_load_si128(&srcP[2]); // Bottom-right
                 src[3] = _mm_load_si128(&srcP[3]); // Bottom-left
 
                 // First triangle
                 _mm_stream_si128(&dstP[0], src[1]); // Top-right
                 _mm_stream_si128(&dstP[1], src[0]); // Top-left
                 _mm_stream_si128(&dstP[2], src[3]); // Bottom-left
 
                 // Second triangle
                 _mm_stream_si128(&dstP[3], src[3]); // Bottom-left
                 _mm_stream_si128(&dstP[4], src[2]); // Bottom-right
                 _mm_stream_si128(&dstP[5], src[1]); // Top-right
 
                 vertex += 6;
             }
         } else
 #endif // __SSE2__
         {
             for (int i = 0; i < count(); i++) {
                 const WindowQuad &quad = at(i);
                 GLVertex2D v[4]; // Four unique vertices / quad
 
                 for (int j = 0; j < 4; j++) {
                     const WindowVertex &wv = quad[j];
 
                     v[j].position = QVector2D(wv.x(), wv.y());
                     v[j].texcoord = QVector2D(wv.u(), wv.v()) * coeff + offset;
                 }
 
                 // First triangle
                 *(vertex++) = v[1]; // Top-right
                 *(vertex++) = v[0]; // Top-left
                 *(vertex++) = v[3]; // Bottom-left
 
                 // Second triangle
                 *(vertex++) = v[3]; // Bottom-left
                 *(vertex++) = v[2]; // Bottom-right
                 *(vertex++) = v[1]; // Top-right
             }
         }
         break;
 
     default:
         break;
     }
 }
 
 void WindowQuadList::makeArrays(float **vertices, float **texcoords, const QSizeF &size, bool yInverted) const
 {
     *vertices = new float[count() * 6 * 2];
     *texcoords = new float[count() * 6 * 2];
 
     float *vpos = *vertices;
     float *tpos = *texcoords;
 
      // Note: The positions in a WindowQuad are stored in clockwise order
     const int index[] = { 1, 0, 3, 3, 2, 1 };
 
     for (int i = 0; i < count(); i++) {
         const WindowQuad &quad = at(i);
 
         for (int j = 0; j < 6; j++) {
             const WindowVertex &wv = quad[index[j]];
 
             *vpos++ = wv.x();
             *vpos++ = wv.y();
 
             *tpos++ = wv.u() / size.width();
             *tpos++ = yInverted ? (wv.v() / size.height()) : (1.0 - wv.v() / size.height());
         }
     }
 }
 
 WindowQuadList WindowQuadList::select(WindowQuadType type) const
 {
     foreach (const WindowQuad & q, *this) {
         if (q.type() != type) { // something else than ones to select, make a copy and filter
             WindowQuadList ret;
             foreach (const WindowQuad & q, *this) {
                 if (q.type() == type)
                     ret.append(q);
             }
             return ret;
         }
     }
     return *this; // nothing to filter out
 }
 
 WindowQuadList WindowQuadList::filterOut(WindowQuadType type) const
 {
     foreach (const WindowQuad & q, *this) {
         if (q.type() == type) { // something to filter out, make a copy and filter
             WindowQuadList ret;
             foreach (const WindowQuad & q, *this) {
                 if (q.type() != type)
                     ret.append(q);
             }
             return ret;
         }
     }
     return *this; // nothing to filter out
 }
 
 bool WindowQuadList::smoothNeeded() const
 {
     foreach (const WindowQuad & q, *this)
     if (q.smoothNeeded())
         return true;
     return false;
 }
 
 bool WindowQuadList::isTransformed() const
 {
     foreach (const WindowQuad & q, *this)
     if (q.isTransformed())
         return true;
     return false;
 }
 
 /***************************************************************
  PaintClipper
 ***************************************************************/
 
 QStack< QRegion >* PaintClipper::areas = nullptr;
 
 PaintClipper::PaintClipper(const QRegion& allowed_area)
     : area(allowed_area)
 {
     push(area);
 }
 
 PaintClipper::~PaintClipper()
 {
     pop(area);
 }
 
 void PaintClipper::push(const QRegion& allowed_area)
 {
     if (allowed_area == infiniteRegion())  // don't push these
         return;
     if (areas == nullptr)
         areas = new QStack< QRegion >;
     areas->push(allowed_area);
 }
 
 void PaintClipper::pop(const QRegion& allowed_area)
 {
     if (allowed_area == infiniteRegion())
         return;
     Q_ASSERT(areas != nullptr);
     Q_ASSERT(areas->top() == allowed_area);
     areas->pop();
     if (areas->isEmpty()) {
         delete areas;
         areas = nullptr;
     }
 }
 
 bool PaintClipper::clip()
 {
     return areas != nullptr;
 }
 
 QRegion PaintClipper::paintArea()
 {
     Q_ASSERT(areas != nullptr);   // can be called only with clip() == true
     const QSize &s = effects->virtualScreenSize();
     QRegion ret = QRegion(0, 0, s.width(), s.height());
     foreach (const QRegion & r, *areas)
     ret &= r;
     return ret;
 }
 
 struct PaintClipper::Iterator::Data {
     Data() : index(0) {}
     int index;
     QRegion region;
 };
 
 PaintClipper::Iterator::Iterator()
     : data(new Data)
 {
     if (clip() && effects->isOpenGLCompositing()) {
         data->region = paintArea();
         data->index = -1;
         next(); // move to the first one
     }
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (clip() && effects->compositingType() == XRenderCompositing) {
         XFixesRegion region(paintArea());
         xcb_xfixes_set_picture_clip_region(connection(), effects->xrenderBufferPicture(), region, 0, 0);
     }
 #endif
 }
 
 PaintClipper::Iterator::~Iterator()
 {
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (clip() && effects->compositingType() == XRenderCompositing)
         xcb_xfixes_set_picture_clip_region(connection(), effects->xrenderBufferPicture(), XCB_XFIXES_REGION_NONE, 0, 0);
 #endif
     delete data;
 }
 
 bool PaintClipper::Iterator::isDone()
 {
     if (!clip())
         return data->index == 1; // run once
     if (effects->isOpenGLCompositing())
         return data->index >= data->region.rectCount(); // run once per each area
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (effects->compositingType() == XRenderCompositing)
         return data->index == 1; // run once
 #endif
     abort();
 }
 
 void PaintClipper::Iterator::next()
 {
     data->index++;
 }
 
 QRect PaintClipper::Iterator::boundingRect() const
 {
     if (!clip())
         return infiniteRegion();
     if (effects->isOpenGLCompositing())
         return *(data->region.begin() + data->index);
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     if (effects->compositingType() == XRenderCompositing)
         return data->region.boundingRect();
 #endif
     abort();
     return infiniteRegion();
 }
 
 /***************************************************************
  Motion1D
 ***************************************************************/
 
 Motion1D::Motion1D(double initial, double strength, double smoothness)
     : Motion<double>(initial, strength, smoothness)
 {
 }
 
 Motion1D::Motion1D(const Motion1D &other)
     : Motion<double>(other)
 {
 }
 
 Motion1D::~Motion1D()
 {
 }
 
 /***************************************************************
  Motion2D
 ***************************************************************/
 
 Motion2D::Motion2D(QPointF initial, double strength, double smoothness)
     : Motion<QPointF>(initial, strength, smoothness)
 {
 }
 
 Motion2D::Motion2D(const Motion2D &other)
     : Motion<QPointF>(other)
 {
 }
 
 Motion2D::~Motion2D()
 {
 }
 
 /***************************************************************
  WindowMotionManager
 ***************************************************************/
 
 WindowMotionManager::WindowMotionManager(bool useGlobalAnimationModifier)
     :   m_useGlobalAnimationModifier(useGlobalAnimationModifier)
 
 {
     // TODO: Allow developer to modify motion attributes
 } // TODO: What happens when the window moves by an external force?
 
 WindowMotionManager::~WindowMotionManager()
 {
 }
 
 void WindowMotionManager::manage(EffectWindow *w)
 {
     if (m_managedWindows.contains(w))
         return;
 
     double strength = 0.08;
     double smoothness = 4.0;
     if (m_useGlobalAnimationModifier && effects->animationTimeFactor()) {
         // If the factor is == 0 then we just skip the calculation completely
         strength = 0.08 / effects->animationTimeFactor();
         smoothness = effects->animationTimeFactor() * 4.0;
     }
 
     WindowMotion &motion = m_managedWindows[ w ];
     motion.translation.setStrength(strength);
     motion.translation.setSmoothness(smoothness);
     motion.scale.setStrength(strength * 1.33);
     motion.scale.setSmoothness(smoothness / 2.0);
 
     motion.translation.setValue(w->pos());
     motion.scale.setValue(QPointF(1.0, 1.0));
 }
 
 void WindowMotionManager::unmanage(EffectWindow *w)
 {
     m_movingWindowsSet.remove(w);
     m_managedWindows.remove(w);
 }
 
 void WindowMotionManager::unmanageAll()
 {
     m_managedWindows.clear();
     m_movingWindowsSet.clear();
 }
 
 void WindowMotionManager::calculate(int time)
 {
     if (!effects->animationTimeFactor()) {
         // Just skip it completely if the user wants no animation
         m_movingWindowsSet.clear();
         QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.begin();
         for (; it != m_managedWindows.end(); ++it) {
             WindowMotion *motion = &it.value();
             motion->translation.finish();
             motion->scale.finish();
         }
     }
 
     QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.begin();
     for (; it != m_managedWindows.end(); ++it) {
         WindowMotion *motion = &it.value();
         int stopped = 0;
 
         // TODO: What happens when distance() == 0 but we are still moving fast?
         // TODO: Motion needs to be calculated from the window's center
 
         Motion2D *trans = &motion->translation;
         if (trans->distance().isNull())
             ++stopped;
         else {
             // Still moving
             trans->calculate(time);
             const short fx = trans->target().x() <= trans->startValue().x() ? -1 : 1;
             const short fy = trans->target().y() <= trans->startValue().y() ? -1 : 1;
             if (trans->distance().x()*fx/0.5 < 1.0 && trans->velocity().x()*fx/0.2 < 1.0 &&
                 trans->distance().y()*fy/0.5 < 1.0 && trans->velocity().y()*fy/0.2 < 1.0) {
                 // Hide tiny oscillations
                 motion->translation.finish();
                 ++stopped;
             }
         }
 
         Motion2D *scale = &motion->scale;
         if (scale->distance().isNull())
             ++stopped;
         else {
             // Still scaling
             scale->calculate(time);
             const short fx = scale->target().x() < 1.0 ? -1 : 1;
             const short fy = scale->target().y() < 1.0 ? -1 : 1;
             if (scale->distance().x()*fx/0.001 < 1.0 && scale->velocity().x()*fx/0.05 < 1.0 &&
                 scale->distance().y()*fy/0.001 < 1.0 && scale->velocity().y()*fy/0.05 < 1.0) {
                 // Hide tiny oscillations
                 motion->scale.finish();
                 ++stopped;
             }
         }
 
         // We just finished this window's motion
         if (stopped == 2)
             m_movingWindowsSet.remove(it.key());
     }
 }
 
 void WindowMotionManager::reset()
 {
     QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.begin();
     for (; it != m_managedWindows.end(); ++it) {
         WindowMotion *motion = &it.value();
         EffectWindow *window = it.key();
         motion->translation.setTarget(window->pos());
         motion->translation.finish();
         motion->scale.setTarget(QPointF(1.0, 1.0));
         motion->scale.finish();
     }
 }
 
 void WindowMotionManager::reset(EffectWindow *w)
 {
     QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.find(w);
     if (it == m_managedWindows.end())
         return;
 
     WindowMotion *motion = &it.value();
     motion->translation.setTarget(w->pos());
     motion->translation.finish();
     motion->scale.setTarget(QPointF(1.0, 1.0));
     motion->scale.finish();
 }
 
 void WindowMotionManager::apply(EffectWindow *w, WindowPaintData &data)
 {
     QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.find(w);
     if (it == m_managedWindows.end())
         return;
 
     // TODO: Take into account existing scale so that we can work with multiple managers (E.g. Present windows + grid)
     WindowMotion *motion = &it.value();
     data += (motion->translation.value() - QPointF(w->x(), w->y()));
     data *= QVector2D(motion->scale.value());
 }
 
 void WindowMotionManager::moveWindow(EffectWindow *w, QPoint target, double scale, double yScale)
 {
     QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.find(w);
     if (it == m_managedWindows.end())
         abort(); // Notify the effect author that they did something wrong
 
     WindowMotion *motion = &it.value();
 
     if (yScale == 0.0)
         yScale = scale;
     QPointF scalePoint(scale, yScale);
 
     if (motion->translation.value() == target && motion->scale.value() == scalePoint)
         return; // Window already at that position
 
     motion->translation.setTarget(target);
     motion->scale.setTarget(scalePoint);
 
     m_movingWindowsSet << w;
 }
 
 QRectF WindowMotionManager::transformedGeometry(EffectWindow *w) const
 {
     QHash<EffectWindow*, WindowMotion>::const_iterator it = m_managedWindows.constFind(w);
     if (it == m_managedWindows.end())
         return w->geometry();
 
     const WindowMotion *motion = &it.value();
     QRectF geometry(w->geometry());
 
     // TODO: Take into account existing scale so that we can work with multiple managers (E.g. Present windows + grid)
     geometry.moveTo(motion->translation.value());
     geometry.setWidth(geometry.width() * motion->scale.value().x());
     geometry.setHeight(geometry.height() * motion->scale.value().y());
 
     return geometry;
 }
 
 void WindowMotionManager::setTransformedGeometry(EffectWindow *w, const QRectF &geometry)
 {
     QHash<EffectWindow*, WindowMotion>::iterator it = m_managedWindows.find(w);
     if (it == m_managedWindows.end())
         return;
     WindowMotion *motion = &it.value();
     motion->translation.setValue(geometry.topLeft());
     motion->scale.setValue(QPointF(geometry.width() / qreal(w->width()), geometry.height() / qreal(w->height())));
 }
 
 QRectF WindowMotionManager::targetGeometry(EffectWindow *w) const
 {
     QHash<EffectWindow*, WindowMotion>::const_iterator it = m_managedWindows.constFind(w);
     if (it == m_managedWindows.end())
         return w->geometry();
 
     const WindowMotion *motion = &it.value();
     QRectF geometry(w->geometry());
 
     // TODO: Take into account existing scale so that we can work with multiple managers (E.g. Present windows + grid)
     geometry.moveTo(motion->translation.target());
     geometry.setWidth(geometry.width() * motion->scale.target().x());
     geometry.setHeight(geometry.height() * motion->scale.target().y());
 
     return geometry;
 }
 
 EffectWindow* WindowMotionManager::windowAtPoint(QPoint point, bool useStackingOrder) const
 {
     Q_UNUSED(useStackingOrder);
     // TODO: Stacking order uses EffectsHandler::stackingOrder() then filters by m_managedWindows
     QHash< EffectWindow*, WindowMotion >::ConstIterator it = m_managedWindows.constBegin();
     while (it != m_managedWindows.constEnd()) {
         if (transformedGeometry(it.key()).contains(point))
             return it.key();
         ++it;
     }
 
     return nullptr;
 }
 
 /***************************************************************
  EffectFramePrivate
 ***************************************************************/
 class EffectFramePrivate
 {
 public:
     EffectFramePrivate();
     ~EffectFramePrivate();
 
     bool crossFading;
     qreal crossFadeProgress;
     QMatrix4x4 screenProjectionMatrix;
 };
 
 EffectFramePrivate::EffectFramePrivate()
     : crossFading(false)
     , crossFadeProgress(1.0)
 {
 }
 
 EffectFramePrivate::~EffectFramePrivate()
 {
 }
 
 /***************************************************************
  EffectFrame
 ***************************************************************/
 EffectFrame::EffectFrame()
     : d(new EffectFramePrivate)
 {
 }
 
 EffectFrame::~EffectFrame()
 {
     delete d;
 }
 
 qreal EffectFrame::crossFadeProgress() const
 {
     return d->crossFadeProgress;
 }
 
 void EffectFrame::setCrossFadeProgress(qreal progress)
 {
     d->crossFadeProgress = progress;
 }
 
 bool EffectFrame::isCrossFade() const
 {
     return d->crossFading;
 }
 
 void EffectFrame::enableCrossFade(bool enable)
 {
     d->crossFading = enable;
 }
 
 QMatrix4x4 EffectFrame::screenProjectionMatrix() const
 {
     return d->screenProjectionMatrix;
 }
 
 void EffectFrame::setScreenProjectionMatrix(const QMatrix4x4 &spm)
 {
     d->screenProjectionMatrix = spm;
 }
 
 /***************************************************************
  TimeLine
 ***************************************************************/
 
 class Q_DECL_HIDDEN TimeLine::Data : public QSharedData
 {
 public:
     std::chrono::milliseconds duration;
     Direction direction;
     QEasingCurve easingCurve;
 
     std::chrono::milliseconds elapsed = std::chrono::milliseconds::zero();
     bool done = false;
     RedirectMode sourceRedirectMode = RedirectMode::Relaxed;
     RedirectMode targetRedirectMode = RedirectMode::Strict;
 };
 
 TimeLine::TimeLine(std::chrono::milliseconds duration, Direction direction)
     : d(new Data)
 {
     Q_ASSERT(duration > std::chrono::milliseconds::zero());
     d->duration = duration;
     d->direction = direction;
 }
 
 TimeLine::TimeLine(const TimeLine &other)
     : d(other.d)
 {
 }
 
 TimeLine::~TimeLine() = default;
 
 qreal TimeLine::progress() const
 {
     return static_cast<qreal>(d->elapsed.count()) / d->duration.count();
 }
 
 qreal TimeLine::value() const
 {
     const qreal t = progress();
     return d->easingCurve.valueForProgress(
         d->direction == Backward ? 1.0 - t : t);
 }
 
 void TimeLine::update(std::chrono::milliseconds delta)
 {
     Q_ASSERT(delta >= std::chrono::milliseconds::zero());
     if (d->done) {
         return;
     }
     d->elapsed += delta;
     if (d->elapsed >= d->duration) {
         d->done = true;
         d->elapsed = d->duration;
     }
 }
 
 std::chrono::milliseconds TimeLine::elapsed() const
 {
     return d->elapsed;
 }
 
 void TimeLine::setElapsed(std::chrono::milliseconds elapsed)
 {
     Q_ASSERT(elapsed >= std::chrono::milliseconds::zero());
     if (elapsed == d->elapsed) {
         return;
     }
     reset();
     update(elapsed);
 }
 
 std::chrono::milliseconds TimeLine::duration() const
 {
     return d->duration;
 }
 
 void TimeLine::setDuration(std::chrono::milliseconds duration)
 {
     Q_ASSERT(duration > std::chrono::milliseconds::zero());
     if (duration == d->duration) {
         return;
     }
     d->elapsed = std::chrono::milliseconds(qRound(progress() * duration.count()));
     d->duration = duration;
     if (d->elapsed == d->duration) {
         d->done = true;
     }
 }
 
 TimeLine::Direction TimeLine::direction() const
 {
     return d->direction;
 }
 
 void TimeLine::setDirection(TimeLine::Direction direction)
 {
     if (d->direction == direction) {
         return;
     }
 
     d->direction = direction;
 
     if (d->elapsed > std::chrono::milliseconds::zero()
             || d->sourceRedirectMode == RedirectMode::Strict) {
         d->elapsed = d->duration - d->elapsed;
     }
 
     if (d->done && d->targetRedirectMode == RedirectMode::Relaxed) {
         d->done = false;
     }
 
     if (d->elapsed >= d->duration) {
         d->done = true;
     }
 }
 
 void TimeLine::toggleDirection()
 {
     setDirection(d->direction == Forward ? Backward : Forward);
 }
 
 QEasingCurve TimeLine::easingCurve() const
 {
     return d->easingCurve;
 }
 
 void TimeLine::setEasingCurve(const QEasingCurve &easingCurve)
 {
     d->easingCurve = easingCurve;
 }
 
 void TimeLine::setEasingCurve(QEasingCurve::Type type)
 {
     d->easingCurve.setType(type);
 }
 
 bool TimeLine::running() const
 {
     return d->elapsed != std::chrono::milliseconds::zero()
         && d->elapsed != d->duration;
 }
 
 bool TimeLine::done() const
 {
     return d->done;
 }
 
 void TimeLine::reset()
 {
     d->elapsed = std::chrono::milliseconds::zero();
     d->done = false;
 }
 
 TimeLine::RedirectMode TimeLine::sourceRedirectMode() const
 {
     return d->sourceRedirectMode;
 }
 
 void TimeLine::setSourceRedirectMode(RedirectMode mode)
 {
     d->sourceRedirectMode = mode;
 }
 
 TimeLine::RedirectMode TimeLine::targetRedirectMode() const
 {
     return d->targetRedirectMode;
 }
 
 void TimeLine::setTargetRedirectMode(RedirectMode mode)
 {
     d->targetRedirectMode = mode;
 }
 
 TimeLine &TimeLine::operator=(const TimeLine &other)
 {
     d = other.d;
     return *this;
 }
 
 } // namespace
 
 #include "moc_kwinglobals.cpp"
diff --git a/libkwineffects/kwineffects.h b/libkwineffects/kwineffects.h
index 8762d5055..3d7341991 100644
--- a/libkwineffects/kwineffects.h
+++ b/libkwineffects/kwineffects.h
@@ -1,4026 +1,4024 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWINEFFECTS_H
 #define KWINEFFECTS_H
 
 #include <kwinconfig.h>
 #include <kwineffects_export.h>
 #include <kwinglobals.h>
 
 #include <QEasingCurve>
 #include <QIcon>
 #include <QPair>
 #include <QSet>
 #include <QRect>
 #include <QRegion>
 #include <QVector2D>
 #include <QVector3D>
 
 #include <QVector>
 #include <QLoggingCategory>
 #include <QList>
 #include <QHash>
 #include <QStack>
 #include <QScopedPointer>
 
 #include <KPluginFactory>
 #include <KSharedConfig>
 
 #include <netwm.h>
 
 #include <climits>
 #include <functional>
 
 class KConfigGroup;
 class QFont;
 class QGraphicsScale;
 class QKeyEvent;
 class QMatrix4x4;
 class QAction;
 
 /**
  * Logging category to be used inside the KWin effects.
  * Do not use in this library.
  */
 Q_DECLARE_LOGGING_CATEGORY(KWINEFFECTS)
 
-namespace KWayland {
-    namespace Server {
-        class SurfaceInterface;
-        class Display;
-    }
+namespace KWaylandServer {
+    class SurfaceInterface;
+    class Display;
 }
 
 namespace KWin
 {
 
 class PaintDataPrivate;
 class WindowPaintDataPrivate;
 
 class EffectWindow;
 class EffectWindowGroup;
 class EffectFrame;
 class EffectFramePrivate;
 class EffectQuickView;
 class Effect;
 class WindowQuad;
 class GLShader;
 class XRenderPicture;
 class WindowQuadList;
 class WindowPrePaintData;
 class WindowPaintData;
 class ScreenPrePaintData;
 class ScreenPaintData;
 
 typedef QPair< QString, Effect* > EffectPair;
 typedef QList< KWin::EffectWindow* > EffectWindowList;
 
 
 /** @defgroup kwineffects KWin effects library
  * KWin effects library contains necessary classes for creating new KWin
  * compositing effects.
  *
  * @section creating Creating new effects
  * This example will demonstrate the basics of creating an effect. We'll use
  *  CoolEffect as the class name, cooleffect as internal name and
  *  "Cool Effect" as user-visible name of the effect.
  *
  * This example doesn't demonstrate how to write the effect's code. For that,
  *  see the documentation of the Effect class.
  *
  * @subsection creating-class CoolEffect class
  * First you need to create CoolEffect class which has to be a subclass of
  *  @ref KWin::Effect. In that class you can reimplement various virtual
  *  methods to control how and where the windows are drawn.
  *
  * @subsection creating-macro KWIN_EFFECT_FACTORY macro
  * This library provides a specialized KPluginFactory subclass and macros to
  * create a sub class. This subclass of KPluginFactory has to be used, otherwise
  * KWin won't load the plugin. Use the @ref KWIN_EFFECT_FACTORY macro to create the
  * plugin factory.
  *
  * @subsection creating-buildsystem Buildsystem
  * To build the effect, you can use the KWIN_ADD_EFFECT() cmake macro which
  *  can be found in effects/CMakeLists.txt file in KWin's source. First
  *  argument of the macro is the name of the library that will contain
  *  your effect. Although not strictly required, it is usually a good idea to
  *  use the same name as your effect's internal name there. Following arguments
  *  to the macro are the files containing your effect's source. If our effect's
  *  source is in cooleffect.cpp, we'd use following:
  * @code
  *  KWIN_ADD_EFFECT(cooleffect cooleffect.cpp)
  * @endcode
  *
  * This macro takes care of compiling your effect. You'll also need to install
  *  your effect's .desktop file, so the example CMakeLists.txt file would be
  *  as follows:
  * @code
  *  KWIN_ADD_EFFECT(cooleffect cooleffect.cpp)
  *  install( FILES cooleffect.desktop DESTINATION ${SERVICES_INSTALL_DIR}/kwin )
  * @endcode
  *
  * @subsection creating-desktop Effect's .desktop file
  * You will also need to create .desktop file to set name, description, icon
  *  and other properties of your effect. Important fields of the .desktop file
  *  are:
  *  @li Name User-visible name of your effect
  *  @li Icon Name of the icon of the effect
  *  @li Comment Short description of the effect
  *  @li Type must be "Service"
  *  @li X-KDE-ServiceTypes must be "KWin/Effect"
  *  @li X-KDE-PluginInfo-Name effect's internal name as passed to the KWIN_EFFECT macro plus "kwin4_effect_" prefix
  *  @li X-KDE-PluginInfo-Category effect's category. Should be one of Appearance, Accessibility, Window Management, Demos, Tests, Misc
  *  @li X-KDE-PluginInfo-EnabledByDefault whether the effect should be enabled by default (use sparingly). Default is false
  *  @li X-KDE-Library name of the library containing the effect. This is the first argument passed to the KWIN_ADD_EFFECT macro in cmake file plus "kwin4_effect_" prefix.
  *
  * Example cooleffect.desktop file follows:
  * @code
 [Desktop Entry]
 Name=Cool Effect
 Comment=The coolest effect you've ever seen
 Icon=preferences-system-windows-effect-cooleffect
 
 Type=Service
 X-KDE-ServiceTypes=KWin/Effect
 X-KDE-PluginInfo-Author=My Name
 X-KDE-PluginInfo-Email=my@email.here
 X-KDE-PluginInfo-Name=kwin4_effect_cooleffect
 X-KDE-PluginInfo-Category=Misc
 X-KDE-Library=kwin4_effect_cooleffect
  * @endcode
  *
  *
  * @section accessing Accessing windows and workspace
  * Effects can gain access to the properties of windows and workspace via
  *  EffectWindow and EffectsHandler classes.
  *
  * There is one global EffectsHandler object which you can access using the
  *  @ref effects pointer.
  * For each window, there is an EffectWindow object which can be used to read
  *  window properties such as position and also to change them.
  *
  * For more information about this, see the documentation of the corresponding
  *  classes.
  *
  * @{
  */
 
 #define KWIN_EFFECT_API_MAKE_VERSION( major, minor ) (( major ) << 8 | ( minor ))
 #define KWIN_EFFECT_API_VERSION_MAJOR 0
 #define KWIN_EFFECT_API_VERSION_MINOR 230
 #define KWIN_EFFECT_API_VERSION KWIN_EFFECT_API_MAKE_VERSION( \
         KWIN_EFFECT_API_VERSION_MAJOR, KWIN_EFFECT_API_VERSION_MINOR )
 
 enum WindowQuadType {
     WindowQuadError, // for the stupid default ctor
     WindowQuadContents,
     WindowQuadDecoration,
     // Shadow Quad types
     WindowQuadShadow,             // OpenGL only. The other shadow types are only used by Xrender
     WindowQuadShadowTop,
     WindowQuadShadowTopRight,
     WindowQuadShadowRight,
     WindowQuadShadowBottomRight,
     WindowQuadShadowBottom,
     WindowQuadShadowBottomLeft,
     WindowQuadShadowLeft,
     WindowQuadShadowTopLeft,
     EFFECT_QUAD_TYPE_START = 100 ///< @internal
 };
 
 /**
  * EffectWindow::setData() and EffectWindow::data() global roles.
  * All values between 0 and 999 are reserved for global roles.
  */
 enum DataRole {
     // Grab roles are used to force all other animations to ignore the window.
     // The value of the data is set to the Effect's `this` value.
     WindowAddedGrabRole = 1,
     WindowClosedGrabRole,
     WindowMinimizedGrabRole,
     WindowUnminimizedGrabRole,
     WindowForceBlurRole, ///< For fullscreen effects to enforce blurring of windows,
     WindowBlurBehindRole, ///< For single windows to blur behind
     WindowForceBackgroundContrastRole, ///< For fullscreen effects to enforce the background contrast,
     WindowBackgroundContrastRole, ///< For single windows to enable Background contrast
     LanczosCacheRole
 };
 
 /**
  * Style types used by @ref EffectFrame.
  * @since 4.6
  */
 enum EffectFrameStyle {
     EffectFrameNone, ///< Displays no frame around the contents.
     EffectFrameUnstyled, ///< Displays a basic box around the contents.
     EffectFrameStyled ///< Displays a Plasma-styled frame around the contents.
 };
 
 /**
  * Infinite region (i.e. a special region type saying that everything needs to be painted).
  */
 KWINEFFECTS_EXPORT inline
 QRect infiniteRegion()
 {
     // INT_MIN / 2 because width/height is used (INT_MIN+INT_MAX==-1)
     return QRect(INT_MIN / 2, INT_MIN / 2, INT_MAX, INT_MAX);
 }
 
 /**
  * @short Base class for all KWin effects
  *
  * This is the base class for all effects. By reimplementing virtual methods
  *  of this class, you can customize how the windows are painted.
  *
  * The virtual methods are used for painting and need to be implemented for
  * custom painting.
  *
  * In order to react to state changes (e.g. a window gets closed) the effect
  * should provide slots for the signals emitted by the EffectsHandler.
  *
  * @section Chaining
  * Most methods of this class are called in chain style. This means that when
  *  effects A and B area active then first e.g. A::paintWindow() is called and
  *  then from within that method B::paintWindow() is called (although
  *  indirectly). To achieve this, you need to make sure to call corresponding
  *  method in EffectsHandler class from each such method (using @ref effects
  *  pointer):
  * @code
  *  void MyEffect::postPaintScreen()
  *  {
  *      // Do your own processing here
  *      ...
  *      // Call corresponding EffectsHandler method
  *      effects->postPaintScreen();
  *  }
  * @endcode
  *
  * @section Effectsptr Effects pointer
  * @ref effects pointer points to the global EffectsHandler object that you can
  *  use to interact with the windows.
  *
  * @section painting Painting stages
  * Painting of windows is done in three stages:
  * @li First, the prepaint pass.<br>
  *  Here you can specify how the windows will be painted, e.g. that they will
  *  be translucent and transformed.
  * @li Second, the paint pass.<br>
  *  Here the actual painting takes place. You can change attributes such as
  *  opacity of windows as well as apply transformations to them. You can also
  *  paint something onto the screen yourself.
  * @li Finally, the postpaint pass.<br>
  *  Here you can mark windows, part of windows or even the entire screen for
  *  repainting to create animations.
  *
  * For each stage there are *Screen() and *Window() methods. The window method
  *  is called for every window which the screen method is usually called just
  *  once.
  *
  * @section OpenGL
  * Effects can use OpenGL if EffectsHandler::isOpenGLCompositing() returns @c true.
  * The OpenGL context may not always be current when code inside the effect is
  * executed. The framework ensures that the OpenGL context is current when the Effect
  * gets created, destroyed or reconfigured and during the painting stages. All virtual
  * methods which have the OpenGL context current are documented.
  *
  * If OpenGL code is going to be executed outside the painting stages, e.g. in reaction
  * to a global shortcut, it is the task of the Effect to make the OpenGL context current:
  * @code
  * effects->makeOpenGLContextCurrent();
  * @endcode
  *
  * There is in general no need to call the matching doneCurrent method.
  */
 class KWINEFFECTS_EXPORT Effect : public QObject
 {
     Q_OBJECT
 public:
     /** Flags controlling how painting is done. */
     // TODO: is that ok here?
     enum {
         /**
          * Window (or at least part of it) will be painted opaque.
          */
         PAINT_WINDOW_OPAQUE         = 1 << 0,
         /**
          * Window (or at least part of it) will be painted translucent.
          */
         PAINT_WINDOW_TRANSLUCENT    = 1 << 1,
         /**
          * Window will be painted with transformed geometry.
          */
         PAINT_WINDOW_TRANSFORMED    = 1 << 2,
         /**
          * Paint only a region of the screen (can be optimized, cannot
          * be used together with TRANSFORMED flags).
          */
         PAINT_SCREEN_REGION         = 1 << 3,
         /**
          * The whole screen will be painted with transformed geometry.
          * Forces the entire screen to be painted.
          */
         PAINT_SCREEN_TRANSFORMED    = 1 << 4,
         /**
          * At least one window will be painted with transformed geometry.
          * Forces the entire screen to be painted.
          */
         PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
         /**
          * Clear whole background as the very first step, without optimizing it
          */
         PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
         // PAINT_DECORATION_ONLY = 1 << 7 has been deprecated
         /**
          * Window will be painted with a lanczos filter.
          */
         PAINT_WINDOW_LANCZOS = 1 << 8
         // PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS = 1 << 9 has been removed
     };
 
     enum Feature {
         Nothing = 0,
         Resize,
         GeometryTip,
         Outline, /**< @deprecated */
         ScreenInversion,
         Blur,
         Contrast,
         HighlightWindows
     };
 
     /**
      * Constructs new Effect object.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when the Effect is constructed.
      */
     Effect();
     /**
      * Destructs the Effect object.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when the Effect is destroyed.
      */
     ~Effect() override;
 
     /**
      * Flags describing which parts of configuration have changed.
      */
     enum ReconfigureFlag {
         ReconfigureAll = 1 << 0 /// Everything needs to be reconfigured.
     };
     Q_DECLARE_FLAGS(ReconfigureFlags, ReconfigureFlag)
 
     /**
      * Called when configuration changes (either the effect's or KWin's global).
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when the Effect is reconfigured. If this method is called from within the Effect it is
      * required to ensure that the context is current if the implementation does OpenGL calls.
      */
     virtual void reconfigure(ReconfigureFlags flags);
 
     /**
      * Called when another effect requests the proxy for this effect.
      */
     virtual void* proxy();
 
     /**
      * Called before starting to paint the screen.
      * In this method you can:
      * @li set whether the windows or the entire screen will be transformed
      * @li change the region of the screen that will be painted
      * @li do various housekeeping tasks such as initing your effect's variables
             for the upcoming paint pass or updating animation's progress
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
     */
     virtual void prePaintScreen(ScreenPrePaintData& data, int time);
     /**
      * In this method you can:
      * @li paint something on top of the windows (by painting after calling
      *      effects->paintScreen())
      * @li paint multiple desktops and/or multiple copies of the same desktop
      *      by calling effects->paintScreen() multiple times
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void paintScreen(int mask, const QRegion &region, ScreenPaintData& data);
     /**
      * Called after all the painting has been finished.
      * In this method you can:
      * @li schedule next repaint in case of animations
      * You shouldn't paint anything here.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void postPaintScreen();
 
     /**
      * Called for every window before the actual paint pass
      * In this method you can:
      * @li enable or disable painting of the window (e.g. enable paiting of minimized window)
      * @li set window to be painted with translucency
      * @li set window to be transformed
      * @li request the window to be divided into multiple parts
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time);
     /**
      * This is the main method for painting windows.
      * In this method you can:
      * @li do various transformations
      * @li change opacity of the window
      * @li change brightness and/or saturation, if it's supported
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void paintWindow(EffectWindow* w, int mask, QRegion region, WindowPaintData& data);
     /**
      * Called for every window after all painting has been finished.
      * In this method you can:
      * @li schedule next repaint for individual window(s) in case of animations
      * You shouldn't paint anything here.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void postPaintWindow(EffectWindow* w);
 
     /**
      * This method is called directly before painting an @ref EffectFrame.
      * You can implement this method if you need to bind a shader or perform
      * other operations before the frame is rendered.
      * @param frame The EffectFrame which will be rendered
      * @param region Region to restrict painting to
      * @param opacity Opacity of text/icon
      * @param frameOpacity Opacity of background
      * @since 4.6
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity);
 
     /**
      * Called on Transparent resizes.
      * return true if your effect substitutes questioned feature
      */
     virtual bool provides(Feature);
 
     /**
      * Performs the @p feature with the @p arguments.
      *
      * This allows to have specific protocols between KWin core and an Effect.
      *
      * The method is supposed to return @c true if it performed the features,
      * @c false otherwise.
      *
      * The default implementation returns @c false.
      * @since 5.8
      */
     virtual bool perform(Feature feature, const QVariantList &arguments);
 
     /**
      * Can be called to draw multiple copies (e.g. thumbnails) of a window.
      * You can change window's opacity/brightness/etc here, but you can't
      *  do any transformations.
      *
      * In OpenGL based compositing, the frameworks ensures that the context is current
      * when this method is invoked.
      */
     virtual void drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data);
 
     /**
      * Define new window quads so that they can be transformed by other effects.
      * It's up to the effect to keep track of them.
      */
     virtual void buildQuads(EffectWindow* w, WindowQuadList& quadList);
 
     virtual void windowInputMouseEvent(QEvent* e);
     virtual void grabbedKeyboardEvent(QKeyEvent* e);
 
     /**
      * Overwrite this method to indicate whether your effect will be doing something in
      * the next frame to be rendered. If the method returns @c false the effect will be
      * excluded from the chained methods in the next rendered frame.
      *
      * This method is called always directly before the paint loop begins. So it is totally
      * fine to e.g. react on a window event, issue a repaint to trigger an animation and
      * change a flag to indicate that this method returns @c true.
      *
      * As the method is called each frame, you should not perform complex calculations.
      * Best use just a boolean flag.
      *
      * The default implementation of this method returns @c true.
      * @since 4.8
      */
     virtual bool isActive() const;
 
     /**
      * Reimplement this method to provide online debugging.
      * This could be as trivial as printing specific detail information about the effect state
      * but could also be used to move the effect in and out of a special debug modes, clear bogus
      * data, etc.
      * Notice that the functions is const by intent! Whenever you alter the state of the object
      * due to random user input, you should do so with greatest care, hence const_cast<> your
      * object - signalling "let me alone, i know what i'm doing"
      * @param parameter A freeform string user input for your effect to interpret.
      * @since 4.11
      */
     virtual QString debug(const QString &parameter) const;
 
     /**
      * Reimplement this method to indicate where in the Effect chain the Effect should be placed.
      *
      * A low number indicates early chain position, thus before other Effects got called, a high
      * number indicates a late position. The returned number should be in the interval [0, 100].
      * The default value is 0.
      *
      * In KWin4 this information was provided in the Effect's desktop file as property
      * X-KDE-Ordering. In the case of Scripted Effects this property is still used.
      *
      * @since 5.0
      */
     virtual int requestedEffectChainPosition() const;
 
 
     /**
      * A touch point was pressed.
      *
      * If the effect wants to exclusively use the touch event it should return @c true.
      * If @c false is returned the touch event is passed to further effects.
      *
      * In general an Effect should only return @c true if it is the exclusive effect getting
      * input events. E.g. has grabbed mouse events.
      *
      * Default implementation returns @c false.
      *
      * @param id The unique id of the touch point
      * @param pos The position of the touch point in global coordinates
      * @param time Timestamp
      *
      * @see touchMotion
      * @see touchUp
      * @since 5.8
      */
     virtual bool touchDown(qint32 id, const QPointF &pos, quint32 time);
     /**
      * A touch point moved.
      *
      * If the effect wants to exclusively use the touch event it should return @c true.
      * If @c false is returned the touch event is passed to further effects.
      *
      * In general an Effect should only return @c true if it is the exclusive effect getting
      * input events. E.g. has grabbed mouse events.
      *
      * Default implementation returns @c false.
      *
      * @param id The unique id of the touch point
      * @param pos The position of the touch point in global coordinates
      * @param time Timestamp
      *
      * @see touchDown
      * @see touchUp
      * @since 5.8
      */
     virtual bool touchMotion(qint32 id, const QPointF &pos, quint32 time);
     /**
      * A touch point was released.
      *
      * If the effect wants to exclusively use the touch event it should return @c true.
      * If @c false is returned the touch event is passed to further effects.
      *
      * In general an Effect should only return @c true if it is the exclusive effect getting
      * input events. E.g. has grabbed mouse events.
      *
      * Default implementation returns @c false.
      *
      * @param id The unique id of the touch point
      * @param time Timestamp
      *
      * @see touchDown
      * @see touchMotion
      * @since 5.8
      */
     virtual bool touchUp(qint32 id, quint32 time);
 
     static QPoint cursorPos();
 
     /**
      * Read animation time from the configuration and possibly adjust using animationTimeFactor().
      * The configuration value in the effect should also have special value 'default' (set using
      * QSpinBox::setSpecialValueText()) with the value 0. This special value is adjusted
      * using the global animation speed, otherwise the exact time configured is returned.
      * @param cfg configuration group to read value from
      * @param key configuration key to read value from
      * @param defaultTime default animation time in milliseconds
      */
     // return type is intentionally double so that one can divide using it without losing data
     static double animationTime(const KConfigGroup& cfg, const QString& key, int defaultTime);
     /**
      * @overload Use this variant if the animation time is hardcoded and not configurable
      * in the effect itself.
      */
     static double animationTime(int defaultTime);
     /**
      * @overload Use this variant if animation time is provided through a KConfigXT generated class
      * having a property called "duration".
      */
     template <typename T>
     int animationTime(int defaultDuration);
     /**
      * Linearly interpolates between @p x and @p y.
      *
      * Returns @p x when @p a = 0; returns @p y when @p a = 1.
      */
     static double interpolate(double x, double y, double a) {
         return x * (1 - a) + y * a;
     }
     /** Helper to set WindowPaintData and QRegion to necessary transformations so that
      * a following drawWindow() would put the window at the requested geometry (useful for thumbnails)
      */
     static void setPositionTransformations(WindowPaintData& data, QRect& region, EffectWindow* w,
                                            const QRect& r, Qt::AspectRatioMode aspect);
 
 public Q_SLOTS:
     virtual bool borderActivated(ElectricBorder border);
 
 protected:
     xcb_connection_t *xcbConnection() const;
     xcb_window_t x11RootWindow() const;
 
     /**
      * An implementing class can call this with it's kconfig compiled singleton class.
      * This method will perform the instance on the class.
      * @since 5.9
      */
     template <typename T>
     void initConfig();
 };
 
 
 /**
  * Prefer the KWIN_EFFECT_FACTORY macros.
  */
 class KWINEFFECTS_EXPORT EffectPluginFactory : public KPluginFactory
 {
     Q_OBJECT
 public:
     EffectPluginFactory();
     ~EffectPluginFactory() override;
     /**
      * Returns whether the Effect is supported.
      *
      * An Effect can implement this method to determine at runtime whether the Effect is supported.
      *
      * If the current compositing backend is not supported it should return @c false.
      *
      * This method is optional, by default @c true is returned.
      */
     virtual bool isSupported() const;
     /**
      * Returns whether the Effect should get enabled by default.
      *
      * This function provides a way for an effect to override the default at runtime,
      * e.g. based on the capabilities of the hardware.
      *
      * This method is optional; the effect doesn't have to provide it.
      *
      * Note that this function is only called if the supported() function returns true,
      * and if X-KDE-PluginInfo-EnabledByDefault is set to true in the .desktop file.
      *
      * This method is optional, by default @c true is returned.
      */
     virtual bool enabledByDefault() const;
     /**
      * This method returns the created Effect.
      */
     virtual KWin::Effect *createEffect() const = 0;
 };
 
 /**
  * Defines an EffectPluginFactory sub class with customized isSupported and enabledByDefault methods.
  *
  * If the Effect to be created does not need the isSupported or enabledByDefault methods prefer
  * the simplified KWIN_EFFECT_FACTORY, KWIN_EFFECT_FACTORY_SUPPORTED or KWIN_EFFECT_FACTORY_ENABLED
  * macros which create an EffectPluginFactory with a useable default value.
  *
  * The macro also adds a useable K_EXPORT_PLUGIN_VERSION to the definition. KWin will not load
  * any Effect with a non-matching plugin version. This API is not providing binary compatibility
  * and thus the effect plugin must be compiled against the same kwineffects library version as
  * KWin.
  *
  * @param factoryName The name to be used for the EffectPluginFactory
  * @param className The class name of the Effect sub class which is to be created by the factory
  * @param jsonFile Name of the json file to be compiled into the plugin as metadata
  * @param supported Source code to go into the isSupported() method, must return a boolean
  * @param enabled Source code to go into the enabledByDefault() method, must return a boolean
  */
 #define KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, supported, enabled ) \
     class factoryName : public KWin::EffectPluginFactory \
     { \
         Q_OBJECT \
         Q_PLUGIN_METADATA(IID KPluginFactory_iid FILE jsonFile) \
         Q_INTERFACES(KPluginFactory) \
     public: \
         explicit factoryName() {} \
         ~factoryName() {} \
         bool isSupported() const override { \
             supported \
         } \
         bool enabledByDefault() const override { \
             enabled \
         } \
         KWin::Effect *createEffect() const override { \
             return new className(); \
         } \
     }; \
     K_EXPORT_PLUGIN_VERSION(quint32(KWIN_EFFECT_API_VERSION))
 
 #define KWIN_EFFECT_FACTORY_ENABLED( factoryName, className, jsonFile, enabled ) \
     KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, return true;, enabled )
 
 #define KWIN_EFFECT_FACTORY_SUPPORTED( factoryName, classname, jsonFile, supported ) \
     KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, supported, return true; )
 
 #define KWIN_EFFECT_FACTORY( factoryName, classname, jsonFile ) \
     KWIN_EFFECT_FACTORY_SUPPORTED_ENABLED( factoryName, className, jsonFile, return true;, return true; )
 
 
 
 /**
  * @short Manager class that handles all the effects.
  *
  * This class creates Effect objects and calls it's appropriate methods.
  *
  * Effect objects can call methods of this class to interact with the
  *  workspace, e.g. to activate or move a specific window, change current
  *  desktop or create a special input window to receive mouse and keyboard
  *  events.
  */
 class KWINEFFECTS_EXPORT EffectsHandler : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(int currentDesktop READ currentDesktop WRITE setCurrentDesktop NOTIFY desktopChanged)
     Q_PROPERTY(QString currentActivity READ currentActivity NOTIFY currentActivityChanged)
     Q_PROPERTY(KWin::EffectWindow *activeWindow READ activeWindow WRITE activateWindow NOTIFY windowActivated)
     Q_PROPERTY(QSize desktopGridSize READ desktopGridSize)
     Q_PROPERTY(int desktopGridWidth READ desktopGridWidth)
     Q_PROPERTY(int desktopGridHeight READ desktopGridHeight)
     Q_PROPERTY(int workspaceWidth READ workspaceWidth)
     Q_PROPERTY(int workspaceHeight READ workspaceHeight)
     /**
      * The number of desktops currently used. Minimum number of desktops is 1, maximum 20.
      */
     Q_PROPERTY(int desktops READ numberOfDesktops WRITE setNumberOfDesktops NOTIFY numberDesktopsChanged)
     Q_PROPERTY(bool optionRollOverDesktops READ optionRollOverDesktops)
     Q_PROPERTY(int activeScreen READ activeScreen)
     Q_PROPERTY(int numScreens READ numScreens NOTIFY numberScreensChanged)
     /**
      * Factor by which animation speed in the effect should be modified (multiplied).
      * If configurable in the effect itself, the option should have also 'default'
      * animation speed. The actual value should be determined using animationTime().
      * Note: The factor can be also 0, so make sure your code can cope with 0ms time
      * if used manually.
      */
     Q_PROPERTY(qreal animationTimeFactor READ animationTimeFactor)
     Q_PROPERTY(QList< KWin::EffectWindow* > stackingOrder READ stackingOrder)
     /**
      * Whether window decorations use the alpha channel.
      */
     Q_PROPERTY(bool decorationsHaveAlpha READ decorationsHaveAlpha)
     /**
      * Whether the window decorations support blurring behind the decoration.
      */
     Q_PROPERTY(bool decorationSupportsBlurBehind READ decorationSupportsBlurBehind)
     Q_PROPERTY(CompositingType compositingType READ compositingType CONSTANT)
     Q_PROPERTY(QPoint cursorPos READ cursorPos)
     Q_PROPERTY(QSize virtualScreenSize READ virtualScreenSize NOTIFY virtualScreenSizeChanged)
     Q_PROPERTY(QRect virtualScreenGeometry READ virtualScreenGeometry NOTIFY virtualScreenGeometryChanged)
     Q_PROPERTY(bool hasActiveFullScreenEffect READ hasActiveFullScreenEffect NOTIFY hasActiveFullScreenEffectChanged)
 
     /**
      * The status of the session i.e if the user is logging out
      * @since 5.18
      */
     Q_PROPERTY(KWin::SessionState sessionState READ sessionState NOTIFY sessionStateChanged)
 
     friend class Effect;
 public:
     explicit EffectsHandler(CompositingType type);
     ~EffectsHandler() override;
     // for use by effects
     virtual void prePaintScreen(ScreenPrePaintData& data, int time) = 0;
     virtual void paintScreen(int mask, const QRegion &region, ScreenPaintData& data) = 0;
     virtual void postPaintScreen() = 0;
     virtual void prePaintWindow(EffectWindow* w, WindowPrePaintData& data, int time) = 0;
     virtual void paintWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) = 0;
     virtual void postPaintWindow(EffectWindow* w) = 0;
     virtual void paintEffectFrame(EffectFrame* frame, const QRegion &region, double opacity, double frameOpacity) = 0;
     virtual void drawWindow(EffectWindow* w, int mask, const QRegion &region, WindowPaintData& data) = 0;
     virtual void buildQuads(EffectWindow* w, WindowQuadList& quadList) = 0;
     virtual QVariant kwinOption(KWinOption kwopt) = 0;
     /**
      * Sets the cursor while the mouse is intercepted.
      * @see startMouseInterception
      * @since 4.11
      */
     virtual void defineCursor(Qt::CursorShape shape) = 0;
     virtual QPoint cursorPos() const = 0;
     virtual bool grabKeyboard(Effect* effect) = 0;
     virtual void ungrabKeyboard() = 0;
     /**
      * Ensures that all mouse events are sent to the @p effect.
      * No window will get the mouse events. Only fullscreen effects providing a custom user interface should
      * be using this method. The input events are delivered to Effect::windowInputMouseEvent.
      *
      * @note This method does not perform an X11 mouse grab. On X11 a fullscreen input window is raised above
      * all other windows, but no grab is performed.
      *
      * @param effect The effect
      * @param shape Sets the cursor to be used while the mouse is intercepted
      * @see stopMouseInterception
      * @see Effect::windowInputMouseEvent
      * @since 4.11
      */
     virtual void startMouseInterception(Effect *effect, Qt::CursorShape shape) = 0;
     /**
      * Releases the hold mouse interception for @p effect
      * @see startMouseInterception
      * @since 4.11
      */
     virtual void stopMouseInterception(Effect *effect) = 0;
 
     /**
      * @brief Registers a global shortcut with the provided @p action.
      *
      * @param shortcut The global shortcut which should trigger the action
      * @param action The action which gets triggered when the shortcut matches
      */
     virtual void registerGlobalShortcut(const QKeySequence &shortcut, QAction *action) = 0;
     /**
      * @brief Registers a global pointer shortcut with the provided @p action.
      *
      * @param modifiers The keyboard modifiers which need to be holded
      * @param pointerButtons The pointer buttons which need to be pressed
      * @param action The action which gets triggered when the shortcut matches
      */
     virtual void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action) = 0;
     /**
      * @brief Registers a global axis shortcut with the provided @p action.
      *
      * @param modifiers The keyboard modifiers which need to be holded
      * @param axis The direction in which the axis needs to be moved
      * @param action The action which gets triggered when the shortcut matches
      */
     virtual void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action) = 0;
 
     /**
      * @brief Registers a global touchpad swipe gesture shortcut with the provided @p action.
      *
      * @param direction The direction for the swipe
      * @param action The action which gets triggered when the gesture triggers
      * @since 5.10
      */
     virtual void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action) = 0;
 
     /**
      * Retrieve the proxy class for an effect if it has one. Will return NULL if
      * the effect isn't loaded or doesn't have a proxy class.
      */
     virtual void* getProxy(QString name) = 0;
 
     // Mouse polling
     virtual void startMousePolling() = 0;
     virtual void stopMousePolling() = 0;
 
     virtual void reserveElectricBorder(ElectricBorder border, Effect *effect) = 0;
     virtual void unreserveElectricBorder(ElectricBorder border, Effect *effect) = 0;
 
     /**
      * Registers the given @p action for the given @p border to be activated through
      * a touch swipe gesture.
      *
      * If the @p border gets triggered through a touch swipe gesture the QAction::triggered
      * signal gets invoked.
      *
      * To unregister the touch screen action either delete the @p action or
      * invoke unregisterTouchBorder.
      *
      * @see unregisterTouchBorder
      * @since 5.10
      */
     virtual void registerTouchBorder(ElectricBorder border, QAction *action) = 0;
     /**
      * Unregisters the given @p action for the given touch @p border.
      *
      * @see registerTouchBorder
      * @since 5.10
      */
     virtual void unregisterTouchBorder(ElectricBorder border, QAction *action) = 0;
 
     // functions that allow controlling windows/desktop
     virtual void activateWindow(KWin::EffectWindow* c) = 0;
     virtual KWin::EffectWindow* activeWindow() const = 0 ;
     Q_SCRIPTABLE virtual void moveWindow(KWin::EffectWindow* w, const QPoint& pos, bool snap = false, double snapAdjust = 1.0) = 0;
 
     /**
      * Moves the window to the specific desktop
      * Setting desktop to NET::OnAllDesktops will set the window on all desktops
      */
     Q_SCRIPTABLE virtual void windowToDesktop(KWin::EffectWindow* w, int desktop) = 0;
 
     /**
      * Moves a window to the given desktops
      * On X11, the window will end up on the last window in the list
      * Setting this to an empty list will set the window on all desktops
      *
      * @arg desktopIds a list of desktops the window should be placed on. NET::OnAllDesktops is not a valid desktop X11Id
      */
     Q_SCRIPTABLE virtual void windowToDesktops(KWin::EffectWindow* w, const QVector<uint> &desktopIds) = 0;
 
     Q_SCRIPTABLE virtual void windowToScreen(KWin::EffectWindow* w, int screen) = 0;
     virtual void setShowingDesktop(bool showing) = 0;
 
     // Activities
     /**
      * @returns The ID of the current activity.
      */
     virtual QString currentActivity() const = 0;
     // Desktops
     /**
      * @returns The ID of the current desktop.
      */
     virtual int currentDesktop() const = 0;
     /**
      * @returns Total number of desktops currently in existence.
      */
     virtual int numberOfDesktops() const = 0;
     /**
      * Set the current desktop to @a desktop.
      */
     virtual void setCurrentDesktop(int desktop) = 0;
     /**
      * Sets the total number of desktops to @a desktops.
      */
     virtual void setNumberOfDesktops(int desktops) = 0;
     /**
      * @returns The size of desktop layout in grid units.
      */
     virtual QSize desktopGridSize() const = 0;
     /**
      * @returns The width of desktop layout in grid units.
      */
     virtual int desktopGridWidth() const = 0;
     /**
      * @returns The height of desktop layout in grid units.
      */
     virtual int desktopGridHeight() const = 0;
     /**
      * @returns The width of desktop layout in pixels.
      */
     virtual int workspaceWidth() const = 0;
     /**
      * @returns The height of desktop layout in pixels.
      */
     virtual int workspaceHeight() const = 0;
     /**
      * @returns The ID of the desktop at the point @a coords or 0 if no desktop exists at that
      * point. @a coords is to be in grid units.
      */
     virtual int desktopAtCoords(QPoint coords) const = 0;
     /**
      * @returns The coords of desktop @a id in grid units.
      */
     virtual QPoint desktopGridCoords(int id) const = 0;
     /**
      * @returns The coords of the top-left corner of desktop @a id in pixels.
      */
     virtual QPoint desktopCoords(int id) const = 0;
     /**
      * @returns The ID of the desktop above desktop @a id. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopAbove(int desktop = 0, bool wrap = true) const = 0;
     /**
      * @returns The ID of the desktop to the right of desktop @a id. Wraps around to the
      * left of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopToRight(int desktop = 0, bool wrap = true) const = 0;
     /**
      * @returns The ID of the desktop below desktop @a id. Wraps around to the top of the
      * layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopBelow(int desktop = 0, bool wrap = true) const = 0;
     /**
      * @returns The ID of the desktop to the left of desktop @a id. Wraps around to the
      * right of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     Q_SCRIPTABLE virtual int desktopToLeft(int desktop = 0, bool wrap = true) const = 0;
     Q_SCRIPTABLE virtual QString desktopName(int desktop) const = 0;
     virtual bool optionRollOverDesktops() const = 0;
 
     virtual int activeScreen() const = 0; // Xinerama
     virtual int numScreens() const = 0; // Xinerama
     Q_SCRIPTABLE virtual int screenNumber(const QPoint& pos) const = 0;   // Xinerama
     virtual QRect clientArea(clientAreaOption, int screen, int desktop) const = 0;
     virtual QRect clientArea(clientAreaOption, const EffectWindow* c) const = 0;
     virtual QRect clientArea(clientAreaOption, const QPoint& p, int desktop) const = 0;
 
     /**
      * The bounding size of all screens combined. Overlapping areas
      * are not counted multiple times.
      *
      * @see virtualScreenGeometry()
      * @see virtualScreenSizeChanged()
      * @since 5.0
      */
     virtual QSize virtualScreenSize() const = 0;
     /**
      * The bounding geometry of all outputs combined. Always starts at (0,0) and has
      * virtualScreenSize as it's size.
      *
      * @see virtualScreenSize()
      * @see virtualScreenGeometryChanged()
      * @since 5.0
      */
     virtual QRect virtualScreenGeometry() const = 0;
     /**
      * Factor by which animation speed in the effect should be modified (multiplied).
      * If configurable in the effect itself, the option should have also 'default'
      * animation speed. The actual value should be determined using animationTime().
      * Note: The factor can be also 0, so make sure your code can cope with 0ms time
      * if used manually.
      */
     virtual double animationTimeFactor() const = 0;
     virtual WindowQuadType newWindowQuadType() = 0;
 
     Q_SCRIPTABLE virtual KWin::EffectWindow* findWindow(WId id) const = 0;
-    Q_SCRIPTABLE virtual KWin::EffectWindow* findWindow(KWayland::Server::SurfaceInterface *surf) const = 0;
+    Q_SCRIPTABLE virtual KWin::EffectWindow* findWindow(KWaylandServer::SurfaceInterface *surf) const = 0;
     /**
      * Finds the EffectWindow for the internal window @p w.
      * If there is no such window @c null is returned.
      *
      * On Wayland this returns the internal window. On X11 it returns an Unamanged with the
      * window id matching that of the provided window @p w.
      *
      * @since 5.16
      */
     Q_SCRIPTABLE virtual KWin::EffectWindow *findWindow(QWindow *w) const = 0;
     /**
      * Finds the EffectWindow for the Toplevel with KWin internal @p id.
      * If there is no such window @c null is returned.
      *
      * @since 5.16
      */
     Q_SCRIPTABLE virtual KWin::EffectWindow *findWindow(const QUuid &id) const = 0;
     virtual EffectWindowList stackingOrder() const = 0;
     // window will be temporarily painted as if being at the top of the stack
     Q_SCRIPTABLE virtual void setElevatedWindow(KWin::EffectWindow* w, bool set) = 0;
 
     virtual void setTabBoxWindow(EffectWindow*) = 0;
     virtual void setTabBoxDesktop(int) = 0;
     virtual EffectWindowList currentTabBoxWindowList() const = 0;
     virtual void refTabBox() = 0;
     virtual void unrefTabBox() = 0;
     virtual void closeTabBox() = 0;
     virtual QList< int > currentTabBoxDesktopList() const = 0;
     virtual int currentTabBoxDesktop() const = 0;
     virtual EffectWindow* currentTabBoxWindow() const = 0;
 
     virtual void setActiveFullScreenEffect(Effect* e) = 0;
     virtual Effect* activeFullScreenEffect() const = 0;
 
     /**
      * Schedules the entire workspace to be repainted next time.
      * If you call it during painting (including prepaint) then it does not
      *  affect the current painting.
      */
     Q_SCRIPTABLE virtual void addRepaintFull() = 0;
     Q_SCRIPTABLE virtual void addRepaint(const QRect& r) = 0;
     Q_SCRIPTABLE virtual void addRepaint(const QRegion& r) = 0;
     Q_SCRIPTABLE virtual void addRepaint(int x, int y, int w, int h) = 0;
 
     CompositingType compositingType() const;
     /**
      * @brief Whether the Compositor is OpenGL based (either GL 1 or 2).
      *
      * @return bool @c true in case of OpenGL based Compositor, @c false otherwise
      */
     bool isOpenGLCompositing() const;
     virtual unsigned long xrenderBufferPicture() = 0;
     /**
      * @brief Provides access to the QPainter which is rendering to the back buffer.
      *
      * Only relevant for CompositingType QPainterCompositing. For all other compositing types
      * @c null is returned.
      *
      * @return QPainter* The Scene's QPainter or @c null.
      */
     virtual QPainter *scenePainter() = 0;
     virtual void reconfigure() = 0;
 
     virtual QByteArray readRootProperty(long atom, long type, int format) const = 0;
     /**
      * @brief Announces support for the feature with the given name. If no other Effect
      * has announced support for this feature yet, an X11 property will be installed on
      * the root window.
      *
      * The Effect will be notified for events through the signal propertyNotify().
      *
      * To remove the support again use removeSupportProperty. When an Effect is
      * destroyed it is automatically taken care of removing the support. It is not
      * required to call removeSupportProperty in the Effect's cleanup handling.
      *
      * @param propertyName The name of the property to announce support for
      * @param effect The effect which announces support
      * @return xcb_atom_t The created X11 atom
      * @see removeSupportProperty
      * @since 4.11
      */
     virtual xcb_atom_t announceSupportProperty(const QByteArray &propertyName, Effect *effect) = 0;
     /**
      * @brief Removes support for the feature with the given name. If there is no other Effect left
      * which has announced support for the given property, the property will be removed from the
      * root window.
      *
      * In case the Effect had not registered support, calling this function does not change anything.
      *
      * @param propertyName The name of the property to remove support for
      * @param effect The effect which had registered the property.
      * @see announceSupportProperty
      * @since 4.11
      */
     virtual void removeSupportProperty(const QByteArray &propertyName, Effect *effect) = 0;
 
     /**
      * Returns @a true if the active window decoration has shadow API hooks.
      */
     virtual bool hasDecorationShadows() const = 0;
 
     /**
      * Returns @a true if the window decorations use the alpha channel, and @a false otherwise.
      * @since 4.5
      */
     virtual bool decorationsHaveAlpha() const = 0;
 
     /**
      * Returns @a true if the window decorations support blurring behind the decoration, and @a false otherwise
      * @since 4.6
      */
     virtual bool decorationSupportsBlurBehind() const = 0;
 
     /**
      * Creates a new frame object. If the frame does not have a static size
      * then it will be located at @a position with @a alignment. A
      * non-static frame will automatically adjust its size to fit the contents.
      * @returns A new @ref EffectFrame. It is the responsibility of the caller to delete the
      * EffectFrame.
      * @since 4.6
      */
     virtual EffectFrame* effectFrame(EffectFrameStyle style, bool staticSize = true,
                                      const QPoint& position = QPoint(-1, -1), Qt::Alignment alignment = Qt::AlignCenter) const = 0;
 
     /**
      * Allows an effect to trigger a reload of itself.
      * This can be used by an effect which needs to be reloaded when screen geometry changes.
      * It is possible that the effect cannot be loaded again as it's supported method does no longer
      * hold.
      * @param effect The effect to reload
      * @since 4.8
      */
     virtual void reloadEffect(Effect *effect) = 0;
 
     /**
      * Whether the screen is currently considered as locked.
      * Note for technical reasons this is not always possible to detect. The screen will only
      * be considered as locked if the screen locking process implements the
      * org.freedesktop.ScreenSaver interface.
      *
      * @returns @c true if the screen is currently locked, @c false otherwise
      * @see screenLockingChanged
      * @since 4.11
      */
     virtual bool isScreenLocked() const = 0;
 
     /**
      * @brief Makes the OpenGL compositing context current.
      *
      * If the compositing backend is not using OpenGL, this method returns @c false.
      *
      * @return bool @c true if the context became current, @c false otherwise.
      */
     virtual bool makeOpenGLContextCurrent() = 0;
     /**
      * @brief Makes a null OpenGL context current resulting in no context
      * being current.
      *
      * If the compositing backend is not OpenGL based, this method is a noop.
      *
      * There is normally no reason for an Effect to call this method.
      */
     virtual void doneOpenGLContextCurrent() = 0;
 
     virtual xcb_connection_t *xcbConnection() const = 0;
     virtual xcb_window_t x11RootWindow() const = 0;
 
     /**
      * Interface to the Wayland display: this is relevant only
      * on Wayland, on X11 it will be nullptr
      * @since 5.5
      */
-    virtual KWayland::Server::Display *waylandDisplay() const = 0;
+    virtual KWaylandServer::Display *waylandDisplay() const = 0;
 
     /**
      * Whether animations are supported by the Scene.
      * If this method returns @c false Effects are supposed to not
      * animate transitions.
      *
      * @returns Whether the Scene can drive animations
      * @since 5.8
      */
     virtual bool animationsSupported() const = 0;
 
     /**
      * The current cursor image of the Platform.
      * @see cursorPos
      * @since 5.9
      */
     virtual PlatformCursorImage cursorImage() const = 0;
 
     /**
      * The cursor image should be hidden.
      * @see showCursor
      * @since 5.9
      */
     virtual void hideCursor() = 0;
 
     /**
      * The cursor image should be shown again after having been hidden.
      * @see hideCursor
      * @since 5.9
      */
     virtual void showCursor() = 0;
 
     /**
      * Starts an interactive window selection process.
      *
      * Once the user selected a window the @p callback is invoked with the selected EffectWindow as
      * argument. In case the user cancels the interactive window selection or selecting a window is currently
      * not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor.
      *
      * @param callback The function to invoke once the interactive window selection ends
      * @since 5.9
      */
     virtual void startInteractiveWindowSelection(std::function<void(KWin::EffectWindow*)> callback) = 0;
 
     /**
      * Starts an interactive position selection process.
      *
      * Once the user selected a position on the screen the @p callback is invoked with
      * the selected point as argument. In case the user cancels the interactive position selection
      * or selecting a position is currently not possible (e.g. screen locked) the @p callback
      * is invoked with a point at @c -1 as x and y argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor.
      *
      * @param callback The function to invoke once the interactive position selection ends
      * @since 5.9
      */
     virtual void startInteractivePositionSelection(std::function<void(const QPoint &)> callback) = 0;
 
     /**
      * Shows an on-screen-message. To hide it again use hideOnScreenMessage.
      *
      * @param message The message to show
      * @param iconName The optional themed icon name
      * @see hideOnScreenMessage
      * @since 5.9
      */
     virtual void showOnScreenMessage(const QString &message, const QString &iconName = QString()) = 0;
 
     /**
      * Flags for how to hide a shown on-screen-message
      * @see hideOnScreenMessage
      * @since 5.9
      */
     enum class OnScreenMessageHideFlag {
         /**
          * The on-screen-message should skip the close window animation.
          * @see EffectWindow::skipsCloseAnimation
          */
         SkipsCloseAnimation = 1
     };
     Q_DECLARE_FLAGS(OnScreenMessageHideFlags, OnScreenMessageHideFlag)
     /**
      * Hides a previously shown on-screen-message again.
      * @param flags The flags for how to hide the message
      * @see showOnScreenMessage
      * @since 5.9
      */
     virtual void hideOnScreenMessage(OnScreenMessageHideFlags flags = OnScreenMessageHideFlags()) = 0;
 
     /*
      * @returns The configuration used by the EffectsHandler.
      * @since 5.10
      */
     virtual KSharedConfigPtr config() const = 0;
 
     /**
      * @returns The global input configuration (kcminputrc)
      * @since 5.10
      */
     virtual KSharedConfigPtr inputConfig() const = 0;
 
     /**
      * Returns if activeFullScreenEffect is set
      */
     virtual bool hasActiveFullScreenEffect() const = 0;
 
     /**
      * Render the supplied EffectQuickView onto the scene
      * It can be called at any point during the scene rendering
      * @since 5.18
      */
     virtual void renderEffectQuickView(EffectQuickView *effectQuickView) const = 0;
 
     /**
      * The status of the session i.e if the user is logging out
      * @since 5.18
      */
     virtual SessionState sessionState() const = 0;
 Q_SIGNALS:
     /**
      * Signal emitted when the current desktop changed.
      * @param oldDesktop The previously current desktop
      * @param newDesktop The new current desktop
      * @param with The window which is taken over to the new desktop, can be NULL
      * @since 4.9
      */
     void desktopChanged(int oldDesktop, int newDesktop, KWin::EffectWindow *with);
     /**
      * @since 4.7
      * @deprecated
      */
     void desktopChanged(int oldDesktop, int newDesktop);
     /**
      * Signal emitted when a window moved to another desktop
      * NOTICE that this does NOT imply that the desktop has changed
      * The @param window which is moved to the new desktop
      * @param oldDesktop The previous desktop of the window
      * @param newDesktop The new desktop of the window
      * @since 4.11.4
      */
     void desktopPresenceChanged(KWin::EffectWindow *window, int oldDesktop, int newDesktop);
     /**
     * Signal emitted when the number of currently existing desktops is changed.
     * @param old The previous number of desktops in used.
     * @see EffectsHandler::numberOfDesktops.
     * @since 4.7
     */
     void numberDesktopsChanged(uint old);
     /**
      * Signal emitted when the number of screens changed.
      * @since 5.0
      */
     void numberScreensChanged();
     /**
      * Signal emitted when the desktop showing ("dashboard") state changed
      * The desktop is risen to the keepAbove layer, you may want to elevate
      * windows or such.
      * @since 5.3
      */
     void showingDesktopChanged(bool);
     /**
      * Signal emitted when a new window has been added to the Workspace.
      * @param w The added window
      * @since 4.7
      */
     void windowAdded(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window is being removed from the Workspace.
      * An effect which wants to animate the window closing should connect
      * to this signal and reference the window by using
      * refWindow
      * @param w The window which is being closed
      * @since 4.7
      */
     void windowClosed(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window get's activated.
      * @param w The new active window, or @c NULL if there is no active window.
      * @since 4.7
      */
     void windowActivated(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window is deleted.
      * This means that a closed window is not referenced any more.
      * An effect bookkeeping the closed windows should connect to this
      * signal to clean up the internal references.
      * @param w The window which is going to be deleted.
      * @see EffectWindow::refWindow
      * @see EffectWindow::unrefWindow
      * @see windowClosed
      * @since 4.7
      */
     void windowDeleted(KWin::EffectWindow *w);
     /**
      * Signal emitted when a user begins a window move or resize operation.
      * To figure out whether the user resizes or moves the window use
      * isUserMove or isUserResize.
      * Whenever the geometry is updated the signal @ref windowStepUserMovedResized
      * is emitted with the current geometry.
      * The move/resize operation ends with the signal @ref windowFinishUserMovedResized.
      * Only one window can be moved/resized by the user at the same time!
      * @param w The window which is being moved/resized
      * @see windowStepUserMovedResized
      * @see windowFinishUserMovedResized
      * @see EffectWindow::isUserMove
      * @see EffectWindow::isUserResize
      * @since 4.7
      */
     void windowStartUserMovedResized(KWin::EffectWindow *w);
     /**
      * Signal emitted during a move/resize operation when the user changed the geometry.
      * Please note: KWin supports two operation modes. In one mode all changes are applied
      * instantly. This means the window's geometry matches the passed in @p geometry. In the
      * other mode the geometry is changed after the user ended the move/resize mode.
      * The @p geometry differs from the window's geometry. Also the window's pixmap still has
      * the same size as before. Depending what the effect wants to do it would be recommended
      * to scale/translate the window.
      * @param w The window which is being moved/resized
      * @param geometry The geometry of the window in the current move/resize step.
      * @see windowStartUserMovedResized
      * @see windowFinishUserMovedResized
      * @see EffectWindow::isUserMove
      * @see EffectWindow::isUserResize
      * @since 4.7
      */
     void windowStepUserMovedResized(KWin::EffectWindow *w, const QRect &geometry);
     /**
      * Signal emitted when the user finishes move/resize of window @p w.
      * @param w The window which has been moved/resized
      * @see windowStartUserMovedResized
      * @see windowFinishUserMovedResized
      * @since 4.7
      */
     void windowFinishUserMovedResized(KWin::EffectWindow *w);
     /**
      * Signal emitted when the maximized state of the window @p w changed.
      * A window can be in one of four states:
      * @li restored: both @p horizontal and @p vertical are @c false
      * @li horizontally maximized: @p horizontal is @c true and @p vertical is @c false
      * @li vertically maximized: @p horizontal is @c false and @p vertical is @c true
      * @li completely maximized: both @p horizontal and @p vertical are @c true
      * @param w The window whose maximized state changed
      * @param horizontal If @c true maximized horizontally
      * @param vertical If @c true maximized vertically
      * @since 4.7
      */
     void windowMaximizedStateChanged(KWin::EffectWindow *w, bool horizontal, bool vertical);
     /**
      * Signal emitted when the geometry or shape of a window changed.
      * This is caused if the window changes geometry without user interaction.
      * E.g. the decoration is changed. This is in opposite to windowUserMovedResized
      * which is caused by direct user interaction.
      * @param w The window whose geometry changed
      * @param old The previous geometry
      * @see windowUserMovedResized
      * @since 4.7
      */
     void windowGeometryShapeChanged(KWin::EffectWindow *w, const QRect &old);
     /**
      * This signal is emitted when the frame geometry of a window changed.
      * @param window The window whose geometry changed
      * @param oldGeometry The previous geometry
      * @since 5.19
      */
     void windowFrameGeometryChanged(KWin::EffectWindow *window, const QRect &oldGeometry);
     /**
      * Signal emitted when the padding of a window changed. (eg. shadow size)
      * @param w The window whose geometry changed
      * @param old The previous expandedGeometry()
      * @since 4.9
      */
     void windowPaddingChanged(KWin::EffectWindow *w, const QRect &old);
     /**
      * Signal emitted when the windows opacity is changed.
      * @param w The window whose opacity level is changed.
      * @param oldOpacity The previous opacity level
      * @param newOpacity The new opacity level
      * @since 4.7
      */
     void windowOpacityChanged(KWin::EffectWindow *w, qreal oldOpacity, qreal newOpacity);
     /**
      * Signal emitted when a window got minimized.
      * @param w The window which was minimized
      * @since 4.7
      */
     void windowMinimized(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window got unminimized.
      * @param w The window which was unminimized
      * @since 4.7
      */
     void windowUnminimized(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window either becomes modal (ie. blocking for its main client) or looses that state.
      * @param w The window which was unminimized
      * @since 4.11
      */
     void windowModalityChanged(KWin::EffectWindow *w);
     /**
      * Signal emitted when a window either became unresponsive (eg. app froze or crashed)
      * or respoonsive
      * @param w The window that became (un)responsive
      * @param unresponsive Whether the window is responsive or unresponsive
      * @since 5.10
      */
     void windowUnresponsiveChanged(KWin::EffectWindow *w, bool unresponsive);
     /**
      * Signal emitted when an area of a window is scheduled for repainting.
      * Use this signal in an effect if another area needs to be synced as well.
      * @param w The window which is scheduled for repainting
      * @param r Always empty.
      * @since 4.7
      */
     void windowDamaged(KWin::EffectWindow *w, const QRect &r);
     /**
      * Signal emitted when a tabbox is added.
      * An effect who wants to replace the tabbox with itself should use refTabBox.
      * @param mode The TabBoxMode.
      * @see refTabBox
      * @see tabBoxClosed
      * @see tabBoxUpdated
      * @see tabBoxKeyEvent
      * @since 4.7
      */
     void tabBoxAdded(int mode);
     /**
      * Signal emitted when the TabBox was closed by KWin core.
      * An effect which referenced the TabBox should use unrefTabBox to unref again.
      * @see unrefTabBox
      * @see tabBoxAdded
      * @since 4.7
      */
     void tabBoxClosed();
     /**
      * Signal emitted when the selected TabBox window changed or the TabBox List changed.
      * An effect should only response to this signal if it referenced the TabBox with refTabBox.
      * @see refTabBox
      * @see currentTabBoxWindowList
      * @see currentTabBoxDesktopList
      * @see currentTabBoxWindow
      * @see currentTabBoxDesktop
      * @since 4.7
      */
     void tabBoxUpdated();
     /**
      * Signal emitted when a key event, which is not handled by TabBox directly is, happens while
      * TabBox is active. An effect might use the key event to e.g. change the selected window.
      * An effect should only response to this signal if it referenced the TabBox with refTabBox.
      * @param event The key event not handled by TabBox directly
      * @see refTabBox
      * @since 4.7
      */
     void tabBoxKeyEvent(QKeyEvent* event);
     void currentTabAboutToChange(KWin::EffectWindow* from, KWin::EffectWindow* to);
     void tabAdded(KWin::EffectWindow* from, KWin::EffectWindow* to);   // from merged with to
     void tabRemoved(KWin::EffectWindow* c, KWin::EffectWindow* group);   // c removed from group
     /**
      * Signal emitted when mouse changed.
      * If an effect needs to get updated mouse positions, it needs to first call startMousePolling.
      * For a fullscreen effect it is better to use an input window and react on windowInputMouseEvent.
      * @param pos The new mouse position
      * @param oldpos The previously mouse position
      * @param buttons The pressed mouse buttons
      * @param oldbuttons The previously pressed mouse buttons
      * @param modifiers Pressed keyboard modifiers
      * @param oldmodifiers Previously pressed keyboard modifiers.
      * @see startMousePolling
      * @since 4.7
      */
     void mouseChanged(const QPoint& pos, const QPoint& oldpos,
                               Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
                               Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers);
     /**
      * Signal emitted when the cursor shape changed.
      * You'll likely want to query the current cursor as reaction: xcb_xfixes_get_cursor_image_unchecked
      * Connection to this signal is tracked, so if you don't need it anymore, disconnect from it to stop cursor event filtering
      */
     void cursorShapeChanged();
     /**
      * Receives events registered for using registerPropertyType.
      * Use readProperty() to get the property data.
      * Note that the property may be already set on the window, so doing the same
      * processing from windowAdded() (e.g. simply calling propertyNotify() from it)
      * is usually needed.
      * @param w The window whose property changed, is @c null if it is a root window property
      * @param atom The property
      * @since 4.7
      */
     void propertyNotify(KWin::EffectWindow* w, long atom);
 
     /**
      * Signal emitted after the screen geometry changed (e.g. add of a monitor).
      * Effects using displayWidth()/displayHeight() to cache information should
      * react on this signal and update the caches.
      * @param size The new screen size
      * @since 4.8
      */
     void screenGeometryChanged(const QSize &size);
 
     /**
      * This signal is emitted when the global
      * activity is changed
      * @param id id of the new current activity
      * @since 4.9
      */
     void currentActivityChanged(const QString &id);
     /**
      * This signal is emitted when a new activity is added
      * @param id id of the new activity
      * @since 4.9
      */
     void activityAdded(const QString &id);
     /**
      * This signal is emitted when the activity
      * is removed
      * @param id id of the removed activity
      * @since 4.9
      */
     void activityRemoved(const QString &id);
     /**
      * This signal is emitted when the screen got locked or unlocked.
      * @param locked @c true if the screen is now locked, @c false if it is now unlocked
      * @since 4.11
      */
     void screenLockingChanged(bool locked);
 
     /**
      * This signal is emitted just before the screen locker tries to grab keys and lock the screen
      * Effects should release any grabs immediately
      * @since 5.17
      */
     void screenAboutToLock();
 
     /**
      * This signels is emitted when ever the stacking order is change, ie. a window is risen
      * or lowered
      * @since 4.10
      */
     void stackingOrderChanged();
     /**
      * This signal is emitted when the user starts to approach the @p border with the mouse.
      * The @p factor describes how far away the mouse is in a relative mean. The values are in
      * [0.0, 1.0] with 0.0 being emitted when first entered and on leaving. The value 1.0 means that
      * the @p border is reached with the mouse. So the values are well suited for animations.
      * The signal is always emitted when the mouse cursor position changes.
      * @param border The screen edge which is being approached
      * @param factor Value in range [0.0,1.0] to describe how close the mouse is to the border
      * @param geometry The geometry of the edge which is being approached
      * @since 4.11
      */
     void screenEdgeApproaching(ElectricBorder border, qreal factor, const QRect &geometry);
     /**
      * Emitted whenever the virtualScreenSize changes.
      * @see virtualScreenSize()
      * @since 5.0
      */
     void virtualScreenSizeChanged();
     /**
      * Emitted whenever the virtualScreenGeometry changes.
      * @see virtualScreenGeometry()
      * @since 5.0
      */
     void virtualScreenGeometryChanged();
 
     /**
      * The window @p w gets shown again. The window was previously
      * initially shown with windowAdded and hidden with windowHidden.
      *
      * @see windowHidden
      * @see windowAdded
      * @since 5.8
      */
     void windowShown(KWin::EffectWindow *w);
 
     /**
      * The window @p w got hidden but not yet closed.
      * This can happen when a window is still being used and is supposed to be shown again
      * with windowShown. On X11 an example is autohiding panels. On Wayland every
      * window first goes through the window hidden state and might get shown again, or might
      * get closed the normal way.
      *
      * @see windowShown
      * @see windowClosed
      * @since 5.8
      */
     void windowHidden(KWin::EffectWindow *w);
 
     /**
      * This signal gets emitted when the data on EffectWindow @p w for @p role changed.
      *
      * An Effect can connect to this signal to read the new value and react on it.
      * E.g. an Effect which does not operate on windows grabbed by another Effect wants
      * to cancel the already scheduled animation if another Effect adds a grab.
      *
      * @param w The EffectWindow for which the data changed
      * @param role The data role which changed
      * @see EffectWindow::setData
      * @see EffectWindow::data
      * @since 5.8.4
      */
     void windowDataChanged(KWin::EffectWindow *w, int role);
 
     /**
      * The xcb connection changed, either a new xcbConnection got created or the existing one
      * got destroyed.
      * Effects can use this to refetch the properties they want to set.
      *
      * When the xcbConnection changes also the x11RootWindow becomes invalid.
      * @see xcbConnection
      * @see x11RootWindow
      * @since 5.11
      */
     void xcbConnectionChanged();
 
     /**
      * This signal is emitted when active fullscreen effect changed.
      *
      * @see activeFullScreenEffect
      * @see setActiveFullScreenEffect
      * @since 5.14
      */
     void activeFullScreenEffectChanged();
 
     /**
      * This signal is emitted when active fullscreen effect changed to being
      * set or unset
      *
      * @see activeFullScreenEffect
      * @see setActiveFullScreenEffect
      * @since 5.15
      */
     void hasActiveFullScreenEffectChanged();
 
     /**
      * This signal is emitted when the keep above state of @p w was changed.
      *
      * @param w The window whose the keep above state was changed.
      * @since 5.15
      */
     void windowKeepAboveChanged(KWin::EffectWindow *w);
 
     /**
      * This signal is emitted when the keep below state of @p was changed.
      *
      * @param w The window whose the keep below state was changed.
      * @since 5.15
      */
     void windowKeepBelowChanged(KWin::EffectWindow *w);
 
     /**
      * This signal is emitted when the full screen state of @p w was changed.
      *
      * @param w The window whose the full screen state was changed.
      * @since 5.15
      */
     void windowFullScreenChanged(KWin::EffectWindow *w);
 
     /**
      * This signal is emitted when the session state was changed
      * @since 5.18
      */
     void sessionStateChanged();
 
 protected:
     QVector< EffectPair > loaded_effects;
     //QHash< QString, EffectFactory* > effect_factories;
     CompositingType compositing_type;
 };
 
 
 /**
  * @short Representation of a window used by/for Effect classes.
  *
  * The purpose is to hide internal data and also to serve as a single
  *  representation for the case when Client/Unmanaged becomes Deleted.
  */
 class KWINEFFECTS_EXPORT EffectWindow : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool alpha READ hasAlpha CONSTANT)
     Q_PROPERTY(QRect geometry READ geometry)
     Q_PROPERTY(QRect expandedGeometry READ expandedGeometry)
     Q_PROPERTY(int height READ height)
     Q_PROPERTY(qreal opacity READ opacity)
     Q_PROPERTY(QPoint pos READ pos)
     Q_PROPERTY(int screen READ screen)
     Q_PROPERTY(QSize size READ size)
     Q_PROPERTY(int width READ width)
     Q_PROPERTY(int x READ x)
     Q_PROPERTY(int y READ y)
     Q_PROPERTY(int desktop READ desktop)
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops)
     Q_PROPERTY(bool onCurrentDesktop READ isOnCurrentDesktop)
     Q_PROPERTY(QRect rect READ rect)
     Q_PROPERTY(QString windowClass READ windowClass)
     Q_PROPERTY(QString windowRole READ windowRole)
     /**
      * Returns whether the window is a desktop background window (the one with wallpaper).
      * See _NET_WM_WINDOW_TYPE_DESKTOP at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool desktopWindow READ isDesktop)
     /**
      * Returns whether the window is a dock (i.e. a panel).
      * See _NET_WM_WINDOW_TYPE_DOCK at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dock READ isDock)
     /**
      * Returns whether the window is a standalone (detached) toolbar window.
      * See _NET_WM_WINDOW_TYPE_TOOLBAR at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool toolbar READ isToolbar)
     /**
      * Returns whether the window is a torn-off menu.
      * See _NET_WM_WINDOW_TYPE_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool menu READ isMenu)
     /**
      * Returns whether the window is a "normal" window, i.e. an application or any other window
      * for which none of the specialized window types fit.
      * See _NET_WM_WINDOW_TYPE_NORMAL at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool normalWindow READ isNormalWindow)
     /**
      * Returns whether the window is a dialog window.
      * See _NET_WM_WINDOW_TYPE_DIALOG at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dialog READ isDialog)
     /**
      * Returns whether the window is a splashscreen. Note that many (especially older) applications
      * do not support marking their splash windows with this type.
      * See _NET_WM_WINDOW_TYPE_SPLASH at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool splash READ isSplash)
     /**
      * Returns whether the window is a utility window, such as a tool window.
      * See _NET_WM_WINDOW_TYPE_UTILITY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool utility READ isUtility)
     /**
      * Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
      * from the applications menubar).
      * See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dropdownMenu READ isDropdownMenu)
     /**
      * Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
      * See _NET_WM_WINDOW_TYPE_POPUP_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool popupMenu READ isPopupMenu)
     /**
      * Returns whether the window is a tooltip.
      * See _NET_WM_WINDOW_TYPE_TOOLTIP at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool tooltip READ isTooltip)
     /**
      * Returns whether the window is a window with a notification.
      * See _NET_WM_WINDOW_TYPE_NOTIFICATION at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool notification READ isNotification)
     /**
      * Returns whether the window is a window with a critical notification.
      * using the non-standard _KDE_NET_WM_WINDOW_TYPE_CRITICAL_NOTIFICATION
      */
     Q_PROPERTY(bool criticalNotification READ isCriticalNotification)
     /**
      * Returns whether the window is an on screen display window
      * using the non-standard _KDE_NET_WM_WINDOW_TYPE_ON_SCREEN_DISPLAY
      */
     Q_PROPERTY(bool onScreenDisplay READ isOnScreenDisplay)
     /**
      * Returns whether the window is a combobox popup.
      * See _NET_WM_WINDOW_TYPE_COMBO at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool comboBox READ isComboBox)
     /**
      * Returns whether the window is a Drag&Drop icon.
      * See _NET_WM_WINDOW_TYPE_DND at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dndIcon READ isDNDIcon)
     /**
      * Returns the NETWM window type
      * See https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(int windowType READ windowType)
     /**
      * Whether this EffectWindow is managed by KWin (it has control over its placement and other
      * aspects, as opposed to override-redirect windows that are entirely handled by the application).
      */
     Q_PROPERTY(bool managed READ isManaged)
     /**
      * Whether this EffectWindow represents an already deleted window and only kept for the compositor for animations.
      */
     Q_PROPERTY(bool deleted READ isDeleted)
     /**
      * Whether the window has an own shape
      */
     Q_PROPERTY(bool shaped READ hasOwnShape)
     /**
      * The Window's shape
      */
     Q_PROPERTY(QRegion shape READ shape)
     /**
      * The Caption of the window. Read from WM_NAME property together with a suffix for hostname and shortcut.
      */
     Q_PROPERTY(QString caption READ caption)
     /**
      * Whether the window is set to be kept above other windows.
      */
     Q_PROPERTY(bool keepAbove READ keepAbove)
     /**
      * Whether the window is set to be kept below other windows.
      */
     Q_PROPERTY(bool keepBelow READ keepBelow)
     /**
      * Whether the window is minimized.
      */
     Q_PROPERTY(bool minimized READ isMinimized WRITE setMinimized)
     /**
      * Whether the window represents a modal window.
      */
     Q_PROPERTY(bool modal READ isModal)
     /**
      * Whether the window is moveable. Even if it is not moveable, it might be possible to move
      * it to another screen.
      * @see moveableAcrossScreens
      */
     Q_PROPERTY(bool moveable READ isMovable)
     /**
      * Whether the window can be moved to another screen.
      * @see moveable
      */
     Q_PROPERTY(bool moveableAcrossScreens READ isMovableAcrossScreens)
     /**
      * By how much the window wishes to grow/shrink at least. Usually QSize(1,1).
      * MAY BE DISOBEYED BY THE WM! It's only for information, do NOT rely on it at all.
      */
     Q_PROPERTY(QSize basicUnit READ basicUnit)
     /**
      * Whether the window is currently being moved by the user.
      */
     Q_PROPERTY(bool move READ isUserMove)
     /**
      * Whether the window is currently being resized by the user.
      */
     Q_PROPERTY(bool resize READ isUserResize)
     /**
      * The optional geometry representing the minimized Client in e.g a taskbar.
      * See _NET_WM_ICON_GEOMETRY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(QRect iconGeometry READ iconGeometry)
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      */
     Q_PROPERTY(bool specialWindow READ isSpecialWindow)
     Q_PROPERTY(QIcon icon READ icon)
     /**
      * Whether the window should be excluded from window switching effects.
      */
     Q_PROPERTY(bool skipSwitcher READ isSkipSwitcher)
     /**
      * Geometry of the actual window contents inside the whole (including decorations) window.
      */
     Q_PROPERTY(QRect contentsRect READ contentsRect)
     /**
      * Geometry of the transparent rect in the decoration.
      * May be different from contentsRect if the decoration is extended into the client area.
      */
     Q_PROPERTY(QRect decorationInnerRect READ decorationInnerRect)
     Q_PROPERTY(bool hasDecoration READ hasDecoration)
     Q_PROPERTY(QStringList activities READ activities)
     Q_PROPERTY(bool onCurrentActivity READ isOnCurrentActivity)
     Q_PROPERTY(bool onAllActivities READ isOnAllActivities)
     /**
      * Whether the decoration currently uses an alpha channel.
      * @since 4.10
      */
     Q_PROPERTY(bool decorationHasAlpha READ decorationHasAlpha)
     /**
      * Whether the window is currently visible to the user, that is:
      * <ul>
      * <li>Not minimized</li>
      * <li>On current desktop</li>
      * <li>On current activity</li>
      * </ul>
      * @since 4.11
      */
     Q_PROPERTY(bool visible READ isVisible)
     /**
      * Whether the window does not want to be animated on window close.
      * In case this property is @c true it is not useful to start an animation on window close.
      * The window will not be visible, but the animation hooks are executed.
      * @since 5.0
      */
     Q_PROPERTY(bool skipsCloseAnimation READ skipsCloseAnimation)
 
     /**
      * Interface to the corresponding wayland surface.
      * relevant only in Wayland, on X11 it will be nullptr
      */
-    Q_PROPERTY(KWayland::Server::SurfaceInterface *surface READ surface)
+    Q_PROPERTY(KWaylandServer::SurfaceInterface *surface READ surface)
 
     /**
      * Whether the window is fullscreen.
      * @since 5.6
      */
     Q_PROPERTY(bool fullScreen READ isFullScreen)
 
     /**
      * Whether this client is unresponsive.
      *
      * When an application failed to react on a ping request in time, it is
      * considered unresponsive. This usually indicates that the application froze or crashed.
      *
      * @since 5.10
      */
     Q_PROPERTY(bool unresponsive READ isUnresponsive)
 
     /**
      * Whether this is a Wayland client.
      * @since 5.15
      */
     Q_PROPERTY(bool waylandClient READ isWaylandClient CONSTANT)
 
     /**
      * Whether this is an X11 client.
      * @since 5.15
      */
     Q_PROPERTY(bool x11Client READ isX11Client CONSTANT)
 
     /**
      * Whether the window is a popup.
      *
      * A popup is a window that can be used to implement tooltips, combo box popups,
      * popup menus and other similar user interface concepts.
      *
      * @since 5.15
      */
     Q_PROPERTY(bool popupWindow READ isPopupWindow CONSTANT)
 
     /**
      * KWin internal window. Specific to Wayland platform.
      *
      * If the EffectWindow does not reference an internal window, this property is @c null.
      * @since 5.16
      */
     Q_PROPERTY(QWindow *internalWindow READ internalWindow CONSTANT)
 
     /**
      * Whether this EffectWindow represents the outline.
      *
      * When compositing is turned on, the outline is an actual window.
      *
      * @since 5.16
      */
     Q_PROPERTY(bool outline READ isOutline CONSTANT)
 
     /**
      * The PID of the application this window belongs to.
      *
      * @since 5.18
      */
     Q_PROPERTY(bool outline READ isOutline CONSTANT)
 
 public:
     /**  Flags explaining why painting should be disabled  */
     enum {
         /**  Window will not be painted  */
         PAINT_DISABLED                 = 1 << 0,
         /**  Window will not be painted because it is deleted  */
         PAINT_DISABLED_BY_DELETE       = 1 << 1,
         /**  Window will not be painted because of which desktop it's on  */
         PAINT_DISABLED_BY_DESKTOP      = 1 << 2,
         /**  Window will not be painted because it is minimized  */
         PAINT_DISABLED_BY_MINIMIZE     = 1 << 3,
         /**  Deprecated, tab groups have been removed: Window will not be painted because it is not the active window in a client group */
         PAINT_DISABLED_BY_TAB_GROUP = 1 << 4,
         /**  Window will not be painted because it's not on the current activity  */
         PAINT_DISABLED_BY_ACTIVITY     = 1 << 5
     };
 
     explicit EffectWindow(QObject *parent = nullptr);
     ~EffectWindow() override;
 
     virtual void enablePainting(int reason) = 0;
     virtual void disablePainting(int reason) = 0;
     virtual bool isPaintingEnabled() = 0;
     Q_SCRIPTABLE virtual void addRepaint(const QRect &r) = 0;
     Q_SCRIPTABLE virtual void addRepaint(int x, int y, int w, int h) = 0;
     Q_SCRIPTABLE virtual void addRepaintFull() = 0;
     Q_SCRIPTABLE virtual void addLayerRepaint(const QRect &r) = 0;
     Q_SCRIPTABLE virtual void addLayerRepaint(int x, int y, int w, int h) = 0;
 
     virtual void refWindow() = 0;
     virtual void unrefWindow() = 0;
 
     virtual bool isDeleted() const = 0;
 
     virtual bool isMinimized() const = 0;
     virtual double opacity() const = 0;
     virtual bool hasAlpha() const = 0;
 
     bool isOnCurrentActivity() const;
     Q_SCRIPTABLE bool isOnActivity(const QString &id) const;
     bool isOnAllActivities() const;
     virtual QStringList activities() const = 0;
 
     Q_SCRIPTABLE bool isOnDesktop(int d) const;
     bool isOnCurrentDesktop() const;
     bool isOnAllDesktops() const;
     /**
      * The desktop this window is in. This makes sense only on X11
      * where desktops are mutually exclusive, on Wayland it's the last
      * desktop the window has been added to.
      * use desktops() instead.
      * @see desktops()
      * @deprecated
      */
 #ifndef KWIN_NO_DEPRECATED
     virtual int KWIN_DEPRECATED desktop() const = 0; // prefer isOnXXX()
 #endif
     /**
      * All the desktops by number that the window is in. On X11 this list will always have
      * a length of 1, on Wayland can be any subset.
      * If the list is empty it means the window is on all desktops
      */
     virtual QVector<uint> desktops() const = 0;
 
     virtual int x() const = 0;
     virtual int y() const = 0;
     virtual int width() const = 0;
     virtual int height() const = 0;
     /**
      * By how much the window wishes to grow/shrink at least. Usually QSize(1,1).
      * MAY BE DISOBEYED BY THE WM! It's only for information, do NOT rely on it at all.
      */
     virtual QSize basicUnit() const = 0;
     /**
      * @deprecated Use frameGeometry() instead.
      */
     virtual QRect geometry() const = 0;
     /**
      * Returns the geometry of the window excluding server-side and client-side
      * drop-shadows.
      *
      * @since 5.18
      */
     virtual QRect frameGeometry() const = 0;
     /**
      * Returns the geometry of the pixmap or buffer attached to this window.
      *
      * For X11 clients, this method returns server-side geometry of the Toplevel.
      *
      * For Wayland clients, this method returns rectangle that the main surface
      * occupies on the screen, in global screen coordinates.
      *
      * @since 5.18
      */
     virtual QRect bufferGeometry() const = 0;
     /**
      * Geometry of the window including decoration and potentially shadows.
      * May be different from geometry() if the window has a shadow.
      * @since 4.9
      */
     virtual QRect expandedGeometry() const = 0;
     virtual QRegion shape() const = 0;
     virtual int screen() const = 0;
     /** @internal Do not use */
     virtual bool hasOwnShape() const = 0; // only for shadow effect, for now
     virtual QPoint pos() const = 0;
     virtual QSize size() const = 0;
     virtual QRect rect() const = 0;
     virtual bool isMovable() const = 0;
     virtual bool isMovableAcrossScreens() const = 0;
     virtual bool isUserMove() const = 0;
     virtual bool isUserResize() const = 0;
     virtual QRect iconGeometry() const = 0;
 
     /**
      * Geometry of the actual window contents inside the whole (including decorations) window.
      */
     virtual QRect contentsRect() const = 0;
     /**
      * Geometry of the transparent rect in the decoration.
      * May be different from contentsRect() if the decoration is extended into the client area.
      * @since 4.5
      */
     virtual QRect decorationInnerRect() const = 0;
     bool hasDecoration() const;
     virtual bool decorationHasAlpha() const = 0;
     virtual QByteArray readProperty(long atom, long type, int format) const = 0;
     virtual void deleteProperty(long atom) const = 0;
 
     virtual QString caption() const = 0;
     virtual QIcon icon() const = 0;
     virtual QString windowClass() const = 0;
     virtual QString windowRole() const = 0;
     virtual const EffectWindowGroup* group() const = 0;
 
     /**
      * Returns whether the window is a desktop background window (the one with wallpaper).
      * See _NET_WM_WINDOW_TYPE_DESKTOP at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isDesktop() const = 0;
     /**
      * Returns whether the window is a dock (i.e. a panel).
      * See _NET_WM_WINDOW_TYPE_DOCK at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isDock() const = 0;
     /**
      * Returns whether the window is a standalone (detached) toolbar window.
      * See _NET_WM_WINDOW_TYPE_TOOLBAR at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isToolbar() const = 0;
     /**
      * Returns whether the window is a torn-off menu.
      * See _NET_WM_WINDOW_TYPE_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isMenu() const = 0;
     /**
      * Returns whether the window is a "normal" window, i.e. an application or any other window
      * for which none of the specialized window types fit.
      * See _NET_WM_WINDOW_TYPE_NORMAL at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isNormalWindow() const = 0; // normal as in 'NET::Normal or NET::Unknown non-transient'
     /**
      * Returns whether the window is any of special windows types (desktop, dock, splash, ...),
      * i.e. window types that usually don't have a window frame and the user does not use window
      * management (moving, raising,...) on them.
      */
     virtual bool isSpecialWindow() const = 0;
     /**
      * Returns whether the window is a dialog window.
      * See _NET_WM_WINDOW_TYPE_DIALOG at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isDialog() const = 0;
     /**
      * Returns whether the window is a splashscreen. Note that many (especially older) applications
      * do not support marking their splash windows with this type.
      * See _NET_WM_WINDOW_TYPE_SPLASH at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isSplash() const = 0;
     /**
      * Returns whether the window is a utility window, such as a tool window.
      * See _NET_WM_WINDOW_TYPE_UTILITY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isUtility() const = 0;
     /**
      * Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
      * from the applications menubar).
      * See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isDropdownMenu() const = 0;
     /**
      * Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
      * See _NET_WM_WINDOW_TYPE_POPUP_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isPopupMenu() const = 0; // a context popup, not dropdown, not torn-off
     /**
      * Returns whether the window is a tooltip.
      * See _NET_WM_WINDOW_TYPE_TOOLTIP at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isTooltip() const = 0;
     /**
      * Returns whether the window is a window with a notification.
      * See _NET_WM_WINDOW_TYPE_NOTIFICATION at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isNotification() const = 0;
     /**
      * Returns whether the window is a window with a critical notification.
      * using the non-standard _KDE_NET_WM_WINDOW_TYPE_CRITICAL_NOTIFICATION
      */
     virtual bool isCriticalNotification() const = 0;
     /**
      * Returns whether the window is an on screen display window
      * using the non-standard _KDE_NET_WM_WINDOW_TYPE_ON_SCREEN_DISPLAY
      */
     virtual bool isOnScreenDisplay() const = 0;
     /**
      * Returns whether the window is a combobox popup.
      * See _NET_WM_WINDOW_TYPE_COMBO at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isComboBox() const = 0;
     /**
      * Returns whether the window is a Drag&Drop icon.
      * See _NET_WM_WINDOW_TYPE_DND at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual bool isDNDIcon() const = 0;
     /**
      * Returns the NETWM window type
      * See https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     virtual NET::WindowType windowType() const = 0;
     /**
      * Returns whether the window is managed by KWin (it has control over its placement and other
      * aspects, as opposed to override-redirect windows that are entirely handled by the application).
      */
     virtual bool isManaged() const = 0; // whether it's managed or override-redirect
     /**
      * Returns whether or not the window can accept keyboard focus.
      */
     virtual bool acceptsFocus() const = 0;
     /**
      * Returns whether or not the window is kept above all other windows.
      */
     virtual bool keepAbove() const = 0;
     /**
      * Returns whether the window is kept below all other windows.
      */
     virtual bool keepBelow() const = 0;
 
     virtual bool isModal() const = 0;
     Q_SCRIPTABLE virtual KWin::EffectWindow* findModal() = 0;
     Q_SCRIPTABLE virtual QList<KWin::EffectWindow*> mainWindows() const = 0;
 
     /**
      * Returns whether the window should be excluded from window switching effects.
      * @since 4.5
      */
     virtual bool isSkipSwitcher() const = 0;
 
     /**
      * Returns the unmodified window quad list. Can also be used to force rebuilding.
      */
     virtual WindowQuadList buildQuads(bool force = false) const = 0;
 
     void setMinimized(bool minimize);
     virtual void minimize() = 0;
     virtual void unminimize() = 0;
     Q_SCRIPTABLE virtual void closeWindow() = 0;
 
     /// deprecated
     virtual bool isCurrentTab() const = 0;
 
     /**
      * @since 4.11
      */
     bool isVisible() const;
 
     /**
      * @since 5.0
      */
     virtual bool skipsCloseAnimation() const = 0;
 
     /**
      * @since 5.5
      */
-    virtual KWayland::Server::SurfaceInterface *surface() const = 0;
+    virtual KWaylandServer::SurfaceInterface *surface() const = 0;
 
     /**
      * @since 5.6
      */
     virtual bool isFullScreen() const = 0;
 
     /**
      * @since 5.10
      */
     virtual bool isUnresponsive() const = 0;
 
     /**
      * @since 5.15
      */
     virtual bool isWaylandClient() const = 0;
 
     /**
      * @since 5.15
      */
     virtual bool isX11Client() const = 0;
 
     /**
      * @since 5.15
      */
     virtual bool isPopupWindow() const = 0;
 
     /**
      * @since 5.16
      */
     virtual QWindow *internalWindow() const = 0;
 
     /**
      * @since 5.16
      */
     virtual bool isOutline() const = 0;
 
     /**
      * @since 5.18
      */
     virtual pid_t pid() const = 0;
 
     /**
      * Can be used to by effects to store arbitrary data in the EffectWindow.
      *
      * Invoking this method will emit the signal EffectsHandler::windowDataChanged.
      * @see EffectsHandler::windowDataChanged
      */
     Q_SCRIPTABLE virtual void setData(int role, const QVariant &data) = 0;
     Q_SCRIPTABLE virtual QVariant data(int role) const = 0;
 
     /**
      * @brief References the previous window pixmap to prevent discarding.
      *
      * This method allows to reference the previous window pixmap in case that a window changed
      * its size, which requires a new window pixmap. By referencing the previous (and then outdated)
      * window pixmap an effect can for example cross fade the current window pixmap with the previous
      * one. This allows for smoother transitions for window geometry changes.
      *
      * If an effect calls this method on a window it also needs to call unreferencePreviousWindowPixmap
      * once it does no longer need the previous window pixmap.
      *
      * Note: the window pixmap is not kept forever even when referenced. If the geometry changes again, so that
      * a new window pixmap is created, the previous window pixmap will be exchanged with the current one. This
      * means it's still possible to have rendering glitches. An effect is supposed to track for itself the changes
      * to the window's geometry and decide how the transition should continue in such a situation.
      *
      * @see unreferencePreviousWindowPixmap
      * @since 4.11
      */
     virtual void referencePreviousWindowPixmap() = 0;
     /**
      * @brief Unreferences the previous window pixmap. Only relevant after referencePreviousWindowPixmap had
      * been called.
      *
      * @see referencePreviousWindowPixmap
      * @since 4.11
      */
     virtual void unreferencePreviousWindowPixmap() = 0;
 
 private:
     class Private;
     QScopedPointer<Private> d;
 };
 
 class KWINEFFECTS_EXPORT EffectWindowGroup
 {
 public:
     virtual ~EffectWindowGroup();
     virtual EffectWindowList members() const = 0;
 };
 
 
 struct GLVertex2D
 {
     QVector2D position;
     QVector2D texcoord;
 };
 
 struct GLVertex3D
 {
     QVector3D position;
     QVector2D texcoord;
 };
 
 
 /**
  * @short Vertex class
  *
  * A vertex is one position in a window. WindowQuad consists of four WindowVertex objects
  * and represents one part of a window.
  */
 class KWINEFFECTS_EXPORT WindowVertex
 {
 public:
     WindowVertex();
     WindowVertex(const QPointF &position, const QPointF &textureCoordinate);
     WindowVertex(double x, double y, double tx, double ty);
 
     double x() const { return px; }
     double y() const { return py; }
     double u() const { return tx; }
     double v() const { return ty; }
     double originalX() const { return ox; }
     double originalY() const { return oy; }
     double textureX() const { return tx; }
     double textureY() const { return ty; }
     void move(double x, double y);
     void setX(double x);
     void setY(double y);
 
 private:
     friend class WindowQuad;
     friend class WindowQuadList;
     double px, py; // position
     double ox, oy; // origional position
     double tx, ty; // texture coords
 };
 
 /**
  * @short Class representing one area of a window.
  *
  * WindowQuads consists of four WindowVertex objects and represents one part of a window.
  */
 // NOTE: This class expects the (original) vertices to be in the clockwise order starting from topleft.
 class KWINEFFECTS_EXPORT WindowQuad
 {
 public:
     explicit WindowQuad(WindowQuadType type, int id = -1);
     WindowQuad makeSubQuad(double x1, double y1, double x2, double y2) const;
     WindowVertex& operator[](int index);
     const WindowVertex& operator[](int index) const;
     WindowQuadType type() const;
     void setUVAxisSwapped(bool value) { uvSwapped = value; }
     bool uvAxisSwapped() const { return uvSwapped; }
     int id() const;
     bool decoration() const;
     bool effect() const;
     double left() const;
     double right() const;
     double top() const;
     double bottom() const;
     double originalLeft() const;
     double originalRight() const;
     double originalTop() const;
     double originalBottom() const;
     bool smoothNeeded() const;
     bool isTransformed() const;
 private:
     friend class WindowQuadList;
     WindowVertex verts[ 4 ];
     WindowQuadType quadType; // 0 - contents, 1 - decoration
     bool uvSwapped;
     int quadID;
 };
 
 class KWINEFFECTS_EXPORT WindowQuadList
     : public QList< WindowQuad >
 {
 public:
     WindowQuadList splitAtX(double x) const;
     WindowQuadList splitAtY(double y) const;
     WindowQuadList makeGrid(int maxquadsize) const;
     WindowQuadList makeRegularGrid(int xSubdivisions, int ySubdivisions) const;
     WindowQuadList select(WindowQuadType type) const;
     WindowQuadList filterOut(WindowQuadType type) const;
     bool smoothNeeded() const;
     void makeInterleavedArrays(unsigned int type, GLVertex2D *vertices, const QMatrix4x4 &matrix) const;
     void makeArrays(float** vertices, float** texcoords, const QSizeF &size, bool yInverted) const;
     bool isTransformed() const;
 };
 
 class KWINEFFECTS_EXPORT WindowPrePaintData
 {
 public:
     int mask;
     /**
      * Region that will be painted, in screen coordinates.
      */
     QRegion paint;
     /**
      * The clip region will be subtracted from paint region of following windows.
      * I.e. window will definitely cover it's clip region
      */
     QRegion clip;
     WindowQuadList quads;
     /**
      * Simple helper that sets data to say the window will be painted as non-opaque.
      * Takes also care of changing the regions.
      */
     void setTranslucent();
     /**
      * Helper to mark that this window will be transformed
      */
     void setTransformed();
 };
 
 class KWINEFFECTS_EXPORT PaintData
 {
 public:
     virtual ~PaintData();
     /**
      * @returns scale factor in X direction.
      * @since 4.10
      */
     qreal xScale() const;
     /**
      * @returns scale factor in Y direction.
      * @since 4.10
      */
     qreal yScale() const;
     /**
      * @returns scale factor in Z direction.
      * @since 4.10
      */
     qreal zScale() const;
     /**
      * Sets the scale factor in X direction to @p scale
      * @param scale The scale factor in X direction
      * @since 4.10
      */
     void setXScale(qreal scale);
     /**
      * Sets the scale factor in Y direction to @p scale
      * @param scale The scale factor in Y direction
      * @since 4.10
      */
     void setYScale(qreal scale);
     /**
      * Sets the scale factor in Z direction to @p scale
      * @param scale The scale factor in Z direction
      * @since 4.10
      */
     void setZScale(qreal scale);
     /**
      * Sets the scale factor in X and Y direction.
      * @param scale The scale factor for X and Y direction
      * @since 4.10
      */
     void setScale(const QVector2D &scale);
     /**
      * Sets the scale factor in X, Y and Z direction
      * @param scale The scale factor for X, Y and Z direction
      * @since 4.10
      */
     void setScale(const QVector3D &scale);
     const QGraphicsScale &scale() const;
     const QVector3D &translation() const;
     /**
      * @returns the translation in X direction.
      * @since 4.10
      */
     qreal xTranslation() const;
     /**
      * @returns the translation in Y direction.
      * @since 4.10
      */
     qreal yTranslation() const;
     /**
      * @returns the translation in Z direction.
      * @since 4.10
      */
     qreal zTranslation() const;
     /**
      * Sets the translation in X direction to @p translate.
      * @since 4.10
      */
     void setXTranslation(qreal translate);
     /**
      * Sets the translation in Y direction to @p translate.
      * @since 4.10
      */
     void setYTranslation(qreal translate);
     /**
      * Sets the translation in Z direction to @p translate.
      * @since 4.10
      */
     void setZTranslation(qreal translate);
     /**
      * Performs a translation by adding the values component wise.
      * @param x Translation in X direction
      * @param y Translation in Y direction
      * @param z Translation in Z direction
      * @since 4.10
      */
     void translate(qreal x, qreal y = 0.0, qreal z = 0.0);
     /**
      * Performs a translation by adding the values component wise.
      * Overloaded method for convenience.
      * @param translate The translation
      * @since 4.10
      */
     void translate(const QVector3D &translate);
 
     /**
      * Sets the rotation angle.
      * @param angle The new rotation angle.
      * @since 4.10
      * @see rotationAngle()
      */
     void setRotationAngle(qreal angle);
     /**
      * Returns the rotation angle.
      * Initially 0.0.
      * @returns The current rotation angle.
      * @since 4.10
      * @see setRotationAngle
      */
     qreal rotationAngle() const;
     /**
      * Sets the rotation origin.
      * @param origin The new rotation origin.
      * @since 4.10
      * @see rotationOrigin()
      */
     void setRotationOrigin(const QVector3D &origin);
     /**
      * Returns the rotation origin. That is the point in space which is fixed during the rotation.
      * Initially this is 0/0/0.
      * @returns The rotation's origin
      * @since 4.10
      * @see setRotationOrigin()
      */
     QVector3D rotationOrigin() const;
     /**
      * Sets the rotation axis.
      * Set a component to 1.0 to rotate around this axis and to 0.0 to disable rotation around the
      * axis.
      * @param axis A vector holding information on which axis to rotate
      * @since 4.10
      * @see rotationAxis()
      */
     void setRotationAxis(const QVector3D &axis);
     /**
      * Sets the rotation axis.
      * Overloaded method for convenience.
      * @param axis The axis around which should be rotated.
      * @since 4.10
      * @see rotationAxis()
      */
     void setRotationAxis(Qt::Axis axis);
     /**
      * The current rotation axis.
      * By default the rotation is (0/0/1) which means a rotation around the z axis.
      * @returns The current rotation axis.
      * @since 4.10
      * @see setRotationAxis
      */
     QVector3D rotationAxis() const;
 
 protected:
     PaintData();
     PaintData(const PaintData &other);
 
 private:
     PaintDataPrivate * const d;
 };
 
 class KWINEFFECTS_EXPORT WindowPaintData : public PaintData
 {
 public:
     explicit WindowPaintData(EffectWindow* w);
     explicit WindowPaintData(EffectWindow* w, const QMatrix4x4 &screenProjectionMatrix);
     WindowPaintData(const WindowPaintData &other);
     ~WindowPaintData() override;
     /**
      * Scales the window by @p scale factor.
      * Multiplies all three components by the given factor.
      * @since 4.10
      */
     WindowPaintData& operator*=(qreal scale);
     /**
      * Scales the window by @p scale factor.
      * Performs a component wise multiplication on x and y components.
      * @since 4.10
      */
     WindowPaintData& operator*=(const QVector2D &scale);
     /**
      * Scales the window by @p scale factor.
      * Performs a component wise multiplication.
      * @since 4.10
      */
     WindowPaintData& operator*=(const QVector3D &scale);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * @since 4.10
      */
     WindowPaintData& operator+=(const QPointF &translation);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      */
     WindowPaintData& operator+=(const QPoint &translation);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      */
     WindowPaintData& operator+=(const QVector2D &translation);
     /**
      * Translates the window by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      */
     WindowPaintData& operator+=(const QVector3D &translation);
     /**
      * Window opacity, in range 0 = transparent to 1 = fully opaque
      * @see setOpacity
      * @since 4.10
      */
     qreal opacity() const;
     /**
      * Sets the window opacity to the new @p opacity.
      * If you want to modify the existing opacity level consider using multiplyOpacity.
      * @param opacity The new opacity level
      * @since 4.10
      */
     void setOpacity(qreal opacity);
     /**
      * Multiplies the current opacity with the @p factor.
      * @param factor Factor with which the opacity should be multiplied
      * @return New opacity level
      * @since 4.10
      */
     qreal multiplyOpacity(qreal factor);
     /**
      * Saturation of the window, in range [0; 1]
      * 1 means that the window is unchanged, 0 means that it's completely
      *  unsaturated (greyscale). 0.5 would make the colors less intense,
      *  but not completely grey
      * Use EffectsHandler::saturationSupported() to find out whether saturation
      * is supported by the system, otherwise this value has no effect.
      * @return The current saturation
      * @see setSaturation()
      * @since 4.10
      */
     qreal saturation() const;
     /**
      * Sets the window saturation level to @p saturation.
      * If you want to modify the existing saturation level consider using multiplySaturation.
      * @param saturation The new saturation level
      * @since 4.10
      */
     void setSaturation(qreal saturation) const;
     /**
      * Multiplies the current saturation with @p factor.
      * @param factor with which the saturation should be multiplied
      * @return New saturation level
      * @since 4.10
      */
     qreal multiplySaturation(qreal factor);
     /**
      * Brightness of the window, in range [0; 1]
      * 1 means that the window is unchanged, 0 means that it's completely
      * black. 0.5 would make it 50% darker than usual
      */
     qreal brightness() const;
     /**
      * Sets the window brightness level to @p brightness.
      * If you want to modify the existing brightness level consider using multiplyBrightness.
      * @param brightness The new brightness level
      */
     void setBrightness(qreal brightness);
     /**
      * Multiplies the current brightness level with @p factor.
      * @param factor with which the brightness should be multiplied.
      * @return New brightness level
      * @since 4.10
      */
     qreal multiplyBrightness(qreal factor);
     /**
      * The screen number for which the painting should be done.
      * This affects color correction (different screens may need different
      * color correction lookup tables because they have different ICC profiles).
      * @return screen for which painting should be done
      */
     int screen() const;
     /**
      * @param screen New screen number
      * A value less than 0 will indicate that a default profile should be done.
      */
     void setScreen(int screen) const;
     /**
      * @brief Sets the cross fading @p factor to fade over with previously sized window.
      * If @c 1.0 only the current window is used, if @c 0.0 only the previous window is used.
      *
      * By default only the current window is used. This factor can only make any visual difference
      * if the previous window get referenced.
      *
      * @param factor The cross fade factor between @c 0.0 (previous window) and @c 1.0 (current window)
      * @see crossFadeProgress
      */
     void setCrossFadeProgress(qreal factor);
     /**
      * @see setCrossFadeProgress
      */
     qreal crossFadeProgress() const;
 
     /**
      * Sets the projection matrix that will be used when painting the window.
      *
      * The default projection matrix can be overridden by setting this matrix
      * to a non-identity matrix.
      */
     void setProjectionMatrix(const QMatrix4x4 &matrix);
 
     /**
      * Returns the current projection matrix.
      *
      * The default value for this matrix is the identity matrix.
      */
     QMatrix4x4 projectionMatrix() const;
 
     /**
      * Returns a reference to the projection matrix.
      */
     QMatrix4x4 &rprojectionMatrix();
 
     /**
      * Sets the model-view matrix that will be used when painting the window.
      *
      * The default model-view matrix can be overridden by setting this matrix
      * to a non-identity matrix.
      */
     void setModelViewMatrix(const QMatrix4x4 &matrix);
 
     /**
      * Returns the current model-view matrix.
      *
      * The default value for this matrix is the identity matrix.
      */
     QMatrix4x4 modelViewMatrix() const;
 
     /**
      * Returns a reference to the model-view matrix.
      */
     QMatrix4x4 &rmodelViewMatrix();
 
     /**
      * Returns The projection matrix as used by the current screen painting pass
      * including screen transformations.
      *
      * @since 5.6
      */
     QMatrix4x4 screenProjectionMatrix() const;
 
     WindowQuadList quads;
 
     /**
      * Shader to be used for rendering, if any.
      */
     GLShader* shader;
 
 private:
     WindowPaintDataPrivate * const d;
 };
 
 class KWINEFFECTS_EXPORT ScreenPaintData : public PaintData
 {
 public:
     ScreenPaintData();
     ScreenPaintData(const QMatrix4x4 &projectionMatrix, const QRect &outputGeometry = QRect(), const qreal screenScale = 1.0);
     ScreenPaintData(const ScreenPaintData &other);
     ~ScreenPaintData() override;
     /**
      * Scales the screen by @p scale factor.
      * Multiplies all three components by the given factor.
      * @since 4.10
      */
     ScreenPaintData& operator*=(qreal scale);
     /**
      * Scales the screen by @p scale factor.
      * Performs a component wise multiplication on x and y components.
      * @since 4.10
      */
     ScreenPaintData& operator*=(const QVector2D &scale);
     /**
      * Scales the screen by @p scale factor.
      * Performs a component wise multiplication.
      * @since 4.10
      */
     ScreenPaintData& operator*=(const QVector3D &scale);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * @since 4.10
      */
     ScreenPaintData& operator+=(const QPointF &translation);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      */
     ScreenPaintData& operator+=(const QPoint &translation);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      */
     ScreenPaintData& operator+=(const QVector2D &translation);
     /**
      * Translates the screen by the given @p translation and returns a reference to the ScreenPaintData.
      * Overloaded method for convenience.
      * @since 4.10
      */
     ScreenPaintData& operator+=(const QVector3D &translation);
     ScreenPaintData& operator=(const ScreenPaintData &rhs);
 
     /**
      * The projection matrix used by the scene for the current rendering pass.
      * On non-OpenGL compositors it's set to Identity matrix.
      * @since 5.6
      */
     QMatrix4x4 projectionMatrix() const;
 
     /**
      * The geometry of the currently rendered output.
      * Only set for per-output rendering (e.g. Wayland).
      *
      * This geometry can be used as a hint about the native window the OpenGL context
      * is bound. OpenGL calls need to be translated to this geometry.
      * @since 5.9
      */
     QRect outputGeometry() const;
 
     /**
      * The scale factor for the output
      *
      * @since 5.19
      */
     qreal screenScale() const;
 private:
     class Private;
     QScopedPointer<Private> d;
 };
 
 class KWINEFFECTS_EXPORT ScreenPrePaintData
 {
 public:
     int mask;
     QRegion paint;
 };
 
 /**
  * @short Helper class for restricting painting area only to allowed area.
  *
  * This helper class helps specifying areas that should be painted, clipping
  * out the rest. The simplest usage is creating an object on the stack
  * and giving it the area that is allowed to be painted to. When the object
  * is destroyed, the restriction will be removed.
  * Note that all painting code must use paintArea() to actually perform the clipping.
  */
 class KWINEFFECTS_EXPORT PaintClipper
 {
 public:
     /**
      * Calls push().
      */
     explicit PaintClipper(const QRegion& allowed_area);
     /**
      * Calls pop().
      */
     ~PaintClipper();
     /**
      * Allows painting only in the given area. When areas have been already
      * specified, painting is allowed only in the intersection of all areas.
      */
     static void push(const QRegion& allowed_area);
     /**
      * Removes the given area. It must match the top item in the stack.
      */
     static void pop(const QRegion& allowed_area);
     /**
      * Returns true if any clipping should be performed.
      */
     static bool clip();
     /**
      * If clip() returns true, this function gives the resulting area in which
      * painting is allowed. It is usually simpler to use the helper Iterator class.
      */
     static QRegion paintArea();
     /**
      * Helper class to perform the clipped painting. The usage is:
      * @code
      * for ( PaintClipper::Iterator iterator;
      *      !iterator.isDone();
      *      iterator.next())
      *     { // do the painting, possibly use iterator.boundingRect()
      *     }
      * @endcode
      */
     class KWINEFFECTS_EXPORT Iterator
     {
     public:
         Iterator();
         ~Iterator();
         bool isDone();
         void next();
         QRect boundingRect() const;
     private:
         struct Data;
         Data* data;
     };
 private:
     QRegion area;
     static QStack< QRegion >* areas;
 };
 
 /**
  * @internal
  */
 template <typename T>
 class KWINEFFECTS_EXPORT Motion
 {
 public:
     /**
      * Creates a new motion object. "Strength" is the amount of
      * acceleration that is applied to the object when the target
      * changes and "smoothness" relates to how fast the object
      * can change its direction and speed.
      */
     explicit Motion(T initial, double strength, double smoothness);
     /**
      * Creates an exact copy of another motion object, including
      * position, target and velocity.
      */
     Motion(const Motion<T> &other);
     ~Motion();
 
     inline T value() const {
         return m_value;
     }
     inline void setValue(const T value) {
         m_value = value;
     }
     inline T target() const {
         return m_target;
     }
     inline void setTarget(const T target) {
         m_start = m_value;
         m_target = target;
     }
     inline T velocity() const {
         return m_velocity;
     }
     inline void setVelocity(const T velocity) {
         m_velocity = velocity;
     }
 
     inline double strength() const {
         return m_strength;
     }
     inline void setStrength(const double strength) {
         m_strength = strength;
     }
     inline double smoothness() const {
         return m_smoothness;
     }
     inline void setSmoothness(const double smoothness) {
         m_smoothness = smoothness;
     }
     inline T startValue() {
         return m_start;
     }
 
     /**
      * The distance between the current position and the target.
      */
     inline T distance() const {
         return m_target - m_value;
     }
 
     /**
      * Calculates the new position if not at the target. Called
      * once per frame only.
      */
     void calculate(const int msec);
     /**
      * Place the object on top of the target immediately,
      * bypassing all movement calculation.
      */
     void finish();
 
 private:
     T m_value;
     T m_start;
     T m_target;
     T m_velocity;
     double m_strength;
     double m_smoothness;
 };
 
 /**
  * @short A single 1D motion dynamics object.
  *
  * This class represents a single object that can be moved around a
  * 1D space. Although it can be used directly by itself it is
  * recommended to use a motion manager instead.
  */
 class KWINEFFECTS_EXPORT Motion1D : public Motion<double>
 {
 public:
     explicit Motion1D(double initial = 0.0, double strength = 0.08, double smoothness = 4.0);
     Motion1D(const Motion1D &other);
     ~Motion1D();
 };
 
 /**
  * @short A single 2D motion dynamics object.
  *
  * This class represents a single object that can be moved around a
  * 2D space. Although it can be used directly by itself it is
  * recommended to use a motion manager instead.
  */
 class KWINEFFECTS_EXPORT Motion2D : public Motion<QPointF>
 {
 public:
     explicit Motion2D(QPointF initial = QPointF(), double strength = 0.08, double smoothness = 4.0);
     Motion2D(const Motion2D &other);
     ~Motion2D();
 };
 
 /**
  * @short Helper class for motion dynamics in KWin effects.
  *
  * This motion manager class is intended to help KWin effect authors
  * move windows across the screen smoothly and naturally. Once
  * windows are registered by the manager the effect can issue move
  * commands with the moveWindow() methods. The position of any
  * managed window can be determined in realtime by the
  * transformedGeometry() method. As the manager knows if any windows
  * are moving at any given time it can also be used as a notifier as
  * to see whether the effect is active or not.
  */
 class KWINEFFECTS_EXPORT WindowMotionManager
 {
 public:
     /**
      * Creates a new window manager object.
      */
     explicit WindowMotionManager(bool useGlobalAnimationModifier = true);
     ~WindowMotionManager();
 
     /**
      * Register a window for managing.
      */
     void manage(EffectWindow *w);
     /**
      * Register a list of windows for managing.
      */
     inline void manage(const EffectWindowList &list) {
         for (int i = 0; i < list.size(); i++)
             manage(list.at(i));
     }
     /**
      * Deregister a window. All transformations applied to the
      * window will be permanently removed and cannot be recovered.
      */
     void unmanage(EffectWindow *w);
     /**
      * Deregister all windows, returning the manager to its
      * originally initiated state.
      */
     void unmanageAll();
     /**
      * Determine the new positions for windows that have not
      * reached their target. Called once per frame, usually in
      * prePaintScreen(). Remember to set the
      * Effect::PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS flag.
      */
     void calculate(int time);
     /**
      * Modify a registered window's paint data to make it appear
      * at its real location on the screen. Usually called in
      * paintWindow(). Remember to flag the window as having been
      * transformed in prePaintWindow() by calling
      * WindowPrePaintData::setTransformed()
      */
     void apply(EffectWindow *w, WindowPaintData &data);
     /**
      * Set all motion targets and values back to where the
      * windows were before transformations. The same as
      * unmanaging then remanaging all windows.
      */
     void reset();
     /**
      * Resets the motion target and current value of a single
      * window.
      */
     void reset(EffectWindow *w);
 
     /**
      * Ask the manager to move the window to the target position
      * with the specified scale. If `yScale` is not provided or
      * set to 0.0, `scale` will be used as the scale in the
      * vertical direction as well as in the horizontal direction.
      */
     void moveWindow(EffectWindow *w, QPoint target, double scale = 1.0, double yScale = 0.0);
     /**
      * This is an overloaded method, provided for convenience.
      *
      * Ask the manager to move the window to the target rectangle.
      * Automatically determines scale.
      */
     inline void moveWindow(EffectWindow *w, QRect target) {
         // TODO: Scale might be slightly different in the comparison due to rounding
         moveWindow(w, target.topLeft(),
                    target.width() / double(w->width()), target.height() / double(w->height()));
     }
 
     /**
      * Retrieve the current tranformed geometry of a registered
      * window.
      */
     QRectF transformedGeometry(EffectWindow *w) const;
     /**
      * Sets the current transformed geometry of a registered window to the given geometry.
      * @see transformedGeometry
      * @since 4.5
      */
     void setTransformedGeometry(EffectWindow *w, const QRectF &geometry);
     /**
      * Retrieve the current target geometry of a registered
      * window.
      */
     QRectF targetGeometry(EffectWindow *w) const;
     /**
      * Return the window that has its transformed geometry under
      * the specified point. It is recommended to use the stacking
      * order as it's what the user sees, but it is slightly
      * slower to process.
      */
     EffectWindow* windowAtPoint(QPoint point, bool useStackingOrder = true) const;
 
     /**
      * Return a list of all currently registered windows.
      */
     inline EffectWindowList managedWindows() const {
         return m_managedWindows.keys();
     }
     /**
      * Returns whether or not a specified window is being managed
      * by this manager object.
      */
     inline bool isManaging(EffectWindow *w) const {
         return m_managedWindows.contains(w);
     }
     /**
      * Returns whether or not this manager object is actually
      * managing any windows or not.
      */
     inline bool managingWindows() const {
         return !m_managedWindows.empty();
     }
     /**
      * Returns whether all windows have reached their targets yet
      * or not. Can be used to see if an effect should be
      * processed and displayed or not.
      */
     inline bool areWindowsMoving() const {
         return !m_movingWindowsSet.isEmpty();
     }
     /**
      * Returns whether a window has reached its targets yet
      * or not.
      */
     inline bool isWindowMoving(EffectWindow *w) const {
         return m_movingWindowsSet.contains(w);
     }
 
 private:
     bool m_useGlobalAnimationModifier;
     struct WindowMotion {
         // TODO: Rotation, etc?
         Motion2D translation; // Absolute position
         Motion2D scale; // xScale and yScale
     };
     QHash<EffectWindow*, WindowMotion> m_managedWindows;
     QSet<EffectWindow*> m_movingWindowsSet;
 };
 
 /**
  * @short Helper class for displaying text and icons in frames.
  *
  * Paints text and/or and icon with an optional frame around them. The
  * available frames includes one that follows the default Plasma theme and
  * another that doesn't.
  * It is recommended to use this class whenever displaying text.
  */
 class KWINEFFECTS_EXPORT EffectFrame
 {
 public:
     EffectFrame();
     virtual ~EffectFrame();
 
     /**
      * Delete any existing textures to free up graphics memory. They will
      * be automatically recreated the next time they are required.
      */
     virtual void free() = 0;
 
     /**
      * Render the frame.
      */
     virtual void render(const QRegion &region = infiniteRegion(), double opacity = 1.0, double frameOpacity = 1.0) = 0;
 
     virtual void setPosition(const QPoint& point) = 0;
     /**
      * Set the text alignment for static frames and the position alignment
      * for non-static.
      */
     virtual void setAlignment(Qt::Alignment alignment) = 0;
     virtual Qt::Alignment alignment() const = 0;
     virtual void setGeometry(const QRect& geometry, bool force = false) = 0;
     virtual const QRect& geometry() const = 0;
 
     virtual void setText(const QString& text) = 0;
     virtual const QString& text() const = 0;
     virtual void setFont(const QFont& font) = 0;
     virtual const QFont& font() const = 0;
     /**
      * Set the icon that will appear on the left-hand size of the frame.
      */
     virtual void setIcon(const QIcon& icon) = 0;
     virtual const QIcon& icon() const = 0;
     virtual void setIconSize(const QSize& size) = 0;
     virtual const QSize& iconSize() const = 0;
 
     /**
      * Sets the geometry of a selection.
      * To remove the selection set a null rect.
      * @param selection The geometry of the selection in screen coordinates.
      */
     virtual void setSelection(const QRect& selection) = 0;
 
     /**
      * @param shader The GLShader for rendering.
      */
     virtual void setShader(GLShader* shader) = 0;
     /**
      * @returns The GLShader used for rendering or null if none.
      */
     virtual GLShader* shader() const = 0;
 
     /**
      * @returns The style of this EffectFrame.
      */
     virtual EffectFrameStyle style() const = 0;
 
     /**
      * If @p enable is @c true cross fading between icons and text is enabled
      * By default disabled. Use setCrossFadeProgress to cross fade.
      * Cross Fading is currently only available if OpenGL is used.
      * @param enable @c true enables cross fading, @c false disables it again
      * @see isCrossFade
      * @see setCrossFadeProgress
      * @since 4.6
      */
     void enableCrossFade(bool enable);
     /**
      * @returns @c true if cross fading is enabled, @c false otherwise
      * @see enableCrossFade
      * @since 4.6
      */
     bool isCrossFade() const;
     /**
      * Sets the current progress for cross fading the last used icon/text
      * with current icon/text to @p progress.
      * A value of 0.0 means completely old icon/text, a value of 1.0 means
      * completely current icon/text.
      * Default value is 1.0. You have to enable cross fade before using it.
      * Cross Fading is currently only available if OpenGL is used.
      * @see enableCrossFade
      * @see isCrossFade
      * @see crossFadeProgress
      * @since 4.6
      */
     void setCrossFadeProgress(qreal progress);
     /**
      * @returns The current progress for cross fading
      * @see setCrossFadeProgress
      * @see enableCrossFade
      * @see isCrossFade
      * @since 4.6
      */
     qreal crossFadeProgress() const;
 
     /**
      * Returns The projection matrix as used by the current screen painting pass
      * including screen transformations.
      *
      * This matrix is only valid during a rendering pass started by render.
      *
      * @since 5.6
      * @see render
      * @see EffectsHandler::paintEffectFrame
      * @see Effect::paintEffectFrame
      */
     QMatrix4x4 screenProjectionMatrix() const;
 
 protected:
     void setScreenProjectionMatrix(const QMatrix4x4 &projection);
 
 private:
     EffectFramePrivate* const d;
 };
 
 /**
  * The TimeLine class is a helper for controlling animations.
  */
 class KWINEFFECTS_EXPORT TimeLine
 {
 public:
     /**
      * Direction of the timeline.
      *
      * When the direction of the timeline is Forward, the progress
      * value will go from 0.0 to 1.0.
      *
      * When the direction of the timeline is Backward, the progress
      * value will go from 1.0 to 0.0.
      */
     enum Direction {
         Forward,
         Backward
     };
 
     /**
      * Constructs a new instance of TimeLine.
      *
      * @param duration Duration of the timeline, in milliseconds
      * @param direction Direction of the timeline
      * @since 5.14
      */
     explicit TimeLine(std::chrono::milliseconds duration = std::chrono::milliseconds(1000),
                       Direction direction = Forward);
     TimeLine(const TimeLine &other);
     ~TimeLine();
 
     /**
      * Returns the current value of the timeline.
      *
      * @since 5.14
      */
     qreal value() const;
 
     /**
      * Updates the progress of the timeline.
      *
      * @note The delta value should be a non-negative number, i.e. it
      * should be greater or equal to 0.
      *
      * @param delta The number milliseconds passed since last frame
      * @since 5.14
      */
     void update(std::chrono::milliseconds delta);
 
     /**
      * Returns the number of elapsed milliseconds.
      *
      * @see setElapsed
      * @since 5.14
      */
     std::chrono::milliseconds elapsed() const;
 
     /**
      * Sets the number of elapsed milliseconds.
      *
      * This method overwrites previous value of elapsed milliseconds.
      * If the new value of elapsed milliseconds is greater or equal
      * to duration of the timeline, the timeline will be finished, i.e.
      * proceeding TimeLine::done method calls will return @c true.
      * Please don't use it. Instead, use TimeLine::update.
      *
      * @note The new number of elapsed milliseconds should be a non-negative
      * number, i.e. it should be greater or equal to 0.
      *
      * @param elapsed The new number of elapsed milliseconds
      * @see elapsed
      * @since 5.14
      */
     void setElapsed(std::chrono::milliseconds elapsed);
 
     /**
      * Returns the duration of the timeline.
      *
      * @returns Duration of the timeline, in milliseconds
      * @see setDuration
      * @since 5.14
      */
     std::chrono::milliseconds duration() const;
 
     /**
      * Sets the duration of the timeline.
      *
      * In addition to setting new value of duration, the timeline will
      * try to retarget the number of elapsed milliseconds to match
      * as close as possible old progress value. If the new duration
      * is much smaller than old duration, there is a big chance that
      * the timeline will be finished after setting new duration.
      *
      * @note The new duration should be a positive number, i.e. it
      * should be greater or equal to 1.
      *
      * @param duration The new duration of the timeline, in milliseconds
      * @see duration
      * @since 5.14
      */
     void setDuration(std::chrono::milliseconds duration);
 
     /**
      * Returns the direction of the timeline.
      *
      * @returns Direction of the timeline(TimeLine::Forward or TimeLine::Backward)
      * @see setDirection
      * @see toggleDirection
      * @since 5.14
      */
     Direction direction() const;
 
     /**
      * Sets the direction of the timeline.
      *
      * @param direction The new direction of the timeline
      * @see direction
      * @see toggleDirection
      * @since 5.14
      */
     void setDirection(Direction direction);
 
     /**
      * Toggles the direction of the timeline.
      *
      * If the direction of the timeline was TimeLine::Forward, it becomes
      * TimeLine::Backward, and vice verca.
      *
      * @see direction
      * @see setDirection
      * @since 5.14
      */
     void toggleDirection();
 
     /**
      * Returns the easing curve of the timeline.
      *
      * @see setEasingCurve
      * @since 5.14
      */
     QEasingCurve easingCurve() const;
 
     /**
      * Sets new easing curve.
      *
      * @param easingCurve An easing curve to be set
      * @see easingCurve
      * @since 5.14
      */
     void setEasingCurve(const QEasingCurve &easingCurve);
 
     /**
      * Sets new easing curve by providing its type.
      *
      * @param type Type of the easing curve(e.g. QEasingCurve::InCubic, etc)
      * @see easingCurve
      * @since 5.14
      */
     void setEasingCurve(QEasingCurve::Type type);
 
     /**
      * Returns whether the timeline is currently in progress.
      *
      * @see done
      * @since 5.14
      */
     bool running() const;
 
     /**
      * Returns whether the timeline is finished.
      *
      * @see reset
      * @since 5.14
      */
     bool done() const;
 
     /**
      * Resets the timeline to initial state.
      *
      * @since 5.14
      */
     void reset();
 
     enum class RedirectMode {
         Strict,
         Relaxed
     };
 
     /**
      * Returns the redirect mode for the source position.
      *
      * The redirect mode controls behavior of the timeline when its direction is
      * changed at the source position, e.g. what should we do when the timeline
      * initially goes forward and we change its direction to go backward.
      *
      * In the strict mode, the timeline will stop.
      *
      * In the relaxed mode, the timeline will go in the new direction. For example,
      * if the timeline goes forward(from 0 to 1), then with the new direction it
      * will go backward(from 1 to 0).
      *
      * The default is RedirectMode::Relaxed.
      *
      * @see targetRedirectMode
      * @since 5.15
      */
     RedirectMode sourceRedirectMode() const;
 
     /**
      * Sets the redirect mode for the source position.
      *
      * @param mode The new mode.
      * @since 5.15
      */
     void setSourceRedirectMode(RedirectMode mode);
 
     /**
      * Returns the redirect mode for the target position.
      *
      * The redirect mode controls behavior of the timeline when its direction is
      * changed at the target position.
      *
      * In the strict mode, subsequent update calls won't have any effect on the
      * current value of the timeline.
      *
      * In the relaxed mode, the timeline will go in the new direction.
      *
      * The default is RedirectMode::Strict.
      *
      * @see sourceRedirectMode
      * @since 5.15
      */
     RedirectMode targetRedirectMode() const;
 
     /**
      * Sets the redirect mode for the target position.
      *
      * @param mode The new mode.
      * @since 5.15
      */
     void setTargetRedirectMode(RedirectMode mode);
 
     TimeLine &operator=(const TimeLine &other);
 
 private:
     qreal progress() const;
 
 private:
     class Data;
     QSharedDataPointer<Data> d;
 };
 
 /**
  * Pointer to the global EffectsHandler object.
  */
 extern KWINEFFECTS_EXPORT EffectsHandler* effects;
 
 /***************************************************************
  WindowVertex
 ***************************************************************/
 
 inline
 WindowVertex::WindowVertex()
     : px(0), py(0), ox(0), oy(0), tx(0), ty(0)
 {
 }
 
 inline
 WindowVertex::WindowVertex(double _x, double _y, double _tx, double _ty)
     : px(_x), py(_y), ox(_x), oy(_y), tx(_tx), ty(_ty)
 {
 }
 
 
 inline
 WindowVertex::WindowVertex(const QPointF &position, const QPointF &texturePosition)
     : px(position.x()), py(position.y()), ox(position.x()), oy(position.y()), tx(texturePosition.x()), ty(texturePosition.y())
 {
 }
 
 inline
 void WindowVertex::move(double x, double y)
 {
     px = x;
     py = y;
 }
 
 inline
 void WindowVertex::setX(double x)
 {
     px = x;
 }
 
 inline
 void WindowVertex::setY(double y)
 {
     py = y;
 }
 
 /***************************************************************
  WindowQuad
 ***************************************************************/
 
 inline
 WindowQuad::WindowQuad(WindowQuadType t, int id)
     : quadType(t)
     , uvSwapped(false)
     , quadID(id)
 {
 }
 
 inline
 WindowVertex& WindowQuad::operator[](int index)
 {
     Q_ASSERT(index >= 0 && index < 4);
     return verts[ index ];
 }
 
 inline
 const WindowVertex& WindowQuad::operator[](int index) const
 {
     Q_ASSERT(index >= 0 && index < 4);
     return verts[ index ];
 }
 
 inline
 WindowQuadType WindowQuad::type() const
 {
     Q_ASSERT(quadType != WindowQuadError);
     return quadType;
 }
 
 inline
 int WindowQuad::id() const
 {
     return quadID;
 }
 
 inline
 bool WindowQuad::decoration() const
 {
     Q_ASSERT(quadType != WindowQuadError);
     return quadType == WindowQuadDecoration;
 }
 
 inline
 bool WindowQuad::effect() const
 {
     Q_ASSERT(quadType != WindowQuadError);
     return quadType >= EFFECT_QUAD_TYPE_START;
 }
 
 inline
 bool WindowQuad::isTransformed() const
 {
     return !(verts[ 0 ].px == verts[ 0 ].ox && verts[ 0 ].py == verts[ 0 ].oy
              && verts[ 1 ].px == verts[ 1 ].ox && verts[ 1 ].py == verts[ 1 ].oy
              && verts[ 2 ].px == verts[ 2 ].ox && verts[ 2 ].py == verts[ 2 ].oy
              && verts[ 3 ].px == verts[ 3 ].ox && verts[ 3 ].py == verts[ 3 ].oy);
 }
 
 inline
 double WindowQuad::left() const
 {
     return qMin(verts[ 0 ].px, qMin(verts[ 1 ].px, qMin(verts[ 2 ].px, verts[ 3 ].px)));
 }
 
 inline
 double WindowQuad::right() const
 {
     return qMax(verts[ 0 ].px, qMax(verts[ 1 ].px, qMax(verts[ 2 ].px, verts[ 3 ].px)));
 }
 
 inline
 double WindowQuad::top() const
 {
     return qMin(verts[ 0 ].py, qMin(verts[ 1 ].py, qMin(verts[ 2 ].py, verts[ 3 ].py)));
 }
 
 inline
 double WindowQuad::bottom() const
 {
     return qMax(verts[ 0 ].py, qMax(verts[ 1 ].py, qMax(verts[ 2 ].py, verts[ 3 ].py)));
 }
 
 inline
 double WindowQuad::originalLeft() const
 {
     return verts[ 0 ].ox;
 }
 
 inline
 double WindowQuad::originalRight() const
 {
     return verts[ 2 ].ox;
 }
 
 inline
 double WindowQuad::originalTop() const
 {
     return verts[ 0 ].oy;
 }
 
 inline
 double WindowQuad::originalBottom() const
 {
     return verts[ 2 ].oy;
 }
 
 /***************************************************************
  Motion
 ***************************************************************/
 
 template <typename T>
 Motion<T>::Motion(T initial, double strength, double smoothness)
     :   m_value(initial)
     ,   m_start(initial)
     ,   m_target(initial)
     ,   m_velocity()
     ,   m_strength(strength)
     ,   m_smoothness(smoothness)
 {
 }
 
 template <typename T>
 Motion<T>::Motion(const Motion &other)
     :   m_value(other.value())
     ,   m_start(other.target())
     ,   m_target(other.target())
     ,   m_velocity(other.velocity())
     ,   m_strength(other.strength())
     ,   m_smoothness(other.smoothness())
 {
 }
 
 template <typename T>
 Motion<T>::~Motion()
 {
 }
 
 template <typename T>
 void Motion<T>::calculate(const int msec)
 {
     if (m_value == m_target && m_velocity == T())   // At target and not moving
         return;
 
     // Poor man's time independent calculation
     int steps = qMax(1, msec / 5);
     for (int i = 0; i < steps; i++) {
         T diff = m_target - m_value;
         T strength = diff * m_strength;
         m_velocity = (m_smoothness * m_velocity + strength) / (m_smoothness + 1.0);
         m_value += m_velocity;
     }
 }
 
 template <typename T>
 void Motion<T>::finish()
 {
     m_value = m_target;
     m_velocity = T();
 }
 
 /***************************************************************
  Effect
 ***************************************************************/
 template <typename T>
 int Effect::animationTime(int defaultDuration)
 {
     return animationTime(T::duration() != 0 ? T::duration() : defaultDuration);
 }
 
 template <typename T>
 void Effect::initConfig()
 {
     T::instance(effects->config());
 }
 
 } // namespace
 Q_DECLARE_METATYPE(KWin::EffectWindow*)
 Q_DECLARE_METATYPE(QList<KWin::EffectWindow*>)
 Q_DECLARE_METATYPE(KWin::TimeLine)
 Q_DECLARE_METATYPE(KWin::TimeLine::Direction)
 
 /** @} */
 
 #endif // KWINEFFECTS_H
diff --git a/linux_dmabuf.cpp b/linux_dmabuf.cpp
index 867f358da..ba5f3ab65 100644
--- a/linux_dmabuf.cpp
+++ b/linux_dmabuf.cpp
@@ -1,88 +1,88 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright © 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "linux_dmabuf.h"
 
 #include "wayland_server.h"
 
 #include <unistd.h>
 
 namespace KWin
 {
 
 DmabufBuffer::DmabufBuffer(const QVector<Plane> &planes,
                            uint32_t format,
                            const QSize &size,
                            Flags flags)
-    : KWayland::Server::LinuxDmabufUnstableV1Buffer(format, size)
+    : KWaylandServer::LinuxDmabufUnstableV1Buffer(format, size)
     , m_planes(planes)
     , m_format(format)
     , m_size(size)
     , m_flags(flags)
 {
     waylandServer()->addLinuxDmabufBuffer(this);
 }
 
 DmabufBuffer::~DmabufBuffer()
 {
     // Close all open file descriptors
     for (int i = 0; i < m_planes.count(); i++) {
         if (m_planes[i].fd != -1)
             ::close(m_planes[i].fd);
         m_planes[i].fd = -1;
     }
     if (waylandServer()) {
         waylandServer()->removeLinuxDmabufBuffer(this);
     }
 }
 
 LinuxDmabuf::LinuxDmabuf()
-    : KWayland::Server::LinuxDmabufUnstableV1Interface::Impl()
+    : KWaylandServer::LinuxDmabufUnstableV1Interface::Impl()
 {
     Q_ASSERT(waylandServer());
     waylandServer()->linuxDmabuf()->setImpl(this);
 }
 
 LinuxDmabuf::~LinuxDmabuf()
 {
     waylandServer()->linuxDmabuf()->setImpl(nullptr);
 }
 
-using Plane = KWayland::Server::LinuxDmabufUnstableV1Interface::Plane;
-using Flags = KWayland::Server::LinuxDmabufUnstableV1Interface::Flags;
+using Plane = KWaylandServer::LinuxDmabufUnstableV1Interface::Plane;
+using Flags = KWaylandServer::LinuxDmabufUnstableV1Interface::Flags;
 
-KWayland::Server::LinuxDmabufUnstableV1Buffer* LinuxDmabuf::importBuffer(const QVector<Plane> &planes,
+KWaylandServer::LinuxDmabufUnstableV1Buffer* LinuxDmabuf::importBuffer(const QVector<Plane> &planes,
                                                                          uint32_t format,
                                                                          const QSize &size,
                                                                          Flags flags)
 {
     Q_UNUSED(planes)
     Q_UNUSED(format)
     Q_UNUSED(size)
     Q_UNUSED(flags)
 
     return nullptr;
 }
 
 void LinuxDmabuf::setSupportedFormatsAndModifiers(QHash<uint32_t, QSet<uint64_t> > &set)
 {
     waylandServer()->linuxDmabuf()->setSupportedFormatsWithModifiers(set);
 }
 
 }
diff --git a/linux_dmabuf.h b/linux_dmabuf.h
index abf179346..b2b186140 100644
--- a/linux_dmabuf.h
+++ b/linux_dmabuf.h
@@ -1,74 +1,74 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright © 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #pragma once
 
 #include <kwin_export.h>
 
-#include <KWayland/Server/linuxdmabuf_v1_interface.h>
+#include <KWaylandServer/linuxdmabuf_v1_interface.h>
 
 #include <QVector>
 
 namespace KWin
 {
 
-class KWIN_EXPORT DmabufBuffer : public KWayland::Server::LinuxDmabufUnstableV1Buffer
+class KWIN_EXPORT DmabufBuffer : public KWaylandServer::LinuxDmabufUnstableV1Buffer
 {
 public:
-    using Plane = KWayland::Server::LinuxDmabufUnstableV1Interface::Plane;
-    using Flags = KWayland::Server::LinuxDmabufUnstableV1Interface::Flags;
+    using Plane = KWaylandServer::LinuxDmabufUnstableV1Interface::Plane;
+    using Flags = KWaylandServer::LinuxDmabufUnstableV1Interface::Flags;
 
     DmabufBuffer(const QVector<Plane> &planes,
                  uint32_t format,
                  const QSize &size,
                  Flags flags);
 
     ~DmabufBuffer() override;
 
     const QVector<Plane> &planes() const { return m_planes; }
     uint32_t format() const { return m_format; }
     QSize size() const { return m_size; }
     Flags flags() const { return m_flags; }
 
 private:
     QVector<Plane> m_planes;
     uint32_t m_format;
     QSize m_size;
     Flags m_flags;
 };
 
-class KWIN_EXPORT LinuxDmabuf : public KWayland::Server::LinuxDmabufUnstableV1Interface::Impl
+class KWIN_EXPORT LinuxDmabuf : public KWaylandServer::LinuxDmabufUnstableV1Interface::Impl
 {
 public:
-    using Plane = KWayland::Server::LinuxDmabufUnstableV1Interface::Plane;
-    using Flags = KWayland::Server::LinuxDmabufUnstableV1Interface::Flags;
+    using Plane = KWaylandServer::LinuxDmabufUnstableV1Interface::Plane;
+    using Flags = KWaylandServer::LinuxDmabufUnstableV1Interface::Flags;
 
     explicit LinuxDmabuf();
     ~LinuxDmabuf() override;
 
-    KWayland::Server::LinuxDmabufUnstableV1Buffer *importBuffer(const QVector<Plane> &planes,
+    KWaylandServer::LinuxDmabufUnstableV1Buffer *importBuffer(const QVector<Plane> &planes,
                                                                 uint32_t format,
                                                                 const QSize &size,
                                                                 Flags flags) override;
 
 protected:
     void setSupportedFormatsAndModifiers(QHash<uint32_t, QSet<uint64_t> > &set);
 };
 
 }
diff --git a/main.cpp b/main.cpp
index b4f6836d8..46cdc693d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,462 +1,462 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 
 #include "main.h"
 #include <config-kwin.h>
 // kwin
 #include "platform.h"
 #include "atoms.h"
 #include "composite.h"
 #include "cursor.h"
 #include "input.h"
 #include "logind.h"
 #include "options.h"
 #include "screens.h"
 #include "screenlockerwatcher.h"
 #include "sm.h"
 #include "workspace.h"
 #include "xcbutils.h"
 
 #include <kwineffects.h>
 
 // KDE
 #include <KAboutData>
 #include <KLocalizedString>
 #include <KPluginMetaData>
 #include <KSharedConfig>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 // Qt
 #include <qplatformdefs.h>
 #include <QCommandLineParser>
 #include <QQuickWindow>
 #include <QStandardPaths>
 #include <QTranslator>
 #include <QLibraryInfo>
 
 // system
 #ifdef HAVE_UNISTD_H
 #include <unistd.h>
 #endif // HAVE_UNISTD_H
 
 #ifdef HAVE_MALLOC_H
 #include <malloc.h>
 #endif // HAVE_MALLOC_H
 
 // xcb
 #include <xcb/damage.h>
 #ifndef XCB_GE_GENERIC
 #define XCB_GE_GENERIC 35
 #endif
 
 Q_DECLARE_METATYPE(KSharedConfigPtr)
 
 namespace KWin
 {
 
 Options* options;
 
 Atoms* atoms;
 
 int screen_number = -1;
 bool is_multihead = false;
 
 int Application::crashes = 0;
 
 bool Application::isX11MultiHead()
 {
     return is_multihead;
 }
 
 void Application::setX11MultiHead(bool multiHead)
 {
     is_multihead = multiHead;
 }
 
 void Application::setX11ScreenNumber(int screenNumber)
 {
     screen_number = screenNumber;
 }
 
 int Application::x11ScreenNumber()
 {
     return screen_number;
 }
 
 Application::Application(Application::OperationMode mode, int &argc, char **argv)
     : QApplication(argc, argv)
     , m_eventFilter(new XcbEventFilter())
     , m_configLock(false)
     , m_config()
     , m_kxkbConfig()
     , m_inputConfig()
     , m_operationMode(mode)
 {
     qRegisterMetaType<Options::WindowOperation>("Options::WindowOperation");
     qRegisterMetaType<KWin::EffectWindow*>();
-    qRegisterMetaType<KWayland::Server::SurfaceInterface *>("KWayland::Server::SurfaceInterface *");
+    qRegisterMetaType<KWaylandServer::SurfaceInterface *>("KWaylandServer::SurfaceInterface *");
     qRegisterMetaType<KSharedConfigPtr>();
 }
 
 void Application::setConfigLock(bool lock)
 {
     m_configLock = lock;
 }
 
 Application::OperationMode Application::operationMode() const
 {
     return m_operationMode;
 }
 
 void Application::setOperationMode(OperationMode mode)
 {
     m_operationMode = mode;
 }
 
 bool Application::shouldUseWaylandForCompositing() const
 {
     return m_operationMode == OperationModeWaylandOnly || m_operationMode == OperationModeXwayland;
 }
 
 void Application::start()
 {
     setQuitOnLastWindowClosed(false);
 
     if (!m_config) {
         m_config = KSharedConfig::openConfig();
     }
     if (!m_config->isImmutable() && m_configLock) {
         // TODO: This shouldn't be necessary
         //config->setReadOnly( true );
         m_config->reparseConfiguration();
     }
     if (!m_kxkbConfig) {
         m_kxkbConfig = KSharedConfig::openConfig(QStringLiteral("kxkbrc"), KConfig::NoGlobals);
     }
     if (!m_inputConfig) {
         m_inputConfig = KSharedConfig::openConfig(QStringLiteral("kcminputrc"), KConfig::NoGlobals);
     }
 
     performStartup();
 }
 
 Application::~Application()
 {
     delete options;
     destroyAtoms();
     destroyPlatform();
 }
 
 void Application::destroyAtoms()
 {
     delete atoms;
     atoms = nullptr;
 }
 
 void Application::destroyPlatform()
 {
     delete m_platform;
     m_platform = nullptr;
 }
 
 void Application::resetCrashesCount()
 {
     crashes = 0;
 }
 
 void Application::setCrashCount(int count)
 {
     crashes = count;
 }
 
 bool Application::wasCrash()
 {
     return crashes > 0;
 }
 
 static const char description[] = I18N_NOOP("KDE window manager");
 
 void Application::createAboutData()
 {
     KAboutData aboutData(QStringLiteral(KWIN_NAME),          // The program name used internally
                          i18n("KWin"),                       // A displayable program name string
                          QStringLiteral(KWIN_VERSION_STRING), // The program version string
                          i18n(description),                  // Short description of what the app does
                          KAboutLicense::GPL,            // The license this code is released under
                          i18n("(c) 1999-2019, The KDE Developers"));   // Copyright Statement
 
     aboutData.addAuthor(i18n("Matthias Ettrich"), QString(), QStringLiteral("ettrich@kde.org"));
     aboutData.addAuthor(i18n("Cristian Tibirna"), QString(), QStringLiteral("tibirna@kde.org"));
     aboutData.addAuthor(i18n("Daniel M. Duley"),  QString(), QStringLiteral("mosfet@kde.org"));
     aboutData.addAuthor(i18n("Luboš Luňák"),      QString(), QStringLiteral("l.lunak@kde.org"));
     aboutData.addAuthor(i18n("Martin Flöser"),    QString(), QStringLiteral("mgraesslin@kde.org"));
     aboutData.addAuthor(i18n("David Edmundson"),  QStringLiteral("Maintainer"), QStringLiteral("davidedmundson@kde.org"));
     aboutData.addAuthor(i18n("Roman Gilg"),       QStringLiteral("Maintainer"), QStringLiteral("subdiff@gmail.com"));
     aboutData.addAuthor(i18n("Vlad Zahorodnii"),  QStringLiteral("Maintainer"), QStringLiteral("vlad.zahorodnii@kde.org"));
     KAboutData::setApplicationData(aboutData);
 }
 
 static const QString s_lockOption = QStringLiteral("lock");
 static const QString s_crashesOption = QStringLiteral("crashes");
 
 void Application::setupCommandLine(QCommandLineParser *parser)
 {
     QCommandLineOption lockOption(s_lockOption, i18n("Disable configuration options"));
     QCommandLineOption crashesOption(s_crashesOption, i18n("Indicate that KWin has recently crashed n times"), QStringLiteral("n"));
 
     parser->setApplicationDescription(i18n("KDE window manager"));
     parser->addOption(lockOption);
     parser->addOption(crashesOption);
     KAboutData::applicationData().setupCommandLine(parser);
 }
 
 void Application::processCommandLine(QCommandLineParser *parser)
 {
     KAboutData aboutData = KAboutData::applicationData();
     aboutData.processCommandLine(parser);
     setConfigLock(parser->isSet(s_lockOption));
     Application::setCrashCount(parser->value(s_crashesOption).toInt());
 }
 
 void Application::setupTranslator()
 {
     QTranslator *qtTranslator = new QTranslator(qApp);
     qtTranslator->load("qt_" + QLocale::system().name(),
                        QLibraryInfo::location(QLibraryInfo::TranslationsPath));
     installTranslator(qtTranslator);
 }
 
 void Application::setupMalloc()
 {
 #ifdef M_TRIM_THRESHOLD
     // Prevent fragmentation of the heap by malloc (glibc).
     //
     // The default threshold is 128*1024, which can result in a large memory usage
     // due to fragmentation especially if we use the raster graphicssystem. On the
     // otherside if the threshold is too low, free() starts to permanently ask the kernel
     // about shrinking the heap.
 #ifdef HAVE_UNISTD_H
     const int pagesize = sysconf(_SC_PAGESIZE);
 #else
     const int pagesize = 4*1024;
 #endif // HAVE_UNISTD_H
     mallopt(M_TRIM_THRESHOLD, 5*pagesize);
 #endif // M_TRIM_THRESHOLD
 }
 
 void Application::setupLocalizedString()
 {
     KLocalizedString::setApplicationDomain("kwin");
 }
 
 void Application::createWorkspace()
 {
     // we want all QQuickWindows with an alpha buffer, do here as Workspace might create QQuickWindows
     QQuickWindow::setDefaultAlphaBuffer(true);
 
     // This tries to detect compositing options and can use GLX. GLX problems
     // (X errors) shouldn't cause kwin to abort, so this is out of the
     // critical startup section where x errors cause kwin to abort.
 
     // create workspace.
     (void) new Workspace();
     emit workspaceCreated();
 }
 
 void Application::createInput()
 {
     ScreenLockerWatcher::create(this);
     LogindIntegration::create(this);
     auto input = InputRedirection::create(this);
     input->init();
     m_platform->createPlatformCursor(this);
 }
 
 void Application::createScreens()
 {
     if (Screens::self()) {
         return;
     }
     Screens::create(this);
     emit screensCreated();
 }
 
 void Application::createAtoms()
 {
     atoms = new Atoms;
 }
 
 void Application::createOptions()
 {
     options = new Options;
 }
 
 void Application::setupEventFilters()
 {
     installNativeEventFilter(m_eventFilter.data());
 }
 
 void Application::destroyWorkspace()
 {
     delete Workspace::self();
 }
 
 void Application::destroyCompositor()
 {
     delete Compositor::self();
 }
 
 void Application::updateX11Time(xcb_generic_event_t *event)
 {
     xcb_timestamp_t time = XCB_TIME_CURRENT_TIME;
     const uint8_t eventType = event->response_type & ~0x80;
     switch(eventType) {
     case XCB_KEY_PRESS:
     case XCB_KEY_RELEASE:
         time = reinterpret_cast<xcb_key_press_event_t*>(event)->time;
         break;
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE:
         time = reinterpret_cast<xcb_button_press_event_t*>(event)->time;
         break;
     case XCB_MOTION_NOTIFY:
         time = reinterpret_cast<xcb_motion_notify_event_t*>(event)->time;
         break;
     case XCB_ENTER_NOTIFY:
     case XCB_LEAVE_NOTIFY:
         time = reinterpret_cast<xcb_enter_notify_event_t*>(event)->time;
         break;
     case XCB_FOCUS_IN:
     case XCB_FOCUS_OUT:
     case XCB_KEYMAP_NOTIFY:
     case XCB_EXPOSE:
     case XCB_GRAPHICS_EXPOSURE:
     case XCB_NO_EXPOSURE:
     case XCB_VISIBILITY_NOTIFY:
     case XCB_CREATE_NOTIFY:
     case XCB_DESTROY_NOTIFY:
     case XCB_UNMAP_NOTIFY:
     case XCB_MAP_NOTIFY:
     case XCB_MAP_REQUEST:
     case XCB_REPARENT_NOTIFY:
     case XCB_CONFIGURE_NOTIFY:
     case XCB_CONFIGURE_REQUEST:
     case XCB_GRAVITY_NOTIFY:
     case XCB_RESIZE_REQUEST:
     case XCB_CIRCULATE_NOTIFY:
     case XCB_CIRCULATE_REQUEST:
         // no timestamp
         return;
     case XCB_PROPERTY_NOTIFY:
         time = reinterpret_cast<xcb_property_notify_event_t*>(event)->time;
         break;
     case XCB_SELECTION_CLEAR:
         time = reinterpret_cast<xcb_selection_clear_event_t*>(event)->time;
         break;
     case XCB_SELECTION_REQUEST:
         time = reinterpret_cast<xcb_selection_request_event_t*>(event)->time;
         break;
     case XCB_SELECTION_NOTIFY:
         time = reinterpret_cast<xcb_selection_notify_event_t*>(event)->time;
         break;
     case XCB_COLORMAP_NOTIFY:
     case XCB_CLIENT_MESSAGE:
     case XCB_MAPPING_NOTIFY:
     case XCB_GE_GENERIC:
         // no timestamp
         return;
     default:
         // extension handling
         if (Xcb::Extensions::self()) {
             if (eventType == Xcb::Extensions::self()->shapeNotifyEvent()) {
                 time = reinterpret_cast<xcb_shape_notify_event_t*>(event)->server_time;
             }
             if (eventType == Xcb::Extensions::self()->damageNotifyEvent()) {
                 time = reinterpret_cast<xcb_damage_notify_event_t*>(event)->timestamp;
             }
         }
         break;
     }
     setX11Time(time);
 }
 
 bool XcbEventFilter::nativeEventFilter(const QByteArray &eventType, void *message, long int *result)
 {
     Q_UNUSED(result)
     if (eventType != "xcb_generic_event_t") {
         return false;
     }
     auto event = static_cast<xcb_generic_event_t *>(message);
     kwinApp()->updateX11Time(event);
     if (!Workspace::self()) {
         // Workspace not yet created
         return false;
     }
     return Workspace::self()->workspaceEvent(event);
 }
 
 static bool s_useLibinput = false;
 
 void Application::setUseLibinput(bool use)
 {
     s_useLibinput = use;
 }
 
 bool Application::usesLibinput()
 {
     return s_useLibinput;
 }
 
 QProcessEnvironment Application::processStartupEnvironment() const
 {
     return QProcessEnvironment::systemEnvironment();
 }
 
 void Application::initPlatform(const KPluginMetaData &plugin)
 {
     Q_ASSERT(!m_platform);
     m_platform = qobject_cast<Platform *>(plugin.instantiate());
     if (m_platform) {
         m_platform->setParent(this);
         // check whether it needs libinput
         const QJsonObject &metaData = plugin.rawData();
         auto it = metaData.find(QStringLiteral("input"));
         if (it != metaData.end()) {
             if ((*it).isBool()) {
                 if (!(*it).toBool()) {
                     qCDebug(KWIN_CORE) << "Platform does not support input, enforcing libinput support";
                     setUseLibinput(true);
                 }
             }
         }
     }
 }
 
 ApplicationWaylandAbstract::ApplicationWaylandAbstract(OperationMode mode, int &argc, char **argv)
     : Application(mode, argc, argv)
 {
 }
 
 ApplicationWaylandAbstract::~ApplicationWaylandAbstract()
 {
 }
 
 } // namespace
 
diff --git a/main_wayland.cpp b/main_wayland.cpp
index 544c7d716..11fa4d570 100644
--- a/main_wayland.cpp
+++ b/main_wayland.cpp
@@ -1,705 +1,705 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2014 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "main_wayland.h"
 #include "composite.h"
 #include "virtualkeyboard.h"
 #include "workspace.h"
 #include <config-kwin.h>
 // kwin
 #include "platform.h"
 #include "effects.h"
 #include "tabletmodemanager.h"
 #include "wayland_server.h"
 #include "xwl/xwayland.h"
 
 // KWayland
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/seat_interface.h>
 // KDE
 #include <KCrash>
 #include <KLocalizedString>
 #include <KPluginLoader>
 #include <KPluginMetaData>
 #include <KQuickAddons/QtQuickSettings>
 #include <KShell>
 
 // Qt
 #include <qplatformdefs.h>
 #include <QCommandLineParser>
 #include <QFileInfo>
 #include <QProcess>
 #include <QStyle>
 #include <QDebug>
 #include <QWindow>
 
 // system
 #if HAVE_SYS_PRCTL_H
 #include <sys/prctl.h>
 #endif
 #if HAVE_SYS_PROCCTL_H
 #include <sys/procctl.h>
 #endif
 
 #if HAVE_LIBCAP
 #include <sys/capability.h>
 #endif
 
 #include <sched.h>
 
 #include <iostream>
 #include <iomanip>
 
 namespace KWin
 {
 
 static void sighandler(int)
 {
     QApplication::exit();
 }
 
 void disableDrKonqi()
 {
     KCrash::setDrKonqiEnabled(false);
 }
 // run immediately, before Q_CORE_STARTUP functions
 // that would enable drkonqi
 Q_CONSTRUCTOR_FUNCTION(disableDrKonqi)
 
 enum class RealTimeFlags
 {
     DontReset,
     ResetOnFork
 };
 
 namespace {
 void gainRealTime(RealTimeFlags flags = RealTimeFlags::DontReset)
 {
 #if HAVE_SCHED_RESET_ON_FORK
     const int minPriority = sched_get_priority_min(SCHED_RR);
     struct sched_param sp;
     sp.sched_priority = minPriority;
     int policy = SCHED_RR;
     if (flags == RealTimeFlags::ResetOnFork) {
         policy |= SCHED_RESET_ON_FORK;
     }
     sched_setscheduler(0, policy, &sp);
 #else
     Q_UNUSED(flags);
 #endif
 }
 }
 
 //************************************
 // ApplicationWayland
 //************************************
 
 ApplicationWayland::ApplicationWayland(int &argc, char **argv)
     : ApplicationWaylandAbstract(OperationModeWaylandOnly, argc, argv)
 {
 }
 
 ApplicationWayland::~ApplicationWayland()
 {
     setTerminating();
     if (!waylandServer()) {
         return;
     }
 
     if (auto *platform = kwinApp()->platform()) {
         platform->prepareShutdown();
     }
     // need to unload all effects prior to destroying X connection as they might do X calls
     if (effects) {
         static_cast<EffectsHandlerImpl*>(effects)->unloadAllEffects();
     }
     if (m_xwayland) {
         // needs to be done before workspace gets destroyed
         m_xwayland->prepareDestroy();
     }
     destroyWorkspace();
     waylandServer()->dispatch();
 
     if (QStyle *s = style()) {
         s->unpolish(this);
     }
     // kill Xwayland before terminating its connection
     delete m_xwayland;
     m_xwayland = nullptr;
     waylandServer()->terminateClientConnections();
     destroyCompositor();
 }
 
 void ApplicationWayland::performStartup()
 {
     if (m_startXWayland) {
         setOperationMode(OperationModeXwayland);
     }
     // first load options - done internally by a different thread
     createOptions();
     waylandServer()->createInternalConnection();
 
     // try creating the Wayland Backend
     createInput();
     // now libinput thread has been created, adjust scheduler to not leak into other processes
     gainRealTime(RealTimeFlags::ResetOnFork);
 
     VirtualKeyboard::create(this);
     createBackend();
     TabletModeManager::create(this);
 }
 
 void ApplicationWayland::createBackend()
 {
     connect(platform(), &Platform::screensQueried, this, &ApplicationWayland::continueStartupWithScreens);
     connect(platform(), &Platform::initFailed, this,
         [] () {
             std::cerr <<  "FATAL ERROR: backend failed to initialize, exiting now" << std::endl;
             QCoreApplication::exit(1);
         }
     );
     platform()->init();
 }
 
 void ApplicationWayland::continueStartupWithScreens()
 {
     disconnect(kwinApp()->platform(), &Platform::screensQueried, this, &ApplicationWayland::continueStartupWithScreens);
     createScreens();
     WaylandCompositor::create();
     connect(Compositor::self(), &Compositor::sceneCreated, this, &ApplicationWayland::continueStartupWithScene);
 }
 
 void ApplicationWayland::finalizeStartup()
 {
     if (m_xwayland) {
         disconnect(m_xwayland, &Xwl::Xwayland::initialized, this, &ApplicationWayland::finalizeStartup);
     }
     startSession();
     createWorkspace();
 }
 
 void ApplicationWayland::continueStartupWithScene()
 {
     disconnect(Compositor::self(), &Compositor::sceneCreated, this, &ApplicationWayland::continueStartupWithScene);
 
     if (operationMode() == OperationModeWaylandOnly) {
         finalizeStartup();
         return;
     }
 
     m_xwayland = new Xwl::Xwayland(this);
     connect(m_xwayland, &Xwl::Xwayland::criticalError, this, [](int code) {
         // we currently exit on Xwayland errors always directly
         // TODO: restart Xwayland
         std::cerr << "Xwayland had a critical error. Going to exit now." << std::endl;
         exit(code);
     });
     connect(m_xwayland, &Xwl::Xwayland::initialized, this, &ApplicationWayland::finalizeStartup);
     m_xwayland->init();
 }
 
 void ApplicationWayland::startSession()
 {
     if (!m_inputMethodServerToStart.isEmpty()) {
         QStringList arguments = KShell::splitArgs(m_inputMethodServerToStart);
         if (!arguments.isEmpty()) {
             QString program = arguments.takeFirst();
             int socket = dup(waylandServer()->createInputMethodConnection());
             if (socket >= 0) {
                 QProcessEnvironment environment = processStartupEnvironment();
                 environment.insert(QStringLiteral("WAYLAND_SOCKET"), QByteArray::number(socket));
                 environment.insert(QStringLiteral("QT_QPA_PLATFORM"), QStringLiteral("wayland"));
                 environment.remove("DISPLAY");
                 environment.remove("WAYLAND_DISPLAY");
                 QProcess *p = new Process(this);
                 p->setProcessChannelMode(QProcess::ForwardedErrorChannel);
                 connect(p, qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this,
                     [p] {
                         if (waylandServer()) {
                             waylandServer()->destroyInputMethodConnection();
                         }
                         p->deleteLater();
                     }
                 );
                 p->setProcessEnvironment(environment);
                 p->setProgram(program);
                 p->setArguments(arguments);
                 p->start();
                 p->waitForStarted(); //do we really need to wait?
             }
         } else {
             qWarning("Failed to launch the input method server: %s is an invalid command",
                      qPrintable(m_inputMethodServerToStart));
         }
     }
 
     // start session
     if (!m_sessionArgument.isEmpty()) {
         QStringList arguments = KShell::splitArgs(m_sessionArgument);
         if (!arguments.isEmpty()) {
             QString program = arguments.takeFirst();
             QProcess *p = new Process(this);
             p->setProcessChannelMode(QProcess::ForwardedErrorChannel);
             p->setProcessEnvironment(processStartupEnvironment());
             connect(p, qOverload<int, QProcess::ExitStatus>(&QProcess::finished), this, [p] (int code, QProcess::ExitStatus status) {
                 p->deleteLater();
                 if (status == QProcess::CrashExit) {
                     qWarning() << "Session process has crashed";
                     QCoreApplication::exit(-1);
                     return;
                 }
 
                 if (code) {
                     qWarning() << "Session process exited with code" << code;
                 }
 
                 QCoreApplication::exit(code);
             });
             p->setProgram(program);
             p->setArguments(arguments);
             p->start();
         } else {
             qWarning("Failed to launch the session process: %s is an invalid command",
                      qPrintable(m_sessionArgument));
         }
     }
     // start the applications passed to us as command line arguments
     if (!m_applicationsToStart.isEmpty()) {
         for (const QString &application: m_applicationsToStart) {
             QStringList arguments = KShell::splitArgs(application);
             if (arguments.isEmpty()) {
                 qWarning("Failed to launch application: %s is an invalid command",
                          qPrintable(application));
                 continue;
             }
             QString program = arguments.takeFirst();
             // note: this will kill the started process when we exit
             // this is going to happen anyway as we are the wayland and X server the app connects to
             QProcess *p = new Process(this);
             p->setProcessChannelMode(QProcess::ForwardedErrorChannel);
             p->setProcessEnvironment(processStartupEnvironment());
             p->setProgram(program);
             p->setArguments(arguments);
             p->startDetached();
             p->deleteLater();
         }
     }
 }
 
 static const QString s_waylandPlugin = QStringLiteral("KWinWaylandWaylandBackend");
 static const QString s_x11Plugin = QStringLiteral("KWinWaylandX11Backend");
 static const QString s_fbdevPlugin = QStringLiteral("KWinWaylandFbdevBackend");
 #if HAVE_DRM
 static const QString s_drmPlugin = QStringLiteral("KWinWaylandDrmBackend");
 #endif
 #if HAVE_LIBHYBRIS
 static const QString s_hwcomposerPlugin = QStringLiteral("KWinWaylandHwcomposerBackend");
 #endif
 static const QString s_virtualPlugin = QStringLiteral("KWinWaylandVirtualBackend");
 
 static QString automaticBackendSelection()
 {
     if (qEnvironmentVariableIsSet("WAYLAND_DISPLAY")) {
         return s_waylandPlugin;
     }
     if (qEnvironmentVariableIsSet("DISPLAY")) {
         return s_x11Plugin;
     }
 #if HAVE_LIBHYBRIS
     if (qEnvironmentVariableIsSet("ANDROID_ROOT")) {
         return s_hwcomposerPlugin;
     }
 #endif
 #if HAVE_DRM
     return s_drmPlugin;
 #endif
     return s_fbdevPlugin;
 }
 
 static void disablePtrace()
 {
 #if HAVE_PR_SET_DUMPABLE
     // check whether we are running under a debugger
     const QFileInfo parent(QStringLiteral("/proc/%1/exe").arg(getppid()));
     if (parent.isSymLink() &&
             (parent.symLinkTarget().endsWith(QLatin1String("/gdb")) ||
              parent.symLinkTarget().endsWith(QLatin1String("/gdbserver")) ||
              parent.symLinkTarget().endsWith(QLatin1String("/lldb-server")))) {
         // debugger, don't adjust
         return;
     }
 
     // disable ptrace in kwin_wayland
     prctl(PR_SET_DUMPABLE, 0);
 #endif
 #if HAVE_PROC_TRACE_CTL
     // FreeBSD's rudimentary procfs does not support /proc/<pid>/exe
     // We could use the P_TRACED flag of the process to find out
     // if the process is being debugged ond FreeBSD.
     int mode = PROC_TRACE_CTL_DISABLE;
     procctl(P_PID, getpid(), PROC_TRACE_CTL, &mode);
 #endif
 
 }
 
 static void unsetDumpable(int sig)
 {
 #if HAVE_PR_SET_DUMPABLE
     prctl(PR_SET_DUMPABLE, 1);
 #endif
     signal(sig, SIG_IGN);
     raise(sig);
     return;
 }
 
 void dropNiceCapability()
 {
 #if HAVE_LIBCAP
     cap_t caps = cap_get_proc();
     if (!caps) {
         return;
     }
     cap_value_t capList[] = { CAP_SYS_NICE };
     if (cap_set_flag(caps, CAP_PERMITTED, 1, capList, CAP_CLEAR) == -1) {
         cap_free(caps);
         return;
     }
     if (cap_set_flag(caps, CAP_EFFECTIVE, 1, capList, CAP_CLEAR) == -1) {
         cap_free(caps);
         return;
     }
     cap_set_proc(caps);
     cap_free(caps);
 #endif
 }
 
 } // namespace
 
 int main(int argc, char * argv[])
 {
     if (getuid() == 0) {
         std::cerr << "kwin_wayland does not support running as root." << std::endl;
         return 1;
     }
     KWin::disablePtrace();
     KWin::Application::setupMalloc();
     KWin::Application::setupLocalizedString();
     KWin::gainRealTime();
     KWin::dropNiceCapability();
 
     if (signal(SIGTERM, KWin::sighandler) == SIG_IGN)
         signal(SIGTERM, SIG_IGN);
     if (signal(SIGINT, KWin::sighandler) == SIG_IGN)
         signal(SIGINT, SIG_IGN);
     if (signal(SIGHUP, KWin::sighandler) == SIG_IGN)
         signal(SIGHUP, SIG_IGN);
     signal(SIGABRT, KWin::unsetDumpable);
     signal(SIGSEGV, KWin::unsetDumpable);
     signal(SIGPIPE, SIG_IGN);
     // ensure that no thread takes SIGUSR
     sigset_t userSignals;
     sigemptyset(&userSignals);
     sigaddset(&userSignals, SIGUSR1);
     sigaddset(&userSignals, SIGUSR2);
     pthread_sigmask(SIG_BLOCK, &userSignals, nullptr);
 
     QProcessEnvironment environment = QProcessEnvironment::systemEnvironment();
 
     // enforce our internal qpa plugin, unfortunately command line switch has precedence
     setenv("QT_QPA_PLATFORM", "wayland-org.kde.kwin.qpa", true);
 
     qunsetenv("QT_DEVICE_PIXEL_RATIO");
     qputenv("QT_IM_MODULE", "qtvirtualkeyboard");
     qputenv("QSG_RENDER_LOOP", "basic");
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
     KWin::ApplicationWayland a(argc, argv);
     a.setupTranslator();
     // reset QT_QPA_PLATFORM to a sane value for any processes started from KWin
     setenv("QT_QPA_PLATFORM", "wayland", true);
 
     KWin::Application::createAboutData();
     KQuickAddons::QtQuickSettings::init();
 
     const auto availablePlugins = KPluginLoader::findPlugins(QStringLiteral("org.kde.kwin.waylandbackends"));
     auto hasPlugin = [&availablePlugins] (const QString &name) {
         return std::any_of(availablePlugins.begin(), availablePlugins.end(),
             [name] (const KPluginMetaData &plugin) {
                 return plugin.pluginId() == name;
             }
         );
     };
     const bool hasSizeOption = hasPlugin(KWin::s_x11Plugin) || hasPlugin(KWin::s_virtualPlugin);
     const bool hasOutputCountOption = hasPlugin(KWin::s_x11Plugin);
     const bool hasX11Option = hasPlugin(KWin::s_x11Plugin);
     const bool hasVirtualOption = hasPlugin(KWin::s_virtualPlugin);
     const bool hasWaylandOption = hasPlugin(KWin::s_waylandPlugin);
     const bool hasFramebufferOption = hasPlugin(KWin::s_fbdevPlugin);
 #if HAVE_DRM
     const bool hasDrmOption = hasPlugin(KWin::s_drmPlugin);
 #endif
 #if HAVE_LIBHYBRIS
     const bool hasHwcomposerOption = hasPlugin(KWin::s_hwcomposerPlugin);
 #endif
 
     QCommandLineOption xwaylandOption(QStringLiteral("xwayland"),
                                       i18n("Start a rootless Xwayland server."));
     QCommandLineOption waylandSocketOption(QStringList{QStringLiteral("s"), QStringLiteral("socket")},
                                            i18n("Name of the Wayland socket to listen on. If not set \"wayland-0\" is used."),
                                            QStringLiteral("socket"));
     QCommandLineOption framebufferOption(QStringLiteral("framebuffer"),
                                          i18n("Render to framebuffer."));
     QCommandLineOption framebufferDeviceOption(QStringLiteral("fb-device"),
                                                i18n("The framebuffer device to render to."),
                                                QStringLiteral("fbdev"));
     QCommandLineOption x11DisplayOption(QStringLiteral("x11-display"),
                                         i18n("The X11 Display to use in windowed mode on platform X11."),
                                         QStringLiteral("display"));
     QCommandLineOption waylandDisplayOption(QStringLiteral("wayland-display"),
                                             i18n("The Wayland Display to use in windowed mode on platform Wayland."),
                                             QStringLiteral("display"));
     QCommandLineOption virtualFbOption(QStringLiteral("virtual"), i18n("Render to a virtual framebuffer."));
     QCommandLineOption widthOption(QStringLiteral("width"),
                                    i18n("The width for windowed mode. Default width is 1024."),
                                    QStringLiteral("width"));
     widthOption.setDefaultValue(QString::number(1024));
     QCommandLineOption heightOption(QStringLiteral("height"),
                                     i18n("The height for windowed mode. Default height is 768."),
                                     QStringLiteral("height"));
     heightOption.setDefaultValue(QString::number(768));
 
     QCommandLineOption scaleOption(QStringLiteral("scale"),
                                     i18n("The scale for windowed mode. Default value is 1."),
                                     QStringLiteral("scale"));
     scaleOption.setDefaultValue(QString::number(1));
 
     QCommandLineOption outputCountOption(QStringLiteral("output-count"),
                                     i18n("The number of windows to open as outputs in windowed mode. Default value is 1"),
                                     QStringLiteral("count"));
     outputCountOption.setDefaultValue(QString::number(1));
 
     QCommandLineParser parser;
     a.setupCommandLine(&parser);
     parser.addOption(xwaylandOption);
     parser.addOption(waylandSocketOption);
     if (hasX11Option) {
         parser.addOption(x11DisplayOption);
     }
     if (hasWaylandOption) {
         parser.addOption(waylandDisplayOption);
     }
     if (hasFramebufferOption) {
         parser.addOption(framebufferOption);
         parser.addOption(framebufferDeviceOption);
     }
     if (hasVirtualOption) {
         parser.addOption(virtualFbOption);
     }
     if (hasSizeOption) {
         parser.addOption(widthOption);
         parser.addOption(heightOption);
         parser.addOption(scaleOption);
     }
     if (hasOutputCountOption) {
         parser.addOption(outputCountOption);
     }
 #if HAVE_LIBHYBRIS
     QCommandLineOption hwcomposerOption(QStringLiteral("hwcomposer"), i18n("Use libhybris hwcomposer"));
     if (hasHwcomposerOption) {
         parser.addOption(hwcomposerOption);
     }
 #endif
     QCommandLineOption libinputOption(QStringLiteral("libinput"),
                                       i18n("Enable libinput support for input events processing. Note: never use in a nested session."));
     parser.addOption(libinputOption);
 #if HAVE_DRM
     QCommandLineOption drmOption(QStringLiteral("drm"), i18n("Render through drm node."));
     if (hasDrmOption) {
         parser.addOption(drmOption);
     }
 #endif
 
     QCommandLineOption inputMethodOption(QStringLiteral("inputmethod"),
                                          i18n("Input method that KWin starts."),
                                          QStringLiteral("path/to/imserver"));
     parser.addOption(inputMethodOption);
 
     QCommandLineOption listBackendsOption(QStringLiteral("list-backends"),
                                            i18n("List all available backends and quit."));
     parser.addOption(listBackendsOption);
 
     QCommandLineOption screenLockerOption(QStringLiteral("lockscreen"),
                                           i18n("Starts the session in locked mode."));
     parser.addOption(screenLockerOption);
 
     QCommandLineOption noScreenLockerOption(QStringLiteral("no-lockscreen"),
                                             i18n("Starts the session without lock screen support."));
     parser.addOption(noScreenLockerOption);
 
     QCommandLineOption noGlobalShortcutsOption(QStringLiteral("no-global-shortcuts"),
                                                i18n("Starts the session without global shortcuts support."));
     parser.addOption(noGlobalShortcutsOption);
 
     QCommandLineOption exitWithSessionOption(QStringLiteral("exit-with-session"),
                                              i18n("Exit after the session application, which is started by KWin, closed."),
                                              QStringLiteral("/path/to/session"));
     parser.addOption(exitWithSessionOption);
 
     parser.addPositionalArgument(QStringLiteral("applications"),
                                  i18n("Applications to start once Wayland and Xwayland server are started"),
                                  QStringLiteral("[/path/to/application...]"));
 
     parser.process(a);
     a.processCommandLine(&parser);
 
 #ifdef KWIN_BUILD_ACTIVITIES
     a.setUseKActivities(false);
 #endif
 
     if (parser.isSet(listBackendsOption)) {
         for (const auto &plugin: availablePlugins) {
             std::cout << std::setw(40) << std::left << qPrintable(plugin.name()) << qPrintable(plugin.description()) << std::endl;
         }
         return 0;
     }
 
     if (parser.isSet(exitWithSessionOption)) {
         a.setSessionArgument(parser.value(exitWithSessionOption));
     }
 
     KWin::Application::setUseLibinput(parser.isSet(libinputOption));
 
     QString pluginName;
     QSize initialWindowSize;
     QByteArray deviceIdentifier;
     int outputCount = 1;
     qreal outputScale = 1;
 
 #if HAVE_DRM
     if (hasDrmOption && parser.isSet(drmOption)) {
         pluginName = KWin::s_drmPlugin;
     }
 #endif
 
     if (hasSizeOption) {
         bool ok = false;
         const int width = parser.value(widthOption).toInt(&ok);
         if (!ok) {
             std::cerr << "FATAL ERROR incorrect value for width" << std::endl;
             return 1;
         }
         const int height = parser.value(heightOption).toInt(&ok);
         if (!ok) {
             std::cerr << "FATAL ERROR incorrect value for height" << std::endl;
             return 1;
         }
         const qreal scale = parser.value(scaleOption).toDouble(&ok);
         if (!ok || scale < 1) {
             std::cerr << "FATAL ERROR incorrect value for scale" << std::endl;
             return 1;
         }
 
         outputScale = scale;
         initialWindowSize = QSize(width, height);
     }
 
     if (hasOutputCountOption) {
         bool ok = false;
         const int count = parser.value(outputCountOption).toInt(&ok);
         if (ok) {
             outputCount = qMax(1, count);
         }
     }
 
     if (hasX11Option && parser.isSet(x11DisplayOption)) {
         deviceIdentifier = parser.value(x11DisplayOption).toUtf8();
         pluginName = KWin::s_x11Plugin;
     } else if (hasWaylandOption && parser.isSet(waylandDisplayOption)) {
         deviceIdentifier = parser.value(waylandDisplayOption).toUtf8();
         pluginName = KWin::s_waylandPlugin;
     }
 
     if (hasFramebufferOption && parser.isSet(framebufferOption)) {
         pluginName = KWin::s_fbdevPlugin;
         deviceIdentifier = parser.value(framebufferDeviceOption).toUtf8();
     }
 #if HAVE_LIBHYBRIS
     if (hasHwcomposerOption && parser.isSet(hwcomposerOption)) {
         pluginName = KWin::s_hwcomposerPlugin;
     }
 #endif
     if (hasVirtualOption && parser.isSet(virtualFbOption)) {
         pluginName = KWin::s_virtualPlugin;
     }
 
     if (pluginName.isEmpty()) {
         std::cerr << "No backend specified through command line argument, trying auto resolution" << std::endl;
         pluginName = KWin::automaticBackendSelection();
     }
 
     auto pluginIt = std::find_if(availablePlugins.begin(), availablePlugins.end(),
         [&pluginName] (const KPluginMetaData &plugin) {
             return plugin.pluginId() == pluginName;
         }
     );
     if (pluginIt == availablePlugins.end()) {
         std::cerr << "FATAL ERROR: could not find a backend" << std::endl;
         return 1;
     }
 
     // TODO: create backend without having the server running
     KWin::WaylandServer *server = KWin::WaylandServer::create(&a);
 
     KWin::WaylandServer::InitializationFlags flags;
     if (parser.isSet(screenLockerOption)) {
         flags = KWin::WaylandServer::InitializationFlag::LockScreen;
     } else if (parser.isSet(noScreenLockerOption)) {
         flags = KWin::WaylandServer::InitializationFlag::NoLockScreenIntegration;
     }
     if (parser.isSet(noGlobalShortcutsOption)) {
         flags |= KWin::WaylandServer::InitializationFlag::NoGlobalShortcuts;
     }
     if (!server->init(parser.value(waylandSocketOption).toUtf8(), flags)) {
         std::cerr << "FATAL ERROR: could not create Wayland server" << std::endl;
         return 1;
     }
 
     a.initPlatform(*pluginIt);
     if (!a.platform()) {
         std::cerr << "FATAL ERROR: could not instantiate a backend" << std::endl;
         return 1;
     }
     if (!deviceIdentifier.isEmpty()) {
         a.platform()->setDeviceIdentifier(deviceIdentifier);
     }
     if (initialWindowSize.isValid()) {
         a.platform()->setInitialWindowSize(initialWindowSize);
     }
     a.platform()->setInitialOutputScale(outputScale);
     a.platform()->setInitialOutputCount(outputCount);
 
     QObject::connect(&a, &KWin::Application::workspaceCreated, server, &KWin::WaylandServer::initWorkspace);
     environment.insert(QStringLiteral("WAYLAND_DISPLAY"), server->display()->socketName());
     a.setProcessStartupEnvironment(environment);
     a.setStartXwayland(parser.isSet(xwaylandOption));
     a.setApplicationsToStart(parser.positionalArguments());
     a.setInputMethodServerToStart(parser.value(inputMethodOption));
     a.start();
 
     return a.exec();
 }
diff --git a/platform.cpp b/platform.cpp
index 3b53108bc..945dda128 100644
--- a/platform.cpp
+++ b/platform.cpp
@@ -1,572 +1,572 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "platform.h"
 
 #include "abstract_output.h"
 #include <config-kwin.h>
 #include "composite.h"
 #include "cursor.h"
 #include "effects.h"
 #include <KCoreAddons>
 #include "overlaywindow.h"
 #include "outline.h"
 #include "pointer_input.h"
 #include "scene.h"
 #include "screens.h"
 #include "screenedge.h"
 #include "wayland_server.h"
 #include "colorcorrection/manager.h"
 
-#include <KWayland/Server/outputconfiguration_interface.h>
-#include <KWayland/Server/outputchangeset.h>
+#include <KWaylandServer/outputconfiguration_interface.h>
+#include <KWaylandServer/outputchangeset.h>
 
 #include <QX11Info>
 
 #include <cerrno>
 
 namespace KWin
 {
 
 Platform::Platform(QObject *parent)
     : QObject(parent)
     , m_eglDisplay(EGL_NO_DISPLAY)
 {
     setSoftWareCursor(false);
     m_colorCorrect = new ColorCorrect::Manager(this);
     connect(Cursors::self(), &Cursors::currentCursorRendered, this, &Platform::cursorRendered);
 }
 
 Platform::~Platform()
 {
     if (m_eglDisplay != EGL_NO_DISPLAY) {
         eglTerminate(m_eglDisplay);
     }
 }
 
 PlatformCursorImage Platform::cursorImage() const
 {
     Cursor* cursor = Cursors::self()->currentCursor();
     return PlatformCursorImage(cursor->image(), cursor->hotspot());
 }
 
 void Platform::hideCursor()
 {
     m_hideCursorCounter++;
     if (m_hideCursorCounter == 1) {
         doHideCursor();
     }
 }
 
 void Platform::doHideCursor()
 {
 }
 
 void Platform::showCursor()
 {
     m_hideCursorCounter--;
     if (m_hideCursorCounter == 0) {
         doShowCursor();
     }
 }
 
 void Platform::doShowCursor()
 {
 }
 
 Screens *Platform::createScreens(QObject *parent)
 {
     Q_UNUSED(parent)
     return nullptr;
 }
 
 OpenGLBackend *Platform::createOpenGLBackend()
 {
     return nullptr;
 }
 
 QPainterBackend *Platform::createQPainterBackend()
 {
     return nullptr;
 }
 
 void Platform::prepareShutdown()
 {
     setOutputsEnabled(false);
 }
 
 Edge *Platform::createScreenEdge(ScreenEdges *edges)
 {
     return new Edge(edges);
 }
 
 void Platform::createPlatformCursor(QObject *parent)
 {
     new InputRedirectionCursor(parent);
 }
 
-void Platform::requestOutputsChange(KWayland::Server::OutputConfigurationInterface *config)
+void Platform::requestOutputsChange(KWaylandServer::OutputConfigurationInterface *config)
 {
     if (!m_supportsOutputChanges) {
         qCWarning(KWIN_CORE) << "This backend does not support configuration changes.";
         config->setFailed();
         return;
     }
 
-    using Enablement = KWayland::Server::OutputDeviceInterface::Enablement;
+    using Enablement = KWaylandServer::OutputDeviceInterface::Enablement;
 
     const auto changes = config->changes();
 
     //process all non-disabling changes
     for (auto it = changes.begin(); it != changes.end(); it++) {
-        const KWayland::Server::OutputChangeSet *changeset = it.value();
+        const KWaylandServer::OutputChangeSet *changeset = it.value();
 
         auto output = findOutput(it.key()->uuid());
         if (!output) {
             qCWarning(KWIN_CORE) << "Could NOT find output matching " << it.key()->uuid();
             continue;
         }
 
         if (changeset->enabledChanged() &&
                 changeset->enabled() == Enablement::Enabled) {
             output->setEnabled(true);
         }
         output->applyChanges(changeset);
     }
 
     //process any disable requests
     for (auto it = changes.begin(); it != changes.end(); it++) {
-        const KWayland::Server::OutputChangeSet *changeset = it.value();
+        const KWaylandServer::OutputChangeSet *changeset = it.value();
 
         if (changeset->enabledChanged() &&
                 changeset->enabled() == Enablement::Disabled) {
             if (enabledOutputs().count() == 1) {
                 // TODO: check beforehand this condition and set failed otherwise
                 // TODO: instead create a dummy output?
                 qCWarning(KWIN_CORE) << "Not disabling final screen" << it.key()->uuid();
                 continue;
             }
             auto output = findOutput(it.key()->uuid());
             if (!output) {
                 qCWarning(KWIN_CORE) << "Could NOT find output matching " << it.key()->uuid();
                 continue;
             }
             output->setEnabled(false);
         }
     }
     emit screens()->changed();
     config->setApplied();
 }
 
 AbstractOutput *Platform::findOutput(const QByteArray &uuid)
 {
     const auto outs = outputs();
     auto it = std::find_if(outs.constBegin(), outs.constEnd(),
         [uuid](AbstractOutput *output) {
             return output->uuid() == uuid; }
     );
     if (it != outs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 void Platform::setSoftWareCursor(bool set)
 {
     if (qEnvironmentVariableIsSet("KWIN_FORCE_SW_CURSOR")) {
         set = true;
     }
     if (m_softWareCursor == set) {
         return;
     }
     m_softWareCursor = set;
     if (m_softWareCursor) {
         connect(Cursors::self(), &Cursors::positionChanged, this, &Platform::triggerCursorRepaint);
         connect(Cursors::self(), &Cursors::currentCursorChanged, this, &Platform::triggerCursorRepaint);
     } else {
         disconnect(Cursors::self(), &Cursors::positionChanged, this, &Platform::triggerCursorRepaint);
         disconnect(Cursors::self(), &Cursors::currentCursorChanged, this, &Platform::triggerCursorRepaint);
     }
 }
 
 void Platform::triggerCursorRepaint()
 {
     if (!Compositor::self()) {
         return;
     }
     Compositor::self()->addRepaint(m_cursor.lastRenderedGeometry);
     Compositor::self()->addRepaint(Cursors::self()->currentCursor()->geometry());
 }
 
 void Platform::cursorRendered(const QRect &geometry)
 {
     if (m_softWareCursor) {
         m_cursor.lastRenderedGeometry = geometry;
     }
 }
 
 void Platform::keyboardKeyPressed(quint32 key, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardKey(key, InputRedirection::KeyboardKeyPressed, time);
 }
 
 void Platform::keyboardKeyReleased(quint32 key, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardKey(key, InputRedirection::KeyboardKeyReleased, time);
 }
 
 void Platform::keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     if (!input()) {
         return;
     }
     input()->processKeyboardModifiers(modsDepressed, modsLatched, modsLocked, group);
 }
 
 void Platform::keymapChange(int fd, uint32_t size)
 {
     if (!input()) {
         return;
     }
     input()->processKeymapChange(fd, size);
 }
 
 void Platform::pointerAxisHorizontal(qreal delta, quint32 time, qint32 discreteDelta, InputRedirection::PointerAxisSource source)
 {
     if (!input()) {
         return;
     }
     input()->processPointerAxis(InputRedirection::PointerAxisHorizontal, delta, discreteDelta, source, time);
 }
 
 void Platform::pointerAxisVertical(qreal delta, quint32 time, qint32 discreteDelta, InputRedirection::PointerAxisSource source)
 {
     if (!input()) {
         return;
     }
     input()->processPointerAxis(InputRedirection::PointerAxisVertical, delta, discreteDelta, source, time);
 }
 
 void Platform::pointerButtonPressed(quint32 button, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerButton(button, InputRedirection::PointerButtonPressed, time);
 }
 
 void Platform::pointerButtonReleased(quint32 button, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerButton(button, InputRedirection::PointerButtonReleased, time);
 }
 
 void Platform::pointerMotion(const QPointF &position, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processPointerMotion(position, time);
 }
 
 void Platform::touchCancel()
 {
     if (!input()) {
         return;
     }
     input()->cancelTouch();
 }
 
 void Platform::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchDown(id, pos, time);
 }
 
 void Platform::touchFrame()
 {
     if (!input()) {
         return;
     }
     input()->touchFrame();
 }
 
 void Platform::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchMotion(id, pos, time);
 }
 
 void Platform::touchUp(qint32 id, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->processTouchUp(id, time);
 }
 
 void Platform::processSwipeGestureBegin(int fingerCount, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureBegin(fingerCount, time);
 }
 
 void Platform::processSwipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureUpdate(delta, time);
 }
 
 void Platform::processSwipeGestureEnd(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureEnd(time);
 }
 
 void Platform::processSwipeGestureCancelled(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processSwipeGestureCancelled(time);
 }
 
 void Platform::processPinchGestureBegin(int fingerCount, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureBegin(fingerCount, time);
 }
 
 void Platform::processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureUpdate(scale, angleDelta, delta, time);
 }
 
 void Platform::processPinchGestureEnd(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureEnd(time);
 }
 
 void Platform::processPinchGestureCancelled(quint32 time)
 {
     if (!input()) {
         return;
     }
     input()->pointer()->processPinchGestureCancelled(time);
 }
 
 void Platform::repaint(const QRect &rect)
 {
     if (!Compositor::self()) {
         return;
     }
     Compositor::self()->addRepaint(rect);
 }
 
 void Platform::setReady(bool ready)
 {
     if (m_ready == ready) {
         return;
     }
     m_ready = ready;
     emit readyChanged(m_ready);
 }
 
 void Platform::warpPointer(const QPointF &globalPos)
 {
     Q_UNUSED(globalPos)
 }
 
 bool Platform::supportsQpaContext() const
 {
     if (Compositor *c = Compositor::self()) {
         return c->scene()->openGLPlatformInterfaceExtensions().contains(QByteArrayLiteral("EGL_KHR_surfaceless_context"));
     }
     return false;
 }
 
 EGLDisplay KWin::Platform::sceneEglDisplay() const
 {
     return m_eglDisplay;
 }
 
 void Platform::setSceneEglDisplay(EGLDisplay display)
 {
     m_eglDisplay = display;
 }
 
 QSize Platform::screenSize() const
 {
     return QSize();
 }
 
 QVector<QRect> Platform::screenGeometries() const
 {
     return QVector<QRect>({QRect(QPoint(0, 0), screenSize())});
 }
 
 QVector<qreal> Platform::screenScales() const
 {
     return QVector<qreal>({1});
 }
 
 bool Platform::requiresCompositing() const
 {
     return true;
 }
 
 bool Platform::compositingPossible() const
 {
     return true;
 }
 
 QString Platform::compositingNotPossibleReason() const
 {
     return QString();
 }
 
 bool Platform::openGLCompositingIsBroken() const
 {
     return false;
 }
 
 void Platform::createOpenGLSafePoint(OpenGLSafePoint safePoint)
 {
     Q_UNUSED(safePoint)
 }
 
 void Platform::startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName)
 {
     if (!input()) {
         callback(nullptr);
         return;
     }
     input()->startInteractiveWindowSelection(callback, cursorName);
 }
 
 void Platform::startInteractivePositionSelection(std::function<void(const QPoint &)> callback)
 {
     if (!input()) {
         callback(QPoint(-1, -1));
         return;
     }
     input()->startInteractivePositionSelection(callback);
 }
 
 void Platform::setupActionForGlobalAccel(QAction *action)
 {
     Q_UNUSED(action)
 }
 
 OverlayWindow *Platform::createOverlayWindow()
 {
     return nullptr;
 }
 
 static quint32 monotonicTime()
 {
     timespec ts;
 
     const int result = clock_gettime(CLOCK_MONOTONIC, &ts);
     if (result)
         qCWarning(KWIN_CORE, "Failed to query monotonic time: %s", strerror(errno));
 
     return ts.tv_sec * 1000 + ts.tv_nsec / 1000000L;
 }
 
 void Platform::updateXTime()
 {
     switch (kwinApp()->operationMode()) {
     case Application::OperationModeX11:
         kwinApp()->setX11Time(QX11Info::getTimestamp(), Application::TimestampUpdate::Always);
         break;
 
     case Application::OperationModeXwayland:
         kwinApp()->setX11Time(monotonicTime(), Application::TimestampUpdate::Always);
         break;
 
     default:
         // Do not update the current X11 time stamp if it's the Wayland only session.
         break;
     }
 }
 
 OutlineVisual *Platform::createOutline(Outline *outline)
 {
     if (Compositor::compositing()) {
        return new CompositedOutlineVisual(outline);
     }
     return nullptr;
 }
 
 Decoration::Renderer *Platform::createDecorationRenderer(Decoration::DecoratedClientImpl *client)
 {
     if (Compositor::self()->scene()) {
         return Compositor::self()->scene()->createDecorationRenderer(client);
     }
     return nullptr;
 }
 
 void Platform::invertScreen()
 {
     if (effects) {
         if (Effect *inverter = static_cast<EffectsHandlerImpl*>(effects)->provides(Effect::ScreenInversion)) {
             qCDebug(KWIN_CORE) << "inverting screen using Effect plugin";
             QMetaObject::invokeMethod(inverter, "toggleScreenInversion", Qt::DirectConnection);
         }
     }
 }
 
 void Platform::createEffectsHandler(Compositor *compositor, Scene *scene)
 {
     new EffectsHandlerImpl(compositor, scene);
 }
 
 QString Platform::supportInformation() const
 {
     return QStringLiteral("Name: %1\n").arg(metaObject()->className());
 }
 
 }
diff --git a/platform.h b/platform.h
index 35d708fcb..faf4f8315 100644
--- a/platform.h
+++ b/platform.h
@@ -1,567 +1,565 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_PLATFORM_H
 #define KWIN_PLATFORM_H
 #include <kwin_export.h>
 #include <kwinglobals.h>
 #include <epoxy/egl.h>
 #include <fixx11h.h>
 #include "fixqopengl.h"
 #include "input.h"
 
 #include <QImage>
 #include <QObject>
 
 #include <functional>
 
 class QAction;
 
-namespace KWayland {
-    namespace Server {
-        class OutputConfigurationInterface;
-    }
+namespace KWaylandServer {
+class OutputConfigurationInterface;
 }
 
 namespace KWin
 {
 namespace ColorCorrect {
 class Manager;
 }
 
 class AbstractOutput;
 class Edge;
 class Compositor;
 class OverlayWindow;
 class OpenGLBackend;
 class Outline;
 class OutlineVisual;
 class QPainterBackend;
 class Scene;
 class Screens;
 class ScreenEdges;
 class Toplevel;
 class WaylandCursorTheme;
 
 namespace Decoration
 {
 class Renderer;
 class DecoratedClientImpl;
 }
 
 class KWIN_EXPORT Outputs : public QVector<AbstractOutput*>
 {
 public:
     Outputs(){};
     template <typename T>
     Outputs(const QVector<T> &other) {
         resize(other.size());
         std::copy(other.constBegin(), other.constEnd(), begin());
     }
 };
 
 class KWIN_EXPORT Platform : public QObject
 {
     Q_OBJECT
 public:
     ~Platform() override;
 
     virtual void init() = 0;
     virtual Screens *createScreens(QObject *parent = nullptr);
     virtual OpenGLBackend *createOpenGLBackend();
     virtual QPainterBackend *createQPainterBackend();
 
     /**
      * Informs the Platform that it is about to go down and shall do appropriate cleanup.
      * Child classes can override this function but must call the parent implementation in
      * the end.
      */
     virtual void prepareShutdown();
 
     /**
      * Allows the platform to create a platform specific screen edge.
      * The default implementation creates a Edge.
      */
     virtual Edge *createScreenEdge(ScreenEdges *parent);
     /**
      * Allows the platform to create a platform specific Cursor.
      * The default implementation creates an InputRedirectionCursor.
      */
     virtual void createPlatformCursor(QObject *parent = nullptr);
     virtual void warpPointer(const QPointF &globalPos);
     /**
      * Whether our Compositing EGL display allows a surface less context
      * so that a sharing context could be created.
      */
     virtual bool supportsQpaContext() const;
     /**
      * The EGLDisplay used by the compositing scene.
      */
     EGLDisplay sceneEglDisplay() const;
     void setSceneEglDisplay(EGLDisplay display);
     /**
      * The EGLContext used by the compositing scene.
      */
     virtual EGLContext sceneEglContext() const {
         return m_context;
     }
     /**
      * Sets the @p context used by the compositing scene.
      */
     void setSceneEglContext(EGLContext context) {
         m_context = context;
     }
     /**
      * The first (in case of multiple) EGLSurface used by the compositing scene.
      */
     EGLSurface sceneEglSurface() const {
         return m_surface;
     }
     /**
      * Sets the first @p surface used by the compositing scene.
      * @see sceneEglSurface
      */
     void setSceneEglSurface(EGLSurface surface) {
         m_surface = surface;
     }
 
     /**
      * The EglConfig used by the compositing scene.
      */
     EGLConfig sceneEglConfig() const {
         return m_eglConfig;
     }
     /**
      * Sets the @p config used by the compositing scene.
      * @see sceneEglConfig
      */
     void setSceneEglConfig(EGLConfig config) {
         m_eglConfig = config;
     }
 
     /**
      * Implementing subclasses should provide a size in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns an invalid size.
      */
     virtual QSize screenSize() const;
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns one QRect positioned at 0/0 with screenSize() as size.
      */
     virtual QVector<QRect> screenGeometries() const;
 
     /**
      * Implementing subclasses should provide all geometries in case the backend represents
      * a basic screen and uses the BasicScreens.
      *
      * Base implementation returns a screen with a scale of 1.
      */
     virtual QVector<qreal> screenScales() const;
     /**
      * Implement this method to receive configuration change requests through KWayland's
      * OutputManagement interface.
      *
      * Base implementation warns that the current backend does not implement this
      * functionality.
      */
-    void requestOutputsChange(KWayland::Server::OutputConfigurationInterface *config);
+    void requestOutputsChange(KWaylandServer::OutputConfigurationInterface *config);
 
     /**
      * Whether the Platform requires compositing for rendering.
      * Default implementation returns @c true. If the implementing Platform allows to be used
      * without compositing (e.g. rendering is done by the windowing system), re-implement this method.
      */
     virtual bool requiresCompositing() const;
     /**
      * Whether Compositing is possible in the Platform.
      * Returning @c false in this method makes only sense if requiresCompositing returns @c false.
      *
      * The default implementation returns @c true.
      * @see requiresCompositing
      */
     virtual bool compositingPossible() const;
     /**
      * Returns a user facing text explaining why compositing is not possible in case
      * compositingPossible returns @c false.
      *
      * The default implementation returns an empty string.
      * @see compositingPossible
      */
     virtual QString compositingNotPossibleReason() const;
     /**
      * Whether OpenGL compositing is broken.
      * The Platform can implement this method if it is able to detect whether OpenGL compositing
      * broke (e.g. triggered a crash in a previous run).
      *
      * Default implementation returns @c false.
      * @see createOpenGLSafePoint
      */
     virtual bool openGLCompositingIsBroken() const;
     enum class OpenGLSafePoint {
         PreInit,
         PostInit,
         PreFrame,
         PostFrame,
         PostLastGuardedFrame
     };
     /**
      * This method is invoked before and after creating the OpenGL rendering Scene.
      * An implementing Platform can use it to detect crashes triggered by the OpenGL implementation.
      * This can be used for openGLCompositingIsBroken.
      *
      * The default implementation does nothing.
      * @see openGLCompositingIsBroken.
      */
     virtual void createOpenGLSafePoint(OpenGLSafePoint safePoint);
 
     /**
      * Starts an interactive window selection process.
      *
      * Once the user selected a window the @p callback is invoked with the selected Toplevel as
      * argument. In case the user cancels the interactive window selection or selecting a window is currently
      * not possible (e.g. screen locked) the @p callback is invoked with a @c nullptr argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor unless
      * @p cursorName is provided. The argument @p cursorName is a QByteArray instead of Qt::CursorShape
      * to support the "pirate" cursor for kill window which is not wrapped by Qt::CursorShape.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive window selection ends
      * @param cursorName The optional name of the cursor shape to use, default is crosshair
      */
     virtual void startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName = QByteArray());
 
     /**
      * Starts an interactive position selection process.
      *
      * Once the user selected a position on the screen the @p callback is invoked with
      * the selected point as argument. In case the user cancels the interactive position selection
      * or selecting a position is currently not possible (e.g. screen locked) the @p callback
      * is invoked with a point at @c -1 as x and y argument.
      *
      * During the interactive window selection the cursor is turned into a crosshair cursor.
      *
      * The default implementation forwards to InputRedirection.
      *
      * @param callback The function to invoke once the interactive position selection ends
      */
     virtual void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
 
     /**
      * Platform specific preparation for an @p action which is used for KGlobalAccel.
      *
      * A platform might need to do preparation for an @p action before
      * it can be used with KGlobalAccel.
      *
      * Code using KGlobalAccel should invoke this method for the @p action
      * prior to setting up any shortcuts and connections.
      *
      * The default implementation does nothing.
      *
      * @param action The action which will be used with KGlobalAccel.
      * @since 5.10
      */
     virtual void setupActionForGlobalAccel(QAction *action);
 
     bool usesSoftwareCursor() const {
         return m_softWareCursor;
     }
 
     /**
      * Returns a PlatformCursorImage. By default this is created by softwareCursor and
      * softwareCursorHotspot. An implementing subclass can use this to provide a better
      * suited PlatformCursorImage.
      *
      * @see softwareCursor
      * @see softwareCursorHotspot
      * @since 5.9
      */
     virtual PlatformCursorImage cursorImage() const;
 
     /**
      * The Platform cursor image should be hidden.
      * @see showCursor
      * @see doHideCursor
      * @see isCursorHidden
      * @since 5.9
      */
     void hideCursor();
 
     /**
      * The Platform cursor image should be shown again.
      * @see hideCursor
      * @see doShowCursor
      * @see isCursorHidden
      * @since 5.9
      */
     void showCursor();
 
     /**
      * Whether the cursor is currently hidden.
      * @see showCursor
      * @see hideCursor
      * @since 5.9
      */
     bool isCursorHidden() const {
         return m_hideCursorCounter > 0;
     }
     bool isReady() const {
         return m_ready;
     }
     void setInitialWindowSize(const QSize &size) {
         m_initialWindowSize = size;
     }
     void setDeviceIdentifier(const QByteArray &identifier) {
         m_deviceIdentifier = identifier;
     }
     bool supportsPointerWarping() const {
         return m_pointerWarping;
     }
     bool areOutputsEnabled() const {
         return m_outputsEnabled;
     }
     void setOutputsEnabled(bool enabled) {
         m_outputsEnabled = enabled;
     }
     int initialOutputCount() const {
         return m_initialOutputCount;
     }
     void setInitialOutputCount(int count) {
         m_initialOutputCount = count;
     }
     qreal initialOutputScale() const {
         return m_initialOutputScale;
     }
     void setInitialOutputScale(qreal scale) {
         m_initialOutputScale = scale;
     }
 
     /**
      * Creates the OverlayWindow required for X11 based compositors.
      * Default implementation returns @c nullptr.
      */
     virtual OverlayWindow *createOverlayWindow();
 
     /**
      * Queries the current X11 time stamp of the X server.
      */
     void updateXTime();
 
     /**
      * Creates the OutlineVisual for the given @p outline.
      * Default implementation creates an OutlineVisual suited for composited usage.
      */
     virtual OutlineVisual *createOutline(Outline *outline);
 
     /**
      * Creates the Decoration::Renderer for the given @p client.
      *
      * The default implementation creates a Renderer suited for the Compositor, @c nullptr if there is no Compositor.
      */
     virtual Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *client);
 
     /**
      * Platform specific way to invert the screen.
      * Default implementation invokes the invert effect
      */
     virtual void invertScreen();
 
     /**
      * Default implementation creates an EffectsHandlerImp;
      */
     virtual void createEffectsHandler(Compositor *compositor, Scene *scene);
 
     /**
      * The CompositingTypes supported by the Platform.
      * The first item should be the most preferred one.
      * @since 5.11
      */
     virtual QVector<CompositingType> supportedCompositors() const = 0;
 
     /**
      * Whether gamma control is supported by the backend.
      * @since 5.12
      */
     bool supportsGammaControl() const {
         return m_supportsGammaControl;
     }
 
     ColorCorrect::Manager *colorCorrectManager() {
         return m_colorCorrect;
     }
 
     // outputs with connections (org_kde_kwin_outputdevice)
     virtual Outputs outputs() const {
         return Outputs();
     }
     // actively compositing outputs (wl_output)
     virtual Outputs enabledOutputs() const {
         return Outputs();
     }
     AbstractOutput *findOutput(const QByteArray &uuid);
 
     /**
      * A string of information to include in kwin debug output
      * It should not be translated.
      *
      * The base implementation prints the name.
      * @since 5.12
      */
     virtual QString supportInformation() const;
 
     /**
      * The compositor plugin which got selected from @ref supportedCompositors.
      * Prior to selecting a compositor this returns @c NoCompositing.
      *
      * This method allows the platforms to limit the offerings in @ref supportedCompositors
      * in case they do not support runtime compositor switching
      */
     CompositingType selectedCompositor() const
     {
         return m_selectedCompositor;
     }
     /**
      * Used by Compositor to set the used compositor.
      */
     void setSelectedCompositor(CompositingType type)
     {
         m_selectedCompositor = type;
     }
 
 public Q_SLOTS:
     void pointerMotion(const QPointF &position, quint32 time);
     void pointerButtonPressed(quint32 button, quint32 time);
     void pointerButtonReleased(quint32 button, quint32 time);
     void pointerAxisHorizontal(qreal delta, quint32 time, qint32 discreteDelta = 0,
         InputRedirection::PointerAxisSource source = InputRedirection::PointerAxisSourceUnknown);
     void pointerAxisVertical(qreal delta, quint32 time, qint32 discreteDelta = 0,
         InputRedirection::PointerAxisSource source = InputRedirection::PointerAxisSourceUnknown);
     void keyboardKeyPressed(quint32 key, quint32 time);
     void keyboardKeyReleased(quint32 key, quint32 time);
     void keyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     void keymapChange(int fd, uint32_t size);
     void touchDown(qint32 id, const QPointF &pos, quint32 time);
     void touchUp(qint32 id, quint32 time);
     void touchMotion(qint32 id, const QPointF &pos, quint32 time);
     void touchCancel();
     void touchFrame();
 
     void processSwipeGestureBegin(int fingerCount, quint32 time);
     void processSwipeGestureUpdate(const QSizeF &delta, quint32 time);
     void processSwipeGestureEnd(quint32 time);
     void processSwipeGestureCancelled(quint32 time);
     void processPinchGestureBegin(int fingerCount, quint32 time);
     void processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time);
     void processPinchGestureEnd(quint32 time);
     void processPinchGestureCancelled(quint32 time);
 
     void cursorRendered(const QRect &geometry);
 
 Q_SIGNALS:
     void screensQueried();
     void initFailed();
     void readyChanged(bool);
     /**
      * Emitted by backends using a one screen (nested window) approach and when the size of that changes.
      */
     void screenSizeChanged();
 
 protected:
     explicit Platform(QObject *parent = nullptr);
     void setSoftWareCursor(bool set);
     void repaint(const QRect &rect);
     void setReady(bool ready);
     QSize initialWindowSize() const {
         return m_initialWindowSize;
     }
     QByteArray deviceIdentifier() const {
         return m_deviceIdentifier;
     }
     void setSupportsPointerWarping(bool set) {
         m_pointerWarping = set;
     }
     void setSupportsGammaControl(bool set) {
         m_supportsGammaControl = set;
     }
 
     /**
      * Whether the backend is supposed to change the configuration of outputs.
      */
     void supportsOutputChanges() {
         m_supportsOutputChanges = true;
     }
 
     /**
      * Actual platform specific way to hide the cursor.
      * Sub-classes need to implement if they support hiding the cursor.
      *
      * This method is invoked by hideCursor if the cursor needs to be hidden.
      * The default implementation does nothing.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      */
     virtual void doHideCursor();
     /**
      * Actual platform specific way to show the cursor.
      * Sub-classes need to implement if they support showing the cursor.
      *
      * This method is invoked by showCursor if the cursor needs to be shown again.
      *
      * @see doShowCursor
      * @see hideCursor
      * @see showCursor
      */
     virtual void doShowCursor();
 
 private:
     void triggerCursorRepaint();
     bool m_softWareCursor = false;
     struct {
         QRect lastRenderedGeometry;
     } m_cursor;
     bool m_ready = false;
     QSize m_initialWindowSize;
     QByteArray m_deviceIdentifier;
     bool m_pointerWarping = false;
     bool m_outputsEnabled = true;
     int m_initialOutputCount = 1;
     qreal m_initialOutputScale = 1;
     EGLDisplay m_eglDisplay;
     EGLConfig m_eglConfig = nullptr;
     EGLContext m_context = EGL_NO_CONTEXT;
     EGLSurface m_surface = EGL_NO_SURFACE;
     int m_hideCursorCounter = 0;
     ColorCorrect::Manager *m_colorCorrect = nullptr;
     bool m_supportsGammaControl = false;
     bool m_supportsOutputChanges = false;
     CompositingType m_selectedCompositor = NoCompositing;
 };
 
 }
 
 Q_DECLARE_INTERFACE(KWin::Platform, "org.kde.kwin.Platform")
 
 #endif
diff --git a/platformsupport/scenes/opengl/CMakeLists.txt b/platformsupport/scenes/opengl/CMakeLists.txt
index 7f3fd8f46..6ece689d7 100644
--- a/platformsupport/scenes/opengl/CMakeLists.txt
+++ b/platformsupport/scenes/opengl/CMakeLists.txt
@@ -1,24 +1,24 @@
 set(SCENE_OPENGL_BACKEND_SRCS
     abstract_egl_backend.cpp
     backend.cpp
     egl_dmabuf.cpp
     swap_profiler.cpp
     texture.cpp
 )
 
 include_directories(${CMAKE_SOURCE_DIR})
 
 include(ECMQtDeclareLoggingCategory)
 ecm_qt_declare_logging_category(SCENE_OPENGL_BACKEND_SRCS
     HEADER
         logging.h
     IDENTIFIER
         KWIN_OPENGL
     CATEGORY_NAME
         kwin_scene_opengl
     DEFAULT_SEVERITY
         Critical
 )
 
 add_library(SceneOpenGLBackend STATIC ${SCENE_OPENGL_BACKEND_SRCS})
-target_link_libraries(SceneOpenGLBackend Qt5::Core Qt5::Widgets KF5::CoreAddons KF5::ConfigCore KF5::WindowSystem KF5::WaylandServer)
+target_link_libraries(SceneOpenGLBackend Qt5::Core Qt5::Widgets KF5::CoreAddons KF5::ConfigCore KF5::WindowSystem Plasma::KWaylandServer)
diff --git a/platformsupport/scenes/opengl/abstract_egl_backend.cpp b/platformsupport/scenes/opengl/abstract_egl_backend.cpp
index 28e49c846..2f84cfbe7 100644
--- a/platformsupport/scenes/opengl/abstract_egl_backend.cpp
+++ b/platformsupport/scenes/opengl/abstract_egl_backend.cpp
@@ -1,638 +1,638 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "abstract_egl_backend.h"
 #include "egl_dmabuf.h"
 #include "texture.h"
 #include "composite.h"
 #include "egl_context_attribute_builder.h"
 #include "options.h"
 #include "platform.h"
 #include "scene.h"
 #include "wayland_server.h"
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/surface_interface.h>
 // kwin libs
 #include <logging.h>
 #include <kwinglplatform.h>
 #include <kwinglutils.h>
 // Qt
 #include <QOpenGLContext>
 #include <QOpenGLFramebufferObject>
 
 #include <memory>
 
 namespace KWin
 {
 
 typedef GLboolean(*eglBindWaylandDisplayWL_func)(EGLDisplay dpy, wl_display *display);
 typedef GLboolean(*eglUnbindWaylandDisplayWL_func)(EGLDisplay dpy, wl_display *display);
 typedef GLboolean(*eglQueryWaylandBufferWL_func)(EGLDisplay dpy, struct wl_resource *buffer, EGLint attribute, EGLint *value);
 eglBindWaylandDisplayWL_func eglBindWaylandDisplayWL = nullptr;
 eglUnbindWaylandDisplayWL_func eglUnbindWaylandDisplayWL = nullptr;
 eglQueryWaylandBufferWL_func eglQueryWaylandBufferWL = nullptr;
 
 #ifndef EGL_WAYLAND_BUFFER_WL
 #define EGL_WAYLAND_BUFFER_WL                   0x31D5
 #endif
 #ifndef EGL_WAYLAND_PLANE_WL
 #define EGL_WAYLAND_PLANE_WL                    0x31D6
 #endif
 #ifndef EGL_WAYLAND_Y_INVERTED_WL
 #define EGL_WAYLAND_Y_INVERTED_WL               0x31DB
 #endif
 
 AbstractEglBackend::AbstractEglBackend()
     : QObject(nullptr)
     , OpenGLBackend()
 {
     connect(Compositor::self(), &Compositor::aboutToDestroy, this, &AbstractEglBackend::unbindWaylandDisplay);
 }
 
 AbstractEglBackend::~AbstractEglBackend()
 {
     delete m_dmaBuf;
 }
 
 void AbstractEglBackend::unbindWaylandDisplay()
 {
     if (eglUnbindWaylandDisplayWL && m_display != EGL_NO_DISPLAY) {
         eglUnbindWaylandDisplayWL(m_display, *(WaylandServer::self()->display()));
     }
 }
 
 void AbstractEglBackend::cleanup()
 {
     cleanupGL();
     doneCurrent();
     eglDestroyContext(m_display, m_context);
     cleanupSurfaces();
     eglReleaseThread();
     kwinApp()->platform()->setSceneEglContext(EGL_NO_CONTEXT);
     kwinApp()->platform()->setSceneEglSurface(EGL_NO_SURFACE);
     kwinApp()->platform()->setSceneEglConfig(nullptr);
 }
 
 void AbstractEglBackend::cleanupSurfaces()
 {
     if (m_surface != EGL_NO_SURFACE) {
         eglDestroySurface(m_display, m_surface);
     }
 }
 
 bool AbstractEglBackend::initEglAPI()
 {
     EGLint major, minor;
     if (eglInitialize(m_display, &major, &minor) == EGL_FALSE) {
         qCWarning(KWIN_OPENGL) << "eglInitialize failed";
         EGLint error = eglGetError();
         if (error != EGL_SUCCESS) {
             qCWarning(KWIN_OPENGL) << "Error during eglInitialize " << error;
         }
         return false;
     }
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_OPENGL) << "Error during eglInitialize " << error;
         return false;
     }
     qCDebug(KWIN_OPENGL) << "Egl Initialize succeeded";
 
     if (eglBindAPI(isOpenGLES() ? EGL_OPENGL_ES_API : EGL_OPENGL_API) == EGL_FALSE) {
         qCCritical(KWIN_OPENGL) << "bind OpenGL API failed";
         return false;
     }
     qCDebug(KWIN_OPENGL) << "EGL version: " << major << "." << minor;
     const QByteArray eglExtensions = eglQueryString(m_display, EGL_EXTENSIONS);
     setExtensions(eglExtensions.split(' '));
     return true;
 }
 
 typedef void (*eglFuncPtr)();
 static eglFuncPtr getProcAddress(const char* name)
 {
     return eglGetProcAddress(name);
 }
 
 void AbstractEglBackend::initKWinGL()
 {
     GLPlatform *glPlatform = GLPlatform::instance();
     glPlatform->detect(EglPlatformInterface);
     options->setGlPreferBufferSwap(options->glPreferBufferSwap()); // resolve autosetting
     if (options->glPreferBufferSwap() == Options::AutoSwapStrategy)
         options->setGlPreferBufferSwap('e'); // for unknown drivers - should not happen
     glPlatform->printResults();
     initGL(&getProcAddress);
 }
 
 void AbstractEglBackend::initBufferAge()
 {
     setSupportsBufferAge(false);
 
     if (hasExtension(QByteArrayLiteral("EGL_EXT_buffer_age"))) {
         const QByteArray useBufferAge = qgetenv("KWIN_USE_BUFFER_AGE");
 
         if (useBufferAge != "0")
             setSupportsBufferAge(true);
     }
 }
 
 void AbstractEglBackend::initWayland()
 {
     if (!WaylandServer::self()) {
         return;
     }
     if (hasExtension(QByteArrayLiteral("EGL_WL_bind_wayland_display"))) {
         eglBindWaylandDisplayWL = (eglBindWaylandDisplayWL_func)eglGetProcAddress("eglBindWaylandDisplayWL");
         eglUnbindWaylandDisplayWL = (eglUnbindWaylandDisplayWL_func)eglGetProcAddress("eglUnbindWaylandDisplayWL");
         eglQueryWaylandBufferWL = (eglQueryWaylandBufferWL_func)eglGetProcAddress("eglQueryWaylandBufferWL");
         // only bind if not already done
         if (waylandServer()->display()->eglDisplay() != eglDisplay()) {
             if (!eglBindWaylandDisplayWL(eglDisplay(), *(WaylandServer::self()->display()))) {
                 eglUnbindWaylandDisplayWL = nullptr;
                 eglQueryWaylandBufferWL = nullptr;
             } else {
                 waylandServer()->display()->setEglDisplay(eglDisplay());
             }
         }
     }
 
     Q_ASSERT(!m_dmaBuf);
     m_dmaBuf = EglDmabuf::factory(this);
 }
 
 void AbstractEglBackend::initClientExtensions()
 {
     // Get the list of client extensions
     const char* clientExtensionsCString = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
     const QByteArray clientExtensionsString = QByteArray::fromRawData(clientExtensionsCString, qstrlen(clientExtensionsCString));
     if (clientExtensionsString.isEmpty()) {
         // If eglQueryString() returned NULL, the implementation doesn't support
         // EGL_EXT_client_extensions. Expect an EGL_BAD_DISPLAY error.
         (void) eglGetError();
     }
 
     m_clientExtensions = clientExtensionsString.split(' ');
 }
 
 bool AbstractEglBackend::hasClientExtension(const QByteArray &ext) const
 {
     return m_clientExtensions.contains(ext);
 }
 
 bool AbstractEglBackend::makeCurrent()
 {
     if (QOpenGLContext *context = QOpenGLContext::currentContext()) {
         // Workaround to tell Qt that no QOpenGLContext is current
         context->doneCurrent();
     }
     const bool current = eglMakeCurrent(m_display, m_surface, m_surface, m_context);
     return current;
 }
 
 void AbstractEglBackend::doneCurrent()
 {
     eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
 }
 
 bool AbstractEglBackend::isOpenGLES() const
 {
     if (qstrcmp(qgetenv("KWIN_COMPOSE"), "O2ES") == 0) {
         return true;
     }
     return QOpenGLContext::openGLModuleType() == QOpenGLContext::LibGLES;
 }
 
 bool AbstractEglBackend::createContext()
 {
     const bool haveRobustness = hasExtension(QByteArrayLiteral("EGL_EXT_create_context_robustness"));
     const bool haveCreateContext = hasExtension(QByteArrayLiteral("EGL_KHR_create_context"));
     const bool haveContextPriority = hasExtension(QByteArrayLiteral("EGL_IMG_context_priority"));
 
     std::vector<std::unique_ptr<AbstractOpenGLContextAttributeBuilder>> candidates;
     if (isOpenGLES()) {
         if (haveCreateContext && haveRobustness && haveContextPriority) {
             auto glesRobustPriority = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglOpenGLESContextAttributeBuilder);
             glesRobustPriority->setVersion(2);
             glesRobustPriority->setRobust(true);
             glesRobustPriority->setHighPriority(true);
             candidates.push_back(std::move(glesRobustPriority));
         }
         if (haveCreateContext && haveRobustness) {
             auto glesRobust = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglOpenGLESContextAttributeBuilder);
             glesRobust->setVersion(2);
             glesRobust->setRobust(true);
             candidates.push_back(std::move(glesRobust));
         }
         if (haveContextPriority) {
             auto glesPriority = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglOpenGLESContextAttributeBuilder);
             glesPriority->setVersion(2);
             glesPriority->setHighPriority(true);
             candidates.push_back(std::move(glesPriority));
         }
         auto gles = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglOpenGLESContextAttributeBuilder);
         gles->setVersion(2);
         candidates.push_back(std::move(gles));
     } else {
         if (options->glCoreProfile() && haveCreateContext) {
             if (haveRobustness && haveContextPriority) {
                 auto robustCorePriority = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglContextAttributeBuilder);
                 robustCorePriority->setVersion(3, 1);
                 robustCorePriority->setRobust(true);
                 robustCorePriority->setHighPriority(true);
                 candidates.push_back(std::move(robustCorePriority));
             }
             if (haveRobustness) {
                 auto robustCore = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglContextAttributeBuilder);
                 robustCore->setVersion(3, 1);
                 robustCore->setRobust(true);
                 candidates.push_back(std::move(robustCore));
             }
             if (haveContextPriority) {
                 auto corePriority = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglContextAttributeBuilder);
                 corePriority->setVersion(3, 1);
                 corePriority->setHighPriority(true);
                 candidates.push_back(std::move(corePriority));
             }
             auto core = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglContextAttributeBuilder);
             core->setVersion(3, 1);
             candidates.push_back(std::move(core));
         }
         if (haveRobustness && haveCreateContext && haveContextPriority) {
             auto robustPriority = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglContextAttributeBuilder);
             robustPriority->setRobust(true);
             robustPriority->setHighPriority(true);
             candidates.push_back(std::move(robustPriority));
         }
         if (haveRobustness && haveCreateContext) {
             auto robust = std::unique_ptr<AbstractOpenGLContextAttributeBuilder>(new EglContextAttributeBuilder);
             robust->setRobust(true);
             candidates.push_back(std::move(robust));
         }
         candidates.emplace_back(new EglContextAttributeBuilder);
     }
 
     EGLContext ctx = EGL_NO_CONTEXT;
     for (auto it = candidates.begin(); it != candidates.end(); it++) {
         const auto attribs = (*it)->build();
         ctx = eglCreateContext(m_display, config(), EGL_NO_CONTEXT, attribs.data());
         if (ctx != EGL_NO_CONTEXT) {
             qCDebug(KWIN_OPENGL) << "Created EGL context with attributes:" << (*it).get();
             break;
         }
     }
 
     if (ctx == EGL_NO_CONTEXT) {
         qCCritical(KWIN_OPENGL) << "Create Context failed";
         return false;
     }
     m_context = ctx;
     kwinApp()->platform()->setSceneEglContext(m_context);
     return true;
 }
 
 void AbstractEglBackend::setEglDisplay(const EGLDisplay &display) {
     m_display = display;
     kwinApp()->platform()->setSceneEglDisplay(display);
 }
 
 void AbstractEglBackend::setConfig(const EGLConfig &config)
 {
     m_config = config;
     kwinApp()->platform()->setSceneEglConfig(config);
 }
 
 void AbstractEglBackend::setSurface(const EGLSurface &surface)
 {
     m_surface = surface;
     kwinApp()->platform()->setSceneEglSurface(surface);
 }
 
 AbstractEglTexture::AbstractEglTexture(SceneOpenGLTexture *texture, AbstractEglBackend *backend)
     : SceneOpenGLTexturePrivate()
     , q(texture)
     , m_backend(backend)
     , m_image(EGL_NO_IMAGE_KHR)
 {
     m_target = GL_TEXTURE_2D;
 }
 
 AbstractEglTexture::~AbstractEglTexture()
 {
     if (m_image != EGL_NO_IMAGE_KHR) {
         eglDestroyImageKHR(m_backend->eglDisplay(), m_image);
     }
 }
 
 OpenGLBackend *AbstractEglTexture::backend()
 {
     return m_backend;
 }
 
 bool AbstractEglTexture::loadTexture(WindowPixmap *pixmap)
 {
     // FIXME: Refactor this method.
 
     const auto &buffer = pixmap->buffer();
     if (buffer.isNull()) {
         if (updateFromFBO(pixmap->fbo())) {
             return true;
         }
         if (loadInternalImageObject(pixmap)) {
             return true;
         }
         return false;
     }
     // try Wayland loading
     if (auto s = pixmap->surface()) {
         s->resetTrackedDamage();
     }
     if (buffer->linuxDmabufBuffer()) {
         return loadDmabufTexture(buffer);
     } else if (buffer->shmBuffer()) {
         return loadShmTexture(buffer);
     }
     return loadEglTexture(buffer);
 }
 
 void AbstractEglTexture::updateTexture(WindowPixmap *pixmap)
 {
     // FIXME: Refactor this method.
 
     const auto &buffer = pixmap->buffer();
     if (buffer.isNull()) {
         if (updateFromFBO(pixmap->fbo())) {
             return;
         }
         if (updateFromInternalImageObject(pixmap)) {
             return;
         }
         return;
     }
     auto s = pixmap->surface();
     if (EglDmabufBuffer *dmabuf = static_cast<EglDmabufBuffer *>(buffer->linuxDmabufBuffer())) {
         q->bind();
         glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES) dmabuf->images()[0]);   //TODO
         q->unbind();
         if (m_image != EGL_NO_IMAGE_KHR) {
             eglDestroyImageKHR(m_backend->eglDisplay(), m_image);
         }
         m_image = EGL_NO_IMAGE_KHR; // The wl_buffer has ownership of the image
         // The origin in a dmabuf-buffer is at the upper-left corner, so the meaning
         // of Y-inverted is the inverse of OpenGL.
-        const bool yInverted = !(dmabuf->flags() & KWayland::Server::LinuxDmabufUnstableV1Interface::YInverted);
+        const bool yInverted = !(dmabuf->flags() & KWaylandServer::LinuxDmabufUnstableV1Interface::YInverted);
         if (m_size != dmabuf->size() || yInverted != q->isYInverted()) {
             m_size = dmabuf->size();
             q->setYInverted(yInverted);
         }
         if (s) {
             s->resetTrackedDamage();
         }
         return;
     }
     if (!buffer->shmBuffer()) {
         q->bind();
         EGLImageKHR image = attach(buffer);
         q->unbind();
         if (image != EGL_NO_IMAGE_KHR) {
             if (m_image != EGL_NO_IMAGE_KHR) {
                 eglDestroyImageKHR(m_backend->eglDisplay(), m_image);
             }
             m_image = image;
         }
         if (s) {
             s->resetTrackedDamage();
         }
         return;
     }
     // shm fallback
     const QImage &image = buffer->data();
     if (image.isNull() || !s) {
         return;
     }
     if (image.size() != m_size) {
         // buffer size has changed, reload shm texture
         if (!loadTexture(pixmap)) {
             return;
         }
     }
     Q_ASSERT(image.size() == m_size);
     const QRegion damage = s->trackedDamage();
     s->resetTrackedDamage();
 
     // TODO: this should be shared with GLTexture::update
     createTextureSubImage(s->scale(), image, damage);
 }
 
 bool AbstractEglTexture::createTextureImage(const QImage &image)
 {
     if (image.isNull()) {
         return false;
     }
 
     glGenTextures(1, &m_texture);
     q->setFilter(GL_LINEAR);
     q->setWrapMode(GL_CLAMP_TO_EDGE);
 
     const QSize &size = image.size();
     q->bind();
     GLenum format = 0;
     switch (image.format()) {
     case QImage::Format_ARGB32:
     case QImage::Format_ARGB32_Premultiplied:
         format = GL_RGBA8;
         break;
     case QImage::Format_RGB32:
         format = GL_RGB8;
         break;
     default:
         return false;
     }
     if (GLPlatform::instance()->isGLES()) {
         if (s_supportsARGB32 && format == GL_RGBA8) {
             const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
             glTexImage2D(m_target, 0, GL_BGRA_EXT, im.width(), im.height(),
                          0, GL_BGRA_EXT, GL_UNSIGNED_BYTE, im.bits());
         } else {
             const QImage im = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
             glTexImage2D(m_target, 0, GL_RGBA, im.width(), im.height(),
                          0, GL_RGBA, GL_UNSIGNED_BYTE, im.bits());
         }
     } else {
         glTexImage2D(m_target, 0, format, size.width(), size.height(), 0,
                     GL_BGRA, GL_UNSIGNED_BYTE, image.bits());
     }
     q->unbind();
     q->setYInverted(true);
     m_size = size;
     updateMatrix();
     return true;
 }
 
 void AbstractEglTexture::createTextureSubImage(int scale, const QImage &image, const QRegion &damage)
 {
     q->bind();
     if (GLPlatform::instance()->isGLES()) {
         if (s_supportsARGB32 && (image.format() == QImage::Format_ARGB32 || image.format() == QImage::Format_ARGB32_Premultiplied)) {
             const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
             for (const QRect &rect : damage) {
                 auto scaledRect = QRect(rect.x() * scale, rect.y() * scale, rect.width() * scale, rect.height() * scale);
                 glTexSubImage2D(m_target, 0, scaledRect.x(), scaledRect.y(), scaledRect.width(), scaledRect.height(),
                                 GL_BGRA_EXT, GL_UNSIGNED_BYTE, im.copy(scaledRect).bits());
             }
         } else {
             const QImage im = image.convertToFormat(QImage::Format_RGBA8888_Premultiplied);
             for (const QRect &rect : damage) {
                 auto scaledRect = QRect(rect.x() * scale, rect.y() * scale, rect.width() * scale, rect.height() * scale);
                 glTexSubImage2D(m_target, 0, scaledRect.x(), scaledRect.y(), scaledRect.width(), scaledRect.height(),
                                 GL_RGBA, GL_UNSIGNED_BYTE, im.copy(scaledRect).bits());
             }
         }
     } else {
         const QImage im = image.convertToFormat(QImage::Format_ARGB32_Premultiplied);
         for (const QRect &rect : damage) {
             auto scaledRect = QRect(rect.x() * scale, rect.y() * scale, rect.width() * scale, rect.height() * scale);
             glTexSubImage2D(m_target, 0, scaledRect.x(), scaledRect.y(), scaledRect.width(), scaledRect.height(),
                             GL_BGRA, GL_UNSIGNED_BYTE, im.copy(scaledRect).bits());
         }
     }
     q->unbind();
 }
 
-bool AbstractEglTexture::loadShmTexture(const QPointer< KWayland::Server::BufferInterface > &buffer)
+bool AbstractEglTexture::loadShmTexture(const QPointer< KWaylandServer::BufferInterface > &buffer)
 {
     return createTextureImage(buffer->data());
 }
 
-bool AbstractEglTexture::loadEglTexture(const QPointer< KWayland::Server::BufferInterface > &buffer)
+bool AbstractEglTexture::loadEglTexture(const QPointer< KWaylandServer::BufferInterface > &buffer)
 {
     if (!eglQueryWaylandBufferWL) {
         return false;
     }
     if (!buffer->resource()) {
         return false;
     }
 
     glGenTextures(1, &m_texture);
     q->setWrapMode(GL_CLAMP_TO_EDGE);
     q->setFilter(GL_LINEAR);
     q->bind();
     m_image = attach(buffer);
     q->unbind();
 
     if (EGL_NO_IMAGE_KHR == m_image) {
         qCDebug(KWIN_OPENGL) << "failed to create egl image";
         q->discard();
         return false;
     }
 
     return true;
 }
 
-bool AbstractEglTexture::loadDmabufTexture(const QPointer< KWayland::Server::BufferInterface > &buffer)
+bool AbstractEglTexture::loadDmabufTexture(const QPointer< KWaylandServer::BufferInterface > &buffer)
 {
     auto *dmabuf = static_cast<EglDmabufBuffer *>(buffer->linuxDmabufBuffer());
     if (!dmabuf || dmabuf->images()[0] == EGL_NO_IMAGE_KHR) {
         qCritical(KWIN_OPENGL) << "Invalid dmabuf-based wl_buffer";
         q->discard();
         return false;
     }
 
     Q_ASSERT(m_image == EGL_NO_IMAGE_KHR);
 
     glGenTextures(1, &m_texture);
     q->setWrapMode(GL_CLAMP_TO_EDGE);
     q->setFilter(GL_NEAREST);
     q->bind();
     glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES) dmabuf->images()[0]);
     q->unbind();
 
     m_size = dmabuf->size();
-    q->setYInverted(!(dmabuf->flags() & KWayland::Server::LinuxDmabufUnstableV1Interface::YInverted));
+    q->setYInverted(!(dmabuf->flags() & KWaylandServer::LinuxDmabufUnstableV1Interface::YInverted));
 
     return true;
 }
 
 bool AbstractEglTexture::loadInternalImageObject(WindowPixmap *pixmap)
 {
     return createTextureImage(pixmap->internalImage());
 }
 
-EGLImageKHR AbstractEglTexture::attach(const QPointer< KWayland::Server::BufferInterface > &buffer)
+EGLImageKHR AbstractEglTexture::attach(const QPointer< KWaylandServer::BufferInterface > &buffer)
 {
     EGLint format, yInverted;
     eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_TEXTURE_FORMAT, &format);
     if (format != EGL_TEXTURE_RGB && format != EGL_TEXTURE_RGBA) {
         qCDebug(KWIN_OPENGL) << "Unsupported texture format: " << format;
         return EGL_NO_IMAGE_KHR;
     }
     if (!eglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted)) {
         // if EGL_WAYLAND_Y_INVERTED_WL is not supported wl_buffer should be treated as if value were EGL_TRUE
         yInverted = EGL_TRUE;
     }
 
     const EGLint attribs[] = {
         EGL_WAYLAND_PLANE_WL, 0,
         EGL_NONE
     };
     EGLImageKHR image = eglCreateImageKHR(m_backend->eglDisplay(), EGL_NO_CONTEXT, EGL_WAYLAND_BUFFER_WL,
                                       (EGLClientBuffer)buffer->resource(), attribs);
     if (image != EGL_NO_IMAGE_KHR) {
         glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, (GLeglImageOES)image);
         m_size = buffer->size();
         updateMatrix();
         q->setYInverted(yInverted);
     }
     return image;
 }
 
 bool AbstractEglTexture::updateFromFBO(const QSharedPointer<QOpenGLFramebufferObject> &fbo)
 {
     if (fbo.isNull()) {
         return false;
     }
     m_texture = fbo->texture();
     m_size = fbo->size();
     q->setWrapMode(GL_CLAMP_TO_EDGE);
     q->setFilter(GL_LINEAR);
     q->setYInverted(false);
     updateMatrix();
     return true;
 }
 
 bool AbstractEglTexture::updateFromInternalImageObject(WindowPixmap *pixmap)
 {
     const QImage image = pixmap->internalImage();
     if (image.isNull()) {
         return false;
     }
 
     if (m_size != image.size()) {
         glDeleteTextures(1, &m_texture);
         return loadInternalImageObject(pixmap);
     }
 
     createTextureSubImage(image.devicePixelRatio(), image, pixmap->toplevel()->damage());
 
     return true;
 }
 
 }
 
diff --git a/platformsupport/scenes/opengl/abstract_egl_backend.h b/platformsupport/scenes/opengl/abstract_egl_backend.h
index 2fb6d8301..f27b4bd4c 100644
--- a/platformsupport/scenes/opengl/abstract_egl_backend.h
+++ b/platformsupport/scenes/opengl/abstract_egl_backend.h
@@ -1,130 +1,127 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_ABSTRACT_EGL_BACKEND_H
 #define KWIN_ABSTRACT_EGL_BACKEND_H
 #include "backend.h"
 #include "texture.h"
 
 #include <QObject>
 #include <epoxy/egl.h>
 #include <fixx11h.h>
 
 class QOpenGLFramebufferObject;
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class BufferInterface;
 }
-}
 
 namespace KWin
 {
 
 class EglDmabuf;
 
 class KWIN_EXPORT AbstractEglBackend : public QObject, public OpenGLBackend
 {
     Q_OBJECT
 public:
     ~AbstractEglBackend() override;
     bool makeCurrent() override;
     void doneCurrent() override;
 
     EGLDisplay eglDisplay() const {
         return m_display;
     }
     EGLContext context() const {
         return m_context;
     }
     EGLSurface surface() const {
         return m_surface;
     }
     EGLConfig config() const {
         return m_config;
     }
 
 protected:
     AbstractEglBackend();
     void setEglDisplay(const EGLDisplay &display);
     void setSurface(const EGLSurface &surface);
     void setConfig(const EGLConfig &config);
     void cleanup();
     virtual void cleanupSurfaces();
     bool initEglAPI();
     void initKWinGL();
     void initBufferAge();
     void initClientExtensions();
     void initWayland();
     bool hasClientExtension(const QByteArray &ext) const;
     bool isOpenGLES() const;
 
     bool createContext();
 
 private:
     void unbindWaylandDisplay();
 
     EGLDisplay m_display = EGL_NO_DISPLAY;
     EGLSurface m_surface = EGL_NO_SURFACE;
     EGLContext m_context = EGL_NO_CONTEXT;
     EGLConfig m_config = nullptr;
     QList<QByteArray> m_clientExtensions;
     EglDmabuf *m_dmaBuf = nullptr;
 };
 
 class KWIN_EXPORT AbstractEglTexture : public SceneOpenGLTexturePrivate
 {
 public:
     ~AbstractEglTexture() override;
     bool loadTexture(WindowPixmap *pixmap) override;
     void updateTexture(WindowPixmap *pixmap) override;
     OpenGLBackend *backend() override;
 
 protected:
     AbstractEglTexture(SceneOpenGLTexture *texture, AbstractEglBackend *backend);
     EGLImageKHR image() const {
         return m_image;
     }
     void setImage(const EGLImageKHR &img) {
         m_image = img;
     }
     SceneOpenGLTexture *texture() const {
         return q;
     }
 
 private:
     void createTextureSubImage(int scale, const QImage &image, const QRegion &damage);
     bool createTextureImage(const QImage &image);
-    bool loadShmTexture(const QPointer<KWayland::Server::BufferInterface> &buffer);
-    bool loadEglTexture(const QPointer<KWayland::Server::BufferInterface> &buffer);
-    bool loadDmabufTexture(const QPointer< KWayland::Server::BufferInterface > &buffer);
+    bool loadShmTexture(const QPointer<KWaylandServer::BufferInterface> &buffer);
+    bool loadEglTexture(const QPointer<KWaylandServer::BufferInterface> &buffer);
+    bool loadDmabufTexture(const QPointer< KWaylandServer::BufferInterface > &buffer);
     bool loadInternalImageObject(WindowPixmap *pixmap);
-    EGLImageKHR attach(const QPointer<KWayland::Server::BufferInterface> &buffer);
+    EGLImageKHR attach(const QPointer<KWaylandServer::BufferInterface> &buffer);
     bool updateFromFBO(const QSharedPointer<QOpenGLFramebufferObject> &fbo);
     bool updateFromInternalImageObject(WindowPixmap *pixmap);
     SceneOpenGLTexture *q;
     AbstractEglBackend *m_backend;
     EGLImageKHR m_image;
 };
 
 }
 
 #endif
diff --git a/platformsupport/scenes/opengl/egl_dmabuf.cpp b/platformsupport/scenes/opengl/egl_dmabuf.cpp
index 3f75bc7e6..ecba33a9d 100644
--- a/platformsupport/scenes/opengl/egl_dmabuf.cpp
+++ b/platformsupport/scenes/opengl/egl_dmabuf.cpp
@@ -1,493 +1,493 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright © 2019 Roman Gilg <subdiff@gmail.com>
 Copyright © 2018 Fredrik Höglund <fredrik@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 "egl_dmabuf.h"
 
 #include "drm_fourcc.h"
 #include "../../../wayland_server.h"
 
 #include <unistd.h>
 #include <EGL/eglmesaext.h>
 
 namespace KWin
 {
 
 typedef EGLBoolean (*eglQueryDmaBufFormatsEXT_func) (EGLDisplay dpy, EGLint max_formats, EGLint *formats, EGLint *num_formats);
 typedef EGLBoolean (*eglQueryDmaBufModifiersEXT_func) (EGLDisplay dpy, EGLint format, EGLint max_modifiers, EGLuint64KHR *modifiers, EGLBoolean *external_only, EGLint *num_modifiers);
 eglQueryDmaBufFormatsEXT_func eglQueryDmaBufFormatsEXT = nullptr;
 eglQueryDmaBufModifiersEXT_func eglQueryDmaBufModifiersEXT = nullptr;
 
 #ifndef EGL_EXT_image_dma_buf_import
 #define EGL_LINUX_DMA_BUF_EXT                     0x3270
 #define EGL_LINUX_DRM_FOURCC_EXT                  0x3271
 #define EGL_DMA_BUF_PLANE0_FD_EXT                 0x3272
 #define EGL_DMA_BUF_PLANE0_OFFSET_EXT             0x3273
 #define EGL_DMA_BUF_PLANE0_PITCH_EXT              0x3274
 #define EGL_DMA_BUF_PLANE1_FD_EXT                 0x3275
 #define EGL_DMA_BUF_PLANE1_OFFSET_EXT             0x3276
 #define EGL_DMA_BUF_PLANE1_PITCH_EXT              0x3277
 #define EGL_DMA_BUF_PLANE2_FD_EXT                 0x3278
 #define EGL_DMA_BUF_PLANE2_OFFSET_EXT             0x3279
 #define EGL_DMA_BUF_PLANE2_PITCH_EXT              0x327A
 #define EGL_YUV_COLOR_SPACE_HINT_EXT              0x327B
 #define EGL_SAMPLE_RANGE_HINT_EXT                 0x327C
 #define EGL_YUV_CHROMA_HORIZONTAL_SITING_HINT_EXT 0x327D
 #define EGL_YUV_CHROMA_VERTICAL_SITING_HINT_EXT   0x327E
 #define EGL_ITU_REC601_EXT                        0x327F
 #define EGL_ITU_REC709_EXT                        0x3280
 #define EGL_ITU_REC2020_EXT                       0x3281
 #define EGL_YUV_FULL_RANGE_EXT                    0x3282
 #define EGL_YUV_NARROW_RANGE_EXT                  0x3283
 #define EGL_YUV_CHROMA_SITING_0_EXT               0x3284
 #define EGL_YUV_CHROMA_SITING_0_5_EXT             0x3285
 #endif // EGL_EXT_image_dma_buf_import
 
 #ifndef EGL_EXT_image_dma_buf_import_modifiers
 #define EGL_DMA_BUF_PLANE3_FD_EXT                 0x3440
 #define EGL_DMA_BUF_PLANE3_OFFSET_EXT             0x3441
 #define EGL_DMA_BUF_PLANE3_PITCH_EXT              0x3442
 #define EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT        0x3443
 #define EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT        0x3444
 #define EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT        0x3445
 #define EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT        0x3446
 #define EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT        0x3447
 #define EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT        0x3448
 #define EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT        0x3449
 #define EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT        0x344A
 #endif // EGL_EXT_image_dma_buf_import_modifiers
 
 struct YuvPlane
 {
     int widthDivisor;
     int heightDivisor;
     uint32_t format;
     int planeIndex;
 };
 
 struct YuvFormat
 {
     uint32_t format;
     int inputPlanes;
     int outputPlanes;
     int textureType;
     struct YuvPlane planes[3];
 };
 
 YuvFormat yuvFormats[] = {
     {
         DRM_FORMAT_YUYV,
         1, 2,
         EGL_TEXTURE_Y_XUXV_WL,
         {
             {
                 1, 1,
                 DRM_FORMAT_GR88,
                 0
             },
             {
                 2, 1,
                 DRM_FORMAT_ARGB8888,
                 0
             }
         }
     },
     {
         DRM_FORMAT_NV12,
         2, 2,
         EGL_TEXTURE_Y_UV_WL,
         {
             {
                 1, 1,
                 DRM_FORMAT_R8,
                 0
             },
             {
                 2, 2,
                 DRM_FORMAT_GR88,
                 1
             }
         }
     },
     {
         DRM_FORMAT_YUV420,
         3, 3,
         EGL_TEXTURE_Y_U_V_WL,
         {
             {
                 1, 1,
                 DRM_FORMAT_R8,
                 0
             },
             {
                 2, 2,
                 DRM_FORMAT_R8,
                 1
             },
             {
                 2, 2,
                 DRM_FORMAT_R8,
                 2
             }
         }
     },
     {
         DRM_FORMAT_YUV444,
         3, 3,
         EGL_TEXTURE_Y_U_V_WL,
         {
             {
                 1, 1,
                 DRM_FORMAT_R8,
                 0
             },
             {
                 1, 1,
                 DRM_FORMAT_R8,
                 1
             },
             {
                 1, 1,
                 DRM_FORMAT_R8,
                 2
             }
         }
     }
 };
 
 EglDmabufBuffer::EglDmabufBuffer(EGLImage image,
                                  const QVector<Plane> &planes,
                                  uint32_t format,
                                  const QSize &size,
                                  Flags flags,
                                  EglDmabuf *interfaceImpl)
     : EglDmabufBuffer(planes, format, size, flags, interfaceImpl)
 {
     m_importType = ImportType::Direct;
     addImage(image);
 }
 
 
 EglDmabufBuffer::EglDmabufBuffer(const QVector<Plane> &planes,
                                  uint32_t format,
                                  const QSize &size,
                                  Flags flags,
                                  EglDmabuf *interfaceImpl)
     : DmabufBuffer(planes, format, size, flags)
     , m_interfaceImpl(interfaceImpl)
 {
     m_importType = ImportType::Conversion;
 }
 
 EglDmabufBuffer::~EglDmabufBuffer()
 {
     removeImages();
 }
 
 void EglDmabufBuffer::setInterfaceImplementation(EglDmabuf *interfaceImpl)
 {
     m_interfaceImpl = interfaceImpl;
 }
 
 void EglDmabufBuffer::addImage(EGLImage image)
 {
     m_images << image;
 }
 
 void EglDmabufBuffer::removeImages()
 {
     for (auto image : m_images) {
         eglDestroyImageKHR(m_interfaceImpl->m_backend->eglDisplay(), image);
     }
     m_images.clear();
 }
 
-using Plane = KWayland::Server::LinuxDmabufUnstableV1Interface::Plane;
-using Flags = KWayland::Server::LinuxDmabufUnstableV1Interface::Flags;
+using Plane = KWaylandServer::LinuxDmabufUnstableV1Interface::Plane;
+using Flags = KWaylandServer::LinuxDmabufUnstableV1Interface::Flags;
 
 EGLImage EglDmabuf::createImage(const QVector<Plane> &planes,
                                 uint32_t format,
                                 const QSize &size)
 {
     const bool hasModifiers = eglQueryDmaBufModifiersEXT != nullptr &&
             planes[0].modifier != DRM_FORMAT_MOD_INVALID;
 
     QVector<EGLint> attribs;
     attribs << EGL_WIDTH                            <<  size.width()
             << EGL_HEIGHT                           <<  size.height()
             << EGL_LINUX_DRM_FOURCC_EXT             <<  EGLint(format)
 
             << EGL_DMA_BUF_PLANE0_FD_EXT            <<  planes[0].fd
             << EGL_DMA_BUF_PLANE0_OFFSET_EXT        <<  EGLint(planes[0].offset)
             << EGL_DMA_BUF_PLANE0_PITCH_EXT         <<  EGLint(planes[0].stride);
 
     if (hasModifiers) {
         attribs
             << EGL_DMA_BUF_PLANE0_MODIFIER_LO_EXT   <<  EGLint(planes[0].modifier & 0xffffffff)
             << EGL_DMA_BUF_PLANE0_MODIFIER_HI_EXT   <<  EGLint(planes[0].modifier >> 32);
     }
 
     if (planes.count() > 1) {
         attribs
             << EGL_DMA_BUF_PLANE1_FD_EXT            <<  planes[1].fd
             << EGL_DMA_BUF_PLANE1_OFFSET_EXT        <<  EGLint(planes[1].offset)
             << EGL_DMA_BUF_PLANE1_PITCH_EXT         <<  EGLint(planes[1].stride);
 
         if (hasModifiers) {
             attribs
             << EGL_DMA_BUF_PLANE1_MODIFIER_LO_EXT   <<  EGLint(planes[1].modifier & 0xffffffff)
             << EGL_DMA_BUF_PLANE1_MODIFIER_HI_EXT   <<  EGLint(planes[1].modifier >> 32);
         }
     }
 
     if (planes.count() > 2) {
         attribs
             << EGL_DMA_BUF_PLANE2_FD_EXT            <<  planes[2].fd
             << EGL_DMA_BUF_PLANE2_OFFSET_EXT        <<  EGLint(planes[2].offset)
             << EGL_DMA_BUF_PLANE2_PITCH_EXT         <<  EGLint(planes[2].stride);
 
         if (hasModifiers) {
             attribs
             << EGL_DMA_BUF_PLANE2_MODIFIER_LO_EXT   <<  EGLint(planes[2].modifier & 0xffffffff)
             << EGL_DMA_BUF_PLANE2_MODIFIER_HI_EXT   <<  EGLint(planes[2].modifier >> 32);
         }
     }
 
     if (eglQueryDmaBufModifiersEXT != nullptr && planes.count() > 3) {
         attribs
             << EGL_DMA_BUF_PLANE3_FD_EXT            <<  planes[3].fd
             << EGL_DMA_BUF_PLANE3_OFFSET_EXT        <<  EGLint(planes[3].offset)
             << EGL_DMA_BUF_PLANE3_PITCH_EXT         <<  EGLint(planes[3].stride);
 
         if (hasModifiers) {
             attribs
             << EGL_DMA_BUF_PLANE3_MODIFIER_LO_EXT   <<  EGLint(planes[3].modifier & 0xffffffff)
             << EGL_DMA_BUF_PLANE3_MODIFIER_HI_EXT   <<  EGLint(planes[3].modifier >> 32);
         }
     }
 
     attribs << EGL_NONE;
 
     EGLImage image = eglCreateImageKHR(m_backend->eglDisplay(),
                                        EGL_NO_CONTEXT,
                                        EGL_LINUX_DMA_BUF_EXT,
                                        (EGLClientBuffer) nullptr,
                                        attribs.data());
     if (image == EGL_NO_IMAGE_KHR) {
         return nullptr;
     }
 
     return image;
 }
 
-KWayland::Server::LinuxDmabufUnstableV1Buffer* EglDmabuf::importBuffer(const QVector<Plane> &planes,
+KWaylandServer::LinuxDmabufUnstableV1Buffer* EglDmabuf::importBuffer(const QVector<Plane> &planes,
                                                                        uint32_t format,
                                                                        const QSize &size,
                                                                        Flags flags)
 {
     Q_ASSERT(planes.count() > 0);
 
     // Try first to import as a single image
     if (auto *img = createImage(planes, format, size)) {
         return new EglDmabufBuffer(img, planes, format, size, flags, this);
     }
 
     // TODO: to enable this we must be able to store multiple textures per window pixmap
     //       and when on window draw do yuv to rgb transformation per shader (see Weston)
 //    // not a single image, try yuv import
 //    return yuvImport(planes, format, size, flags);
 
     return nullptr;
 }
 
-KWayland::Server::LinuxDmabufUnstableV1Buffer* EglDmabuf::yuvImport(const QVector<Plane> &planes,
+KWaylandServer::LinuxDmabufUnstableV1Buffer* EglDmabuf::yuvImport(const QVector<Plane> &planes,
                                                                     uint32_t format,
                                                                     const QSize &size,
                                                                     Flags flags)
 {
     YuvFormat yuvFormat;
     for (YuvFormat f : yuvFormats) {
         if (f.format == format) {
             yuvFormat = f;
             break;
         }
     }
     if (yuvFormat.format == 0) {
         return nullptr;
     }
     if (planes.count() != yuvFormat.inputPlanes) {
         return nullptr;
     }
 
     auto *buf = new EglDmabufBuffer(planes, format, size, flags, this);
 
     for (int i = 0; i < yuvFormat.outputPlanes; i++) {
         int planeIndex = yuvFormat.planes[i].planeIndex;
         Plane plane = {
             planes[planeIndex].fd,
             planes[planeIndex].offset,
             planes[planeIndex].stride,
             planes[planeIndex].modifier
         };
         const auto planeFormat = yuvFormat.planes[i].format;
         const auto planeSize = QSize(size.width() / yuvFormat.planes[i].widthDivisor,
                                      size.height() / yuvFormat.planes[i].heightDivisor);
         auto *image = createImage(QVector<Plane>(1, plane),
                                   planeFormat,
                                   planeSize);
         if (!image) {
             delete buf;
             return nullptr;
         }
         buf->addImage(image);
     }
     // TODO: add buf import properties
     return buf;
 }
 
 EglDmabuf* EglDmabuf::factory(AbstractEglBackend *backend)
 {
     if (!backend->hasExtension(QByteArrayLiteral("EGL_EXT_image_dma_buf_import"))) {
         return nullptr;
     }
 
     if (backend->hasExtension(QByteArrayLiteral("EGL_EXT_image_dma_buf_import_modifiers"))) {
         eglQueryDmaBufFormatsEXT = (eglQueryDmaBufFormatsEXT_func) eglGetProcAddress("eglQueryDmaBufFormatsEXT");
         eglQueryDmaBufModifiersEXT = (eglQueryDmaBufModifiersEXT_func) eglGetProcAddress("eglQueryDmaBufModifiersEXT");
     }
 
     if (eglQueryDmaBufFormatsEXT == nullptr) {
         return nullptr;
     }
 
     return new EglDmabuf(backend);
 }
 
 EglDmabuf::EglDmabuf(AbstractEglBackend *backend)
     : LinuxDmabuf()
     , m_backend(backend)
 {
     auto prevBuffersSet = waylandServer()->linuxDmabufBuffers();
     for (auto *buffer : prevBuffersSet) {
         auto *buf = static_cast<EglDmabufBuffer*>(buffer);
         buf->setInterfaceImplementation(this);
         buf->addImage(createImage(buf->planes(), buf->format(), buf->size()));
     }
     setSupportedFormatsAndModifiers();
 }
 
 EglDmabuf::~EglDmabuf()
 {
     auto curBuffers = waylandServer()->linuxDmabufBuffers();
     for (auto *buffer : curBuffers) {
         auto *buf = static_cast<EglDmabufBuffer*>(buffer);
         buf->removeImages();
     }
 }
 
 const uint32_t s_multiPlaneFormats[] = {
     DRM_FORMAT_XRGB8888_A8,
     DRM_FORMAT_XBGR8888_A8,
     DRM_FORMAT_RGBX8888_A8,
     DRM_FORMAT_BGRX8888_A8,
     DRM_FORMAT_RGB888_A8,
     DRM_FORMAT_BGR888_A8,
     DRM_FORMAT_RGB565_A8,
     DRM_FORMAT_BGR565_A8,
 
     DRM_FORMAT_NV12,
     DRM_FORMAT_NV21,
     DRM_FORMAT_NV16,
     DRM_FORMAT_NV61,
     DRM_FORMAT_NV24,
     DRM_FORMAT_NV42,
 
     DRM_FORMAT_YUV410,
     DRM_FORMAT_YVU410,
     DRM_FORMAT_YUV411,
     DRM_FORMAT_YVU411,
     DRM_FORMAT_YUV420,
     DRM_FORMAT_YVU420,
     DRM_FORMAT_YUV422,
     DRM_FORMAT_YVU422,
     DRM_FORMAT_YUV444,
     DRM_FORMAT_YVU444
 };
 
 void filterFormatsWithMultiplePlanes(QVector<uint32_t> &formats)
 {
     QVector<uint32_t>::iterator it = formats.begin();
     while (it != formats.end()) {
         for (auto linuxFormat : s_multiPlaneFormats) {
             if (*it == linuxFormat) {
                 qDebug() << "Filter multi-plane format" << *it;
                 it = formats.erase(it);
                 it--;
                 break;
             }
         }
         it++;
     }
 }
 
 void EglDmabuf::setSupportedFormatsAndModifiers()
 {
     const EGLDisplay eglDisplay = m_backend->eglDisplay();
     EGLint count = 0;
     EGLBoolean success = eglQueryDmaBufFormatsEXT(eglDisplay, 0, nullptr, &count);
 
     if (!success || count == 0) {
         return;
     }
 
     QVector<uint32_t> formats(count);
     if (!eglQueryDmaBufFormatsEXT(eglDisplay, count, (EGLint *) formats.data(), &count)) {
         return;
     }
 
     filterFormatsWithMultiplePlanes(formats);
 
     QHash<uint32_t, QSet<uint64_t> > set;
 
     for (auto format : qAsConst(formats)) {
         if (eglQueryDmaBufModifiersEXT != nullptr) {
             count = 0;
             success = eglQueryDmaBufModifiersEXT(eglDisplay, format, 0, nullptr, nullptr, &count);
 
             if (success && count > 0) {
                 QVector<uint64_t> modifiers(count);
                 if (eglQueryDmaBufModifiersEXT(eglDisplay,
                                                format, count, modifiers.data(),
                                                nullptr, &count)) {
                     QSet<uint64_t> modifiersSet;
                     for (auto mod : qAsConst(modifiers)) {
                         modifiersSet.insert(mod);
                     }
                     set.insert(format, modifiersSet);
                     continue;
                 }
             }
         }
         set.insert(format, QSet<uint64_t>());
     }
 
     LinuxDmabuf::setSupportedFormatsAndModifiers(set);
 }
 
 }
diff --git a/platformsupport/scenes/opengl/egl_dmabuf.h b/platformsupport/scenes/opengl/egl_dmabuf.h
index a9244f743..cd6c8ce5f 100644
--- a/platformsupport/scenes/opengl/egl_dmabuf.h
+++ b/platformsupport/scenes/opengl/egl_dmabuf.h
@@ -1,104 +1,104 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright © 2019 Roman Gilg <subdiff@gmail.com>
 Copyright © 2018 Fredrik Höglund <fredrik@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #pragma once
 
 #include "../../../linux_dmabuf.h"
 
 #include "abstract_egl_backend.h"
 
 #include <QVector>
 
 namespace KWin
 {
 class EglDmabuf;
 
 class EglDmabufBuffer : public DmabufBuffer
 {
 public:
-    using Plane = KWayland::Server::LinuxDmabufUnstableV1Interface::Plane;
-    using Flags = KWayland::Server::LinuxDmabufUnstableV1Interface::Flags;
+    using Plane = KWaylandServer::LinuxDmabufUnstableV1Interface::Plane;
+    using Flags = KWaylandServer::LinuxDmabufUnstableV1Interface::Flags;
 
     enum class ImportType {
         Direct,
         Conversion
     };
 
     EglDmabufBuffer(EGLImage image,
                     const QVector<Plane> &planes,
                     uint32_t format,
                     const QSize &size,
                     Flags flags,
                     EglDmabuf *interfaceImpl);
 
     EglDmabufBuffer(const QVector<Plane> &planes,
                     uint32_t format,
                     const QSize &size,
                     Flags flags,
                     EglDmabuf *interfaceImpl);
 
     ~EglDmabufBuffer() override;
 
     void setInterfaceImplementation(EglDmabuf *interfaceImpl);
     void addImage(EGLImage image);
     void removeImages();
 
     QVector<EGLImage> images() const { return m_images; }
 
 private:
     QVector<EGLImage> m_images;
     EglDmabuf *m_interfaceImpl;
     ImportType m_importType;
 };
 
 class EglDmabuf : public LinuxDmabuf
 {
 public:
-    using Plane = KWayland::Server::LinuxDmabufUnstableV1Interface::Plane;
-    using Flags = KWayland::Server::LinuxDmabufUnstableV1Interface::Flags;
+    using Plane = KWaylandServer::LinuxDmabufUnstableV1Interface::Plane;
+    using Flags = KWaylandServer::LinuxDmabufUnstableV1Interface::Flags;
 
     static EglDmabuf* factory(AbstractEglBackend *backend);
 
     explicit EglDmabuf(AbstractEglBackend *backend);
     ~EglDmabuf() override;
 
-    KWayland::Server::LinuxDmabufUnstableV1Buffer *importBuffer(const QVector<Plane> &planes,
+    KWaylandServer::LinuxDmabufUnstableV1Buffer *importBuffer(const QVector<Plane> &planes,
                                                                 uint32_t format,
                                                                 const QSize &size,
                                                                 Flags flags) override;
 
 private:
     EGLImage createImage(const QVector<Plane> &planes,
                          uint32_t format,
                          const QSize &size);
 
-    KWayland::Server::LinuxDmabufUnstableV1Buffer *yuvImport(const QVector<Plane> &planes,
+    KWaylandServer::LinuxDmabufUnstableV1Buffer *yuvImport(const QVector<Plane> &planes,
                                                              uint32_t format,
                                                              const QSize &size,
                                                              Flags flags);
 
     void setSupportedFormatsAndModifiers();
 
     AbstractEglBackend *m_backend;
 
     friend class EglDmabufBuffer;
 };
 
 }
diff --git a/plugins/platforms/drm/drm_backend.cpp b/plugins/platforms/drm/drm_backend.cpp
index 45fd9d827..3af64c3f1 100644
--- a/plugins/platforms/drm/drm_backend.cpp
+++ b/plugins/platforms/drm/drm_backend.cpp
@@ -1,815 +1,815 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "drm_backend.h"
 #include "drm_output.h"
 #include "drm_object_connector.h"
 #include "drm_object_crtc.h"
 #include "drm_object_plane.h"
 #include "composite.h"
 #include "cursor.h"
 #include "logging.h"
 #include "logind.h"
 #include "main.h"
 #include "scene_qpainter_drm_backend.h"
 #include "screens_drm.h"
 #include "udev.h"
 #include "wayland_server.h"
 #if HAVE_GBM
 #include "egl_gbm_backend.h"
 #include <gbm.h>
 #endif
 #if HAVE_EGL_STREAMS
 #include "egl_stream_backend.h"
 #endif
 // KWayland
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 // KF5
 #include <KConfigGroup>
 #include <KCoreAddons>
 #include <KLocalizedString>
 #include <KSharedConfig>
 // Qt
 #include <QCryptographicHash>
 #include <QSocketNotifier>
 #include <QPainter>
 // system
 #include <algorithm>
 #include <unistd.h>
 // drm
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <libdrm/drm_mode.h>
 
 #ifndef DRM_CAP_CURSOR_WIDTH
 #define DRM_CAP_CURSOR_WIDTH 0x8
 #endif
 
 #ifndef DRM_CAP_CURSOR_HEIGHT
 #define DRM_CAP_CURSOR_HEIGHT 0x9
 #endif
 
 #define KWIN_DRM_EVENT_CONTEXT_VERSION 2
 
 namespace KWin
 {
 
 DrmBackend::DrmBackend(QObject *parent)
     : Platform(parent)
     , m_udev(new Udev)
     , m_udevMonitor(m_udev->monitor())
     , m_dpmsFilter()
 {
 #if HAVE_EGL_STREAMS
     if (qEnvironmentVariableIsSet("KWIN_DRM_USE_EGL_STREAMS")) {
         m_useEglStreams = true;
     }
 #endif
     setSupportsGammaControl(true);
     supportsOutputChanges();
 }
 
 DrmBackend::~DrmBackend()
 {
 #if HAVE_GBM
     if (m_gbmDevice) {
         gbm_device_destroy(m_gbmDevice);
     }
 #endif
     if (m_fd >= 0) {
         // wait for pageflips
         while (m_pageFlipsPending != 0) {
             QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents);
         }
 
         qDeleteAll(m_planes);
         qDeleteAll(m_crtcs);
         qDeleteAll(m_connectors);
         close(m_fd);
     }
 }
 
 void DrmBackend::init()
 {
     LogindIntegration *logind = LogindIntegration::self();
     auto takeControl = [logind, this]() {
         if (logind->hasSessionControl()) {
             openDrm();
         } else {
             logind->takeControl();
             connect(logind, &LogindIntegration::hasSessionControlChanged, this, &DrmBackend::openDrm);
         }
     };
     if (logind->isConnected()) {
         takeControl();
     } else {
         connect(logind, &LogindIntegration::connectedChanged, this, takeControl);
     }
 }
 
 void DrmBackend::prepareShutdown()
 {
     writeOutputsConfiguration();
     for (DrmOutput *output : m_outputs) {
         output->teardown();
     }
     Platform::prepareShutdown();
 }
 
 Outputs DrmBackend::outputs() const
 {
     return m_outputs;
 }
 
 Outputs DrmBackend::enabledOutputs() const
 {
     return m_enabledOutputs;
 }
 
 void DrmBackend::createDpmsFilter()
 {
     if (!m_dpmsFilter.isNull()) {
         // already another output is off
         return;
     }
     m_dpmsFilter.reset(new DpmsInputEventFilter(this));
     input()->prependInputEventFilter(m_dpmsFilter.data());
 }
 
 void DrmBackend::turnOutputsOn()
 {
     m_dpmsFilter.reset();
     for (auto it = m_enabledOutputs.constBegin(), end = m_enabledOutputs.constEnd(); it != end; it++) {
-        (*it)->updateDpms(KWayland::Server::OutputInterface::DpmsMode::On);
+        (*it)->updateDpms(KWaylandServer::OutputInterface::DpmsMode::On);
     }
 }
 
 void DrmBackend::checkOutputsAreOn()
 {
     if (m_dpmsFilter.isNull()) {
         // already disabled, all outputs are on
         return;
     }
     for (auto it = m_enabledOutputs.constBegin(), end = m_enabledOutputs.constEnd(); it != end; it++) {
         if (!(*it)->isDpmsEnabled()) {
             // dpms still disabled, need to keep the filter
             return;
         }
     }
     // all outputs are on, disable the filter
     m_dpmsFilter.reset();
 }
 
 void DrmBackend::activate(bool active)
 {
     if (active) {
         qCDebug(KWIN_DRM) << "Activating session.";
         reactivate();
     } else {
         qCDebug(KWIN_DRM) << "Deactivating session.";
         deactivate();
     }
 }
 
 void DrmBackend::reactivate()
 {
     if (m_active) {
         return;
     }
     m_active = true;
     if (!usesSoftwareCursor()) {
         Cursor* cursor = Cursors::self()->mouse();
         const QPoint cp = cursor->pos() - cursor->hotspot();
         for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
             DrmOutput *o = *it;
             // only relevant in atomic mode
             o->m_modesetRequested = true;
             o->m_crtc->blank();
             o->showCursor();
             o->moveCursor(cursor, cp);
         }
     }
     // restart compositor
     m_pageFlipsPending = 0;
     if (Compositor *compositor = Compositor::self()) {
         compositor->bufferSwapComplete();
         compositor->addRepaintFull();
     }
 }
 
 void DrmBackend::deactivate()
 {
     if (!m_active) {
         return;
     }
     // block compositor
     if (m_pageFlipsPending == 0 && Compositor::self()) {
         Compositor::self()->aboutToSwapBuffers();
     }
     // hide cursor and disable
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         DrmOutput *o = *it;
         o->hideCursor();
     }
     m_active = false;
 }
 
 void DrmBackend::pageFlipHandler(int fd, unsigned int frame, unsigned int sec, unsigned int usec, void *data)
 {
     Q_UNUSED(fd)
     Q_UNUSED(frame)
     Q_UNUSED(sec)
     Q_UNUSED(usec)
     auto output = reinterpret_cast<DrmOutput*>(data);
 
     output->pageFlipped();
     output->m_backend->m_pageFlipsPending--;
     if (output->m_backend->m_pageFlipsPending == 0) {
         // TODO: improve, this currently means we wait for all page flips or all outputs.
         // It would be better to driver the repaint per output
 
         if (Compositor::self()) {
             Compositor::self()->bufferSwapComplete();
         }
     }
 }
 
 void DrmBackend::openDrm()
 {
     connect(LogindIntegration::self(), &LogindIntegration::sessionActiveChanged, this, &DrmBackend::activate);
     UdevDevice::Ptr device = m_udev->primaryGpu();
     if (!device) {
         qCWarning(KWIN_DRM) << "Did not find a GPU";
         return;
     }
     m_devNode = qEnvironmentVariableIsSet("KWIN_DRM_DEVICE_NODE") ? qgetenv("KWIN_DRM_DEVICE_NODE") : QByteArray(device->devNode());
     int fd = LogindIntegration::self()->takeDevice(m_devNode.constData());
     if (fd < 0) {
         qCWarning(KWIN_DRM) << "failed to open drm device at" << m_devNode;
         return;
     }
     m_fd = fd;
     m_active = true;
     QSocketNotifier *notifier = new QSocketNotifier(m_fd, QSocketNotifier::Read, this);
     connect(notifier, &QSocketNotifier::activated, this,
         [this] {
             if (!LogindIntegration::self()->isActiveSession()) {
                 return;
             }
             drmEventContext e;
             memset(&e, 0, sizeof e);
             e.version = KWIN_DRM_EVENT_CONTEXT_VERSION;
             e.page_flip_handler = pageFlipHandler;
             drmHandleEvent(m_fd, &e);
         }
     );
     m_drmId = device->sysNum();
 
     // trying to activate Atomic Mode Setting (this means also Universal Planes)
     if (!qEnvironmentVariableIsSet("KWIN_DRM_NO_AMS")) {
         if (drmSetClientCap(m_fd, DRM_CLIENT_CAP_ATOMIC, 1) == 0) {
             qCDebug(KWIN_DRM) << "Using Atomic Mode Setting.";
             m_atomicModeSetting = true;
 
             DrmScopedPointer<drmModePlaneRes> planeResources(drmModeGetPlaneResources(m_fd));
             if (!planeResources) {
                 qCWarning(KWIN_DRM) << "Failed to get plane resources. Falling back to legacy mode";
                 m_atomicModeSetting = false;
             }
 
             if (m_atomicModeSetting) {
                 qCDebug(KWIN_DRM) << "Number of planes:" << planeResources->count_planes;
 
                 // create the plane objects
                 for (unsigned int i = 0; i < planeResources->count_planes; ++i) {
                     DrmScopedPointer<drmModePlane> kplane(drmModeGetPlane(m_fd, planeResources->planes[i]));
                     DrmPlane *p = new DrmPlane(kplane->plane_id, m_fd);
                     if (p->atomicInit()) {
                         m_planes << p;
                         if (p->type() == DrmPlane::TypeIndex::Overlay) {
                             m_overlayPlanes << p;
                         }
                     } else {
                         delete p;
                     }
                 }
 
                 if (m_planes.isEmpty()) {
                     qCWarning(KWIN_DRM) << "Failed to create any plane. Falling back to legacy mode";
                     m_atomicModeSetting = false;
                 }
             }
         } else {
             qCWarning(KWIN_DRM) << "drmSetClientCap for Atomic Mode Setting failed. Using legacy mode.";
         }
     }
 
     initCursor();
     if (!updateOutputs())
         return;
 
     if (m_outputs.isEmpty()) {
         qCDebug(KWIN_DRM) << "No connected outputs found on startup.";
     }
 
     // setup udevMonitor
     if (m_udevMonitor) {
         m_udevMonitor->filterSubsystemDevType("drm");
         const int fd = m_udevMonitor->fd();
         if (fd != -1) {
             QSocketNotifier *notifier = new QSocketNotifier(fd, QSocketNotifier::Read, this);
             connect(notifier, &QSocketNotifier::activated, this,
                 [this] {
                     auto device = m_udevMonitor->getDevice();
                     if (!device) {
                         return;
                     }
                     if (device->sysNum() != m_drmId) {
                         return;
                     }
                     if (device->hasProperty("HOTPLUG", "1")) {
                         qCDebug(KWIN_DRM) << "Received hot plug event for monitored drm device";
                         updateOutputs();
                         updateCursor();
                     }
                 }
             );
             m_udevMonitor->enable();
         }
     }
     setReady(true);
 }
 
 bool DrmBackend::updateOutputs()
 {
     if (m_fd < 0) {
         return false;
     }
 
     DrmScopedPointer<drmModeRes> resources(drmModeGetResources(m_fd));
     if (!resources) {
         qCWarning(KWIN_DRM) << "drmModeGetResources failed";
         return false;
     }
 
     auto oldConnectors = m_connectors;
     for (int i = 0; i < resources->count_connectors; ++i) {
         const uint32_t currentConnector = resources->connectors[i];
         auto it = std::find_if(m_connectors.constBegin(), m_connectors.constEnd(), [currentConnector] (DrmConnector *c) { return c->id() == currentConnector; });
         if (it == m_connectors.constEnd()) {
             auto c = new DrmConnector(currentConnector, m_fd);
             if (m_atomicModeSetting && !c->atomicInit()) {
                 delete c;
                 continue;
             }
             m_connectors << c;
         } else {
             oldConnectors.removeOne(*it);
         }
     }
 
     auto oldCrtcs = m_crtcs;
     for (int i = 0; i < resources->count_crtcs; ++i) {
         const uint32_t currentCrtc = resources->crtcs[i];
         auto it = std::find_if(m_crtcs.constBegin(), m_crtcs.constEnd(), [currentCrtc] (DrmCrtc *c) { return c->id() == currentCrtc; });
         if (it == m_crtcs.constEnd()) {
             auto c = new DrmCrtc(currentCrtc, this, i);
             if (m_atomicModeSetting && !c->atomicInit()) {
                 delete c;
                 continue;
             }
             m_crtcs << c;
         } else {
             oldCrtcs.removeOne(*it);
         }
     }
 
     for (auto c : qAsConst(oldConnectors)) {
         m_connectors.removeOne(c);
     }
     for (auto c : qAsConst(oldCrtcs)) {
         m_crtcs.removeOne(c);
     }
 
     QVector<DrmOutput*> connectedOutputs;
     QVector<DrmConnector*> pendingConnectors;
 
     // split up connected connectors in already or not yet assigned ones
     for (DrmConnector *con : qAsConst(m_connectors)) {
         if (!con->isConnected()) {
             continue;
         }
 
         if (DrmOutput *o = findOutput(con->id())) {
             connectedOutputs << o;
         } else {
             pendingConnectors << con;
         }
     }
 
     // check for outputs which got removed
     auto it = m_outputs.begin();
     while (it != m_outputs.end()) {
         if (connectedOutputs.contains(*it)) {
             it++;
             continue;
         }
         DrmOutput *removed = *it;
         it = m_outputs.erase(it);
         m_enabledOutputs.removeOne(removed);
         emit outputRemoved(removed);
         removed->teardown();
     }
 
     // now check new connections
     for (DrmConnector *con : qAsConst(pendingConnectors)) {
         DrmScopedPointer<drmModeConnector> connector(drmModeGetConnector(m_fd, con->id()));
         if (!connector) {
             continue;
         }
         if (connector->count_modes == 0) {
             continue;
         }
         bool outputDone = false;
 
         QVector<uint32_t> encoders = con->encoders();
         for (auto encId : qAsConst(encoders)) {
             DrmScopedPointer<drmModeEncoder> encoder(drmModeGetEncoder(m_fd, encId));
             if (!encoder) {
                 continue;
             }
             for (DrmCrtc *crtc : qAsConst(m_crtcs)) {
                 if (!(encoder->possible_crtcs & (1 << crtc->resIndex()))) {
                         continue;
                 }
 
                 // check if crtc isn't used yet -- currently we don't allow multiple outputs on one crtc (cloned mode)
                 auto it = std::find_if(connectedOutputs.constBegin(), connectedOutputs.constEnd(),
                     [crtc] (DrmOutput *o) {
                         return o->m_crtc == crtc;
                     }
                 );
                 if (it != connectedOutputs.constEnd()) {
                     continue;
                 }
 
                 // we found a suitable encoder+crtc
                 // TODO: we could avoid these lib drm calls if we store all struct data in DrmCrtc and DrmConnector in the beginning
                 DrmScopedPointer<drmModeCrtc> modeCrtc(drmModeGetCrtc(m_fd, crtc->id()));
                 if (!modeCrtc) {
                     continue;
                 }
 
                 DrmOutput *output = new DrmOutput(this);
                 con->setOutput(output);
                 output->m_conn = con;
                 crtc->setOutput(output);
                 output->m_crtc = crtc;
 
                 if (modeCrtc->mode_valid) {
                     output->m_mode = modeCrtc->mode;
                 } else {
                     output->m_mode = connector->modes[0];
                 }
                 qCDebug(KWIN_DRM) << "For new output use mode " << output->m_mode.name;
 
                 if (!output->init(connector.data())) {
                     qCWarning(KWIN_DRM) << "Failed to create output for connector " << con->id();
                     delete output;
                     continue;
                 }
                 if (!output->initCursor(m_cursorSize)) {
                     setSoftWareCursor(true);
                 }
                 qCDebug(KWIN_DRM) << "Found new output with uuid" << output->uuid();
 
                 connectedOutputs << output;
                 emit outputAdded(output);
                 outputDone = true;
                 break;
             }
             if (outputDone) {
                 break;
             }
         }
     }
     std::sort(connectedOutputs.begin(), connectedOutputs.end(), [] (DrmOutput *a, DrmOutput *b) { return a->m_conn->id() < b->m_conn->id(); });
     m_outputs = connectedOutputs;
     m_enabledOutputs = connectedOutputs;
     readOutputsConfiguration();
     updateOutputsEnabled();
     if (!m_outputs.isEmpty()) {
         emit screensQueried();
     }
 
     qDeleteAll(oldConnectors);
     qDeleteAll(oldCrtcs);
     return true;
 }
 
 void DrmBackend::readOutputsConfiguration()
 {
     if (m_outputs.isEmpty()) {
         return;
     }
     const QByteArray uuid = generateOutputConfigurationUuid();
     const auto outputGroup = kwinApp()->config()->group("DrmOutputs");
     const auto configGroup = outputGroup.group(uuid);
     // default position goes from left to right
     QPoint pos(0, 0);
     for (auto it = m_outputs.begin(); it != m_outputs.end(); ++it) {
         qCDebug(KWIN_DRM) << "Reading output configuration for [" << uuid << "] ["<< (*it)->uuid() << "]";
         const auto outputConfig = configGroup.group((*it)->uuid());
         (*it)->setGlobalPos(outputConfig.readEntry<QPoint>("Position", pos));
         // TODO: add mode
         if (outputConfig.hasKey("Scale"))
             (*it)->setScale(outputConfig.readEntry("Scale", 1.0));
         pos.setX(pos.x() + (*it)->geometry().width());
     }
 }
 
 void DrmBackend::writeOutputsConfiguration()
 {
     if (m_outputs.isEmpty()) {
         return;
     }
     const QByteArray uuid = generateOutputConfigurationUuid();
     auto configGroup = KSharedConfig::openConfig()->group("DrmOutputs").group(uuid);
     // default position goes from left to right
     for (auto it = m_outputs.cbegin(); it != m_outputs.cend(); ++it) {
         qCDebug(KWIN_DRM) << "Writing output configuration for [" << uuid << "] ["<< (*it)->uuid() << "]";
         auto outputConfig = configGroup.group((*it)->uuid());
         outputConfig.writeEntry("Scale", (*it)->scale());
     }
 }
 
 QByteArray DrmBackend::generateOutputConfigurationUuid() const
 {
     auto it = m_outputs.constBegin();
     if (m_outputs.size() == 1) {
         // special case: one output
         return (*it)->uuid();
     }
     QCryptographicHash hash(QCryptographicHash::Md5);
     for (; it != m_outputs.constEnd(); ++it) {
         hash.addData((*it)->uuid());
     }
     return hash.result().toHex().left(10);
 }
 
 void DrmBackend::enableOutput(DrmOutput *output, bool enable)
 {
     if (enable) {
         Q_ASSERT(!m_enabledOutputs.contains(output));
         m_enabledOutputs << output;
         emit outputAdded(output);
     } else {
         Q_ASSERT(m_enabledOutputs.contains(output));
         m_enabledOutputs.removeOne(output);
         Q_ASSERT(!m_enabledOutputs.contains(output));
         emit outputRemoved(output);
     }
     updateOutputsEnabled();
     checkOutputsAreOn();
     emit screensQueried();
 }
 
 DrmOutput *DrmBackend::findOutput(quint32 connector)
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(), [connector] (DrmOutput *o) {
         return o->m_conn->id() == connector;
     });
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 bool DrmBackend::present(DrmBuffer *buffer, DrmOutput *output)
 {
     if (!buffer || buffer->bufferId() == 0) {
         if (m_deleteBufferAfterPageFlip) {
             delete buffer;
         }
         return false;
     }
 
     if (output->present(buffer)) {
         m_pageFlipsPending++;
         if (m_pageFlipsPending == 1 && Compositor::self()) {
             Compositor::self()->aboutToSwapBuffers();
         }
         return true;
     } else if (m_deleteBufferAfterPageFlip) {
         delete buffer;
     }
     return false;
 }
 
 void DrmBackend::initCursor()
 {
 
 #if HAVE_EGL_STREAMS
     // Hardware cursors aren't currently supported with EGLStream backend,
     // possibly an NVIDIA driver bug
     if (m_useEglStreams) {
         setSoftWareCursor(true);
     }
 #endif
 
     m_cursorEnabled = waylandServer()->seat()->hasPointer();
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::hasPointerChanged, this,
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::hasPointerChanged, this,
         [this] {
             m_cursorEnabled = waylandServer()->seat()->hasPointer();
             if (usesSoftwareCursor()) {
                 return;
             }
             for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
                 if (m_cursorEnabled) {
                     if (!(*it)->showCursor()) {
                         setSoftWareCursor(true);
                     }
                 } else {
                     (*it)->hideCursor();
                 }
             }
         }
     );
     uint64_t capability = 0;
     QSize cursorSize;
     if (drmGetCap(m_fd, DRM_CAP_CURSOR_WIDTH, &capability) == 0) {
         cursorSize.setWidth(capability);
     } else {
         cursorSize.setWidth(64);
     }
     if (drmGetCap(m_fd, DRM_CAP_CURSOR_HEIGHT, &capability) == 0) {
         cursorSize.setHeight(capability);
     } else {
         cursorSize.setHeight(64);
     }
     m_cursorSize = cursorSize;
     // now we have screens and can set cursors, so start tracking
     connect(Cursors::self(), &Cursors::currentCursorChanged, this, &DrmBackend::updateCursor);
     connect(Cursors::self(), &Cursors::positionChanged, this, &DrmBackend::moveCursor);
 }
 
 void DrmBackend::setCursor()
 {
     if (m_cursorEnabled) {
         for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
             if (!(*it)->showCursor()) {
                 setSoftWareCursor(true);
             }
         }
     }
 
     Cursors::self()->currentCursor()->markAsRendered();
 }
 
 void DrmBackend::updateCursor()
 {
     if (usesSoftwareCursor()) {
         return;
     }
     if (isCursorHidden()) {
         return;
     }
 
     auto cursor = Cursors::self()->currentCursor();
     const QImage &cursorImage = cursor->image();
     if (cursorImage.isNull()) {
         doHideCursor();
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->updateCursor();
     }
 
     setCursor();
 
     moveCursor(cursor, cursor->pos());
 }
 
 void DrmBackend::doShowCursor()
 {
     updateCursor();
 }
 
 void DrmBackend::doHideCursor()
 {
     if (!m_cursorEnabled || usesSoftwareCursor()) {
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->hideCursor();
     }
 }
 
 void DrmBackend::moveCursor(Cursor *cursor, const QPoint &pos)
 {
     if (!m_cursorEnabled || isCursorHidden() || usesSoftwareCursor()) {
         return;
     }
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->moveCursor(cursor, pos);
     }
 }
 
 Screens *DrmBackend::createScreens(QObject *parent)
 {
     return new DrmScreens(this, parent);
 }
 
 QPainterBackend *DrmBackend::createQPainterBackend()
 {
     m_deleteBufferAfterPageFlip = false;
     return new DrmQPainterBackend(this);
 }
 
 OpenGLBackend *DrmBackend::createOpenGLBackend()
 {
 #if HAVE_EGL_STREAMS
     if (m_useEglStreams) {
         m_deleteBufferAfterPageFlip = false;
         return new EglStreamBackend(this);
     }
 #endif
 
 #if HAVE_GBM
     m_deleteBufferAfterPageFlip = true;
     return new EglGbmBackend(this);
 #else
     return Platform::createOpenGLBackend();
 #endif
 }
 
 DrmDumbBuffer *DrmBackend::createBuffer(const QSize &size)
 {
     DrmDumbBuffer *b = new DrmDumbBuffer(m_fd, size);
     return b;
 }
 
 #if HAVE_GBM
 DrmSurfaceBuffer *DrmBackend::createBuffer(const std::shared_ptr<GbmSurface> &surface)
 {
     DrmSurfaceBuffer *b = new DrmSurfaceBuffer(m_fd, surface);
     return b;
 }
 #endif
 
 void DrmBackend::updateOutputsEnabled()
 {
     bool enabled = false;
     for (auto it = m_enabledOutputs.constBegin(); it != m_enabledOutputs.constEnd(); ++it) {
         enabled = enabled || (*it)->isDpmsEnabled();
     }
     setOutputsEnabled(enabled);
 }
 
 QVector<CompositingType> DrmBackend::supportedCompositors() const
 {
     if (selectedCompositor() != NoCompositing) {
         return {selectedCompositor()};
     }
 #if HAVE_GBM
     return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
 #elif HAVE_EGL_STREAMS
     return m_useEglStreams ?
         QVector<CompositingType>{OpenGLCompositing, QPainterCompositing} :
         QVector<CompositingType>{QPainterCompositing};
 #else
     return QVector<CompositingType>{QPainterCompositing};
 #endif
 }
 
 QString DrmBackend::supportInformation() const
 {
     QString supportInfo;
     QDebug s(&supportInfo);
     s.nospace();
     s << "Name: " << "DRM" << Qt::endl;
     s << "Active: " << m_active << Qt::endl;
     s << "Atomic Mode Setting: " << m_atomicModeSetting << Qt::endl;
 #if HAVE_EGL_STREAMS
     s << "Using EGL Streams: " << m_useEglStreams << Qt::endl;
 #endif
     return supportInfo;
 }
 
 }
diff --git a/plugins/platforms/drm/drm_inputeventfilter.cpp b/plugins/platforms/drm/drm_inputeventfilter.cpp
index 25697353c..286069e9c 100644
--- a/plugins/platforms/drm/drm_inputeventfilter.cpp
+++ b/plugins/platforms/drm/drm_inputeventfilter.cpp
@@ -1,115 +1,115 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "drm_inputeventfilter.h"
 #include "drm_backend.h"
 #include "wayland_server.h"
 
 #include <QApplication>
 
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 namespace KWin
 {
 
 DpmsInputEventFilter::DpmsInputEventFilter(DrmBackend *backend)
     : InputEventFilter()
     , m_backend(backend)
 {
 }
 
 DpmsInputEventFilter::~DpmsInputEventFilter() = default;
 
 bool DpmsInputEventFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(event)
     Q_UNUSED(nativeButton)
     notify();
     return true;
 }
 
 bool DpmsInputEventFilter::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     notify();
     return true;
 }
 
 bool DpmsInputEventFilter::keyEvent(QKeyEvent *event)
 {
     Q_UNUSED(event)
     notify();
     return true;
 }
 
 bool DpmsInputEventFilter::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(pos)
     Q_UNUSED(time)
     if (m_touchPoints.isEmpty()) {
         if (!m_doubleTapTimer.isValid()) {
             // this is the first tap
             m_doubleTapTimer.start();
         } else {
             if (m_doubleTapTimer.elapsed() < qApp->doubleClickInterval()) {
                 m_secondTap = true;
             } else {
                 // took too long. Let's consider it a new click
                 m_doubleTapTimer.restart();
             }
         }
     } else {
         // not a double tap
         m_doubleTapTimer.invalidate();
         m_secondTap = false;
     }
     m_touchPoints << id;
     return true;
 }
 
 bool DpmsInputEventFilter::touchUp(qint32 id, quint32 time)
 {
     m_touchPoints.removeAll(id);
     if (m_touchPoints.isEmpty() && m_doubleTapTimer.isValid() && m_secondTap) {
         if (m_doubleTapTimer.elapsed() < qApp->doubleClickInterval()) {
             waylandServer()->seat()->setTimestamp(time);
             notify();
         }
         m_doubleTapTimer.invalidate();
         m_secondTap = false;
     }
     return true;
 }
 
 bool DpmsInputEventFilter::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(pos)
     Q_UNUSED(time)
     // ignore the event
     return true;
 }
 
 void DpmsInputEventFilter::notify()
 {
     // queued to not modify the list of event filters while filtering
     QMetaObject::invokeMethod(m_backend, "turnOutputsOn", Qt::QueuedConnection);
 }
 
 }
diff --git a/plugins/platforms/drm/drm_output.cpp b/plugins/platforms/drm/drm_output.cpp
index 3190b6987..0d3ee9778 100644
--- a/plugins/platforms/drm/drm_output.cpp
+++ b/plugins/platforms/drm/drm_output.cpp
@@ -1,1103 +1,1103 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "drm_output.h"
 #include "drm_backend.h"
 #include "drm_object_plane.h"
 #include "drm_object_crtc.h"
 #include "drm_object_connector.h"
 
 #include "composite.h"
 #include "cursor.h"
 #include "logind.h"
 #include "logging.h"
 #include "main.h"
 #include "screens_drm.h"
 #include "wayland_server.h"
 // KWayland
-#include <KWayland/Server/output_interface.h>
+#include <KWaylandServer/output_interface.h>
 // KF5
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 // Qt
 #include <QMatrix4x4>
 #include <QCryptographicHash>
 #include <QPainter>
 // c++
 #include <cerrno>
 // drm
 #include <xf86drm.h>
 #include <xf86drmMode.h>
 #include <libdrm/drm_mode.h>
 
 namespace KWin
 {
 
 DrmOutput::DrmOutput(DrmBackend *backend)
     : AbstractWaylandOutput(backend)
     , m_backend(backend)
 {
 }
 
 DrmOutput::~DrmOutput()
 {
     Q_ASSERT(!m_pageFlipPending);
     teardown();
 }
 
 void DrmOutput::teardown()
 {
     if (m_deleted) {
         return;
     }
     m_deleted = true;
     hideCursor();
     m_crtc->blank();
 
     if (m_primaryPlane) {
         // TODO: when having multiple planes, also clean up these
         m_primaryPlane->setOutput(nullptr);
 
         if (m_backend->deleteBufferAfterPageFlip()) {
             delete m_primaryPlane->current();
         }
         m_primaryPlane->setCurrent(nullptr);
     }
     if (m_cursorPlane) {
         m_cursorPlane->setOutput(nullptr);
     }
 
     m_crtc->setOutput(nullptr);
     m_conn->setOutput(nullptr);
 
     delete m_cursor[0];
     m_cursor[0] = nullptr;
     delete m_cursor[1];
     m_cursor[1] = nullptr;
     if (!m_pageFlipPending) {
         deleteLater();
     } //else will be deleted in the page flip handler
     //this is needed so that the pageflipcallback handle isn't deleted
 }
 
 void DrmOutput::releaseGbm()
 {
     if (DrmBuffer *b = m_crtc->current()) {
         b->releaseGbm();
     }
     if (m_primaryPlane && m_primaryPlane->current()) {
         m_primaryPlane->current()->releaseGbm();
     }
 }
 
 bool DrmOutput::hideCursor()
 {
     return drmModeSetCursor(m_backend->fd(), m_crtc->id(), 0, 0, 0) == 0;
 }
 
 bool DrmOutput::showCursor(DrmDumbBuffer *c)
 {
     const QSize &s = c->size();
     return drmModeSetCursor(m_backend->fd(), m_crtc->id(), c->handle(), s.width(), s.height()) == 0;
 }
 
 bool DrmOutput::showCursor()
 {
     const bool ret = showCursor(m_cursor[m_cursorIndex]);
     if (!ret) {
         return ret;
     }
 
     if (m_hasNewCursor) {
         m_cursorIndex = (m_cursorIndex + 1) % 2;
         m_hasNewCursor = false;
     }
 
     return ret;
 }
 
 // TODO: Do we need to handle the flipped cases differently?
 int transformToRotation(DrmOutput::Transform transform)
 {
     switch (transform) {
     case DrmOutput::Transform::Normal:
     case DrmOutput::Transform::Flipped:
         return 0;
     case DrmOutput::Transform::Rotated90:
     case DrmOutput::Transform::Flipped90:
         return 90;
     case DrmOutput::Transform::Rotated180:
     case DrmOutput::Transform::Flipped180:
         return 180;
     case DrmOutput::Transform::Rotated270:
     case DrmOutput::Transform::Flipped270:
         return 270;
     }
     Q_UNREACHABLE();
     return 0;
 }
 
 QMatrix4x4 DrmOutput::matrixDisplay(const QSize &s) const
 {
     QMatrix4x4 matrix;
     const int angle = transformToRotation(transform());
     if (angle) {
         const QSize center = s / 2;
 
         matrix.translate(center.width(), center.height());
         matrix.rotate(-angle, 0, 0, 1);
         matrix.translate(-center.width(), -center.height());
     }
     matrix.scale(scale());
     return matrix;
 }
 
 void DrmOutput::updateCursor()
 {
     QImage cursorImage = Cursors::self()->currentCursor()->image();
     if (cursorImage.isNull()) {
         return;
     }
     m_hasNewCursor = true;
     QImage *c = m_cursor[m_cursorIndex]->image();
     c->fill(Qt::transparent);
 
     QPainter p;
     p.begin(c);
     p.setWorldTransform(matrixDisplay(QSize(cursorImage.width(), cursorImage.height())).toTransform());
     p.drawImage(QPoint(0, 0), cursorImage);
     p.end();
 }
 
 void DrmOutput::moveCursor(Cursor* cursor, const QPoint &globalPos)
 {
     const QMatrix4x4 hotspotMatrix = matrixDisplay(cursor->image().size());
 
     const QPoint localPos = globalPos - AbstractWaylandOutput::globalPos();
     QPoint pos = localPos;
 
     // TODO: Do we need to handle the flipped cases differently?
     switch (transform()) {
     case Transform::Normal:
     case Transform::Flipped:
         break;
     case Transform::Rotated90:
     case Transform::Flipped90:
         pos = QPoint(localPos.y(), pixelSize().width() / scale() - localPos.x());
         break;
     case Transform::Rotated270:
     case Transform::Flipped270:
         pos = QPoint(pixelSize().height() / scale() - localPos.y(), localPos.x());
         break;
     case Transform::Rotated180:
     case Transform::Flipped180:
         pos = QPoint(pixelSize().width() / scale() - localPos.x(),
                      pixelSize().height() / scale() - localPos.y());
         break;
     default:
         Q_UNREACHABLE();
     }
     pos *= scale();
     pos -= hotspotMatrix.map(cursor->hotspot());
     drmModeMoveCursor(m_backend->fd(), m_crtc->id(), pos.x(), pos.y());
 }
 
 static QHash<int, QByteArray> s_connectorNames = {
     {DRM_MODE_CONNECTOR_Unknown, QByteArrayLiteral("Unknown")},
     {DRM_MODE_CONNECTOR_VGA, QByteArrayLiteral("VGA")},
     {DRM_MODE_CONNECTOR_DVII, QByteArrayLiteral("DVI-I")},
     {DRM_MODE_CONNECTOR_DVID, QByteArrayLiteral("DVI-D")},
     {DRM_MODE_CONNECTOR_DVIA, QByteArrayLiteral("DVI-A")},
     {DRM_MODE_CONNECTOR_Composite, QByteArrayLiteral("Composite")},
     {DRM_MODE_CONNECTOR_SVIDEO, QByteArrayLiteral("SVIDEO")},
     {DRM_MODE_CONNECTOR_LVDS, QByteArrayLiteral("LVDS")},
     {DRM_MODE_CONNECTOR_Component, QByteArrayLiteral("Component")},
     {DRM_MODE_CONNECTOR_9PinDIN, QByteArrayLiteral("DIN")},
     {DRM_MODE_CONNECTOR_DisplayPort, QByteArrayLiteral("DP")},
     {DRM_MODE_CONNECTOR_HDMIA, QByteArrayLiteral("HDMI-A")},
     {DRM_MODE_CONNECTOR_HDMIB, QByteArrayLiteral("HDMI-B")},
     {DRM_MODE_CONNECTOR_TV, QByteArrayLiteral("TV")},
     {DRM_MODE_CONNECTOR_eDP, QByteArrayLiteral("eDP")},
     {DRM_MODE_CONNECTOR_VIRTUAL, QByteArrayLiteral("Virtual")},
     {DRM_MODE_CONNECTOR_DSI, QByteArrayLiteral("DSI")},
 #ifdef DRM_MODE_CONNECTOR_DPI
     {DRM_MODE_CONNECTOR_DPI, QByteArrayLiteral("DPI")},
 #endif
 };
 
 namespace {
 quint64 refreshRateForMode(_drmModeModeInfo *m)
 {
     // Calculate higher precision (mHz) refresh rate
     // logic based on Weston, see compositor-drm.c
     quint64 refreshRate = (m->clock * 1000000LL / m->htotal + m->vtotal / 2) / m->vtotal;
     if (m->flags & DRM_MODE_FLAG_INTERLACE) {
         refreshRate *= 2;
     }
     if (m->flags & DRM_MODE_FLAG_DBLSCAN) {
         refreshRate /= 2;
     }
     if (m->vscan > 1) {
         refreshRate /= m->vscan;
     }
     return refreshRate;
 }
 }
 
 bool DrmOutput::init(drmModeConnector *connector)
 {
     initEdid(connector);
     initDpms(connector);
     initUuid();
     if (m_backend->atomicModeSetting()) {
         if (!initPrimaryPlane()) {
             return false;
         }
     }
 
     setInternal(connector->connector_type == DRM_MODE_CONNECTOR_LVDS || connector->connector_type == DRM_MODE_CONNECTOR_eDP
                 || connector->connector_type == DRM_MODE_CONNECTOR_DSI);
     setDpmsSupported(true);
     initOutputDevice(connector);
 
     if (!m_backend->atomicModeSetting() && !m_crtc->blank()) {
         // We use legacy mode and the initial output blank failed.
         return false;
     }
 
-    updateDpms(KWayland::Server::OutputInterface::DpmsMode::On);
+    updateDpms(KWaylandServer::OutputInterface::DpmsMode::On);
     return true;
 }
 
 void DrmOutput::initUuid()
 {
     QCryptographicHash hash(QCryptographicHash::Md5);
     hash.addData(QByteArray::number(m_conn->id()));
     hash.addData(m_edid.eisaId());
     hash.addData(m_edid.monitorName());
     hash.addData(m_edid.serialNumber());
     m_uuid = hash.result().toHex().left(10);
 }
 
 void DrmOutput::initOutputDevice(drmModeConnector *connector)
 {
     QString manufacturer;
     if (!m_edid.vendor().isEmpty()) {
         manufacturer = QString::fromLatin1(m_edid.vendor());
     } else if (!m_edid.eisaId().isEmpty()) {
         manufacturer = QString::fromLatin1(m_edid.eisaId());
     }
 
     QString connectorName = s_connectorNames.value(connector->connector_type, QByteArrayLiteral("Unknown")) + QStringLiteral("-") + QString::number(connector->connector_type_id);
     QString modelName;
 
     if (!m_edid.monitorName().isEmpty()) {
         QString m = QString::fromLatin1(m_edid.monitorName());
         if (!m_edid.serialNumber().isEmpty()) {
             m.append('/');
             m.append(QString::fromLatin1(m_edid.serialNumber()));
         }
         modelName = m;
     } else if (!m_edid.serialNumber().isEmpty()) {
         modelName = QString::fromLatin1(m_edid.serialNumber());
     } else {
         modelName = i18n("unknown");
     }
 
     const QString model = connectorName + QStringLiteral("-") + modelName;
 
     // read in mode information
-    QVector<KWayland::Server::OutputDeviceInterface::Mode> modes;
+    QVector<KWaylandServer::OutputDeviceInterface::Mode> modes;
     for (int i = 0; i < connector->count_modes; ++i) {
         // TODO: in AMS here we could read and store for later every mode's blob_id
         // would simplify isCurrentMode(..) and presentAtomically(..) in case of mode set
         auto *m = &connector->modes[i];
-        KWayland::Server::OutputDeviceInterface::ModeFlags deviceflags;
+        KWaylandServer::OutputDeviceInterface::ModeFlags deviceflags;
         if (isCurrentMode(m)) {
-            deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
+            deviceflags |= KWaylandServer::OutputDeviceInterface::ModeFlag::Current;
         }
         if (m->type & DRM_MODE_TYPE_PREFERRED) {
-            deviceflags |= KWayland::Server::OutputDeviceInterface::ModeFlag::Preferred;
+            deviceflags |= KWaylandServer::OutputDeviceInterface::ModeFlag::Preferred;
         }
 
-        KWayland::Server::OutputDeviceInterface::Mode mode;
+        KWaylandServer::OutputDeviceInterface::Mode mode;
         mode.id = i;
         mode.size = QSize(m->hdisplay, m->vdisplay);
         mode.flags = deviceflags;
         mode.refreshRate = refreshRateForMode(m);
         modes << mode;
     }
 
     QSize physicalSize = !m_edid.physicalSize().isEmpty() ? m_edid.physicalSize() : QSize(connector->mmWidth, connector->mmHeight);
     // the size might be completely borked. E.g. Samsung SyncMaster 2494HS reports 160x90 while in truth it's 520x292
     // as this information is used to calculate DPI info, it's going to result in everything being huge
     const QByteArray unknown = QByteArrayLiteral("unknown");
     KConfigGroup group = kwinApp()->config()->group("EdidOverwrite").group(m_edid.eisaId().isEmpty() ? unknown : m_edid.eisaId())
                                                        .group(m_edid.monitorName().isEmpty() ? unknown : m_edid.monitorName())
                                                        .group(m_edid.serialNumber().isEmpty() ? unknown : m_edid.serialNumber());
     if (group.hasKey("PhysicalSize")) {
         const QSize overwriteSize = group.readEntry("PhysicalSize", physicalSize);
         qCWarning(KWIN_DRM) << "Overwriting monitor physical size for" << m_edid.eisaId() << "/" << m_edid.monitorName() << "/" << m_edid.serialNumber() << " from " << physicalSize << "to " << overwriteSize;
         physicalSize = overwriteSize;
     }
     setName(connectorName);
     initInterfaces(model, manufacturer, m_uuid, physicalSize, modes);
 }
 
 bool DrmOutput::isCurrentMode(const drmModeModeInfo *mode) const
 {
     return mode->clock       == m_mode.clock
         && mode->hdisplay    == m_mode.hdisplay
         && mode->hsync_start == m_mode.hsync_start
         && mode->hsync_end   == m_mode.hsync_end
         && mode->htotal      == m_mode.htotal
         && mode->hskew       == m_mode.hskew
         && mode->vdisplay    == m_mode.vdisplay
         && mode->vsync_start == m_mode.vsync_start
         && mode->vsync_end   == m_mode.vsync_end
         && mode->vtotal      == m_mode.vtotal
         && mode->vscan       == m_mode.vscan
         && mode->vrefresh    == m_mode.vrefresh
         && mode->flags       == m_mode.flags
         && mode->type        == m_mode.type
         && qstrcmp(mode->name, m_mode.name) == 0;
 }
 void DrmOutput::initEdid(drmModeConnector *connector)
 {
     DrmScopedPointer<drmModePropertyBlobRes> edid;
     for (int i = 0; i < connector->count_props; ++i) {
         DrmScopedPointer<drmModePropertyRes> property(drmModeGetProperty(m_backend->fd(), connector->props[i]));
         if (!property) {
             continue;
         }
         if ((property->flags & DRM_MODE_PROP_BLOB) && qstrcmp(property->name, "EDID") == 0) {
             edid.reset(drmModeGetPropertyBlob(m_backend->fd(), connector->prop_values[i]));
         }
     }
     if (!edid) {
         return;
     }
 
     m_edid = Edid(edid->data, edid->length);
     if (!m_edid.isValid()) {
         qCWarning(KWIN_DRM, "Couldn't parse EDID for connector with id %d", m_conn->id());
     }
 }
 
 bool DrmOutput::initPrimaryPlane()
 {
     for (int i = 0; i < m_backend->planes().size(); ++i) {
         DrmPlane* p = m_backend->planes()[i];
         if (!p) {
             continue;
         }
         if (p->type() != DrmPlane::TypeIndex::Primary) {
             continue;
         }
         if (p->output()) {     // Plane already has an output
             continue;
         }
         if (m_primaryPlane) {     // Output already has a primary plane
             continue;
         }
         if (!p->isCrtcSupported(m_crtc->resIndex())) {
             continue;
         }
         p->setOutput(this);
         m_primaryPlane = p;
         qCDebug(KWIN_DRM) << "Initialized primary plane" << p->id() << "on CRTC" << m_crtc->id();
         return true;
     }
     qCCritical(KWIN_DRM) << "Failed to initialize primary plane.";
     return false;
 }
 
 bool DrmOutput::initCursorPlane()       // TODO: Add call in init (but needs layer support in general first)
 {
     for (int i = 0; i < m_backend->planes().size(); ++i) {
         DrmPlane* p = m_backend->planes()[i];
         if (!p) {
             continue;
         }
         if (p->type() != DrmPlane::TypeIndex::Cursor) {
             continue;
         }
         if (p->output()) {     // Plane already has an output
             continue;
         }
         if (m_cursorPlane) {     // Output already has a cursor plane
             continue;
         }
         if (!p->isCrtcSupported(m_crtc->resIndex())) {
             continue;
         }
         p->setOutput(this);
         m_cursorPlane = p;
         qCDebug(KWIN_DRM) << "Initialized cursor plane" << p->id() << "on CRTC" << m_crtc->id();
         return true;
     }
     return false;
 }
 
 bool DrmOutput::initCursor(const QSize &cursorSize)
 {
     auto createCursor = [this, cursorSize] (int index) {
         m_cursor[index] = m_backend->createBuffer(cursorSize);
         if (!m_cursor[index]->map(QImage::Format_ARGB32_Premultiplied)) {
             return false;
         }
         return true;
     };
     if (!createCursor(0) || !createCursor(1)) {
         return false;
     }
     return true;
 }
 
 void DrmOutput::initDpms(drmModeConnector *connector)
 {
     for (int i = 0; i < connector->count_props; ++i) {
         DrmScopedPointer<drmModePropertyRes> property(drmModeGetProperty(m_backend->fd(), connector->props[i]));
         if (!property) {
             continue;
         }
         if (qstrcmp(property->name, "DPMS") == 0) {
             m_dpms.swap(property);
             break;
         }
     }
 }
 
 void DrmOutput::updateEnablement(bool enable)
 {
     if (enable) {
         m_dpmsModePending = DpmsMode::On;
         if (m_backend->atomicModeSetting()) {
             atomicEnable();
         } else {
             if (dpmsLegacyApply()) {
                 m_backend->enableOutput(this, true);
             }
         }
 
     } else {
         m_dpmsModePending = DpmsMode::Off;
         if (m_backend->atomicModeSetting()) {
             atomicDisable();
         } else {
             if (dpmsLegacyApply()) {
                 m_backend->enableOutput(this, false);
             }
         }
     }
 }
 
 void DrmOutput::atomicEnable()
 {
     m_modesetRequested = true;
 
     if (m_atomicOffPending) {
         Q_ASSERT(m_pageFlipPending);
         m_atomicOffPending = false;
     }
     m_backend->enableOutput(this, true);
 
     if (Compositor *compositor = Compositor::self()) {
         compositor->addRepaintFull();
     }
 }
 
 void DrmOutput::atomicDisable()
 {
     m_modesetRequested = true;
 
     m_backend->enableOutput(this, false);
     m_atomicOffPending = true;
     if (!m_pageFlipPending) {
         dpmsAtomicOff();
     }
 }
 
-static DrmOutput::DpmsMode fromWaylandDpmsMode(KWayland::Server::OutputInterface::DpmsMode wlMode)
+static DrmOutput::DpmsMode fromWaylandDpmsMode(KWaylandServer::OutputInterface::DpmsMode wlMode)
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     switch (wlMode) {
     case OutputInterface::DpmsMode::On:
         return DrmOutput::DpmsMode::On;
     case OutputInterface::DpmsMode::Standby:
         return DrmOutput::DpmsMode::Standby;
     case OutputInterface::DpmsMode::Suspend:
         return DrmOutput::DpmsMode::Suspend;
     case OutputInterface::DpmsMode::Off:
         return DrmOutput::DpmsMode::Off;
     default:
         Q_UNREACHABLE();
     }
 }
 
-static KWayland::Server::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode)
+static KWaylandServer::OutputInterface::DpmsMode toWaylandDpmsMode(DrmOutput::DpmsMode mode)
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     switch (mode) {
     case DrmOutput::DpmsMode::On:
         return OutputInterface::DpmsMode::On;
     case DrmOutput::DpmsMode::Standby:
         return OutputInterface::DpmsMode::Standby;
     case DrmOutput::DpmsMode::Suspend:
         return OutputInterface::DpmsMode::Suspend;
     case DrmOutput::DpmsMode::Off:
         return OutputInterface::DpmsMode::Off;
     default:
         Q_UNREACHABLE();
     }
 }
 
-void DrmOutput::updateDpms(KWayland::Server::OutputInterface::DpmsMode mode)
+void DrmOutput::updateDpms(KWaylandServer::OutputInterface::DpmsMode mode)
 {
     if (m_dpms.isNull() || !isEnabled()) {
         return;
     }
 
     const auto drmMode = fromWaylandDpmsMode(mode);
 
     if (drmMode == m_dpmsModePending) {
         qCDebug(KWIN_DRM) << "New DPMS mode equals old mode. DPMS unchanged.";
         return;
     }
 
     m_dpmsModePending = drmMode;
 
     if (m_backend->atomicModeSetting()) {
         m_modesetRequested = true;
         if (drmMode == DpmsMode::On) {
             if (m_atomicOffPending) {
                 Q_ASSERT(m_pageFlipPending);
                 m_atomicOffPending = false;
             }
             dpmsFinishOn();
         } else {
             m_atomicOffPending = true;
             if (!m_pageFlipPending) {
                 dpmsAtomicOff();
             }
         }
     } else {
        dpmsLegacyApply();
     }
 }
 
 void DrmOutput::dpmsFinishOn()
 {
     qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to On.";
 
     auto wlOutput = waylandOutput();
     if (wlOutput) {
         wlOutput->setDpmsMode(toWaylandDpmsMode(DpmsMode::On));
     }
 
     m_backend->checkOutputsAreOn();
     if (!m_backend->atomicModeSetting()) {
         m_crtc->blank();
     }
     if (Compositor *compositor = Compositor::self()) {
         compositor->addRepaintFull();
     }
 }
 
 void DrmOutput::dpmsFinishOff()
 {
     qCDebug(KWIN_DRM) << "DPMS mode set for output" << m_crtc->id() << "to Off.";
 
     if (isEnabled()) {
         waylandOutput()->setDpmsMode(toWaylandDpmsMode(m_dpmsModePending));
         m_backend->createDpmsFilter();
     }
 }
 
 bool DrmOutput::dpmsLegacyApply()
 {
     if (drmModeConnectorSetProperty(m_backend->fd(), m_conn->id(),
                                     m_dpms->prop_id, uint64_t(m_dpmsModePending)) < 0) {
         m_dpmsModePending = m_dpmsMode;
         qCWarning(KWIN_DRM) << "Setting DPMS failed";
         return false;
     }
     if (m_dpmsModePending == DpmsMode::On) {
         dpmsFinishOn();
     } else {
         dpmsFinishOff();
     }
     m_dpmsMode = m_dpmsModePending;
     return true;
 }
 
 DrmPlane::Transformations outputToPlaneTransform(DrmOutput::Transform transform)
  {
     using OutTrans = DrmOutput::Transform;
     using PlaneTrans = DrmPlane::Transformation;
 
      // TODO: Do we want to support reflections (flips)?
 
      switch (transform) {
     case OutTrans::Normal:
     case OutTrans::Flipped:
         return PlaneTrans::Rotate0;
     case OutTrans::Rotated90:
     case OutTrans::Flipped90:
         return PlaneTrans::Rotate90;
     case OutTrans::Rotated180:
     case OutTrans::Flipped180:
         return PlaneTrans::Rotate180;
     case OutTrans::Rotated270:
     case OutTrans::Flipped270:
         return PlaneTrans::Rotate270;
      default:
          Q_UNREACHABLE();
      }
 }
 
 bool DrmOutput::hardwareTransforms() const
 {
     if (!m_primaryPlane) {
         return false;
     }
     return m_primaryPlane->transformation() == outputToPlaneTransform(transform());
 }
 
 int DrmOutput::rotation() const
 {
     return transformToRotation(transform());
 }
 
 void DrmOutput::updateTransform(Transform transform)
 {
     const auto planeTransform = outputToPlaneTransform(transform);
 
      if (m_primaryPlane) {
         // At the moment we have to exclude hardware transforms for vertical buffers.
         // For that we need to support other buffers and graceful fallback from atomic tests.
         // Reason is that standard linear buffers are not suitable.
         const bool isPortrait = transform == Transform::Rotated90
                                 || transform == Transform::Flipped90
                                 || transform == Transform::Rotated270
                                 || transform == Transform::Flipped270;
 
         if (!qEnvironmentVariableIsSet("KWIN_DRM_SW_ROTATIONS_ONLY") &&
                 (m_primaryPlane->supportedTransformations() & planeTransform) &&
                 !isPortrait) {
             m_primaryPlane->setTransformation(planeTransform);
         } else {
             m_primaryPlane->setTransformation(DrmPlane::Transformation::Rotate0);
         }
     }
     m_modesetRequested = true;
 
     // the cursor might need to get rotated
     updateCursor();
     showCursor();
 }
 
 void DrmOutput::updateMode(int modeIndex)
 {
     // get all modes on the connector
     DrmScopedPointer<drmModeConnector> connector(drmModeGetConnector(m_backend->fd(), m_conn->id()));
     if (connector->count_modes <= modeIndex) {
         // TODO: error?
         return;
     }
     if (isCurrentMode(&connector->modes[modeIndex])) {
         // nothing to do
         return;
     }
     m_mode = connector->modes[modeIndex];
     m_modesetRequested = true;
     setWaylandMode();
 }
 
 void DrmOutput::setWaylandMode()
 {
     AbstractWaylandOutput::setWaylandMode(QSize(m_mode.hdisplay, m_mode.vdisplay),
                                           refreshRateForMode(&m_mode));
 }
 
 void DrmOutput::pageFlipped()
 {
     // In legacy mode we might get a page flip through a blank.
     Q_ASSERT(m_pageFlipPending || !m_backend->atomicModeSetting());
     m_pageFlipPending = false;
 
     if (m_deleted) {
         deleteLater();
         return;
     }
 
     if (!m_crtc) {
         return;
     }
     // Egl based surface buffers get destroyed, QPainter based dumb buffers not
     // TODO: split up DrmOutput in two for dumb and egl/gbm surface buffer compatible subclasses completely?
     if (m_backend->deleteBufferAfterPageFlip()) {
         if (m_backend->atomicModeSetting()) {
             if (!m_primaryPlane->next()) {
                 // on manual vt switch
                 // TODO: when we later use overlay planes it might happen, that we have a page flip with only
                 //       damage on one of these, and therefore the primary plane has no next buffer
                 //       -> Then we don't want to return here!
                 if (m_primaryPlane->current()) {
                     m_primaryPlane->current()->releaseGbm();
                 }
                 return;
             }
             for (DrmPlane *p : m_nextPlanesFlipList) {
                 p->flipBufferWithDelete();
             }
             m_nextPlanesFlipList.clear();
         } else {
             if (!m_crtc->next()) {
                 // on manual vt switch
                 if (DrmBuffer *b = m_crtc->current()) {
                     b->releaseGbm();
                 }
             }
             m_crtc->flipBuffer();
         }
     } else {
         if (m_backend->atomicModeSetting()){
             for (DrmPlane *p : m_nextPlanesFlipList) {
                 p->flipBuffer();
             }
             m_nextPlanesFlipList.clear();
         } else {
             m_crtc->flipBuffer();
         }
         m_crtc->flipBuffer();
     }
 
     if (m_atomicOffPending) {
         dpmsAtomicOff();
     }
 }
 
 bool DrmOutput::present(DrmBuffer *buffer)
 {
     if (m_dpmsModePending != DpmsMode::On) {
         return false;
     }
     if (m_backend->atomicModeSetting()) {
         return presentAtomically(buffer);
     } else {
         return presentLegacy(buffer);
     }
 }
 
 bool DrmOutput::dpmsAtomicOff()
 {
     m_atomicOffPending = false;
 
     // TODO: With multiple planes: deactivate all of them here
     delete m_primaryPlane->next();
     m_primaryPlane->setNext(nullptr);
     m_nextPlanesFlipList << m_primaryPlane;
 
     if (!doAtomicCommit(AtomicCommitMode::Test)) {
         qCDebug(KWIN_DRM) << "Atomic test commit to Dpms Off failed. Aborting.";
         return false;
     }
     if (!doAtomicCommit(AtomicCommitMode::Real)) {
         qCDebug(KWIN_DRM) << "Atomic commit to Dpms Off failed. This should have never happened! Aborting.";
         return false;
     }
     m_nextPlanesFlipList.clear();
     dpmsFinishOff();
 
     return true;
 }
 
 bool DrmOutput::presentAtomically(DrmBuffer *buffer)
 {
     if (!LogindIntegration::self()->isActiveSession()) {
         qCWarning(KWIN_DRM) << "Logind session not active.";
         return false;
     }
 
     if (m_pageFlipPending) {
         qCWarning(KWIN_DRM) << "Page not yet flipped.";
         return false;
     }
 
 #if HAVE_EGL_STREAMS
     if (m_backend->useEglStreams() && !m_modesetRequested) {
         // EglStreamBackend queues normal page flips through EGL,
         // modesets are still performed through DRM-KMS
         m_pageFlipPending = true;
         return true;
     }
 #endif
 
     m_primaryPlane->setNext(buffer);
     m_nextPlanesFlipList << m_primaryPlane;
 
     if (!doAtomicCommit(AtomicCommitMode::Test)) {
         //TODO: When we use planes for layered rendering, fallback to renderer instead. Also for direct scanout?
         //TODO: Probably should undo setNext and reset the flip list
         qCDebug(KWIN_DRM) << "Atomic test commit failed. Aborting present.";
         // go back to previous state
         if (m_lastWorkingState.valid) {
             m_mode = m_lastWorkingState.mode;
             setTransform(m_lastWorkingState.transform);
             setGlobalPos(m_lastWorkingState.globalPos);
             if (m_primaryPlane) {
                 m_primaryPlane->setTransformation(m_lastWorkingState.planeTransformations);
             }
             m_modesetRequested = true;
             // the cursor might need to get rotated
             updateCursor();
             showCursor();
             // TODO: forward to OutputInterface and OutputDeviceInterface
             setWaylandMode();
             emit screens()->changed();
         }
         return false;
     }
     const bool wasModeset = m_modesetRequested;
     if (!doAtomicCommit(AtomicCommitMode::Real)) {
         qCDebug(KWIN_DRM) << "Atomic commit failed. This should have never happened! Aborting present.";
         //TODO: Probably should undo setNext and reset the flip list
         return false;
     }
     if (wasModeset) {
         // store current mode set as new good state
         m_lastWorkingState.mode = m_mode;
         m_lastWorkingState.transform = transform();
         m_lastWorkingState.globalPos = globalPos();
         if (m_primaryPlane) {
             m_lastWorkingState.planeTransformations = m_primaryPlane->transformation();
         }
         m_lastWorkingState.valid = true;
     }
     m_pageFlipPending = true;
     return true;
 }
 
 bool DrmOutput::presentLegacy(DrmBuffer *buffer)
 {
     if (m_crtc->next()) {
         return false;
     }
     if (!LogindIntegration::self()->isActiveSession()) {
         m_crtc->setNext(buffer);
         return false;
     }
 
     // Do we need to set a new mode first?
     if (!m_crtc->current() || m_crtc->current()->needsModeChange(buffer)) {
         if (!setModeLegacy(buffer)) {
             return false;
         }
     }
     const bool ok = drmModePageFlip(m_backend->fd(), m_crtc->id(), buffer->bufferId(), DRM_MODE_PAGE_FLIP_EVENT, this) == 0;
     if (ok) {
         m_crtc->setNext(buffer);
     } else {
         qCWarning(KWIN_DRM) << "Page flip failed:" << strerror(errno);
     }
     return ok;
 }
 
 bool DrmOutput::setModeLegacy(DrmBuffer *buffer)
 {
     uint32_t connId = m_conn->id();
     if (drmModeSetCrtc(m_backend->fd(), m_crtc->id(), buffer->bufferId(), 0, 0, &connId, 1, &m_mode) == 0) {
         return true;
     } else {
         qCWarning(KWIN_DRM) << "Mode setting failed";
         return false;
     }
 }
 
 bool DrmOutput::doAtomicCommit(AtomicCommitMode mode)
 {
     drmModeAtomicReq *req = drmModeAtomicAlloc();
 
     auto errorHandler = [this, mode, req] () {
         if (mode == AtomicCommitMode::Test) {
             // TODO: when we later test overlay planes, make sure we change only the right stuff back
         }
         if (req) {
             drmModeAtomicFree(req);
         }
 
         if (m_dpmsMode != m_dpmsModePending) {
             qCWarning(KWIN_DRM) << "Setting DPMS failed";
             m_dpmsModePending = m_dpmsMode;
             if (m_dpmsMode != DpmsMode::On) {
                 dpmsFinishOff();
             }
         }
 
         // TODO: see above, rework later for overlay planes!
         for (DrmPlane *p : m_nextPlanesFlipList) {
             p->setNext(nullptr);
         }
         m_nextPlanesFlipList.clear();
 
     };
 
     if (!req) {
             qCWarning(KWIN_DRM) << "DRM: couldn't allocate atomic request";
             errorHandler();
             return false;
     }
 
     uint32_t flags = 0;
 
     // Do we need to set a new mode?
     if (m_modesetRequested) {
         if (m_dpmsModePending == DpmsMode::On) {
             if (drmModeCreatePropertyBlob(m_backend->fd(), &m_mode, sizeof(m_mode), &m_blobId) != 0) {
                 qCWarning(KWIN_DRM) << "Failed to create property blob";
                 errorHandler();
                 return false;
             }
         }
         if (!atomicReqModesetPopulate(req, m_dpmsModePending == DpmsMode::On)){
             qCWarning(KWIN_DRM) << "Failed to populate Atomic Modeset";
             errorHandler();
             return false;
         }
         flags |= DRM_MODE_ATOMIC_ALLOW_MODESET;
     }
 
     if (mode == AtomicCommitMode::Real) {
         if (m_dpmsModePending == DpmsMode::On) {
             if (!(flags & DRM_MODE_ATOMIC_ALLOW_MODESET)) {
                 // TODO: Evaluating this condition should only be necessary, as long as we expect older kernels than 4.10.
                 flags |= DRM_MODE_ATOMIC_NONBLOCK;
             }
 
 #if HAVE_EGL_STREAMS
             if (!m_backend->useEglStreams())
                 // EglStreamBackend uses the NV_output_drm_flip_event EGL extension
                 // to register the flip event through eglStreamConsumerAcquireAttribNV
 #endif
                 flags |= DRM_MODE_PAGE_FLIP_EVENT;
         }
     } else {
         flags |= DRM_MODE_ATOMIC_TEST_ONLY;
     }
 
     bool ret = true;
     // TODO: Make sure when we use more than one plane at a time, that we go through this list in the right order.
     for (int i = m_nextPlanesFlipList.size() - 1; 0 <= i; i-- ) {
         DrmPlane *p = m_nextPlanesFlipList[i];
         ret &= p->atomicPopulate(req);
     }
 
     if (!ret) {
         qCWarning(KWIN_DRM) << "Failed to populate atomic planes. Abort atomic commit!";
         errorHandler();
         return false;
     }
 
     if (drmModeAtomicCommit(m_backend->fd(), req, flags, this)) {
         qCWarning(KWIN_DRM) << "Atomic request failed to commit:" << strerror(errno);
         errorHandler();
         return false;
     }
 
     if (mode == AtomicCommitMode::Real && (flags & DRM_MODE_ATOMIC_ALLOW_MODESET)) {
         qCDebug(KWIN_DRM) << "Atomic Modeset successful.";
         m_modesetRequested = false;
         m_dpmsMode = m_dpmsModePending;
     }
 
     drmModeAtomicFree(req);
     return true;
 }
 
 bool DrmOutput::atomicReqModesetPopulate(drmModeAtomicReq *req, bool enable)
 {
     if (enable) {
         const QSize mSize = modeSize();
         const QSize sourceSize = hardwareTransforms() ? pixelSize() : mSize;
 
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcX), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcY), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcW), sourceSize.width() << 16);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcH), sourceSize.height() << 16);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcW), mSize.width());
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcH), mSize.height());
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcId), m_crtc->id());
     } else {
         if (m_backend->deleteBufferAfterPageFlip()) {
             delete m_primaryPlane->current();
             delete m_primaryPlane->next();
         }
         m_primaryPlane->setCurrent(nullptr);
         m_primaryPlane->setNext(nullptr);
 
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcX), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcY), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcW), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::SrcH), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcW), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcH), 0);
         m_primaryPlane->setValue(int(DrmPlane::PropertyIndex::CrtcId), 0);
     }
     m_conn->setValue(int(DrmConnector::PropertyIndex::CrtcId), enable ? m_crtc->id() : 0);
     m_crtc->setValue(int(DrmCrtc::PropertyIndex::ModeId), enable ? m_blobId : 0);
     m_crtc->setValue(int(DrmCrtc::PropertyIndex::Active), enable);
 
     bool ret = true;
     ret &= m_conn->atomicPopulate(req);
     ret &= m_crtc->atomicPopulate(req);
 
     return ret;
 }
 
 bool DrmOutput::supportsTransformations() const
 {
     if (!m_primaryPlane) {
         return false;
     }
     const auto transformations = m_primaryPlane->supportedTransformations();
     return transformations.testFlag(DrmPlane::Transformation::Rotate90)
         || transformations.testFlag(DrmPlane::Transformation::Rotate180)
         || transformations.testFlag(DrmPlane::Transformation::Rotate270);
 }
 
 int DrmOutput::gammaRampSize() const
 {
     return m_crtc->gammaRampSize();
 }
 
 bool DrmOutput::setGammaRamp(const GammaRamp &gamma)
 {
     return m_crtc->setGammaRamp(gamma);
 }
 
 }
 
 QDebug& operator<<(QDebug& s, const KWin::DrmOutput* output)
 {
     if (!output)
         return s.nospace() << "DrmOutput()";
     return s.nospace() << "DrmOutput(" << output->name() << ", crtc:" << output->crtc() << ", connector:" << output->connector() << ", geometry:" << output->geometry() << ')';
 }
diff --git a/plugins/platforms/drm/drm_output.h b/plugins/platforms/drm/drm_output.h
index e2e0403f4..8e5918aad 100644
--- a/plugins/platforms/drm/drm_output.h
+++ b/plugins/platforms/drm/drm_output.h
@@ -1,198 +1,198 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_DRM_OUTPUT_H
 #define KWIN_DRM_OUTPUT_H
 
 #include "abstract_wayland_output.h"
 #include "drm_pointer.h"
 #include "drm_object.h"
 #include "drm_object_plane.h"
 #include "edid.h"
 
 #include <QObject>
 #include <QPoint>
 #include <QSize>
 #include <QVector>
 #include <xf86drmMode.h>
 
 namespace KWin
 {
 
 class DrmBackend;
 class DrmBuffer;
 class DrmDumbBuffer;
 class DrmPlane;
 class DrmConnector;
 class DrmCrtc;
 class Cursor;
 
 class KWIN_EXPORT DrmOutput : public AbstractWaylandOutput
 {
     Q_OBJECT
 public:
     ///deletes the output, calling this whilst a page flip is pending will result in an error
     ~DrmOutput() override;
     ///queues deleting the output after a page flip has completed.
     void teardown();
     void releaseGbm();
     bool showCursor(DrmDumbBuffer *buffer);
     bool showCursor();
     bool hideCursor();
     void updateCursor();
     void moveCursor(Cursor* cursor, const QPoint &globalPos);
     bool init(drmModeConnector *connector);
     bool present(DrmBuffer *buffer);
     void pageFlipped();
 
     // These values are defined by the kernel
     enum class DpmsMode {
         On = DRM_MODE_DPMS_ON,
         Standby = DRM_MODE_DPMS_STANDBY,
         Suspend = DRM_MODE_DPMS_SUSPEND,
         Off = DRM_MODE_DPMS_OFF
     };
     Q_ENUM(DpmsMode);
     bool isDpmsEnabled() const {
         // We care for current as well as pending mode in order to allow first present in AMS.
         return m_dpmsModePending == DpmsMode::On;
     }
 
     DpmsMode dpmsMode() const {
         return m_dpmsMode;
     }
     DpmsMode dpmsModePending() const {
         return m_dpmsModePending;
     }
 
     const DrmCrtc *crtc() const {
         return m_crtc;
     }
     const DrmConnector *connector() const {
         return m_conn;
     }
     const DrmPlane *primaryPlane() const {
         return m_primaryPlane;
     }
 
     bool initCursor(const QSize &cursorSize);
 
     bool supportsTransformations() const;
 
     /**
      * Drm planes might be capable of realizing the current output transform without usage
      * of compositing. This is a getter to query the current state of that
      *
      * @return true if the hardware realizes the transform without further assistance
      */
     bool hardwareTransforms() const;
 
     /**
      * The current rotation of the output
      *
      * @return rotation in degree
      */
     int rotation() const;
 
 private:
     friend class DrmBackend;
     friend class DrmCrtc;   // TODO: For use of setModeLegacy. Remove later when we allow multiple connectors per crtc
                             //       and save the connector ids in the DrmCrtc instance.
     DrmOutput(DrmBackend *backend);
 
     bool presentAtomically(DrmBuffer *buffer);
 
     enum class AtomicCommitMode {
         Test,
         Real
     };
     bool doAtomicCommit(AtomicCommitMode mode);
 
     bool presentLegacy(DrmBuffer *buffer);
     bool setModeLegacy(DrmBuffer *buffer);
     void initEdid(drmModeConnector *connector);
     void initDpms(drmModeConnector *connector);
     void initOutputDevice(drmModeConnector *connector);
 
     bool isCurrentMode(const drmModeModeInfo *mode) const;
     void initUuid();
     bool initPrimaryPlane();
     bool initCursorPlane();
 
     void atomicEnable();
     void atomicDisable();
     void updateEnablement(bool enable) override;
 
     bool dpmsAtomicOff();
     bool dpmsLegacyApply();
 
     void dpmsFinishOn();
     void dpmsFinishOff();
 
     bool atomicReqModesetPopulate(drmModeAtomicReq *req, bool enable);
-    void updateDpms(KWayland::Server::OutputInterface::DpmsMode mode) override;
+    void updateDpms(KWaylandServer::OutputInterface::DpmsMode mode) override;
     void updateMode(int modeIndex) override;
     void setWaylandMode();
 
     void updateTransform(Transform transform) override;
 
     int gammaRampSize() const override;
     bool setGammaRamp(const GammaRamp &gamma) override;
     QMatrix4x4 matrixDisplay(const QSize &s) const;
 
     DrmBackend *m_backend;
     DrmConnector *m_conn = nullptr;
     DrmCrtc *m_crtc = nullptr;
     bool m_lastGbm = false;
     drmModeModeInfo m_mode;
     Edid m_edid;
     DrmScopedPointer<drmModePropertyRes> m_dpms;
     DpmsMode m_dpmsMode = DpmsMode::On;
     DpmsMode m_dpmsModePending = DpmsMode::On;
     QByteArray m_uuid;
 
     uint32_t m_blobId = 0;
     DrmPlane* m_primaryPlane = nullptr;
     DrmPlane* m_cursorPlane = nullptr;
     QVector<DrmPlane*> m_nextPlanesFlipList;
     bool m_pageFlipPending = false;
     bool m_atomicOffPending = false;
     bool m_modesetRequested = true;
 
     struct {
         Transform transform;
         drmModeModeInfo mode;
         DrmPlane::Transformations planeTransformations;
         QPoint globalPos;
         bool valid = false;
     } m_lastWorkingState;
     DrmDumbBuffer *m_cursor[2] = {nullptr, nullptr};
     int m_cursorIndex = 0;
     bool m_hasNewCursor = false;
     bool m_deleted = false;
 };
 
 }
 
 Q_DECLARE_METATYPE(KWin::DrmOutput*)
 
 QDebug& operator<<(QDebug& stream, const KWin::DrmOutput *);
 
 #endif
 
diff --git a/plugins/platforms/drm/egl_stream_backend.cpp b/plugins/platforms/drm/egl_stream_backend.cpp
index 374ab42bb..0c5de554c 100644
--- a/plugins/platforms/drm/egl_stream_backend.cpp
+++ b/plugins/platforms/drm/egl_stream_backend.cpp
@@ -1,692 +1,692 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 NVIDIA Inc.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "egl_stream_backend.h"
 #include "composite.h"
 #include "drm_backend.h"
 #include "drm_output.h"
 #include "drm_object_crtc.h"
 #include "drm_object_plane.h"
 #include "logging.h"
 #include "logind.h"
 #include "options.h"
 #include "scene.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include <kwinglplatform.h>
 #include <QOpenGLContext>
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/eglstream_controller_interface.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/resource.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/eglstream_controller_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/resource.h>
 #include <wayland-server-core.h>
 
 namespace KWin
 {
 
 typedef EGLStreamKHR (*PFNEGLCREATESTREAMATTRIBNV)(EGLDisplay, EGLAttrib *);
 typedef EGLBoolean (*PFNEGLGETOUTPUTLAYERSEXT)(EGLDisplay, EGLAttrib *, EGLOutputLayerEXT *, EGLint, EGLint *);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMEROUTPUTEXT)(EGLDisplay, EGLStreamKHR, EGLOutputLayerEXT);
 typedef EGLSurface (*PFNEGLCREATESTREAMPRODUCERSURFACEKHR)(EGLDisplay, EGLConfig, EGLStreamKHR, EGLint *);
 typedef EGLBoolean (*PFNEGLDESTROYSTREAMKHR)(EGLDisplay, EGLStreamKHR);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLAttrib *);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)(EGLDisplay, EGLStreamKHR);
 typedef EGLBoolean (*PFNEGLQUERYSTREAMATTRIBNV)(EGLDisplay, EGLStreamKHR, EGLenum, EGLAttrib *);
 typedef EGLBoolean (*PFNEGLSTREAMCONSUMERRELEASEKHR)(EGLDisplay, EGLStreamKHR);
 typedef EGLBoolean (*PFNEGLQUERYWAYLANDBUFFERWL)(EGLDisplay, wl_resource *, EGLint, EGLint *);
 PFNEGLCREATESTREAMATTRIBNV pEglCreateStreamAttribNV = nullptr;
 PFNEGLGETOUTPUTLAYERSEXT pEglGetOutputLayersEXT = nullptr;
 PFNEGLSTREAMCONSUMEROUTPUTEXT pEglStreamConsumerOutputEXT = nullptr;
 PFNEGLCREATESTREAMPRODUCERSURFACEKHR pEglCreateStreamProducerSurfaceKHR = nullptr;
 PFNEGLDESTROYSTREAMKHR pEglDestroyStreamKHR = nullptr;
 PFNEGLSTREAMCONSUMERACQUIREATTRIBNV pEglStreamConsumerAcquireAttribNV = nullptr;
 PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR pEglStreamConsumerGLTextureExternalKHR = nullptr;
 PFNEGLQUERYSTREAMATTRIBNV pEglQueryStreamAttribNV = nullptr;
 PFNEGLSTREAMCONSUMERRELEASEKHR pEglStreamConsumerReleaseKHR = nullptr;
 PFNEGLQUERYWAYLANDBUFFERWL pEglQueryWaylandBufferWL = nullptr;
     
 #ifndef EGL_CONSUMER_AUTO_ACQUIRE_EXT
 #define EGL_CONSUMER_AUTO_ACQUIRE_EXT 0x332B
 #endif
 
 #ifndef EGL_DRM_MASTER_FD_EXT
 #define EGL_DRM_MASTER_FD_EXT 0x333C
 #endif
 
 #ifndef EGL_DRM_FLIP_EVENT_DATA_NV
 #define EGL_DRM_FLIP_EVENT_DATA_NV 0x333E
 #endif
 
 #ifndef EGL_WAYLAND_EGLSTREAM_WL
 #define EGL_WAYLAND_EGLSTREAM_WL 0x334B
 #endif
 
 #ifndef EGL_WAYLAND_Y_INVERTED_WL
 #define EGL_WAYLAND_Y_INVERTED_WL 0x31DB
 #endif    
 
 EglStreamBackend::EglStreamBackend(DrmBackend *b)
     : AbstractEglBackend(), m_backend(b)
 {
     setIsDirectRendering(true);
     setSyncsToVBlank(true);
     connect(m_backend, &DrmBackend::outputAdded, this, &EglStreamBackend::createOutput);
     connect(m_backend, &DrmBackend::outputRemoved, this,
         [this] (DrmOutput *output) {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                                    [output] (const Output &o) {
                                        return o.output == output;
                                    });
             if (it == m_outputs.end()) {
                 return;
             }
             cleanupOutput(*it);
             m_outputs.erase(it);
         });
 }
 
 EglStreamBackend::~EglStreamBackend()
 {
     cleanup();
 }
 
 void EglStreamBackend::cleanupSurfaces()
 {
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         cleanupOutput(*it);
     }
     m_outputs.clear();
 }
 
 void EglStreamBackend::cleanupOutput(const Output &o)
 {
     if (o.buffer != nullptr) {
         delete o.buffer;
     }
     if (o.eglSurface != EGL_NO_SURFACE) {
         eglDestroySurface(eglDisplay(), o.eglSurface);
     }
     if (o.eglStream != EGL_NO_STREAM_KHR) {
         pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
     }
 }
 
 bool EglStreamBackend::initializeEgl()
 {
     initClientExtensions();
     EGLDisplay display = m_backend->sceneEglDisplay();
     if (display == EGL_NO_DISPLAY) {
         if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_device_base")) &&
             !(hasClientExtension(QByteArrayLiteral("EGL_EXT_device_query")) &&
               hasClientExtension(QByteArrayLiteral("EGL_EXT_device_enumeration")))) {
             setFailed("Missing required EGL client extension: "
                       "EGL_EXT_device_base or "
                       "EGL_EXT_device_query and EGL_EXT_device_enumeration");
             return false;
         }
 
         // Try to find the EGLDevice corresponding to our DRM device file
         int numDevices;
         eglQueryDevicesEXT(0, nullptr, &numDevices);
         QVector<EGLDeviceEXT> devices(numDevices);
         eglQueryDevicesEXT(numDevices, devices.data(), &numDevices);
         for (EGLDeviceEXT device : devices) {
             const char *drmDeviceFile = eglQueryDeviceStringEXT(device, EGL_DRM_DEVICE_FILE_EXT);
             if (m_backend->devNode() != drmDeviceFile) {
                 continue;
             }
             
             const char *deviceExtensionCString = eglQueryDeviceStringEXT(device, EGL_EXTENSIONS);
             QByteArray deviceExtensions = QByteArray::fromRawData(deviceExtensionCString,
                                                                   qstrlen(deviceExtensionCString));
             if (!deviceExtensions.split(' ').contains(QByteArrayLiteral("EGL_EXT_device_drm"))) {
                 continue;
             }
                 
             EGLint platformAttribs[] = {
                 EGL_DRM_MASTER_FD_EXT, m_backend->fd(),
                 EGL_NONE
             };
             display = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, device, platformAttribs);
             break;
         }
     }
 
     if (display == EGL_NO_DISPLAY) {
         setFailed("No suitable EGL device found");
         return false;
     }
     
     setEglDisplay(display);
     if (!initEglAPI()) {
         return false;
     }
 
     const QVector<QByteArray> requiredExtensions = {
         QByteArrayLiteral("EGL_EXT_output_base"),
         QByteArrayLiteral("EGL_EXT_output_drm"),
         QByteArrayLiteral("EGL_KHR_stream"),
         QByteArrayLiteral("EGL_KHR_stream_producer_eglsurface"),
         QByteArrayLiteral("EGL_EXT_stream_consumer_egloutput"),
         QByteArrayLiteral("EGL_NV_stream_attrib"),
         QByteArrayLiteral("EGL_EXT_stream_acquire_mode"),
         QByteArrayLiteral("EGL_KHR_stream_consumer_gltexture"),
         QByteArrayLiteral("EGL_WL_wayland_eglstream")
     };
     for (const QByteArray &ext : requiredExtensions) {
         if (!hasExtension(ext)) {
             setFailed(QStringLiteral("Missing required EGL extension: ") + ext);
             return false;
         }
     }
 
     pEglCreateStreamAttribNV = (PFNEGLCREATESTREAMATTRIBNV)eglGetProcAddress("eglCreateStreamAttribNV");
     pEglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXT)eglGetProcAddress("eglGetOutputLayersEXT");
     pEglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXT)eglGetProcAddress("eglStreamConsumerOutputEXT");
     pEglCreateStreamProducerSurfaceKHR = (PFNEGLCREATESTREAMPRODUCERSURFACEKHR)eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
     pEglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHR)eglGetProcAddress("eglDestroyStreamKHR");
     pEglStreamConsumerAcquireAttribNV = (PFNEGLSTREAMCONSUMERACQUIREATTRIBNV)eglGetProcAddress("eglStreamConsumerAcquireAttribNV");
     pEglStreamConsumerGLTextureExternalKHR = (PFNEGLSTREAMCONSUMERGLTEXTUREEXTERNALKHR)eglGetProcAddress("eglStreamConsumerGLTextureExternalKHR");
     pEglQueryStreamAttribNV = (PFNEGLQUERYSTREAMATTRIBNV)eglGetProcAddress("eglQueryStreamAttribNV");
     pEglStreamConsumerReleaseKHR = (PFNEGLSTREAMCONSUMERRELEASEKHR)eglGetProcAddress("eglStreamConsumerReleaseKHR");
     pEglQueryWaylandBufferWL = (PFNEGLQUERYWAYLANDBUFFERWL)eglGetProcAddress("eglQueryWaylandBufferWL");
     return true;
 }
 
-EglStreamBackend::StreamTexture *EglStreamBackend::lookupStreamTexture(KWayland::Server::SurfaceInterface *surface)
+EglStreamBackend::StreamTexture *EglStreamBackend::lookupStreamTexture(KWaylandServer::SurfaceInterface *surface)
 {
     auto it = m_streamTextures.find(surface);
     return it != m_streamTextures.end() ?
            &it.value() : 
            nullptr;
 }
 
-void EglStreamBackend::attachStreamConsumer(KWayland::Server::SurfaceInterface *surface,
+void EglStreamBackend::attachStreamConsumer(KWaylandServer::SurfaceInterface *surface,
                                             void *eglStream,
                                             wl_array *attribs)
 {
     QVector<EGLAttrib> streamAttribs;
     streamAttribs << EGL_WAYLAND_EGLSTREAM_WL << (EGLAttrib)eglStream;
     EGLAttrib *attribArray = (EGLAttrib *)attribs->data;
     for (unsigned int i = 0; i < attribs->size; ++i) {
         streamAttribs << attribArray[i];
     }
     streamAttribs << EGL_NONE;
 
     EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay(), streamAttribs.data());
     if (stream == EGL_NO_STREAM_KHR) {
         qCWarning(KWIN_DRM) << "Failed to create EGL stream";
         return;
     }
 
     GLuint texture;
     StreamTexture *st = lookupStreamTexture(surface);
     if (st != nullptr) {
         pEglDestroyStreamKHR(eglDisplay(), st->stream);
         st->stream = stream;
         texture = st->texture;
     } else {
         StreamTexture newSt = { stream, 0 };
         glGenTextures(1, &newSt.texture);
         m_streamTextures.insert(surface, newSt);
         texture = newSt.texture;
 
-        connect(surface, &KWayland::Server::Resource::unbound, this,
+        connect(surface, &KWaylandServer::Resource::unbound, this,
             [surface, this]() {
                 const StreamTexture &st = m_streamTextures.take(surface);
                 pEglDestroyStreamKHR(eglDisplay(), st.stream);
                 glDeleteTextures(1, &st.texture);
             });
     }
 
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture);
     if (!pEglStreamConsumerGLTextureExternalKHR(eglDisplay(), stream)) {
         qCWarning(KWIN_DRM) << "Failed to bind EGL stream to texture";
     }
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
 }
 
 void EglStreamBackend::init()
 {
     if (!m_backend->atomicModeSetting()) {
         setFailed("EGLStream backend requires atomic modesetting");
         return;
     }
     
     if (!initializeEgl()) {
         setFailed("Failed to initialize EGL api");
         return;
     }
     if (!initRenderingContext()) {
         setFailed("Failed to initialize rendering context");
         return;
     }
 
     initKWinGL();
     setSupportsBufferAge(false);
     initWayland();
 
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     m_eglStreamControllerInterface = waylandServer()->display()->createEglStreamControllerInterface();
     connect(m_eglStreamControllerInterface, &EglStreamControllerInterface::streamConsumerAttached, this,
             &EglStreamBackend::attachStreamConsumer);
     m_eglStreamControllerInterface->create();
     if (!m_eglStreamControllerInterface->isValid()) {
         setFailed("failed to initialize wayland-eglstream-controller interface");
     }
 }
 
 bool EglStreamBackend::initRenderingContext()
 {
     initBufferConfigs();
 
     if (!createContext()) {
         return false;
     }
 
     const auto outputs = m_backend->drmOutputs();
     for (DrmOutput *drmOutput : outputs) {
         createOutput(drmOutput);
     }
     if (m_outputs.isEmpty()) {
         qCCritical(KWIN_DRM) << "Failed to create output surface";
         return false;
     }
     // set our first surface as the one for the abstract backend
     setSurface(m_outputs.first().eglSurface);
 
     return makeContextCurrent(m_outputs.first());
 }
 
 bool EglStreamBackend::resetOutput(Output &o, DrmOutput *drmOutput)
 {
     o.output = drmOutput;
     if (o.buffer != nullptr) {
         delete o.buffer;
     }
     // dumb buffer used for modesetting
     o.buffer = m_backend->createBuffer(drmOutput->pixelSize());
 
     EGLAttrib streamAttribs[] = {
         EGL_STREAM_FIFO_LENGTH_KHR, 0, // mailbox mode
         EGL_CONSUMER_AUTO_ACQUIRE_EXT, EGL_FALSE,
         EGL_NONE
     };
     EGLStreamKHR stream = pEglCreateStreamAttribNV(eglDisplay(), streamAttribs);
     if (stream == EGL_NO_STREAM_KHR) {
         qCCritical(KWIN_DRM) << "Failed to create EGL stream for output";
         return false;
     }
 
     EGLAttrib outputAttribs[3];
     if (drmOutput->primaryPlane()) {
         outputAttribs[0] = EGL_DRM_PLANE_EXT;
         outputAttribs[1] = drmOutput->primaryPlane()->id();
     } else {
         outputAttribs[0] = EGL_DRM_CRTC_EXT;
         outputAttribs[1] = drmOutput->crtc()->id();
     }
     outputAttribs[2] = EGL_NONE;
     EGLint numLayers;
     EGLOutputLayerEXT outputLayer;
     pEglGetOutputLayersEXT(eglDisplay(), outputAttribs, &outputLayer, 1, &numLayers);
     if (numLayers == 0) {
         qCCritical(KWIN_DRM) << "No EGL output layers found";
         return false;
     }
 
     pEglStreamConsumerOutputEXT(eglDisplay(), stream, outputLayer);
     EGLint streamProducerAttribs[] = {
         EGL_WIDTH, drmOutput->pixelSize().width(),
         EGL_HEIGHT, drmOutput->pixelSize().height(),
         EGL_NONE
     };
     EGLSurface eglSurface = pEglCreateStreamProducerSurfaceKHR(eglDisplay(), config(), stream,
                                                                streamProducerAttribs);
     if (eglSurface == EGL_NO_SURFACE) {
         qCCritical(KWIN_DRM) << "Failed to create EGL surface for output";
         return false;
     }
 
     if (o.eglSurface != EGL_NO_SURFACE) {
         if (surface() == o.eglSurface) {
             setSurface(eglSurface);
         }
         eglDestroySurface(eglDisplay(), o.eglSurface);
     }
     
     if (o.eglStream != EGL_NO_STREAM_KHR) {
         pEglDestroyStreamKHR(eglDisplay(), o.eglStream);
     }
     
     o.eglStream = stream;
     o.eglSurface = eglSurface;
     return true;
 }
 
 void EglStreamBackend::createOutput(DrmOutput *drmOutput)
 {
     Output o;
     if (!resetOutput(o, drmOutput)) {
         return;
     }
 
     connect(drmOutput, &DrmOutput::modeChanged, this,
         [drmOutput, this] {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [drmOutput] (const auto &o) {
                     return o.output == drmOutput;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             resetOutput(*it, drmOutput);
         }
     );
     m_outputs << o;
 }
 
 bool EglStreamBackend::makeContextCurrent(const Output &output)
 {
     const EGLSurface surface = output.eglSurface;
     if (surface == EGL_NO_SURFACE) {
         return false;
     }
     
     if (eglMakeCurrent(eglDisplay(), surface, surface, context()) == EGL_FALSE) {
         qCCritical(KWIN_DRM) << "Failed to make EGL context current";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_DRM) << "Error occurred while making EGL context current" << error;
         return false;
     }
     
     const QSize &overall = screens()->size();
     const QRect &v = output.output->geometry();
     qreal scale = output.output->scale();
     glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
                overall.width() * scale, overall.height() * scale);
     return true;
 }
 
 bool EglStreamBackend::initBufferConfigs()
 {
     const EGLint configAttribs[] = {
         EGL_SURFACE_TYPE,         EGL_STREAM_BIT_KHR,
         EGL_RED_SIZE,             1,
         EGL_GREEN_SIZE,           1,
         EGL_BLUE_SIZE,            1,
         EGL_ALPHA_SIZE,           0,
         EGL_RENDERABLE_TYPE,      isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
         EGL_CONFIG_CAVEAT,        EGL_NONE,
         EGL_NONE,
     };
     EGLint count;
     EGLConfig config;
     if (!eglChooseConfig(eglDisplay(), configAttribs, &config, 1, &count)) {
         qCCritical(KWIN_DRM) << "Failed to query available EGL configs";
         return false;
     }
     if (count == 0) {
         qCCritical(KWIN_DRM) << "No suitable EGL config found";
         return false;
     }
 
     setConfig(config);
     return true;
 }
 
 void EglStreamBackend::present()
 {
     for (auto &o : m_outputs) {
         makeContextCurrent(o);
         presentOnOutput(o);
     }
 }
 
 void EglStreamBackend::presentOnOutput(EglStreamBackend::Output &o)
 {
     eglSwapBuffers(eglDisplay(), o.eglSurface);
     if (!m_backend->present(o.buffer, o.output)) {
         return;
     }
 
     EGLAttrib acquireAttribs[] = {
         EGL_DRM_FLIP_EVENT_DATA_NV, (EGLAttrib)o.output,
         EGL_NONE,
     };
     if (!pEglStreamConsumerAcquireAttribNV(eglDisplay(), o.eglStream, acquireAttribs)) {
         qCWarning(KWIN_DRM) << "Failed to acquire output EGL stream frame";
     }
 }
 
 void EglStreamBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
 }
 
 SceneOpenGLTexturePrivate *EglStreamBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglStreamTexture(texture, this);
 }
 
 QRegion EglStreamBackend::prepareRenderingFrame()
 {
     startRenderTimer();
     return QRegion();
 }
 
 QRegion EglStreamBackend::prepareRenderingForScreen(int screenId)
 {
     const Output &o = m_outputs.at(screenId);
     makeContextCurrent(o);
     return o.output->geometry();
 }
 
 void EglStreamBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion)
     Q_UNUSED(damagedRegion)
 }
 
 void EglStreamBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion);
     Q_UNUSED(damagedRegion);
     Output &o = m_outputs[screenId];
     presentOnOutput(o);
 }
 
 bool EglStreamBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 bool EglStreamBackend::perScreenRendering() const
 {
     return true;
 }
 
 /************************************************
  * EglTexture
  ************************************************/
 
 EglStreamTexture::EglStreamTexture(SceneOpenGLTexture *texture, EglStreamBackend *backend)
     : AbstractEglTexture(texture, backend), m_backend(backend), m_fbo(0), m_rbo(0)
 {
 }
 
 EglStreamTexture::~EglStreamTexture()
 {
     glDeleteRenderbuffers(1, &m_rbo);
     glDeleteFramebuffers(1, &m_fbo);
 }
 
 bool EglStreamTexture::acquireStreamFrame(EGLStreamKHR stream)
 {
     EGLAttrib streamState;
     if (!pEglQueryStreamAttribNV(m_backend->eglDisplay(), stream,
                                  EGL_STREAM_STATE_KHR, &streamState)) {
         qCWarning(KWIN_DRM) << "Failed to query EGL stream state";
         return false;
     }
 
     if (streamState == EGL_STREAM_STATE_NEW_FRAME_AVAILABLE_KHR) {
         if (pEglStreamConsumerAcquireAttribNV(m_backend->eglDisplay(), stream, nullptr)) {
             return true;
         } else {
             qCWarning(KWIN_DRM) << "Failed to acquire EGL stream frame";
         }
     }
 
     // Re-use previous texture contents if no new frame is available
     // or if acquisition fails for some reason
     return false;
 }
 
 void EglStreamTexture::createFbo()
 {
     glDeleteRenderbuffers(1, &m_rbo);
     glDeleteFramebuffers(1, &m_fbo);
 
     glGenFramebuffers(1, &m_fbo);
     glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     glGenRenderbuffers(1, &m_rbo);
     glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
     glRenderbufferStorage(GL_RENDERBUFFER, m_format, m_size.width(), m_size.height());
     glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
     glBindRenderbuffer(GL_RENDERBUFFER, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
 }
 
 // Renders the contents of the given EXTERNAL_OES texture
 // to the scratch framebuffer, then copies this to m_texture
 void EglStreamTexture::copyExternalTexture(GLuint tex)
 {
     GLint oldViewport[4], oldProgram;
     glGetIntegerv(GL_VIEWPORT, oldViewport);
     glViewport(0, 0, m_size.width(), m_size.height());
     glGetIntegerv(GL_CURRENT_PROGRAM, &oldProgram);
     glUseProgram(0);
     glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
     glBindRenderbuffer(GL_RENDERBUFFER, m_rbo);
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, tex);
     glEnable(GL_TEXTURE_EXTERNAL_OES);
 
     GLfloat yTop = texture()->isYInverted() ? 0 : 1;
     glBegin(GL_QUADS);
     glTexCoord2f(0, yTop);
     glVertex2f(-1, 1);
     glTexCoord2f(0, 1 - yTop);
     glVertex2f(-1, -1);
     glTexCoord2f(1, 1 - yTop);
     glVertex2f(1, -1);
     glTexCoord2f(1, yTop);
     glVertex2f(1, 1);
     glEnd();
 
     texture()->bind();
     glCopyTexImage2D(m_target, 0, m_format, 0, 0, m_size.width(), m_size.height(), 0);
     texture()->unbind();
 
     glDisable(GL_TEXTURE_EXTERNAL_OES);
     glBindTexture(GL_TEXTURE_EXTERNAL_OES, 0);
     glBindRenderbuffer(GL_RENDERBUFFER, 0);
     glBindFramebuffer(GL_FRAMEBUFFER, 0);
     glUseProgram(oldProgram);
     glViewport(oldViewport[0], oldViewport[1], oldViewport[2], oldViewport[3]);
 }
 
-bool EglStreamTexture::attachBuffer(KWayland::Server::BufferInterface *buffer)
+bool EglStreamTexture::attachBuffer(KWaylandServer::BufferInterface *buffer)
 {
     QSize oldSize = m_size;
     m_size = buffer->size();
     GLenum oldFormat = m_format;
     m_format = buffer->hasAlphaChannel() ? GL_RGBA : GL_RGB;
 
     EGLint yInverted, wasYInverted = texture()->isYInverted();
     if (!pEglQueryWaylandBufferWL(m_backend->eglDisplay(), buffer->resource(), EGL_WAYLAND_Y_INVERTED_WL, &yInverted)) {
         yInverted = EGL_TRUE;
     }
     texture()->setYInverted(yInverted);
     updateMatrix();
 
     return oldSize != m_size ||
            oldFormat != m_format ||
            wasYInverted != texture()->isYInverted();
 }
 
 bool EglStreamTexture::loadTexture(WindowPixmap *pixmap)
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     SurfaceInterface *surface = pixmap->surface();
     const EglStreamBackend::StreamTexture *st = m_backend->lookupStreamTexture(surface);
     if (!pixmap->buffer().isNull() && st != nullptr) {
 
         glGenTextures(1, &m_texture);
         texture()->setWrapMode(GL_CLAMP_TO_EDGE);
         texture()->setFilter(GL_LINEAR);
 
         attachBuffer(surface->buffer());
         createFbo();
         surface->resetTrackedDamage();
 
         if (acquireStreamFrame(st->stream)) {
             copyExternalTexture(st->texture);
             if (!pEglStreamConsumerReleaseKHR(m_backend->eglDisplay(), st->stream)) {
                 qCWarning(KWIN_DRM) << "Failed to release EGL stream";
             }
         }
         return true;
     } else {
         // Not an EGLStream surface
         return AbstractEglTexture::loadTexture(pixmap);
     }
 }
 
 void EglStreamTexture::updateTexture(WindowPixmap *pixmap)
 {
-    using namespace KWayland::Server;    
+    using namespace KWaylandServer;
     SurfaceInterface *surface = pixmap->surface();
     const EglStreamBackend::StreamTexture *st = m_backend->lookupStreamTexture(surface);
     if (!pixmap->buffer().isNull() && st != nullptr) {
 
         if (attachBuffer(surface->buffer())) {
             createFbo();
         }
         surface->resetTrackedDamage();
 
         if (acquireStreamFrame(st->stream)) {
             copyExternalTexture(st->texture);
             if (!pEglStreamConsumerReleaseKHR(m_backend->eglDisplay(), st->stream)) {
                 qCWarning(KWIN_DRM) << "Failed to release EGL stream";
             }
         }
     } else {
         // Not an EGLStream surface
         AbstractEglTexture::updateTexture(pixmap);
     }
 }
 
 } // namespace
diff --git a/plugins/platforms/drm/egl_stream_backend.h b/plugins/platforms/drm/egl_stream_backend.h
index 3c1ec67ba..48a16f6b2 100644
--- a/plugins/platforms/drm/egl_stream_backend.h
+++ b/plugins/platforms/drm/egl_stream_backend.h
@@ -1,115 +1,115 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 NVIDIA Inc.
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_EGL_STREAM_BACKEND_H
 #define KWIN_EGL_STREAM_BACKEND_H
 #include "abstract_egl_backend.h"
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/eglstream_controller_interface.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/eglstream_controller_interface.h>
 #include <wayland-server-core.h>
 
 namespace KWin
 {
 
 class DrmBackend;
 class DrmOutput;
 class DrmBuffer;
 
 /**
  * @brief OpenGL Backend using Egl with an EGLDevice.
  */
 class EglStreamBackend : public AbstractEglBackend
 {
     Q_OBJECT
 public:
     EglStreamBackend(DrmBackend *b);
     ~EglStreamBackend() override;
     void screenGeometryChanged(const QSize &size) override;
     SceneOpenGLTexturePrivate *createBackendTexture(SceneOpenGLTexture *texture) override;
     QRegion prepareRenderingFrame() override;
     void endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion) override;
     void endRenderingFrameForScreen(int screenId, const QRegion &damage, const QRegion &damagedRegion) override;
     bool usesOverlayWindow() const override;
     bool perScreenRendering() const override;
     QRegion prepareRenderingForScreen(int screenId) override;
     void init() override;
 
 protected:
     void present() override;
     void cleanupSurfaces() override;
 
 private:
     bool initializeEgl();
     bool initBufferConfigs();
     bool initRenderingContext();
     struct StreamTexture 
     {
         EGLStreamKHR stream;
         GLuint texture;
     };
-    StreamTexture *lookupStreamTexture(KWayland::Server::SurfaceInterface *surface);
-    void attachStreamConsumer(KWayland::Server::SurfaceInterface *surface,
+    StreamTexture *lookupStreamTexture(KWaylandServer::SurfaceInterface *surface);
+    void attachStreamConsumer(KWaylandServer::SurfaceInterface *surface,
                               void *eglStream,
                               wl_array *attribs);
     struct Output 
     {
         DrmOutput *output = nullptr;
         DrmBuffer *buffer = nullptr;
         EGLSurface eglSurface = EGL_NO_SURFACE;
         EGLStreamKHR eglStream = EGL_NO_STREAM_KHR;
     };
     bool resetOutput(Output &output, DrmOutput *drmOutput);
     bool makeContextCurrent(const Output &output);
     void presentOnOutput(Output &output);
     void cleanupOutput(const Output &output);
     void createOutput(DrmOutput *output);
 
     DrmBackend *m_backend;
     QVector<Output> m_outputs;
-    KWayland::Server::EglStreamControllerInterface *m_eglStreamControllerInterface;
-    QHash<KWayland::Server::SurfaceInterface *, StreamTexture> m_streamTextures;
+    KWaylandServer::EglStreamControllerInterface *m_eglStreamControllerInterface;
+    QHash<KWaylandServer::SurfaceInterface *, StreamTexture> m_streamTextures;
 
     friend class EglStreamTexture;
 };
 
 /**
  * @brief External texture bound to an EGLStreamKHR.
  */
 class EglStreamTexture : public AbstractEglTexture
 {
 public:
     ~EglStreamTexture() override;
     bool loadTexture(WindowPixmap *pixmap) override;
     void updateTexture(WindowPixmap *pixmap) override;
 
 private:
     EglStreamTexture(SceneOpenGLTexture *texture, EglStreamBackend *backend);
     bool acquireStreamFrame(EGLStreamKHR stream);
     void createFbo();
     void copyExternalTexture(GLuint tex);
-    bool attachBuffer(KWayland::Server::BufferInterface *buffer);
+    bool attachBuffer(KWaylandServer::BufferInterface *buffer);
     EglStreamBackend *m_backend;
     GLuint m_fbo, m_rbo;
     GLenum m_format;
     friend class EglStreamBackend;
 };
 
 } // namespace
 
 #endif
diff --git a/plugins/platforms/drm/remoteaccess_manager.cpp b/plugins/platforms/drm/remoteaccess_manager.cpp
index abb0b37ef..fad2d348e 100644
--- a/plugins/platforms/drm/remoteaccess_manager.cpp
+++ b/plugins/platforms/drm/remoteaccess_manager.cpp
@@ -1,89 +1,89 @@
 /********************************************************************
  *
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Oleg Chernovskiy <kanedias@xaker.ru>
 
 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 "drm_output.h"
 #include "remoteaccess_manager.h"
 #include "logging.h"
 #include "drm_backend.h"
 #include "../../../wayland_server.h"
 
 // system
-#include <KWayland/Server/output_interface.h>
+#include <KWaylandServer/output_interface.h>
 #include <unistd.h>
 #include <gbm.h>
 
 #include <cerrno>
 
 namespace KWin
 {
 
 RemoteAccessManager::RemoteAccessManager(QObject *parent)
     : QObject(parent)
 {
     if (waylandServer()) {
         m_interface = waylandServer()->display()->createRemoteAccessManager(this);
         m_interface->create();
 
         connect(m_interface, &RemoteAccessManagerInterface::bufferReleased,
                 this, &RemoteAccessManager::releaseBuffer);
     }
 }
 
 RemoteAccessManager::~RemoteAccessManager()
 {
     if (m_interface) {
         m_interface->destroy();
     }
 }
 
 void RemoteAccessManager::releaseBuffer(const BufferHandle *buf)
 {
     int ret = close(buf->fd());
     if (Q_UNLIKELY(ret)) {
         qCWarning(KWIN_DRM) << "Couldn't close released GBM fd:" << strerror(errno);
     }
     delete buf;
 }
 
 void RemoteAccessManager::passBuffer(DrmOutput *output, DrmBuffer *buffer)
 {
     DrmSurfaceBuffer* gbmbuf = static_cast<DrmSurfaceBuffer *>(buffer);
 
     // no connected RemoteAccess instance
     if (!m_interface || !m_interface->isBound()) {
         return;
     }
 
     // first buffer may be null
     if (!gbmbuf || !gbmbuf->hasBo()) {
         return;
     }
 
     auto buf = new BufferHandle;
     auto bo = gbmbuf->getBo();
     buf->setFd(gbm_bo_get_fd(bo));
     buf->setSize(gbm_bo_get_width(bo), gbm_bo_get_height(bo));
     buf->setStride(gbm_bo_get_stride(bo));
     buf->setFormat(gbm_bo_get_format(bo));
 
     m_interface->sendBufferReady(output->waylandOutput().data(), buf);
 }
 
 } // KWin namespace
diff --git a/plugins/platforms/drm/remoteaccess_manager.h b/plugins/platforms/drm/remoteaccess_manager.h
index b521bb8b6..c66ae539b 100644
--- a/plugins/platforms/drm/remoteaccess_manager.h
+++ b/plugins/platforms/drm/remoteaccess_manager.h
@@ -1,61 +1,61 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Oleg Chernovskiy <kanedias@xaker.ru>
 
 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 REMOTEACCESSMANAGER_H
 #define REMOTEACCESSMANAGER_H
 
 // KWayland
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/remote_access_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/remote_access_interface.h>
 // Qt
 #include <QObject>
 
 struct gbm_bo;
 struct gbm_surface;
 
 namespace KWin
 {
 
 class DrmOutput;
 class DrmBuffer;
 
-using KWayland::Server::RemoteAccessManagerInterface;
-using KWayland::Server::BufferHandle;
+using KWaylandServer::RemoteAccessManagerInterface;
+using KWaylandServer::BufferHandle;
 
 class RemoteAccessManager : public QObject
 {
     Q_OBJECT
 public:
     explicit RemoteAccessManager(QObject *parent = nullptr);
     ~RemoteAccessManager() override;
 
     void passBuffer(DrmOutput *output, DrmBuffer *buffer);
 
 signals:
     void bufferNoLongerNeeded(qint32 gbm_handle);
 
 private:
     void releaseBuffer(const BufferHandle *buf);
 
     RemoteAccessManagerInterface *m_interface = nullptr;
 };
 
 } // KWin namespace
 
 #endif // REMOTEACCESSMANAGER_H
diff --git a/plugins/platforms/fbdev/fb_backend.cpp b/plugins/platforms/fbdev/fb_backend.cpp
index 931d7b799..9f357dcfc 100644
--- a/plugins/platforms/fbdev/fb_backend.cpp
+++ b/plugins/platforms/fbdev/fb_backend.cpp
@@ -1,285 +1,285 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "fb_backend.h"
 
 #include "composite.h"
 #include "logging.h"
 #include "logind.h"
 #include "scene_qpainter_fb_backend.h"
 #include "outputscreens.h"
 #include "virtual_terminal.h"
 #include "udev.h"
 // system
 #include <fcntl.h>
 #include <unistd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 // Linux
 #include <linux/fb.h>
 
 namespace KWin
 {
 
 FramebufferOutput::FramebufferOutput(QObject *parent):
     AbstractWaylandOutput(parent)
 {
     setName("FB-0");
 }
 
 void FramebufferOutput::init(const QSize &pixelSize, const QSize &physicalSize)
 {
-    KWayland::Server::OutputDeviceInterface::Mode mode;
+    KWaylandServer::OutputDeviceInterface::Mode mode;
     mode.id = 0;
     mode.size = pixelSize;
-    mode.flags = KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
+    mode.flags = KWaylandServer::OutputDeviceInterface::ModeFlag::Current;
     mode.refreshRate = 60000;  // TODO: get actual refresh rate of fb device?
     initInterfaces("model_TODO", "manufacturer_TODO", "UUID_TODO", physicalSize, { mode });
 }
 
 FramebufferBackend::FramebufferBackend(QObject *parent)
     : Platform(parent)
 {
 }
 
 FramebufferBackend::~FramebufferBackend()
 {
     unmap();
     if (m_fd >= 0) {
         close(m_fd);
     }
 }
 
 Screens *FramebufferBackend::createScreens(QObject *parent)
 {
     return new OutputScreens(this, parent);
 }
 
 QPainterBackend *FramebufferBackend::createQPainterBackend()
 {
     return new FramebufferQPainterBackend(this);
 }
 
 void FramebufferBackend::init()
 {
     setSoftWareCursor(true);
     LogindIntegration *logind = LogindIntegration::self();
     auto takeControl = [logind, this]() {
         if (logind->hasSessionControl()) {
             openFrameBuffer();
         } else {
             logind->takeControl();
             connect(logind, &LogindIntegration::hasSessionControlChanged, this, &FramebufferBackend::openFrameBuffer);
         }
     };
     if (logind->isConnected()) {
         takeControl();
     } else {
         connect(logind, &LogindIntegration::connectedChanged, this, takeControl);
     }
     VirtualTerminal::create(this);
 }
 
 void FramebufferBackend::openFrameBuffer()
 {
     VirtualTerminal::self()->init();
     QString framebufferDevice = deviceIdentifier().constData();
     if (framebufferDevice.isEmpty()) {
         framebufferDevice = QString(Udev().primaryFramebuffer()->devNode());
     }
     int fd = LogindIntegration::self()->takeDevice(framebufferDevice.toUtf8().constData());
     qCDebug(KWIN_FB) << "Using frame buffer device:" << framebufferDevice;
     if (fd < 0) {
         qCWarning(KWIN_FB) << "Failed to open frame buffer device:" << framebufferDevice << "through logind, trying without";
     }
     fd = open(framebufferDevice.toUtf8().constData(), O_RDWR | O_CLOEXEC);
     if (fd < 0) {
         qCWarning(KWIN_FB) << "failed to open frame buffer device:" << framebufferDevice;
         emit initFailed();
         return;
     }
     m_fd = fd;
     if (!handleScreenInfo()) {
         qCWarning(KWIN_FB) << "failed to handle framebuffer information";
         emit initFailed();
         return;
     }
     initImageFormat();
     if (m_imageFormat == QImage::Format_Invalid) {
         emit initFailed();
         return;
     }
     setReady(true);
     emit screensQueried();
 }
 
 bool FramebufferBackend::handleScreenInfo()
 {
     if (m_fd < 0) {
         return false;
     }
 
     fb_var_screeninfo varinfo;
     fb_fix_screeninfo fixinfo;
 
     // Probe the device for screen information.
     if (ioctl(m_fd, FBIOGET_FSCREENINFO, &fixinfo) < 0 || ioctl(m_fd, FBIOGET_VSCREENINFO, &varinfo) < 0) {
         return false;
     }
 
     // Activate the framebuffer device, assuming this is a non-primary framebuffer device
     varinfo.activate = FB_ACTIVATE_NOW | FB_ACTIVATE_FORCE;
     ioctl(m_fd, FBIOPUT_VSCREENINFO, &varinfo);
 
     // Probe the device for new screen information.
     if (ioctl(m_fd, FBIOGET_VSCREENINFO, &varinfo) < 0) {
         return false;
     }
 
     auto *output = new FramebufferOutput(this);
     output->init(QSize(varinfo.xres, varinfo.yres), QSize(varinfo.width, varinfo.height));
     m_outputs << output;
 
     m_id = QByteArray(fixinfo.id);
     m_red = {varinfo.red.offset, varinfo.red.length};
     m_green = {varinfo.green.offset, varinfo.green.length};
     m_blue = {varinfo.blue.offset, varinfo.blue.length};
     m_alpha = {varinfo.transp.offset, varinfo.transp.length};
     m_bitsPerPixel = varinfo.bits_per_pixel;
     m_bufferLength = fixinfo.smem_len;
     m_bytesPerLine = fixinfo.line_length;
 
     return true;
 }
 
 void FramebufferBackend::map()
 {
     if (m_memory) {
         // already mapped;
         return;
     }
     if (m_fd < 0) {
         // not valid
         return;
     }
     void *mem = mmap(nullptr, m_bufferLength, PROT_WRITE, MAP_SHARED, m_fd, 0);
     if (mem == MAP_FAILED) {
         qCWarning(KWIN_FB) << "Failed to mmap frame buffer";
         return;
     }
     m_memory = mem;
 }
 
 void FramebufferBackend::unmap()
 {
     if (!m_memory) {
         return;
     }
     if (munmap(m_memory, m_bufferLength) < 0) {
         qCWarning(KWIN_FB) << "Failed to munmap frame buffer";
     }
     m_memory = nullptr;
 }
 
 QSize FramebufferBackend::screenSize() const
 {
     if (m_outputs.isEmpty()) {
         return QSize();
     }
     return m_outputs[0]->pixelSize();
 }
 
 QImage::Format FramebufferBackend::imageFormat() const
 {
     return m_imageFormat;
 }
 
 void FramebufferBackend::initImageFormat()
 {
     if (m_fd < 0) {
         return;
     }
 
     qCDebug(KWIN_FB) << "Bits Per Pixel: " << m_bitsPerPixel;
     qCDebug(KWIN_FB) << "Buffer Length: " << m_bufferLength;
     qCDebug(KWIN_FB) << "Bytes Per Line: " << m_bytesPerLine;
     qCDebug(KWIN_FB) << "Alpha Length: " << m_alpha.length;
     qCDebug(KWIN_FB) << "Red Length: "   << m_red.length;
     qCDebug(KWIN_FB) << "Green Length: " << m_green.length;
     qCDebug(KWIN_FB) << "Blue Length: "  << m_blue.length;
     qCDebug(KWIN_FB) << "Blue Offset: "  << m_blue.offset;
     qCDebug(KWIN_FB) << "Green Offset: " << m_green.offset;
     qCDebug(KWIN_FB) << "Red Offset: "   << m_red.offset;
     qCDebug(KWIN_FB) << "Alpha Offset: " << m_alpha.offset;
 
     if (m_bitsPerPixel == 32 &&
             m_red.length == 8 &&
             m_green.length == 8 &&
             m_blue.length == 8 &&
             m_blue.offset == 0 &&
             m_green.offset == 8 &&
             m_red.offset == 16) {
         qCDebug(KWIN_FB) << "Framebuffer format is RGB32";
         m_imageFormat = QImage::Format_RGB32;
     } else if (m_bitsPerPixel == 32 &&
             m_red.length == 8 &&
             m_green.length == 8 &&
             m_blue.length == 8 &&
             m_alpha.length == 8 &&
             m_red.offset == 0 &&
             m_green.offset == 8 &&
             m_blue.offset == 16 &&
             m_alpha.offset == 24) {
         qCDebug(KWIN_FB) << "Framebuffer format is RGBA8888";
         m_imageFormat = QImage::Format_RGBA8888;
     } else if (m_bitsPerPixel == 24 &&
             m_red.length == 8 &&
             m_green.length == 8 &&
             m_blue.length == 8 &&
             m_blue.offset == 0 &&
             m_green.offset == 8 &&
             m_red.offset == 16) {
         qCDebug(KWIN_FB) << "Framebuffer Format is RGB888";
         m_bgr = true;
         m_imageFormat = QImage::Format_RGB888;
     } else if (m_bitsPerPixel == 16 &&
             m_red.length == 5 &&
             m_green.length == 6 &&
             m_blue.length == 5 &&
             m_blue.offset == 0 &&
             m_green.offset == 5 &&
             m_red.offset == 11) {
         qCDebug(KWIN_FB) << "Framebuffer Format is RGB16";
         m_imageFormat = QImage::Format_RGB16;
     } else {
         qCWarning(KWIN_FB) << "Framebuffer format is unknown";
     }
 }
 
 Outputs FramebufferBackend::outputs() const
 {
     return m_outputs;
 }
 
 Outputs FramebufferBackend::enabledOutputs() const
 {
     return m_outputs;
 }
 
 }
diff --git a/plugins/platforms/hwcomposer/hwcomposer_backend.cpp b/plugins/platforms/hwcomposer/hwcomposer_backend.cpp
index da974803d..0e63542ec 100644
--- a/plugins/platforms/hwcomposer/hwcomposer_backend.cpp
+++ b/plugins/platforms/hwcomposer/hwcomposer_backend.cpp
@@ -1,549 +1,549 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 3 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 "egl_hwcomposer_backend.h"
 #include "hwcomposer_backend.h"
 #include "logging.h"
 #include "screens_hwcomposer.h"
 #include "composite.h"
 #include "input.h"
 #include "main.h"
 #include "wayland_server.h"
 // KWayland
-#include <KWayland/Server/output_interface.h>
+#include <KWaylandServer/output_interface.h>
 // KDE
 #include <KConfigGroup>
 // Qt
 #include <QKeyEvent>
 #include <QDBusConnection>
 // hybris/android
 #include <hardware/hardware.h>
 #include <hardware/lights.h>
 // linux
 #include <linux/input.h>
 
 // based on test_hwcomposer.c from libhybris project (Apache 2 licensed)
 
-using namespace KWayland::Server;
+using namespace KWaylandServer;
 
 namespace KWin
 {
 
 BacklightInputEventFilter::BacklightInputEventFilter(HwcomposerBackend *backend)
     : InputEventFilter()
     , m_backend(backend)
 {
 }
 
 BacklightInputEventFilter::~BacklightInputEventFilter() = default;
 
 bool BacklightInputEventFilter::pointerEvent(QMouseEvent *event, quint32 nativeButton)
 {
     Q_UNUSED(event)
     Q_UNUSED(nativeButton)
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     toggleBacklight();
     return true;
 }
 
 bool BacklightInputEventFilter::wheelEvent(QWheelEvent *event)
 {
     Q_UNUSED(event)
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     toggleBacklight();
     return true;
 }
 
 bool BacklightInputEventFilter::keyEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_PowerOff && event->type() == QEvent::KeyRelease) {
         toggleBacklight();
         return true;
     }
     return m_backend->isBacklightOff();
 }
 
 bool BacklightInputEventFilter::touchDown(qint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(pos)
     Q_UNUSED(time)
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     if (m_touchPoints.isEmpty()) {
         if (!m_doubleTapTimer.isValid()) {
             // this is the first tap
             m_doubleTapTimer.start();
         } else {
             if (m_doubleTapTimer.elapsed() < qApp->doubleClickInterval()) {
                 m_secondTap = true;
             } else {
                 // took too long. Let's consider it a new click
                 m_doubleTapTimer.restart();
             }
         }
     } else {
         // not a double tap
         m_doubleTapTimer.invalidate();
         m_secondTap = false;
     }
     m_touchPoints << id;
     return true;
 }
 
 bool BacklightInputEventFilter::touchUp(qint32 id, quint32 time)
 {
     Q_UNUSED(time)
     m_touchPoints.removeAll(id);
     if (!m_backend->isBacklightOff()) {
         return false;
     }
     if (m_touchPoints.isEmpty() && m_doubleTapTimer.isValid() && m_secondTap) {
         if (m_doubleTapTimer.elapsed() < qApp->doubleClickInterval()) {
             toggleBacklight();
         }
         m_doubleTapTimer.invalidate();
         m_secondTap = false;
     }
     return true;
 }
 
 bool BacklightInputEventFilter::touchMotion(qint32 id, const QPointF &pos, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(pos)
     Q_UNUSED(time)
     return m_backend->isBacklightOff();
 }
 
 void BacklightInputEventFilter::toggleBacklight()
 {
     // queued to not modify the list of event filters while filtering
     QMetaObject::invokeMethod(m_backend, "toggleBlankOutput", Qt::QueuedConnection);
 }
 
 HwcomposerBackend::HwcomposerBackend(QObject *parent)
     : Platform(parent)
 {
     if (!QDBusConnection::sessionBus().connect(QStringLiteral("org.kde.Solid.PowerManagement"),
                                               QStringLiteral("/org/kde/Solid/PowerManagement/Actions/BrightnessControl"),
                                               QStringLiteral("org.kde.Solid.PowerManagement.Actions.BrightnessControl"),
                                               QStringLiteral("brightnessChanged"), this,
                                               SLOT(screenBrightnessChanged(int)))) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to connect to brightness control";
     }
 }
 
 HwcomposerBackend::~HwcomposerBackend()
 {
     if (!m_outputBlank) {
         toggleBlankOutput();
     }
 }
 
 void HwcomposerBackend::init()
 {
     hw_module_t *hwcModule = nullptr;
     if (hw_get_module(HWC_HARDWARE_MODULE_ID, (const hw_module_t **)&hwcModule) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to get hwcomposer module";
         emit initFailed();
         return;
     }
 
     hwc_composer_device_1_t *hwcDevice = nullptr;
     if (hwc_open_1(hwcModule, &hwcDevice) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to open hwcomposer device";
         emit initFailed();
         return;
     }
 
     // unblank, setPowerMode?
     m_device = hwcDevice;
 
     m_hwcVersion = m_device->common.version;
     if ((m_hwcVersion & 0xffff0000) == 0) {
         // Assume header version is always 1
         uint32_t header_version = 1;
         // Legacy version encoding
         m_hwcVersion = (m_hwcVersion << 16) | header_version;
     }
 
     // register callbacks
     hwc_procs_t *procs = new hwc_procs_t;
     procs->invalidate = [] (const struct hwc_procs* procs) {
         Q_UNUSED(procs)
     };
     procs->vsync = [] (const struct hwc_procs* procs, int disp, int64_t timestamp) {
         Q_UNUSED(procs)
         if (disp != 0) {
             return;
         }
         dynamic_cast<HwcomposerBackend*>(kwinApp()->platform())->wakeVSync();
     };
     procs->hotplug = [] (const struct hwc_procs* procs, int disp, int connected) {
         Q_UNUSED(procs)
         Q_UNUSED(disp)
         Q_UNUSED(connected)
     };
     m_device->registerProcs(m_device, procs);
 
     //move to HwcomposerOutput + signal
 
     initLights();
     toggleBlankOutput();
     m_filter.reset(new BacklightInputEventFilter(this));
     input()->prependInputEventFilter(m_filter.data());
 
     // get display configuration
     m_output.reset(new HwcomposerOutput(hwcDevice));
     if (!m_output->isValid()) {
         emit initFailed();
         return;
     }
 
     if (m_output->refreshRate() != 0) {
         m_vsyncInterval = 1000000/m_output->refreshRate();
     }
 
     if (m_lights) {
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
 
         auto updateDpms = [this] {
             if (!m_output || !m_output->waylandOutput()) {
                 m_output->waylandOutput()->setDpmsMode(m_outputBlank ? OutputInterface::DpmsMode::Off : OutputInterface::DpmsMode::On);
             }
         };
         connect(this, &HwcomposerBackend::outputBlankChanged, this, updateDpms);
 
         connect(m_output.data(), &HwcomposerOutput::dpmsModeRequested, this,
-            [this] (KWayland::Server::OutputInterface::DpmsMode mode) {
+            [this] (KWaylandServer::OutputInterface::DpmsMode mode) {
                 if (mode == OutputInterface::DpmsMode::On) {
                     if (m_outputBlank) {
                         toggleBlankOutput();
                     }
                 } else {
                     if (!m_outputBlank) {
                         toggleBlankOutput();
                     }
                 }
             }
         );
     }
 
     emit screensQueried();
     setReady(true);
 }
 
 QSize HwcomposerBackend::size() const
 {
     if (m_output) {
         return m_output->pixelSize();
     }
     return QSize();
 }
 
 QSize HwcomposerBackend::screenSize() const
 {
     if (m_output) {
         return m_output->pixelSize() / m_output->scale();
     }
     return QSize();
 }
 
 int HwcomposerBackend::scale() const
  {
     if (m_output) {
         return m_output->scale();
     }
     return 1;
 }
 
 void HwcomposerBackend::initLights()
 {
     hw_module_t *lightsModule = nullptr;
     if (hw_get_module(LIGHTS_HARDWARE_MODULE_ID, (const hw_module_t **)&lightsModule) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to get lights module";
         return;
     }
     light_device_t *lightsDevice = nullptr;
     if (lightsModule->methods->open(lightsModule, LIGHT_ID_BACKLIGHT, (hw_device_t **)&lightsDevice) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to create lights device";
         return;
     }
     m_lights = lightsDevice;
 }
 
 void HwcomposerBackend::toggleBlankOutput()
 {
     if (!m_device) {
         return;
     }
     m_outputBlank = !m_outputBlank;
     toggleScreenBrightness();
 
 #if defined(HWC_DEVICE_API_VERSION_1_4) || defined(HWC_DEVICE_API_VERSION_1_5)
     if (m_hwcVersion > HWC_DEVICE_API_VERSION_1_3)
         m_device->setPowerMode(m_device, 0, m_outputBlank ? HWC_POWER_MODE_OFF : HWC_POWER_MODE_NORMAL);
     else
 #endif
         m_device->blank(m_device, 0, m_outputBlank ? 1 : 0);
 
     // only disable Vsync, enable happens after next frame rendered
     if (m_outputBlank) {
          enableVSync(false);
     }
     // enable/disable compositor repainting when blanked
     setOutputsEnabled(!m_outputBlank);
     if (Compositor *compositor = Compositor::self()) {
         if (!m_outputBlank) {
             compositor->addRepaintFull();
         }
     }
     emit outputBlankChanged();
 }
 
 void HwcomposerBackend::toggleScreenBrightness()
 {
     if (!m_lights) {
         return;
     }
     const int brightness = m_outputBlank ? 0 : m_oldScreenBrightness;
     struct light_state_t state;
     state.flashMode = LIGHT_FLASH_NONE;
     state.brightnessMode = BRIGHTNESS_MODE_USER;
 
     state.color = (int)((0xffU << 24) | (brightness << 16) |
                         (brightness << 8) | brightness);
     m_lights->set_light(m_lights, &state);
 }
 
 void HwcomposerBackend::enableVSync(bool enable)
 {
     if (m_hasVsync == enable) {
         return;
     }
     const int result = m_device->eventControl(m_device, 0, HWC_EVENT_VSYNC, enable ? 1: 0);
     m_hasVsync = enable && (result == 0);
 }
 
 HwcomposerWindow *HwcomposerBackend::createSurface()
 {
     return new HwcomposerWindow(this);
 }
 
 Screens *HwcomposerBackend::createScreens(QObject *parent)
 {
     return new HwcomposerScreens(this, parent);
 }
 
 Outputs HwcomposerBackend::outputs() const
 {
     if (!m_output.isNull()) {
         return QVector<HwcomposerOutput*>({m_output.data()});
     }
     return {};
 }
 
 Outputs HwcomposerBackend::enabledOutputs() const
 {
     return outputs();
 }
 
 
 OpenGLBackend *HwcomposerBackend::createOpenGLBackend()
 {
     return new EglHwcomposerBackend(this);
 }
 
 void HwcomposerBackend::waitVSync()
 {
     if (!m_hasVsync) {
          return;
     }
     m_vsyncMutex.lock();
     m_vsyncWaitCondition.wait(&m_vsyncMutex, m_vsyncInterval);
     m_vsyncMutex.unlock();
 }
 
 void HwcomposerBackend::wakeVSync()
 {
     m_vsyncMutex.lock();
     m_vsyncWaitCondition.wakeAll();
     m_vsyncMutex.unlock();
 }
 
 static void initLayer(hwc_layer_1_t *layer, const hwc_rect_t &rect, int layerCompositionType)
 {
     memset(layer, 0, sizeof(hwc_layer_1_t));
     layer->compositionType = layerCompositionType;
     layer->hints = 0;
     layer->flags = 0;
     layer->handle = 0;
     layer->transform = 0;
     layer->blending = HWC_BLENDING_NONE;
 #ifdef HWC_DEVICE_API_VERSION_1_3
     layer->sourceCropf.top = 0.0f;
     layer->sourceCropf.left = 0.0f;
     layer->sourceCropf.bottom = (float) rect.bottom;
     layer->sourceCropf.right = (float) rect.right;
 #else
     layer->sourceCrop = rect;
 #endif
     layer->displayFrame = rect;
     layer->visibleRegionScreen.numRects = 1;
     layer->visibleRegionScreen.rects = &layer->displayFrame;
     layer->acquireFenceFd = -1;
     layer->releaseFenceFd = -1;
     layer->planeAlpha = 0xFF;
 #ifdef HWC_DEVICE_API_VERSION_1_5
     layer->surfaceDamage.numRects = 0;
 #endif
 }
 
 HwcomposerWindow::HwcomposerWindow(HwcomposerBackend *backend)
     : HWComposerNativeWindow(backend->size().width(), backend->size().height(), HAL_PIXEL_FORMAT_RGBA_8888)
     , m_backend(backend)
 {
     setBufferCount(3);
 
     size_t size = sizeof(hwc_display_contents_1_t) + 2 * sizeof(hwc_layer_1_t);
     hwc_display_contents_1_t *list = (hwc_display_contents_1_t*)malloc(size);
     m_list = (hwc_display_contents_1_t**)malloc(HWC_NUM_DISPLAY_TYPES * sizeof(hwc_display_contents_1_t *));
     for (int i = 0; i < HWC_NUM_DISPLAY_TYPES; ++i) {
         m_list[i] = nullptr;
     }
     // Assign buffer only to the first item, otherwise you get tearing
     // if passed the same to multiple places
     // see https://github.com/mer-hybris/qt5-qpa-hwcomposer-plugin/commit/f1d802151e8a4f5d10d60eb8de8e07552b93a34a
     m_list[0] = list;
     const hwc_rect_t rect = {
         0,
         0,
         m_backend->size().width(),
         m_backend->size().height()
     };
     initLayer(&list->hwLayers[0], rect, HWC_FRAMEBUFFER);
     initLayer(&list->hwLayers[1], rect, HWC_FRAMEBUFFER_TARGET);
 
     list->retireFenceFd = -1;
     list->flags = HWC_GEOMETRY_CHANGED;
     list->numHwLayers = 2;
 }
 
 HwcomposerWindow::~HwcomposerWindow()
 {
     // TODO: cleanup
 }
 
 void HwcomposerWindow::present(HWComposerNativeWindowBuffer *buffer)
 {
     m_backend->waitVSync();
     hwc_composer_device_1_t *device = m_backend->device();
 
     auto fblayer = &m_list[0]->hwLayers[1];
     fblayer->handle = buffer->handle;
     fblayer->acquireFenceFd = getFenceBufferFd(buffer);
     fblayer->releaseFenceFd = -1;
 
     int err = device->prepare(device, 1, m_list);
     Q_ASSERT(err == 0);
 
     err = device->set(device, 1, m_list);
     Q_ASSERT(err == 0);
     m_backend->enableVSync(true);
     setFenceBufferFd(buffer, fblayer->releaseFenceFd);
 
     if (m_list[0]->retireFenceFd != -1) {
         close(m_list[0]->retireFenceFd);
         m_list[0]->retireFenceFd = -1;
     }
     m_list[0]->flags = 0;
 }
 
 HwcomposerOutput::HwcomposerOutput(hwc_composer_device_1_t *device)
     : AbstractWaylandOutput()
     , m_device(device)
 {
     uint32_t configs[5];
     size_t numConfigs = 5;
     if (device->getDisplayConfigs(device, 0, configs, &numConfigs) != 0) {
         qCWarning(KWIN_HWCOMPOSER) << "Failed to get hwcomposer display configurations";
         return;
     }
 
     int32_t attr_values[5];
     uint32_t attributes[] = {
         HWC_DISPLAY_WIDTH,
         HWC_DISPLAY_HEIGHT,
         HWC_DISPLAY_DPI_X,
         HWC_DISPLAY_DPI_Y,
         HWC_DISPLAY_VSYNC_PERIOD ,
         HWC_DISPLAY_NO_ATTRIBUTE
     };
     device->getDisplayAttributes(device, 0, configs[0], attributes, attr_values);
     QSize pixelSize(attr_values[0], attr_values[1]);
     if (pixelSize.isEmpty()) {
         return;
     }
 
     QSizeF physicalSize;
     if (attr_values[2] != 0 && attr_values[3] != 0) {
          static const qreal factor = 25.4;
          physicalSize = QSizeF(qreal(pixelSize.width() * 1000) / qreal(attr_values[2]) * factor,
                                qreal(pixelSize.height() * 1000) / qreal(attr_values[3]) * factor);
     } else {
          // couldn't read physical size, assume 96 dpi
          physicalSize = pixelSize / 3.8;
     }
 
     OutputDeviceInterface::Mode mode;
     mode.id = 0;
     mode.size = pixelSize;
     mode.flags = OutputDeviceInterface::ModeFlag::Current | OutputDeviceInterface::ModeFlag::Preferred;
     mode.refreshRate = (attr_values[4] == 0) ? 60000 : 10E11/attr_values[4];
 
     initInterfaces(QString(), QString(), QByteArray(), physicalSize.toSize(), {mode});
     setInternal(true);
     setDpmsSupported(true);
 
     const auto outputGroup = kwinApp()->config()->group("HWComposerOutputs").group("0");
     setScale(outputGroup.readEntry("Scale", 1));
     setWaylandMode(pixelSize, mode.refreshRate);
 }
 
 HwcomposerOutput::~HwcomposerOutput()
 {
     hwc_close_1(m_device);
 }
 
 bool HwcomposerOutput::isValid() const
 {
     return isEnabled();
 }
 
-void HwcomposerOutput::updateDpms(KWayland::Server::OutputInterface::DpmsMode mode)
+void HwcomposerOutput::updateDpms(KWaylandServer::OutputInterface::DpmsMode mode)
 {
     emit dpmsModeRequested(mode);
 }
 
 }
diff --git a/plugins/platforms/hwcomposer/hwcomposer_backend.h b/plugins/platforms/hwcomposer/hwcomposer_backend.h
index ce1bb5442..2e2a5bedb 100644
--- a/plugins/platforms/hwcomposer/hwcomposer_backend.h
+++ b/plugins/platforms/hwcomposer/hwcomposer_backend.h
@@ -1,166 +1,166 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 3 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_HWCOMPOSER_BACKEND_H
 #define KWIN_HWCOMPOSER_BACKEND_H
 #include "platform.h"
 #include "abstract_wayland_output.h"
 #include "input.h"
 
 #include <QElapsedTimer>
 #include <QMutex>
 #include <QWaitCondition>
 
 #include <android-config.h>
 // libhybris
 #include <hardware/hwcomposer.h>
 #include <hwcomposer_window.h>
 // needed as hwcomposer_window.h includes EGL which on non-arm includes Xlib
 #include <fixx11h.h>
 
 typedef struct hwc_display_contents_1 hwc_display_contents_1_t;
 typedef struct hwc_layer_1 hwc_layer_1_t;
 typedef struct hwc_composer_device_1 hwc_composer_device_1_t;
 struct light_device_t;
 
 class HWComposerNativeWindowBuffer;
 
 namespace KWin
 {
 
 class HwcomposerWindow;
 class BacklightInputEventFilter;
 
 class HwcomposerOutput : public AbstractWaylandOutput
 {
     Q_OBJECT
 public:
     HwcomposerOutput(hwc_composer_device_1_t *device);
     ~HwcomposerOutput() override;
     bool isValid() const;
 
-    void updateDpms(KWayland::Server::OutputInterface::DpmsMode mode) override;
+    void updateDpms(KWaylandServer::OutputInterface::DpmsMode mode) override;
 Q_SIGNALS:
-    void dpmsModeRequested(KWayland::Server::OutputInterface::DpmsMode mode);
+    void dpmsModeRequested(KWaylandServer::OutputInterface::DpmsMode mode);
 private:
     QSize m_pixelSize;
     hwc_composer_device_1_t *m_device;
 };
 
 class HwcomposerBackend : public Platform
 {
     Q_OBJECT
     Q_INTERFACES(KWin::Platform)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Platform" FILE "hwcomposer.json")
 public:
     explicit HwcomposerBackend(QObject *parent = nullptr);
     virtual ~HwcomposerBackend();
 
     void init() override;
     Screens *createScreens(QObject *parent = nullptr) override;
     OpenGLBackend *createOpenGLBackend() override;
 
     Outputs outputs() const override;
     Outputs enabledOutputs() const override;
 
     QSize size() const;
     QSize screenSize() const override;
 
     int scale() const;
 
     HwcomposerWindow *createSurface();
 
     hwc_composer_device_1_t *device() const {
         return m_device;
     }
     void enableVSync(bool enable);
     void waitVSync();
     void wakeVSync();
 
     bool isBacklightOff() const {
         return m_outputBlank;
     }
 
     QVector<CompositingType> supportedCompositors() const override {
         return QVector<CompositingType>{OpenGLCompositing};
     }
 
 Q_SIGNALS:
     void outputBlankChanged();
 
 private Q_SLOTS:
     void toggleBlankOutput();
     void screenBrightnessChanged(int brightness) {
         m_oldScreenBrightness = brightness;
     }
 
 private:
     void initLights();
     void toggleScreenBrightness();
     hwc_composer_device_1_t *m_device = nullptr;
     light_device_t *m_lights = nullptr;
     bool m_outputBlank = true;
     int m_vsyncInterval = 16;
     uint32_t m_hwcVersion;
     int m_oldScreenBrightness = 0x7f;
     bool m_hasVsync = false;
     QMutex m_vsyncMutex;
     QWaitCondition m_vsyncWaitCondition;
     QScopedPointer<BacklightInputEventFilter> m_filter;
     QScopedPointer<HwcomposerOutput> m_output;
 };
 
 class HwcomposerWindow : public HWComposerNativeWindow
 {
 public:
     virtual ~HwcomposerWindow();
 
     void present(HWComposerNativeWindowBuffer *buffer);
 
 private:
     friend HwcomposerBackend;
     HwcomposerWindow(HwcomposerBackend *backend);
     HwcomposerBackend *m_backend;
     hwc_display_contents_1_t **m_list;
 };
 
 class BacklightInputEventFilter : public InputEventFilter
 {
 public:
     BacklightInputEventFilter(HwcomposerBackend *backend);
     virtual ~BacklightInputEventFilter();
 
     bool pointerEvent(QMouseEvent *event, quint32 nativeButton) override;
     bool wheelEvent(QWheelEvent *event) override;
     bool keyEvent(QKeyEvent *event) override;
     bool touchDown(qint32 id, const QPointF &pos, quint32 time) override;
     bool touchMotion(qint32 id, const QPointF &pos, quint32 time) override;
     bool touchUp(qint32 id, quint32 time) override;
 
 private:
     void toggleBacklight();
     HwcomposerBackend *m_backend;
     QElapsedTimer m_doubleTapTimer;
     QVector<qint32> m_touchPoints;
     bool m_secondTap = false;
 };
 
 }
 
 #endif
diff --git a/plugins/platforms/virtual/virtual_backend.cpp b/plugins/platforms/virtual/virtual_backend.cpp
index 2cfa23ed1..aa315a21a 100644
--- a/plugins/platforms/virtual/virtual_backend.cpp
+++ b/plugins/platforms/virtual/virtual_backend.cpp
@@ -1,144 +1,144 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtual_backend.h"
 #include "virtual_output.h"
 #include "scene_qpainter_virtual_backend.h"
 #include "screens_virtual.h"
 #include "wayland_server.h"
 #include "egl_gbm_backend.h"
 // Qt
 #include <QTemporaryDir>
 // KWayland
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 // system
 #include <fcntl.h>
 #include <unistd.h>
 #include <config-kwin.h>
 
 namespace KWin
 {
 
 VirtualBackend::VirtualBackend(QObject *parent)
     : Platform(parent)
 {
     if (qEnvironmentVariableIsSet("KWIN_WAYLAND_VIRTUAL_SCREENSHOTS")) {
         m_screenshotDir.reset(new QTemporaryDir);
         if (!m_screenshotDir->isValid()) {
             m_screenshotDir.reset();
         }
         if (!m_screenshotDir.isNull()) {
             qDebug() << "Screenshots saved to: " << m_screenshotDir->path();
         }
     }
     setSupportsPointerWarping(true);
     setSupportsGammaControl(true);
 }
 
 VirtualBackend::~VirtualBackend()
 {
 }
 
 void VirtualBackend::init()
 {
     /*
      * Some tests currently expect one output present at start,
      * others set them explicitly.
      *
      * TODO: rewrite all tests to explicitly set the outputs.
      */
     if (!m_outputs.size()) {
         VirtualOutput *dummyOutput = new VirtualOutput(this);
         dummyOutput->init(QPoint(0, 0), initialWindowSize());
         m_outputs << dummyOutput ;
         m_enabledOutputs << dummyOutput ;
     }
 
     setSoftWareCursor(true);
     setReady(true);
     waylandServer()->seat()->setHasPointer(true);
     waylandServer()->seat()->setHasKeyboard(true);
     waylandServer()->seat()->setHasTouch(true);
 
     emit screensQueried();
 }
 
 QString VirtualBackend::screenshotDirPath() const
 {
     if (m_screenshotDir.isNull()) {
         return QString();
     }
     return m_screenshotDir->path();
 }
 
 Screens *VirtualBackend::createScreens(QObject *parent)
 {
     return new VirtualScreens(this, parent);
 }
 
 QPainterBackend *VirtualBackend::createQPainterBackend()
 {
     return new VirtualQPainterBackend(this);
 }
 
 OpenGLBackend *VirtualBackend::createOpenGLBackend()
 {
     return new EglGbmBackend(this);
 }
 
 Outputs VirtualBackend::outputs() const
 {
     return m_outputs;
 }
 
 Outputs VirtualBackend::enabledOutputs() const
 {
     return m_enabledOutputs;
 }
 
 void VirtualBackend::setVirtualOutputs(int count, QVector<QRect> geometries, QVector<int> scales)
 {
     Q_ASSERT(geometries.size() == 0 || geometries.size() == count);
     Q_ASSERT(scales.size() == 0 || scales.size() == count);
 
     bool countChanged = m_outputs.size() != count;
     qDeleteAll(m_outputs.begin(), m_outputs.end());
     m_outputs.resize(count);
     m_enabledOutputs.resize(count);
 
     int sumWidth = 0;
     for (int i = 0; i < count; i++) {
         VirtualOutput *vo = new VirtualOutput(this);
         if (geometries.size()) {
             const QRect geo = geometries.at(i);
             vo->init(geo.topLeft(), geo.size());
         } else {
             vo->init(QPoint(sumWidth, 0), initialWindowSize());
             sumWidth += initialWindowSize().width();
         }
         if (scales.size()) {
             vo->setScale(scales.at(i));
         }
         m_outputs[i] = m_enabledOutputs[i] = vo;
     }
 
     emit virtualOutputsSet(countChanged);
 }
 
 }
diff --git a/plugins/platforms/virtual/virtual_output.cpp b/plugins/platforms/virtual/virtual_output.cpp
index 28ad0f15e..f680bf218 100644
--- a/plugins/platforms/virtual/virtual_output.cpp
+++ b/plugins/platforms/virtual/virtual_output.cpp
@@ -1,55 +1,55 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtual_output.h"
 
 namespace KWin
 {
 
 VirtualOutput::VirtualOutput(QObject *parent)
     : AbstractWaylandOutput()
 {
     Q_UNUSED(parent);
     static int identifier = -1;
     identifier++;
     setName("Virtual-" + QString::number(identifier));
 }
 
 VirtualOutput::~VirtualOutput()
 {
 }
 
 void VirtualOutput::init(const QPoint &logicalPosition, const QSize &pixelSize)
 {
-    KWayland::Server::OutputDeviceInterface::Mode mode;
+    KWaylandServer::OutputDeviceInterface::Mode mode;
     mode.id = 0;
     mode.size = pixelSize;
-    mode.flags = KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
+    mode.flags = KWaylandServer::OutputDeviceInterface::ModeFlag::Current;
     mode.refreshRate = 60000;  // TODO
     initInterfaces("model_TODO", "manufacturer_TODO", "UUID_TODO", pixelSize, { mode });
     setGeometry(QRect(logicalPosition, pixelSize));
 }
 
 void VirtualOutput::setGeometry(const QRect &geo)
 {
     // TODO: set mode to have updated pixelSize
     setGlobalPos(geo.topLeft());
 }
 
 }
diff --git a/plugins/platforms/wayland/egl_wayland_backend.cpp b/plugins/platforms/wayland/egl_wayland_backend.cpp
index 74f285bfb..40b6c3a8a 100644
--- a/plugins/platforms/wayland/egl_wayland_backend.cpp
+++ b/plugins/platforms/wayland/egl_wayland_backend.cpp
@@ -1,414 +1,414 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 Copyright 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #define WL_EGL_PLATFORM 1
 
 #include "egl_wayland_backend.h"
 
 #include "wayland_backend.h"
 #include "wayland_output.h"
 
 #include "composite.h"
 #include "logging.h"
 #include "options.h"
 
 #include "wayland_server.h"
 #include "screens.h"
 
 // kwin libs
 #include <kwinglplatform.h>
 
 // KDE
 #include <KWayland/Client/surface.h>
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/display.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/display.h>
 
 // Qt
 #include <QOpenGLContext>
 
 namespace KWin
 {
 namespace Wayland
 {
 
 EglWaylandOutput::EglWaylandOutput(WaylandOutput *output, QObject *parent)
     : QObject(parent)
     , m_waylandOutput(output)
 {
 }
 
 bool EglWaylandOutput::init(EglWaylandBackend *backend)
 {
     auto surface = m_waylandOutput->surface();
     const QSize &size = m_waylandOutput->geometry().size();
     auto overlay = wl_egl_window_create(*surface, size.width(), size.height());
     if (!overlay) {
         qCCritical(KWIN_WAYLAND_BACKEND) << "Creating Wayland Egl window failed";
         return false;
     }
     m_overlay = overlay;
 
     EGLSurface eglSurface = EGL_NO_SURFACE;
     if (backend->havePlatformBase()) {
         eglSurface = eglCreatePlatformWindowSurfaceEXT(backend->eglDisplay(), backend->config(), (void *) overlay, nullptr);
     } else {
         eglSurface = eglCreateWindowSurface(backend->eglDisplay(), backend->config(), overlay, nullptr);
     }
     if (eglSurface == EGL_NO_SURFACE) {
         qCCritical(KWIN_WAYLAND_BACKEND) << "Create Window Surface failed";
         return false;
     }
     m_eglSurface = eglSurface;
 
     connect(m_waylandOutput, &WaylandOutput::sizeChanged, this, &EglWaylandOutput::updateSize);
 
     return true;
 }
 
 void EglWaylandOutput::updateSize(const QSize &size)
 {
     wl_egl_window_resize(m_overlay, size.width(), size.height(), 0, 0);
 }
 
 EglWaylandBackend::EglWaylandBackend(WaylandBackend *b)
     : AbstractEglBackend()
     , m_backend(b)
 {
     if (!m_backend) {
         setFailed("Wayland Backend has not been created");
         return;
     }
     qCDebug(KWIN_WAYLAND_BACKEND) << "Connected to Wayland display?" << (m_backend->display() ? "yes" : "no" );
     if (!m_backend->display()) {
         setFailed("Could not connect to Wayland compositor");
         return;
     }
 
     // Egl is always direct rendering
     setIsDirectRendering(true);
 
     connect(m_backend, &WaylandBackend::outputAdded, this, &EglWaylandBackend::createEglWaylandOutput);
     connect(m_backend, &WaylandBackend::outputRemoved, this,
         [this] (WaylandOutput *output) {
             auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                 [output] (const EglWaylandOutput *o) {
                     return o->m_waylandOutput == output;
                 }
             );
             if (it == m_outputs.end()) {
                 return;
             }
             cleanupOutput(*it);
             m_outputs.erase(it);
         }
     );
 }
 
 EglWaylandBackend::~EglWaylandBackend()
 {
     cleanup();
 }
 
 void EglWaylandBackend::cleanupSurfaces()
 {
     for (auto o : m_outputs) {
         cleanupOutput(o);
     }
     m_outputs.clear();
 }
 
 bool EglWaylandBackend::createEglWaylandOutput(WaylandOutput *waylandOutput)
 {
     auto *output = new EglWaylandOutput(waylandOutput, this);
     if (!output->init(this)) {
         return false;
     }
     m_outputs << output;
     return true;
 }
 
 void EglWaylandBackend::cleanupOutput(EglWaylandOutput *output)
 {
     wl_egl_window_destroy(output->m_overlay);
 }
 
 bool EglWaylandBackend::initializeEgl()
 {
     initClientExtensions();
     EGLDisplay display = m_backend->sceneEglDisplay();
 
     // Use eglGetPlatformDisplayEXT() to get the display pointer
     // if the implementation supports it.
     if (display == EGL_NO_DISPLAY) {
         m_havePlatformBase = hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_base"));
         if (m_havePlatformBase) {
             // Make sure that the wayland platform is supported
             if (!hasClientExtension(QByteArrayLiteral("EGL_EXT_platform_wayland")))
                 return false;
 
             display = eglGetPlatformDisplayEXT(EGL_PLATFORM_WAYLAND_EXT, m_backend->display(), nullptr);
         } else {
             display = eglGetDisplay(m_backend->display());
         }
     }
 
     if (display == EGL_NO_DISPLAY)
         return false;
     setEglDisplay(display);
     return initEglAPI();
 }
 
 void EglWaylandBackend::init()
 {
     if (!initializeEgl()) {
         setFailed("Could not initialize egl");
         return;
     }
     if (!initRenderingContext()) {
         setFailed("Could not initialize rendering context");
         return;
     }
 
     initKWinGL();
     initBufferAge();
     initWayland();
 }
 
 bool EglWaylandBackend::initRenderingContext()
 {
     initBufferConfigs();
 
     if (!createContext()) {
         return false;
     }
 
     auto waylandOutputs = m_backend->waylandOutputs();
 
     // we only allow to start with at least one output
     if (waylandOutputs.isEmpty()) {
         return false;
     }
 
     for (auto *out : waylandOutputs) {
         if (!createEglWaylandOutput(out)) {
             return false;
         }
     }
 
     if (m_outputs.isEmpty()) {
         qCCritical(KWIN_WAYLAND_BACKEND) << "Create Window Surfaces failed";
         return false;
     }
 
     auto *firstOutput = m_outputs.first();
     // set our first surface as the one for the abstract backend, just to make it happy
     setSurface(firstOutput->m_eglSurface);
     return makeContextCurrent(firstOutput);
 }
 
 bool EglWaylandBackend::makeContextCurrent(EglWaylandOutput *output)
 {
     const EGLSurface eglSurface = output->m_eglSurface;
     if (eglSurface == EGL_NO_SURFACE) {
         return false;
     }
     if (eglMakeCurrent(eglDisplay(), eglSurface, eglSurface, context()) == EGL_FALSE) {
         qCCritical(KWIN_WAYLAND_BACKEND) << "Make Context Current failed";
         return false;
     }
 
     EGLint error = eglGetError();
     if (error != EGL_SUCCESS) {
         qCWarning(KWIN_WAYLAND_BACKEND) << "Error occurred while creating context " << error;
         return false;
     }
 
     const QRect &v = output->m_waylandOutput->geometry();
 
     qreal scale = output->m_waylandOutput->scale();
 
     const QSize overall = screens()->size();
     glViewport(-v.x() * scale, (v.height() - overall.height() + v.y()) * scale,
                overall.width() * scale, overall.height() * scale);
     return true;
 }
 
 bool EglWaylandBackend::initBufferConfigs()
 {
     const EGLint config_attribs[] = {
         EGL_SURFACE_TYPE,         EGL_WINDOW_BIT,
         EGL_RED_SIZE,             1,
         EGL_GREEN_SIZE,           1,
         EGL_BLUE_SIZE,            1,
         EGL_ALPHA_SIZE,           0,
         EGL_RENDERABLE_TYPE,      isOpenGLES() ? EGL_OPENGL_ES2_BIT : EGL_OPENGL_BIT,
         EGL_CONFIG_CAVEAT,        EGL_NONE,
         EGL_NONE,
     };
 
     EGLint count;
     EGLConfig configs[1024];
     if (eglChooseConfig(eglDisplay(), config_attribs, configs, 1, &count) == EGL_FALSE) {
         qCCritical(KWIN_WAYLAND_BACKEND) << "choose config failed";
         return false;
     }
     if (count != 1) {
         qCCritical(KWIN_WAYLAND_BACKEND) << "choose config did not return a config" << count;
         return false;
     }
     setConfig(configs[0]);
 
     return true;
 }
 
 void EglWaylandBackend::present()
 {
     for (auto *output: qAsConst(m_outputs)) {
         makeContextCurrent(output);
         presentOnSurface(output);
     }
 }
 
 void EglWaylandBackend::presentOnSurface(EglWaylandOutput *output)
 {
     output->m_waylandOutput->surface()->setupFrameCallback();
     if (!m_swapping) {
         m_swapping = true;
         Compositor::self()->aboutToSwapBuffers();
     }
 
     if (supportsBufferAge()) {
         eglSwapBuffers(eglDisplay(), output->m_eglSurface);
         eglQuerySurface(eglDisplay(), output->m_eglSurface, EGL_BUFFER_AGE_EXT, &output->m_bufferAge);
     } else {
         eglSwapBuffers(eglDisplay(), output->m_eglSurface);
     }
 
 }
 
 void EglWaylandBackend::screenGeometryChanged(const QSize &size)
 {
     Q_UNUSED(size)
     // no backend specific code needed
     // TODO: base implementation in OpenGLBackend
 
     // The back buffer contents are now undefined
     for (auto *output : qAsConst(m_outputs)) {
         output->m_bufferAge = 0;
     }
 }
 
 SceneOpenGLTexturePrivate *EglWaylandBackend::createBackendTexture(SceneOpenGLTexture *texture)
 {
     return new EglWaylandTexture(texture, this);
 }
 
 QRegion EglWaylandBackend::prepareRenderingFrame()
 {
     eglWaitNative(EGL_CORE_NATIVE_ENGINE);
     startRenderTimer();
     m_swapping = false;
     return QRegion();
 }
 
 QRegion EglWaylandBackend::prepareRenderingForScreen(int screenId)
 {
     auto *output = m_outputs.at(screenId);
     makeContextCurrent(output);
     if (supportsBufferAge()) {
         QRegion region;
 
         // Note: An age of zero means the buffer contents are undefined
         if (output->m_bufferAge > 0 && output->m_bufferAge <= output->m_damageHistory.count()) {
             for (int i = 0; i < output->m_bufferAge - 1; i++)
                 region |= output->m_damageHistory[i];
         } else {
             region = output->m_waylandOutput->geometry();
         }
 
         return region;
     }
     return QRegion();
 }
 
 void EglWaylandBackend::endRenderingFrame(const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     Q_UNUSED(renderedRegion)
     Q_UNUSED(damagedRegion)
 }
 
 void EglWaylandBackend::endRenderingFrameForScreen(int screenId, const QRegion &renderedRegion, const QRegion &damagedRegion)
 {
     EglWaylandOutput *output = m_outputs[screenId];
     if (damagedRegion.intersected(output->m_waylandOutput->geometry()).isEmpty() && screenId == 0) {
 
         // If the damaged region of a window is fully occluded, the only
         // rendering done, if any, will have been to repair a reused back
         // buffer, making it identical to the front buffer.
         //
         // In this case we won't post the back buffer. Instead we'll just
         // set the buffer age to 1, so the repaired regions won't be
         // rendered again in the next frame.
         if (!renderedRegion.intersected(output->m_waylandOutput->geometry()).isEmpty()) {
             glFlush();
         }
 
         for (auto *o : qAsConst(m_outputs)) {
             o->m_bufferAge = 1;
         }
         return;
     }
     presentOnSurface(output);
 
     // Save the damaged region to history
     // Note: damage history is only collected for the first screen. See EglGbmBackend
     // for mor information regarding this limitation.
     if (supportsBufferAge() && screenId == 0) {
         if (output->m_damageHistory.count() > 10) {
             output->m_damageHistory.removeLast();
         }
 
         output->m_damageHistory.prepend(damagedRegion.intersected(output->m_waylandOutput->geometry()));
     }
 }
 
 bool EglWaylandBackend::usesOverlayWindow() const
 {
     return false;
 }
 
 bool EglWaylandBackend::perScreenRendering() const
 {
     return true;
 }
 
 /************************************************
  * EglTexture
  ************************************************/
 
 EglWaylandTexture::EglWaylandTexture(KWin::SceneOpenGLTexture *texture, KWin::Wayland::EglWaylandBackend *backend)
     : AbstractEglTexture(texture, backend)
 {
 }
 
 EglWaylandTexture::~EglWaylandTexture() = default;
 
 }
 }
diff --git a/plugins/platforms/wayland/wayland_backend.cpp b/plugins/platforms/wayland/wayland_backend.cpp
index bb5f4102e..233943a3d 100644
--- a/plugins/platforms/wayland/wayland_backend.cpp
+++ b/plugins/platforms/wayland/wayland_backend.cpp
@@ -1,840 +1,840 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 Copyright 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "wayland_backend.h"
 
 #if HAVE_WAYLAND_EGL
 #include "egl_wayland_backend.h"
 #endif
 #include "logging.h"
 #include "scene_qpainter_wayland_backend.h"
 #include "wayland_output.h"
 
 #include "composite.h"
 #include "cursor.h"
 #include "input.h"
 #include "main.h"
 #include "outputscreens.h"
 #include "pointer_input.h"
 #include "screens.h"
 #include "wayland_cursor_theme.h"
 #include "wayland_server.h"
 
 #include <config-kwin.h>
 
 #include <KWayland/Client/buffer.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/keyboard.h>
 #include <KWayland/Client/pointer.h>
 #include <KWayland/Client/pointerconstraints.h>
 #include <KWayland/Client/pointergestures.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/relativepointer.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/server_decoration.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/subcompositor.h>
 #include <KWayland/Client/subsurface.h>
 #include <KWayland/Client/surface.h>
 #include <KWayland/Client/touch.h>
 #include <KWayland/Client/xdgshell.h>
 
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <QMetaMethod>
 #include <QThread>
 
 #include <linux/input.h>
 #include <wayland-cursor.h>
 
 namespace KWin
 {
 namespace Wayland
 {
 
 using namespace KWayland::Client;
 
 WaylandCursor::WaylandCursor(WaylandBackend *backend)
     : QObject(backend)
     , m_backend(backend)
 {
     resetSurface();
 }
 
 void WaylandCursor::resetSurface()
 {
     delete m_surface;
     m_surface = backend()->compositor()->createSurface(this);
 }
 
 void WaylandCursor::init()
 {
     installImage();
 }
 
 WaylandCursor::~WaylandCursor()
 {
     delete m_surface;
 }
 
 void WaylandCursor::installImage()
 {
     const QImage image = Cursors::self()->currentCursor()->image();
     if (image.isNull() || image.size().isEmpty()) {
         doInstallImage(nullptr, QSize());
         return;
     }
 
     auto buffer = m_backend->shmPool()->createBuffer(image).toStrongRef();
     wl_buffer *imageBuffer = *buffer.data();
     doInstallImage(imageBuffer, image.size());
 }
 
 void WaylandCursor::doInstallImage(wl_buffer *image, const QSize &size)
 {
     auto *pointer = m_backend->seat()->pointer();
     if (!pointer || !pointer->isValid()) {
         return;
     }
     pointer->setCursor(m_surface, image ? Cursors::self()->currentCursor()->hotspot() : QPoint());
     drawSurface(image, size);
 }
 
 void WaylandCursor::drawSurface(wl_buffer *image, const QSize &size)
 {
     m_surface->attachBuffer(image);
     m_surface->damage(QRect(QPoint(0,0), size));
     m_surface->commit(Surface::CommitFlag::None);
     m_backend->flush();
 }
 
 WaylandSubSurfaceCursor::WaylandSubSurfaceCursor(WaylandBackend *backend)
     : WaylandCursor(backend)
 {
 }
 
 void WaylandSubSurfaceCursor::init()
 {
     if (auto *pointer = backend()->seat()->pointer()) {
         pointer->hideCursor();
     }
 }
 
 WaylandSubSurfaceCursor::~WaylandSubSurfaceCursor()
 {
     delete m_subSurface;
 }
 
 void WaylandSubSurfaceCursor::changeOutput(WaylandOutput *output)
 {
     delete m_subSurface;
     m_subSurface = nullptr;
     m_output = output;
     if (!output) {
         return;
     }
     createSubSurface();
     surface()->commit();
 }
 
 void WaylandSubSurfaceCursor::createSubSurface()
 {
     if (m_subSurface) {
         return;
     }
     if (!m_output) {
         return;
     }
     resetSurface();
     m_subSurface = backend()->subCompositor()->createSubSurface(surface(), m_output->surface(), this);
     m_subSurface->setMode(SubSurface::Mode::Desynchronized);
 }
 
 void WaylandSubSurfaceCursor::doInstallImage(wl_buffer *image, const QSize &size)
 {
     if (!image) {
         delete m_subSurface;
         m_subSurface = nullptr;
         return;
     }
     createSubSurface();
     // cursor position might have changed due to different cursor hot spot
     move(input()->pointer()->pos());
     drawSurface(image, size);
 }
 
 QPointF WaylandSubSurfaceCursor::absoluteToRelativePosition(const QPointF &position)
 {
     return position - m_output->geometry().topLeft() - Cursors::self()->currentCursor()->hotspot();
 }
 
 void WaylandSubSurfaceCursor::move(const QPointF &globalPosition)
 {
     auto *output = backend()->getOutputAt(globalPosition.toPoint());
     if (!m_output || (output && m_output != output)) {
         changeOutput(output);
         if (!m_output) {
             // cursor might be off the grid
             return;
         }
         installImage();
         return;
     }
     if (!m_subSurface) {
         return;
     }
     // place the sub-surface relative to the output it is on and factor in the hotspot
     const auto relativePosition = globalPosition.toPoint() - Cursors::self()->currentCursor()->hotspot() - m_output->geometry().topLeft();
     m_subSurface->setPosition(relativePosition);
     Compositor::self()->addRepaintFull();
 }
 
 WaylandSeat::WaylandSeat(wl_seat *seat, WaylandBackend *backend)
     : QObject(nullptr)
     , m_seat(new Seat(this))
     , m_pointer(nullptr)
     , m_keyboard(nullptr)
     , m_touch(nullptr)
     , m_enteredSerial(0)
     , m_backend(backend)
 {
     m_seat->setup(seat);
     connect(m_seat, &Seat::hasKeyboardChanged, this,
         [this](bool hasKeyboard) {
             if (hasKeyboard) {
                 m_keyboard = m_seat->createKeyboard(this);
                 connect(m_keyboard, &Keyboard::keyChanged, this,
                     [this](quint32 key, Keyboard::KeyState state, quint32 time) {
                         switch (state) {
                         case Keyboard::KeyState::Pressed:
                             if (key == KEY_RIGHTCTRL) {
                                 m_backend->togglePointerLock();
                             }
                             m_backend->keyboardKeyPressed(key, time);
                             break;
                         case Keyboard::KeyState::Released:
                             m_backend->keyboardKeyReleased(key, time);
                             break;
                         default:
                             Q_UNREACHABLE();
                         }
                     }
                 );
                 connect(m_keyboard, &Keyboard::modifiersChanged, this,
                     [this](quint32 depressed, quint32 latched, quint32 locked, quint32 group) {
                         m_backend->keyboardModifiers(depressed, latched, locked, group);
                     }
                 );
                 connect(m_keyboard, &Keyboard::keymapChanged, this,
                     [this](int fd, quint32 size) {
                         m_backend->keymapChange(fd, size);
                     }
                 );
             } else {
                 destroyKeyboard();
             }
         }
     );
     connect(m_seat, &Seat::hasPointerChanged, this,
         [this](bool hasPointer) {
             if (hasPointer && !m_pointer) {
                 m_pointer = m_seat->createPointer(this);
                 setupPointerGestures();
                 connect(m_pointer, &Pointer::entered, this,
                     [this](quint32 serial, const QPointF &relativeToSurface) {
                         Q_UNUSED(relativeToSurface)
                         m_enteredSerial = serial;
                     }
                 );
                 connect(m_pointer, &Pointer::motion, this,
                     [this](const QPointF &relativeToSurface, quint32 time) {
                         m_backend->pointerMotionRelativeToOutput(relativeToSurface, time);
                     }
                 );
                 connect(m_pointer, &Pointer::buttonStateChanged, this,
                     [this](quint32 serial, quint32 time, quint32 button, Pointer::ButtonState state) {
                         Q_UNUSED(serial)
                         switch (state) {
                         case Pointer::ButtonState::Pressed:
                             m_backend->pointerButtonPressed(button, time);
                             break;
                         case Pointer::ButtonState::Released:
                             m_backend->pointerButtonReleased(button, time);
                             break;
                         default:
                             Q_UNREACHABLE();
                         }
                     }
                 );
                 // TODO: Send discreteDelta and source as well.
                 connect(m_pointer, &Pointer::axisChanged, this,
                     [this](quint32 time, Pointer::Axis axis, qreal delta) {
                         switch (axis) {
                         case Pointer::Axis::Horizontal:
                             m_backend->pointerAxisHorizontal(delta, time);
                             break;
                         case Pointer::Axis::Vertical:
                             m_backend->pointerAxisVertical(delta, time);
                             break;
                         default:
                             Q_UNREACHABLE();
                         }
                     }
                 );
             } else {
                 destroyPointer();
             }
         }
     );
     connect(m_seat, &Seat::hasTouchChanged,
         [this] (bool hasTouch) {
             if (hasTouch && !m_touch) {
                 m_touch = m_seat->createTouch(this);
                 connect(m_touch, &Touch::sequenceCanceled, m_backend, &Platform::touchCancel);
                 connect(m_touch, &Touch::frameEnded, m_backend, &Platform::touchFrame);
                 connect(m_touch, &Touch::sequenceStarted, this,
                     [this] (TouchPoint *tp) {
                         m_backend->touchDown(tp->id(), tp->position(), tp->time());
                     }
                 );
                 connect(m_touch, &Touch::pointAdded, this,
                     [this] (TouchPoint *tp) {
                         m_backend->touchDown(tp->id(), tp->position(), tp->time());
                     }
                 );
                 connect(m_touch, &Touch::pointRemoved, this,
                     [this] (TouchPoint *tp) {
                         m_backend->touchUp(tp->id(), tp->time());
                     }
                 );
                 connect(m_touch, &Touch::pointMoved, this,
                     [this] (TouchPoint *tp) {
                         m_backend->touchMotion(tp->id(), tp->position(), tp->time());
                     }
                 );
             } else {
                 destroyTouch();
             }
         }
     );
     WaylandServer *server = waylandServer();
     if (server) {
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
         SeatInterface *si = server->seat();
         connect(m_seat, &Seat::hasKeyboardChanged, si, &SeatInterface::setHasKeyboard);
         connect(m_seat, &Seat::hasPointerChanged, si, &SeatInterface::setHasPointer);
         connect(m_seat, &Seat::hasTouchChanged, si, &SeatInterface::setHasTouch);
         connect(m_seat, &Seat::nameChanged, si, &SeatInterface::setName);
     }
 }
 
 void WaylandBackend::pointerMotionRelativeToOutput(const QPointF &position, quint32 time)
 {
     auto outputIt = std::find_if(m_outputs.begin(), m_outputs.end(), [this](WaylandOutput *wo) {
             return wo->surface() == m_seat->pointer()->enteredSurface();
     });
     Q_ASSERT(outputIt != m_outputs.end());
     const QPointF outputPosition = (*outputIt)->geometry().topLeft() + position;
     Platform::pointerMotion(outputPosition, time);
 }
 
 WaylandSeat::~WaylandSeat()
 {
     destroyPointer();
     destroyKeyboard();
     destroyTouch();
 }
 
 void WaylandSeat::destroyPointer()
 {
     delete m_pinchGesture;
     m_pinchGesture = nullptr;
     delete m_swipeGesture;
     m_swipeGesture = nullptr;
     delete m_pointer;
     m_pointer = nullptr;
 }
 
 void WaylandSeat::destroyKeyboard()
 {
     delete m_keyboard;
     m_keyboard = nullptr;
 }
 
 void WaylandSeat::destroyTouch()
 {
     delete m_touch;
     m_touch = nullptr;
 }
 
 void WaylandSeat::setupPointerGestures()
 {
     if (!m_pointer || !m_gesturesInterface) {
         return;
     }
     if (m_pinchGesture || m_swipeGesture) {
         return;
     }
     m_pinchGesture = m_gesturesInterface->createPinchGesture(m_pointer, this);
     m_swipeGesture = m_gesturesInterface->createSwipeGesture(m_pointer, this);
     connect(m_pinchGesture, &PointerPinchGesture::started, m_backend,
         [this] (quint32 serial, quint32 time) {
             Q_UNUSED(serial);
             m_backend->processPinchGestureBegin(m_pinchGesture->fingerCount(), time);
         }
     );
     connect(m_pinchGesture, &PointerPinchGesture::updated, m_backend,
         [this] (const QSizeF &delta, qreal scale, qreal rotation, quint32 time) {
             m_backend->processPinchGestureUpdate(scale, rotation, delta, time);
         }
     );
     connect(m_pinchGesture, &PointerPinchGesture::ended, m_backend,
         [this] (quint32 serial, quint32 time) {
             Q_UNUSED(serial)
             m_backend->processPinchGestureEnd(time);
         }
     );
     connect(m_pinchGesture, &PointerPinchGesture::cancelled, m_backend,
         [this] (quint32 serial, quint32 time) {
             Q_UNUSED(serial)
             m_backend->processPinchGestureCancelled(time);
         }
     );
 
     connect(m_swipeGesture, &PointerSwipeGesture::started, m_backend,
         [this] (quint32 serial, quint32 time) {
             Q_UNUSED(serial)
             m_backend->processSwipeGestureBegin(m_swipeGesture->fingerCount(), time);
         }
     );
     connect(m_swipeGesture, &PointerSwipeGesture::updated, m_backend, &Platform::processSwipeGestureUpdate);
     connect(m_swipeGesture, &PointerSwipeGesture::ended, m_backend,
         [this] (quint32 serial, quint32 time) {
             Q_UNUSED(serial)
             m_backend->processSwipeGestureEnd(time);
         }
     );
     connect(m_swipeGesture, &PointerSwipeGesture::cancelled, m_backend,
         [this] (quint32 serial, quint32 time) {
             Q_UNUSED(serial)
             m_backend->processSwipeGestureCancelled(time);
         }
     );
 }
 
 WaylandBackend::WaylandBackend(QObject *parent)
     : Platform(parent)
     , m_display(nullptr)
     , m_eventQueue(new EventQueue(this))
     , m_registry(new Registry(this))
     , m_compositor(new KWayland::Client::Compositor(this))
     , m_subCompositor(new KWayland::Client::SubCompositor(this))
     , m_shm(new ShmPool(this))
     , m_connectionThreadObject(new ConnectionThread(nullptr))
     , m_connectionThread(nullptr)
 {
     connect(this, &WaylandBackend::connectionFailed, this, &WaylandBackend::initFailed);
 }
 
 WaylandBackend::~WaylandBackend()
 {
     if (m_pointerConstraints) {
         m_pointerConstraints->release();
     }
     delete m_waylandCursor;
 
     m_eventQueue->release();
     qDeleteAll(m_outputs);
 
     if (m_xdgShell) {
         m_xdgShell->release();
     }
     m_subCompositor->release();
     m_compositor->release();
     m_registry->release();
     delete m_seat;
     m_shm->release();
 
     m_connectionThread->quit();
     m_connectionThread->wait();
     m_connectionThreadObject->deleteLater();
 
     qCDebug(KWIN_WAYLAND_BACKEND) << "Destroyed Wayland display";
 }
 
 void WaylandBackend::init()
 {
     connect(m_registry, &Registry::compositorAnnounced, this,
         [this](quint32 name) {
             m_compositor->setup(m_registry->bindCompositor(name, 1));
         }
     );
     connect(m_registry, &Registry::subCompositorAnnounced, this,
         [this](quint32 name) {
             m_subCompositor->setup(m_registry->bindSubCompositor(name, 1));
         }
     );
     connect(m_registry, &Registry::seatAnnounced, this,
         [this](quint32 name) {
             if (Application::usesLibinput()) {
                 return;
             }
             m_seat = new WaylandSeat(m_registry->bindSeat(name, 2), this);
         }
     );
     connect(m_registry, &Registry::shmAnnounced, this,
         [this](quint32 name) {
             m_shm->setup(m_registry->bindShm(name, 1));
         }
     );
     connect(m_registry, &Registry::relativePointerManagerUnstableV1Announced, this,
         [this](quint32 name, quint32 version) {
             if (m_relativePointerManager) {
                 return;
             }
             m_relativePointerManager = m_registry->createRelativePointerManager(name, version, this);
             if (m_pointerConstraints) {
                 emit pointerLockSupportedChanged();
             }
         }
     );
     connect(m_registry, &Registry::pointerConstraintsUnstableV1Announced, this,
         [this](quint32 name, quint32 version) {
             if (m_pointerConstraints) {
                 return;
             }
             m_pointerConstraints = m_registry->createPointerConstraints(name, version, this);
             if (m_relativePointerManager) {
                 emit pointerLockSupportedChanged();
             }
         }
     );
     connect(m_registry, &Registry::interfacesAnnounced, this, &WaylandBackend::createOutputs);
     connect(m_registry, &Registry::interfacesAnnounced, this,
         [this] {
             if (!m_seat) {
                 return;
             }
             const auto gi = m_registry->interface(Registry::Interface::PointerGesturesUnstableV1);
             if (gi.name == 0) {
                 return;
             }
             auto gesturesInterface = m_registry->createPointerGestures(gi.name, gi.version, m_seat);
             m_seat->installGesturesInterface(gesturesInterface);
 
             m_waylandCursor = new WaylandCursor(this);
         }
     );
     if (!deviceIdentifier().isEmpty()) {
         m_connectionThreadObject->setSocketName(deviceIdentifier());
     }
     connect(Cursors::self(), &Cursors::currentCursorChanged, this,
         [this] {
             if (!m_seat) {
                 return;
             }
             m_waylandCursor->installImage();
             auto c = Cursors::self()->currentCursor();
             c->rendered(c->geometry());
         }
     );
     connect(this, &WaylandBackend::pointerLockChanged, this, [this] (bool locked) {
         delete m_waylandCursor;
         if (locked) {
             Q_ASSERT(!m_relativePointer);
             m_waylandCursor = new WaylandSubSurfaceCursor(this);
             m_waylandCursor->move(input()->pointer()->pos());
             m_relativePointer = m_relativePointerManager->createRelativePointer(m_seat->pointer(), this);
             if (!m_relativePointer->isValid()) {
                 return;
             }
             connect(m_relativePointer, &RelativePointer::relativeMotion,
                     this, &WaylandBackend::relativeMotionHandler);
         } else {
             delete m_relativePointer;
             m_relativePointer = nullptr;
             m_waylandCursor = new WaylandCursor(this);
         }
         m_waylandCursor->init();
     });
     initConnection();
 }
 
 void WaylandBackend::relativeMotionHandler(const QSizeF &delta, const QSizeF &deltaNonAccelerated, quint64 timestamp)
 {
     Q_UNUSED(deltaNonAccelerated)
     Q_ASSERT(m_waylandCursor);
 
     const auto oldGlobalPos = input()->pointer()->pos();
     const QPointF newPos = oldGlobalPos + QPointF(delta.width(), delta.height());
     m_waylandCursor->move(newPos);
     Platform::pointerMotion(newPos, timestamp);
 }
 
 void WaylandBackend::initConnection()
 {
     connect(m_connectionThreadObject, &ConnectionThread::connected, this,
         [this]() {
             // create the event queue for the main gui thread
             m_display = m_connectionThreadObject->display();
             m_eventQueue->setup(m_connectionThreadObject);
             m_registry->setEventQueue(m_eventQueue);
             // setup registry
             m_registry->create(m_display);
             m_registry->setup();
         },
         Qt::QueuedConnection);
     connect(m_connectionThreadObject, &ConnectionThread::connectionDied, this,
         [this]() {
             setReady(false);
             emit systemCompositorDied();
             delete m_seat;
             m_shm->destroy();
 
             qDeleteAll(m_outputs);
             m_outputs.clear();
 
             if (m_xdgShell) {
                 m_xdgShell->destroy();
             }
             m_subCompositor->destroy();
             m_compositor->destroy();
             m_registry->destroy();
             m_eventQueue->destroy();
             if (m_display) {
                 m_display = nullptr;
             }
         },
         Qt::QueuedConnection);
     connect(m_connectionThreadObject, &ConnectionThread::failed, this, &WaylandBackend::connectionFailed, Qt::QueuedConnection);
 
     m_connectionThread = new QThread(this);
     m_connectionThreadObject->moveToThread(m_connectionThread);
     m_connectionThread->start();
 
     m_connectionThreadObject->initConnection();
 }
 
 void WaylandBackend::updateScreenSize(WaylandOutput *output)
 {
    auto it = std::find(m_outputs.begin(), m_outputs.end(), output);
 
    int nextLogicalPosition = output->geometry().topRight().x();
    while (++it != m_outputs.end()) {
        const QRect geo = (*it)->geometry();
        (*it)->setGeometry(QPoint(nextLogicalPosition, 0), geo.size());
        nextLogicalPosition = geo.topRight().x();
    }
 }
 
 void WaylandBackend::createOutputs()
 {
     using namespace KWayland::Client;
 
     const auto ssdManagerIface = m_registry->interface(Registry::Interface::ServerSideDecorationManager);
     ServerSideDecorationManager *ssdManager = ssdManagerIface.name == 0 ? nullptr :
             m_registry->createServerSideDecorationManager(ssdManagerIface.name, ssdManagerIface.version, this);
 
 
     const auto xdgIface = m_registry->interface(Registry::Interface::XdgShellStable);
     if (xdgIface.name != 0) {
         m_xdgShell = m_registry->createXdgShell(xdgIface.name, xdgIface.version, this);
     }
 
     // we need to multiply the initial window size with the scale in order to
     // create an output window of this size in the end
     const int pixelWidth = initialWindowSize().width() * initialOutputScale() + 0.5;
     const int pixelHeight = initialWindowSize().height() * initialOutputScale() + 0.5;
     const int logicalWidth = initialWindowSize().width();
 
     int logicalWidthSum = 0;
     for (int i = 0; i < initialOutputCount(); i++) {
         auto surface = m_compositor->createSurface(this);
         if (!surface || !surface->isValid()) {
             qCCritical(KWIN_WAYLAND_BACKEND) << "Creating Wayland Surface failed";
             return;
         }
 
         if (ssdManager) {
             auto decoration = ssdManager->create(surface, this);
             connect(decoration, &ServerSideDecoration::modeChanged, this,
                 [decoration] {
                     if (decoration->mode() != ServerSideDecoration::Mode::Server) {
                         decoration->requestMode(ServerSideDecoration::Mode::Server);
                     }
                 }
             );
         }
 
         WaylandOutput *waylandOutput = nullptr;
 
         if (m_xdgShell && m_xdgShell->isValid()) {
             waylandOutput = new XdgShellOutput(surface, m_xdgShell, this, i+1);
         }
 
         if (!waylandOutput) {
             qCCritical(KWIN_WAYLAND_BACKEND) << "Binding to all shell interfaces failed for output" << i;
             return;
         }
 
         waylandOutput->init(QPoint(logicalWidthSum, 0), QSize(pixelWidth, pixelHeight));
 
         connect(waylandOutput, &WaylandOutput::sizeChanged, this, [this, waylandOutput](const QSize &size) {
             Q_UNUSED(size)
             updateScreenSize(waylandOutput);
             Compositor::self()->addRepaintFull();
         });
         connect(waylandOutput, &WaylandOutput::frameRendered, this, &WaylandBackend::checkBufferSwap);
 
         logicalWidthSum += logicalWidth;
         m_outputs << waylandOutput;
     }
     setReady(true);
     emit screensQueried();
 }
 
 Screens *WaylandBackend::createScreens(QObject *parent)
 {
     return new OutputScreens(this, parent);
 }
 
 OpenGLBackend *WaylandBackend::createOpenGLBackend()
 {
 #if HAVE_WAYLAND_EGL
     return new EglWaylandBackend(this);
 #else
     return nullptr;
 #endif
 }
 
 QPainterBackend *WaylandBackend::createQPainterBackend()
 {
     return new WaylandQPainterBackend(this);
 }
 
 void WaylandBackend::checkBufferSwap()
 {
     const bool allRendered = std::all_of(m_outputs.begin(), m_outputs.end(), [](WaylandOutput *o) {
             return o->rendered();
         });
     if (!allRendered) {
         // need to wait more
         // TODO: what if one does not need to be rendered (no damage)?
         return;
     }
 
     for (auto *output : m_outputs) {
         if (!output->rendered()) {
             return;
         }
     }
     Compositor::self()->bufferSwapComplete();
 
     for (auto *output : m_outputs) {
         output->resetRendered();
     }
 }
 
 void WaylandBackend::flush()
 {
     if (m_connectionThreadObject) {
         m_connectionThreadObject->flush();
     }
 }
 
 WaylandOutput* WaylandBackend::getOutputAt(const QPointF globalPosition)
 {
     const auto pos = globalPosition.toPoint();
     auto checkPosition = [pos](WaylandOutput *output) {
         return output->geometry().contains(pos);
     };
     auto it = std::find_if(m_outputs.begin(), m_outputs.end(), checkPosition);
     return it == m_outputs.end() ? nullptr : *it;
 }
 
 bool WaylandBackend::supportsPointerLock()
 {
     return m_pointerConstraints && m_relativePointerManager;
 }
 
 void WaylandBackend::togglePointerLock()
 {
     if (!m_pointerConstraints) {
         return;
     }
     if (!m_relativePointerManager) {
         return;
     }
     if (!m_seat) {
         return;
     }
     auto pointer = m_seat->pointer();
     if (!pointer) {
         return;
     }
     if (m_outputs.isEmpty()) {
         return;
     }
 
     for (auto output : m_outputs) {
         output->lockPointer(m_seat->pointer(), !m_pointerLockRequested);
     }
     m_pointerLockRequested = !m_pointerLockRequested;
     flush();
 }
 
 bool WaylandBackend::pointerIsLocked()
 {
     for (auto *output : m_outputs) {
         if (output->pointerIsLocked()) {
             return true;
         }
     }
     return false;
 }
 
 QVector<CompositingType> WaylandBackend::supportedCompositors() const
 {
     if (selectedCompositor() != NoCompositing) {
         return {selectedCompositor()};
     }
 #if HAVE_WAYLAND_EGL
     return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
 #else
     return QVector<CompositingType>{QPainterCompositing};
 #endif
 }
 
 Outputs WaylandBackend::outputs() const
 {
     return m_outputs;
 }
 
 Outputs WaylandBackend::enabledOutputs() const
 {
     // all outputs are enabled
     return m_outputs;
 }
 
 }
 
 } // KWin
diff --git a/plugins/platforms/wayland/wayland_output.cpp b/plugins/platforms/wayland/wayland_output.cpp
index bd253c96b..6be848834 100644
--- a/plugins/platforms/wayland/wayland_output.cpp
+++ b/plugins/platforms/wayland/wayland_output.cpp
@@ -1,183 +1,183 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "wayland_output.h"
 #include "wayland_backend.h"
 
 #include "wayland_server.h"
 
 #include <KWayland/Client/pointerconstraints.h>
 #include <KWayland/Client/surface.h>
 
-#include <KWayland/Server/display.h>
+#include <KWaylandServer/display.h>
 
 #include <KLocalizedString>
 
 namespace KWin
 {
 namespace Wayland
 {
 
 using namespace KWayland::Client;
 
 WaylandOutput::WaylandOutput(Surface *surface, WaylandBackend *backend)
     : AbstractWaylandOutput(backend)
     , m_surface(surface)
     , m_backend(backend)
 {
     static int identifier = -1;
     identifier++;
     setName("WL-" + QString::number(identifier));
 
     connect(surface, &Surface::frameRendered, [this] {
         m_rendered = true;
         emit frameRendered();
     });
 }
 
 WaylandOutput::~WaylandOutput()
 {
     m_surface->destroy();
     delete m_surface;
 }
 
 void WaylandOutput::init(const QPoint &logicalPosition, const QSize &pixelSize)
 {
-    KWayland::Server::OutputDeviceInterface::Mode mode;
+    KWaylandServer::OutputDeviceInterface::Mode mode;
     mode.id = 0;
     mode.size = pixelSize;
-    mode.flags = KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
+    mode.flags = KWaylandServer::OutputDeviceInterface::ModeFlag::Current;
     mode.refreshRate = 60000;  // TODO: can we get refresh rate data from Wayland host?
     initInterfaces("model_TODO", "manufacturer_TODO", "UUID_TODO", pixelSize, { mode });
     setGeometry(logicalPosition, pixelSize);
     setScale(backend()->initialOutputScale());
 }
 
 void WaylandOutput::setGeometry(const QPoint &logicalPosition, const QSize &pixelSize)
 {
     // TODO: set mode to have updated pixelSize
     Q_UNUSED(pixelSize)
 
     setGlobalPos(logicalPosition);
 }
 
 XdgShellOutput::XdgShellOutput(Surface *surface, XdgShell *xdgShell, WaylandBackend *backend, int number)
     : WaylandOutput(surface, backend)
     , m_number(number)
 {
     m_xdgShellSurface = xdgShell->createSurface(surface, this);
     updateWindowTitle();
 
     connect(m_xdgShellSurface, &XdgShellSurface::configureRequested, this, &XdgShellOutput::handleConfigure);
     connect(m_xdgShellSurface, &XdgShellSurface::closeRequested, qApp, &QCoreApplication::quit);
 
     connect(backend, &WaylandBackend::pointerLockSupportedChanged, this, &XdgShellOutput::updateWindowTitle);
     connect(backend, &WaylandBackend::pointerLockChanged, this, [this](bool locked) {
         if (locked) {
             if (!m_hasPointerLock) {
                 // some other output has locked the pointer
                 // this surface can stop trying to lock the pointer
                 lockPointer(nullptr, false);
                 // set it true for the other surface
                 m_hasPointerLock = true;
             }
         } else {
             // just try unlocking
             lockPointer(nullptr, false);
         }
         updateWindowTitle();
     });
 
     surface->commit(Surface::CommitFlag::None);
 }
 
 XdgShellOutput::~XdgShellOutput()
 {
     m_xdgShellSurface->destroy();
     delete m_xdgShellSurface;
 }
 
 void XdgShellOutput::handleConfigure(const QSize &size, XdgShellSurface::States states, quint32 serial)
 {
     Q_UNUSED(states);
     if (size.width() > 0 && size.height() > 0) {
         setGeometry(geometry().topLeft(), size);
         emit sizeChanged(size);
     }
     m_xdgShellSurface->ackConfigure(serial);
 }
 
 void XdgShellOutput::updateWindowTitle()
 {
     QString grab;
     if (m_hasPointerLock) {
         grab = i18n("Press right control to ungrab pointer");
     } else if (backend()->pointerConstraints()) {
         grab = i18n("Press right control key to grab pointer");
     }
     const QString title = i18nc("Title of nested KWin Wayland with Wayland socket identifier as argument",
                                 "KDE Wayland Compositor #%1 (%2)", m_number, waylandServer()->display()->socketName());
 
     if (grab.isEmpty()) {
         m_xdgShellSurface->setTitle(title);
     } else {
         m_xdgShellSurface->setTitle(title + QStringLiteral(" — ") + grab);
     }
 }
 
 void XdgShellOutput::lockPointer(Pointer *pointer, bool lock)
 {
     if (!lock) {
         const bool surfaceWasLocked = m_pointerLock && m_hasPointerLock;
         delete m_pointerLock;
         m_pointerLock = nullptr;
         m_hasPointerLock = false;
         if (surfaceWasLocked) {
             emit backend()->pointerLockChanged(false);
         }
         return;
     }
 
     Q_ASSERT(!m_pointerLock);
     m_pointerLock = backend()->pointerConstraints()->lockPointer(surface(), pointer, nullptr,
                                                                  PointerConstraints::LifeTime::OneShot,
                                                                  this);
     if (!m_pointerLock->isValid()) {
         delete m_pointerLock;
         m_pointerLock = nullptr;
         return;
     }
     connect(m_pointerLock, &LockedPointer::locked, this,
         [this] {
             m_hasPointerLock = true;
             emit backend()->pointerLockChanged(true);
         }
     );
     connect(m_pointerLock, &LockedPointer::unlocked, this,
         [this] {
             delete m_pointerLock;
             m_pointerLock = nullptr;
             m_hasPointerLock = false;
             emit backend()->pointerLockChanged(false);
         }
     );
 }
 
 }
 }
diff --git a/plugins/platforms/x11/windowed/x11windowed_backend.cpp b/plugins/platforms/x11/windowed/x11windowed_backend.cpp
index 064dcab61..038e2f2b1 100644
--- a/plugins/platforms/x11/windowed/x11windowed_backend.cpp
+++ b/plugins/platforms/x11/windowed/x11windowed_backend.cpp
@@ -1,546 +1,546 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "x11windowed_backend.h"
 #include "x11windowed_output.h"
 #include "scene_qpainter_x11_backend.h"
 #include "logging.h"
 #include "wayland_server.h"
 #include "xcbutils.h"
 #include "egl_x11_backend.h"
 #include "outputscreens.h"
 #include <kwinxrenderutils.h>
 #include <cursor.h>
 #include <pointer_input.h>
 // KDE
 #include <KLocalizedString>
 #include <QAbstractEventDispatcher>
 #include <QCoreApplication>
 #include <QSocketNotifier>
 // kwayland
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/seat_interface.h>
 // xcb
 #include <xcb/xcb_keysyms.h>
 // X11
 #if HAVE_X11_XINPUT
 #include "ge_event_mem_mover.h"
 #include <X11/extensions/XInput2.h>
 #include <X11/extensions/XI2proto.h>
 #endif
 // system
 #include <linux/input.h>
 #include <X11/Xlib-xcb.h>
 
 namespace KWin
 {
 
 X11WindowedBackend::X11WindowedBackend(QObject *parent)
     : Platform(parent)
 {
     setSupportsPointerWarping(true);
     connect(this, &X11WindowedBackend::sizeChanged, this, &X11WindowedBackend::screenSizeChanged);
 }
 
 X11WindowedBackend::~X11WindowedBackend()
 {
     if (m_connection) {
         if (m_keySymbols) {
             xcb_key_symbols_free(m_keySymbols);
         }
         if (m_cursor) {
             xcb_free_cursor(m_connection, m_cursor);
         }
         xcb_disconnect(m_connection);
     }
 }
 
 void X11WindowedBackend::init()
 {
     int screen = 0;
     xcb_connection_t *c = nullptr;
     Display *xDisplay = XOpenDisplay(deviceIdentifier().constData());
     if (xDisplay) {
         c = XGetXCBConnection(xDisplay);
         XSetEventQueueOwner(xDisplay, XCBOwnsEventQueue);
         screen = XDefaultScreen(xDisplay);
     }
     if (c && !xcb_connection_has_error(c)) {
         m_connection = c;
         m_screenNumber = screen;
         m_display = xDisplay;
         for (xcb_screen_iterator_t it = xcb_setup_roots_iterator(xcb_get_setup(m_connection));
             it.rem;
             --screen, xcb_screen_next(&it)) {
             if (screen == m_screenNumber) {
                 m_screen = it.data;
             }
         }
         initXInput();
         XRenderUtils::init(m_connection, m_screen->root);
         createOutputs();
         connect(kwinApp(), &Application::workspaceCreated, this, &X11WindowedBackend::startEventReading);
         connect(Cursors::self(), &Cursors::currentCursorChanged, this,
             [this] {
                 KWin::Cursor* c = KWin::Cursors::self()->currentCursor();
                 createCursor(c->image(), c->hotspot());
             }
         );
         setReady(true);
         waylandServer()->seat()->setHasPointer(true);
         waylandServer()->seat()->setHasKeyboard(true);
         if (m_hasXInput) {
             waylandServer()->seat()->setHasTouch(true);
         }
         emit screensQueried();
     } else {
         emit initFailed();
     }
 }
 
 void X11WindowedBackend::initXInput()
 {
 #if HAVE_X11_XINPUT
     int xi_opcode, event, error;
     // init XInput extension
     if (!XQueryExtension(m_display, "XInputExtension", &xi_opcode, &event, &error)) {
         qCDebug(KWIN_X11WINDOWED) << "XInputExtension not present";
         return;
     }
 
     // verify that the XInput extension is at at least version 2.0
     int major = 2, minor = 2;
     int result = XIQueryVersion(m_display, &major, &minor);
     if (result != Success) {
         qCDebug(KWIN_X11WINDOWED) << "Failed to init XInput 2.2, trying 2.0";
         minor = 0;
         if (XIQueryVersion(m_display, &major, &minor) != Success) {
             qCDebug(KWIN_X11WINDOWED) << "Failed to init XInput";
             return;
         }
     }
     m_xiOpcode = xi_opcode;
     m_majorVersion = major;
     m_minorVersion = minor;
     m_hasXInput = m_majorVersion >=2 && m_minorVersion >= 2;
 #endif
 }
 
 X11WindowedOutput *X11WindowedBackend::findOutput(xcb_window_t window) const
 {
     auto it = std::find_if(m_outputs.constBegin(), m_outputs.constEnd(),
         [window] (X11WindowedOutput *output) {
             return output->window() == window;
         }
     );
     if (it != m_outputs.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 void X11WindowedBackend::createOutputs()
 {
     Xcb::Atom protocolsAtom(QByteArrayLiteral("WM_PROTOCOLS"), false, m_connection);
     Xcb::Atom deleteWindowAtom(QByteArrayLiteral("WM_DELETE_WINDOW"), false, m_connection);
 
     // we need to multiply the initial window size with the scale in order to
     // create an output window of this size in the end
     const int pixelWidth = initialWindowSize().width() * initialOutputScale() + 0.5;
     const int pixelHeight = initialWindowSize().height() * initialOutputScale() + 0.5;
     const int logicalWidth = initialWindowSize().width();
 
     int logicalWidthSum = 0;
     for (int i = 0; i < initialOutputCount(); ++i) {
         auto *output = new X11WindowedOutput(this);
         output->init(QPoint(logicalWidthSum, 0), QSize(pixelWidth, pixelHeight));
 
         m_protocols = protocolsAtom;
         m_deleteWindowProtocol = deleteWindowAtom;
 
         xcb_change_property(m_connection,
                             XCB_PROP_MODE_REPLACE,
                             output->window(),
                             m_protocols,
                             XCB_ATOM_ATOM,
                             32, 1,
                             &m_deleteWindowProtocol);
 
         logicalWidthSum += logicalWidth;
         m_outputs << output;
     }
 
     updateWindowTitle();
 
     xcb_flush(m_connection);
 }
 
 void X11WindowedBackend::startEventReading()
 {
     QSocketNotifier *notifier = new QSocketNotifier(xcb_get_file_descriptor(m_connection), QSocketNotifier::Read, this);
     auto processXcbEvents = [this] {
         while (auto event = xcb_poll_for_event(m_connection)) {
             handleEvent(event);
             free(event);
         }
         xcb_flush(m_connection);
     };
     connect(notifier, &QSocketNotifier::activated, this, processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::aboutToBlock, this, processXcbEvents);
     connect(QCoreApplication::eventDispatcher(), &QAbstractEventDispatcher::awake, this, processXcbEvents);
 }
 
 #if HAVE_X11_XINPUT
 
 static inline qreal fixed1616ToReal(FP1616 val)
 {
     return (val) * 1.0 / (1 << 16);
 }
 #endif
 
 void X11WindowedBackend::handleEvent(xcb_generic_event_t *e)
 {
     const uint8_t eventType = e->response_type & ~0x80;
     switch (eventType) {
     case XCB_BUTTON_PRESS:
     case XCB_BUTTON_RELEASE:
         handleButtonPress(reinterpret_cast<xcb_button_press_event_t*>(e));
         break;
     case XCB_MOTION_NOTIFY: {
             auto event = reinterpret_cast<xcb_motion_notify_event_t*>(e);
             const X11WindowedOutput *output = findOutput(event->event);
             if (!output) {
                 break;
             }
             const QPointF position = output->mapFromGlobal(QPointF(event->root_x, event->root_y));
             pointerMotion(position, event->time);
         }
         break;
     case XCB_KEY_PRESS:
     case XCB_KEY_RELEASE: {
             auto event = reinterpret_cast<xcb_key_press_event_t*>(e);
             if (eventType == XCB_KEY_PRESS) {
                 if (!m_keySymbols) {
                     m_keySymbols = xcb_key_symbols_alloc(m_connection);
                 }
                 const xcb_keysym_t kc = xcb_key_symbols_get_keysym(m_keySymbols, event->detail, 0);
                 if (kc == XK_Control_R) {
                     grabKeyboard(event->time);
                 }
                 keyboardKeyPressed(event->detail - 8, event->time);
             } else {
                 keyboardKeyReleased(event->detail - 8, event->time);
             }
         }
         break;
     case XCB_CONFIGURE_NOTIFY:
         updateSize(reinterpret_cast<xcb_configure_notify_event_t*>(e));
         break;
     case XCB_ENTER_NOTIFY: {
             auto event = reinterpret_cast<xcb_enter_notify_event_t*>(e);
             const X11WindowedOutput *output = findOutput(event->event);
             if (!output) {
                 break;
             }
             const QPointF position = output->mapFromGlobal(QPointF(event->root_x, event->root_y));
             pointerMotion(position, event->time);
         }
         break;
     case XCB_CLIENT_MESSAGE:
         handleClientMessage(reinterpret_cast<xcb_client_message_event_t*>(e));
         break;
     case XCB_EXPOSE:
         handleExpose(reinterpret_cast<xcb_expose_event_t*>(e));
         break;
     case XCB_MAPPING_NOTIFY:
         if (m_keySymbols) {
             xcb_refresh_keyboard_mapping(m_keySymbols, reinterpret_cast<xcb_mapping_notify_event_t*>(e));
         }
         break;
 #if HAVE_X11_XINPUT
     case XCB_GE_GENERIC: {
         GeEventMemMover ge(e);
         auto te = reinterpret_cast<xXIDeviceEvent*>(e);
         const X11WindowedOutput *output = findOutput(te->event);
         if (!output) {
             break;
         }
 
         const QPointF position = output->mapFromGlobal(QPointF(fixed1616ToReal(te->root_x), fixed1616ToReal(te->root_y)));
 
         switch (ge->event_type) {
 
         case XI_TouchBegin: {
             touchDown(te->detail, position, te->time);
             touchFrame();
             break;
         }
         case XI_TouchUpdate: {
             touchMotion(te->detail, position, te->time);
             touchFrame();
             break;
         }
         case XI_TouchEnd: {
             touchUp(te->detail, te->time);
             touchFrame();
             break;
         }
         case XI_TouchOwnership: {
             auto te = reinterpret_cast<xXITouchOwnershipEvent*>(e);
             XIAllowTouchEvents(m_display, te->deviceid, te->sourceid, te->touchid, XIAcceptTouch);
             break;
         }
         }
         break;
     }
 #endif
     default:
         break;
     }
 }
 
 void X11WindowedBackend::grabKeyboard(xcb_timestamp_t time)
 {
     const bool oldState = m_keyboardGrabbed;
     if (m_keyboardGrabbed) {
         xcb_ungrab_keyboard(m_connection, time);
         xcb_ungrab_pointer(m_connection, time);
         m_keyboardGrabbed = false;
     } else {
         const auto c = xcb_grab_keyboard_unchecked(m_connection, false, window(), time,
                                                    XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
         ScopedCPointer<xcb_grab_keyboard_reply_t> grab(xcb_grab_keyboard_reply(m_connection, c, nullptr));
         if (grab.isNull()) {
             return;
         }
         if (grab->status == XCB_GRAB_STATUS_SUCCESS) {
             const auto c = xcb_grab_pointer_unchecked(m_connection, false, window(),
                                                       XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE |
                                                       XCB_EVENT_MASK_POINTER_MOTION |
                                                       XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW,
                                                       XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
                                                       window(), XCB_CURSOR_NONE, time);
             ScopedCPointer<xcb_grab_pointer_reply_t> grab(xcb_grab_pointer_reply(m_connection, c, nullptr));
             if (grab.isNull() || grab->status != XCB_GRAB_STATUS_SUCCESS) {
                 xcb_ungrab_keyboard(m_connection, time);
                 return;
             }
             m_keyboardGrabbed = true;
         }
     }
     if (oldState != m_keyboardGrabbed) {
         updateWindowTitle();
         xcb_flush(m_connection);
     }
 }
 
 void X11WindowedBackend::updateWindowTitle()
 {
     const QString grab = m_keyboardGrabbed ? i18n("Press right control to ungrab input") : i18n("Press right control key to grab input");
     const QString title = QStringLiteral("%1 (%2) - %3").arg(i18n("KDE Wayland Compositor"))
                                                         .arg(waylandServer()->display()->socketName())
                                                         .arg(grab);
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         (*it)->setWindowTitle(title);
     }
 }
 
 void X11WindowedBackend::handleClientMessage(xcb_client_message_event_t *event)
 {
     auto it = std::find_if(m_outputs.begin(), m_outputs.end(),
                            [event] (X11WindowedOutput *output) { return output->window() == event->window; }
               );
     if (it == m_outputs.end()) {
         return;
     }
     if (event->type == m_protocols && m_protocols != XCB_ATOM_NONE) {
         if (event->data.data32[0] == m_deleteWindowProtocol && m_deleteWindowProtocol != XCB_ATOM_NONE) {
             if (m_outputs.count() == 1) {
                 qCDebug(KWIN_X11WINDOWED) << "Backend window is going to be closed, shutting down.";
                 QCoreApplication::quit();
             } else {
                 // remove the window
                 qCDebug(KWIN_X11WINDOWED) << "Removing one output window.";
 
                 auto removedOutput = *it;
                 it = m_outputs.erase(it);
 
                 // update the sizes
                 int x = removedOutput->internalPosition().x();
                 for (; it != m_outputs.end(); ++it) {
                     (*it)->setGeometry(QPoint(x, 0), (*it)->pixelSize());
                     x += (*it)->geometry().width();
                 }
 
                 delete removedOutput;
                 QMetaObject::invokeMethod(screens(), "updateCount");
             }
         }
     }
 }
 
 void X11WindowedBackend::handleButtonPress(xcb_button_press_event_t *event)
 {
     const X11WindowedOutput *output = findOutput(event->event);
     if (!output) {
         return;
     }
     bool const pressed = (event->response_type & ~0x80) == XCB_BUTTON_PRESS;
     if (event->detail >= XCB_BUTTON_INDEX_4 && event->detail <= 7) {
         // wheel
         if (!pressed) {
             return;
         }
         const int delta = (event->detail == XCB_BUTTON_INDEX_4 || event->detail == 6) ? -1 : 1;
         static const qreal s_defaultAxisStepDistance = 10.0;
         if (event->detail > 5) {
             pointerAxisHorizontal(delta * s_defaultAxisStepDistance, event->time, delta);
         } else {
             pointerAxisVertical(delta * s_defaultAxisStepDistance, event->time, delta);
         }
         return;
     }
     uint32_t button = 0;
     switch (event->detail) {
     case XCB_BUTTON_INDEX_1:
         button = BTN_LEFT;
         break;
     case XCB_BUTTON_INDEX_2:
         button = BTN_MIDDLE;
         break;
     case XCB_BUTTON_INDEX_3:
         button = BTN_RIGHT;
         break;
     default:
         button = event->detail + BTN_LEFT - 1;
         return;
     }
 
     const QPointF position = output->mapFromGlobal(QPointF(event->root_x, event->root_y));
     pointerMotion(position, event->time);
 
     if (pressed) {
         pointerButtonPressed(button, event->time);
     } else {
         pointerButtonReleased(button, event->time);
     }
 }
 
 void X11WindowedBackend::handleExpose(xcb_expose_event_t *event)
 {
     repaint(QRect(event->x, event->y, event->width, event->height));
 }
 
 void X11WindowedBackend::updateSize(xcb_configure_notify_event_t *event)
 {
     X11WindowedOutput *output = findOutput(event->window);
     if (!output) {
         return;
     }
 
     output->setHostPosition(QPoint(event->x, event->y));
 
     const QSize s = QSize(event->width, event->height);
     if (s != output->pixelSize()) {
         output->setGeometry(output->internalPosition(), s);
     }
     emit sizeChanged();
 }
 
 void X11WindowedBackend::createCursor(const QImage &srcImage, const QPoint &hotspot)
 {
     const xcb_pixmap_t pix = xcb_generate_id(m_connection);
     const xcb_gcontext_t gc = xcb_generate_id(m_connection);
     const xcb_cursor_t cid = xcb_generate_id(m_connection);
 
     //right now on X we only have one scale between all screens, and we know we will have at least one screen
     const qreal outputScale = screenScales().first();
     const QSize targetSize = srcImage.size() * outputScale / srcImage.devicePixelRatio();
     const QImage img = srcImage.scaled(targetSize, Qt::KeepAspectRatio);
 
     xcb_create_pixmap(m_connection, 32, pix, m_screen->root, img.width(), img.height());
     xcb_create_gc(m_connection, gc, pix, 0, nullptr);
 
     xcb_put_image(m_connection, XCB_IMAGE_FORMAT_Z_PIXMAP, pix, gc, img.width(), img.height(), 0, 0, 0, 32, img.sizeInBytes(), img.constBits());
 
     XRenderPicture pic(pix, 32);
     xcb_render_create_cursor(m_connection, cid, pic, qRound(hotspot.x() * outputScale), qRound(hotspot.y() * outputScale));
     for (auto it = m_outputs.constBegin(); it != m_outputs.constEnd(); ++it) {
         xcb_change_window_attributes(m_connection, (*it)->window(), XCB_CW_CURSOR, &cid);
     }
 
     xcb_free_pixmap(m_connection, pix);
     xcb_free_gc(m_connection, gc);
     if (m_cursor) {
         xcb_free_cursor(m_connection, m_cursor);
     }
     m_cursor = cid;
     xcb_flush(m_connection);
     Cursors::self()->currentCursor()->markAsRendered();
 }
 
 xcb_window_t X11WindowedBackend::rootWindow() const
 {
     if (!m_screen) {
         return XCB_WINDOW_NONE;
     }
     return m_screen->root;
 }
 
 Screens *X11WindowedBackend::createScreens(QObject *parent)
 {
     return new OutputScreens(this, parent);
 }
 
 OpenGLBackend *X11WindowedBackend::createOpenGLBackend()
 {
     return  new EglX11Backend(this);
 }
 
 QPainterBackend *X11WindowedBackend::createQPainterBackend()
 {
     return new X11WindowedQPainterBackend(this);
 }
 
 void X11WindowedBackend::warpPointer(const QPointF &globalPos)
 {
     const xcb_window_t w = m_outputs.at(0)->window();
     xcb_warp_pointer(m_connection, w, w, 0, 0, 0, 0, globalPos.x(), globalPos.y());
     xcb_flush(m_connection);
 }
 
 xcb_window_t X11WindowedBackend::windowForScreen(int screen) const
 {
     if (screen > m_outputs.count()) {
         return XCB_WINDOW_NONE;
     }
     return m_outputs.at(screen)->window();
 }
 
 Outputs X11WindowedBackend::outputs() const
 {
     return m_outputs;
 }
 
 Outputs X11WindowedBackend::enabledOutputs() const
 {
     return m_outputs;
 }
 
 }
diff --git a/plugins/platforms/x11/windowed/x11windowed_output.cpp b/plugins/platforms/x11/windowed/x11windowed_output.cpp
index 896faf036..c639dedc4 100644
--- a/plugins/platforms/x11/windowed/x11windowed_output.cpp
+++ b/plugins/platforms/x11/windowed/x11windowed_output.cpp
@@ -1,167 +1,167 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "x11windowed_output.h"
 
 #include "x11windowed_backend.h"
 
 #include <NETWM>
 
 #if HAVE_X11_XINPUT
 #include <X11/extensions/XInput2.h>
 #endif
 
 #include <QIcon>
 
 namespace KWin
 {
 
 X11WindowedOutput::X11WindowedOutput(X11WindowedBackend *backend)
     : AbstractWaylandOutput(backend)
     , m_backend(backend)
 {
     m_window = xcb_generate_id(m_backend->connection());
 
     static int identifier = -1;
     identifier++;
     setName("X11-" + QString::number(identifier));
 }
 
 X11WindowedOutput::~X11WindowedOutput()
 {
     xcb_unmap_window(m_backend->connection(), m_window);
     xcb_destroy_window(m_backend->connection(), m_window);
     delete m_winInfo;
     xcb_flush(m_backend->connection());
 }
 
 void X11WindowedOutput::init(const QPoint &logicalPosition, const QSize &pixelSize)
 {
-    KWayland::Server::OutputDeviceInterface::Mode mode;
+    KWaylandServer::OutputDeviceInterface::Mode mode;
     mode.id = 0;
     mode.size = pixelSize;
-    mode.flags = KWayland::Server::OutputDeviceInterface::ModeFlag::Current;
+    mode.flags = KWaylandServer::OutputDeviceInterface::ModeFlag::Current;
     mode.refreshRate = 60000;  // TODO: get refresh rate via randr
 
     // Physicial size must be adjusted, such that QPA calculates correct sizes of
     // internal elements.
     const QSize physicalSize = pixelSize / 96.0 * 25.4 / m_backend->initialOutputScale();
     initInterfaces("model_TODO", "manufacturer_TODO", "UUID_TODO", physicalSize, { mode });
     setGeometry(logicalPosition, pixelSize);
     setScale(m_backend->initialOutputScale());
 
     uint32_t mask = XCB_CW_BACK_PIXEL | XCB_CW_EVENT_MASK;
     const uint32_t values[] = {
         m_backend->screen()->black_pixel,
         XCB_EVENT_MASK_KEY_PRESS |
         XCB_EVENT_MASK_KEY_RELEASE |
         XCB_EVENT_MASK_BUTTON_PRESS |
         XCB_EVENT_MASK_BUTTON_RELEASE |
         XCB_EVENT_MASK_POINTER_MOTION |
         XCB_EVENT_MASK_ENTER_WINDOW |
         XCB_EVENT_MASK_LEAVE_WINDOW |
         XCB_EVENT_MASK_STRUCTURE_NOTIFY |
         XCB_EVENT_MASK_EXPOSURE
     };
     xcb_create_window(m_backend->connection(),
                       XCB_COPY_FROM_PARENT,
                       m_window,
                       m_backend->screen()->root,
                       0, 0,
                       pixelSize.width(), pixelSize.height(),
                       0, XCB_WINDOW_CLASS_INPUT_OUTPUT, XCB_COPY_FROM_PARENT,
                       mask, values);
 
     // select xinput 2 events
     initXInputForWindow();
 
     m_winInfo = new NETWinInfo(m_backend->connection(),
                                m_window,
                                m_backend->screen()->root,
                                NET::WMWindowType, NET::Properties2());
 
     m_winInfo->setWindowType(NET::Normal);
     m_winInfo->setPid(QCoreApplication::applicationPid());
     QIcon windowIcon = QIcon::fromTheme(QStringLiteral("kwin"));
     auto addIcon = [&windowIcon, this] (const QSize &size) {
         if (windowIcon.actualSize(size) != size) {
             return;
         }
         NETIcon icon;
         icon.data = windowIcon.pixmap(size).toImage().bits();
         icon.size.width = size.width();
         icon.size.height = size.height();
         m_winInfo->setIcon(icon, false);
     };
     addIcon(QSize(16, 16));
     addIcon(QSize(32, 32));
     addIcon(QSize(48, 48));
 
     xcb_map_window(m_backend->connection(), m_window);
 }
 
 void X11WindowedOutput::initXInputForWindow()
 {
     if (!m_backend->hasXInput()) {
         return;
     }
 #if HAVE_X11_XINPUT
     XIEventMask evmasks[1];
     unsigned char mask1[XIMaskLen(XI_LASTEVENT)];
 
     memset(mask1, 0, sizeof(mask1));
     XISetMask(mask1, XI_TouchBegin);
     XISetMask(mask1, XI_TouchUpdate);
     XISetMask(mask1, XI_TouchOwnership);
     XISetMask(mask1, XI_TouchEnd);
     evmasks[0].deviceid = XIAllMasterDevices;
     evmasks[0].mask_len = sizeof(mask1);
     evmasks[0].mask = mask1;
     XISelectEvents(m_backend->display(), m_window, evmasks, 1);
 #endif
 }
 
 void X11WindowedOutput::setGeometry(const QPoint &logicalPosition, const QSize &pixelSize)
 {
     // TODO: set mode to have updated pixelSize
     Q_UNUSED(pixelSize);
     setGlobalPos(logicalPosition);
 }
 
 void X11WindowedOutput::setWindowTitle(const QString &title)
 {
     m_winInfo->setName(title.toUtf8().constData());
 }
 
 QPoint X11WindowedOutput::internalPosition() const
 {
     return geometry().topLeft();
 }
 
 void X11WindowedOutput::setHostPosition(const QPoint &pos)
 {
     m_hostPosition = pos;
 }
 
 QPointF X11WindowedOutput::mapFromGlobal(const QPointF &pos) const
 {
     return (pos - hostPosition() + internalPosition()) / scale();
 }
 
 }
diff --git a/plugins/scenes/opengl/scene_opengl.cpp b/plugins/scenes/opengl/scene_opengl.cpp
index 1814264c1..22cc179de 100644
--- a/plugins/scenes/opengl/scene_opengl.cpp
+++ b/plugins/scenes/opengl/scene_opengl.cpp
@@ -1,2722 +1,2722 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009, 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 Based on glcompmgr code by Felix Bellaby.
 Using code from Compiz and Beryl.
 
 Explicit command stream synchronization based on the sample
 implementation by James Jones <jajones@nvidia.com>,
 
 Copyright © 2011 NVIDIA Corporation
 
 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 "scene_opengl.h"
 
 #include "platform.h"
 #include "wayland_server.h"
 #include "platformsupport/scenes/opengl/texture.h"
 
 #include <kwinglplatform.h>
 #include <kwineffectquickview.h>
 
 #include "utils.h"
 #include "x11client.h"
 #include "composite.h"
 #include "deleted.h"
 #include "effects.h"
 #include "lanczosfilter.h"
 #include "main.h"
 #include "overlaywindow.h"
 #include "screens.h"
 #include "cursor.h"
 #include "decorations/decoratedclient.h"
 #include <logging.h>
 
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/subcompositor_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/subcompositor_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <array>
 #include <cmath>
 #include <cstddef>
 #include <unistd.h>
 
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusInterface>
 #include <QGraphicsScale>
 #include <QPainter>
 #include <QStringList>
 #include <QVector2D>
 #include <QVector4D>
 #include <QMatrix4x4>
 
 #include <KLocalizedString>
 #include <KNotification>
 #include <KProcess>
 
 // HACK: workaround for libepoxy < 1.3
 #ifndef GL_GUILTY_CONTEXT_RESET
 #define GL_GUILTY_CONTEXT_RESET 0x8253
 #endif
 #ifndef GL_INNOCENT_CONTEXT_RESET
 #define GL_INNOCENT_CONTEXT_RESET 0x8254
 #endif
 #ifndef GL_UNKNOWN_CONTEXT_RESET
 #define GL_UNKNOWN_CONTEXT_RESET 0x8255
 #endif
 
 namespace KWin
 {
 
 extern int currentRefreshRate();
 
 
 /**
  * SyncObject represents a fence used to synchronize operations in
  * the kwin command stream with operations in the X command stream.
  */
 class SyncObject
 {
 public:
     enum State { Ready, TriggerSent, Waiting, Done, Resetting };
 
     SyncObject();
     ~SyncObject();
 
     State state() const { return m_state; }
 
     void trigger();
     void wait();
     bool finish();
     void reset();
     void finishResetting();
 
 private:
     State m_state;
     GLsync m_sync;
     xcb_sync_fence_t m_fence;
     xcb_get_input_focus_cookie_t m_reset_cookie;
 };
 
 SyncObject::SyncObject()
 {
     m_state = Ready;
 
     xcb_connection_t * const c = connection();
 
     m_fence = xcb_generate_id(c);
     xcb_sync_create_fence(c, rootWindow(), m_fence, false);
     xcb_flush(c);
 
     m_sync = glImportSyncEXT(GL_SYNC_X11_FENCE_EXT, m_fence, 0);
 }
 
 SyncObject::~SyncObject()
 {
     // If glDeleteSync is called before the xcb fence is signalled
     // the nvidia driver (the only one to implement GL_SYNC_X11_FENCE_EXT)
     // deadlocks waiting for the fence to be signalled.
     // To avoid this, make sure the fence is signalled before
     // deleting the sync.
     if (m_state == Resetting || m_state == Ready){
         trigger();
         // The flush is necessary!
         // The trigger command needs to be sent to the X server.
         xcb_flush(connection());
     }
     xcb_sync_destroy_fence(connection(), m_fence);
     glDeleteSync(m_sync);
 
     if (m_state == Resetting)
         xcb_discard_reply(connection(), m_reset_cookie.sequence);
 }
 
 void SyncObject::trigger()
 {
     Q_ASSERT(m_state == Ready || m_state == Resetting);
 
     // Finish resetting the fence if necessary
     if (m_state == Resetting)
         finishResetting();
 
     xcb_sync_trigger_fence(connection(), m_fence);
     m_state = TriggerSent;
 }
 
 void SyncObject::wait()
 {
     if (m_state != TriggerSent)
         return;
 
     glWaitSync(m_sync, 0, GL_TIMEOUT_IGNORED);
     m_state = Waiting;
 }
 
 bool SyncObject::finish()
 {
     if (m_state == Done)
         return true;
 
     // Note: It is possible that we never inserted a wait for the fence.
     //       This can happen if we ended up not rendering the damaged
     //       window because it is fully occluded.
     Q_ASSERT(m_state == TriggerSent || m_state == Waiting);
 
     // Check if the fence is signaled
     GLint value;
     glGetSynciv(m_sync, GL_SYNC_STATUS, 1, nullptr, &value);
 
     if (value != GL_SIGNALED) {
         qCDebug(KWIN_OPENGL) << "Waiting for X fence to finish";
 
         // Wait for the fence to become signaled with a one second timeout
         const GLenum result = glClientWaitSync(m_sync, 0, 1000000000);
 
         switch (result) {
         case GL_TIMEOUT_EXPIRED:
             qCWarning(KWIN_OPENGL) << "Timeout while waiting for X fence";
             return false;
 
         case GL_WAIT_FAILED:
             qCWarning(KWIN_OPENGL) << "glClientWaitSync() failed";
             return false;
         }
     }
 
     m_state = Done;
     return true;
 }
 
 void SyncObject::reset()
 {
     Q_ASSERT(m_state == Done);
 
     xcb_connection_t * const c = connection();
 
     // Send the reset request along with a sync request.
     // We use the cookie to ensure that the server has processed the reset
     // request before we trigger the fence and call glWaitSync().
     // Otherwise there is a race condition between the reset finishing and
     // the glWaitSync() call.
     xcb_sync_reset_fence(c, m_fence);
     m_reset_cookie = xcb_get_input_focus(c);
     xcb_flush(c);
 
     m_state = Resetting;
 }
 
 void SyncObject::finishResetting()
 {
     Q_ASSERT(m_state == Resetting);
     free(xcb_get_input_focus_reply(connection(), m_reset_cookie, nullptr));
     m_state = Ready;
 }
 
 
 
 // -----------------------------------------------------------------------
 
 
 
 /**
  * SyncManager manages a set of fences used for explicit synchronization
  * with the X command stream.
  */
 class SyncManager
 {
 public:
     enum { MaxFences = 4 };
 
     SyncManager();
     ~SyncManager();
 
     SyncObject *nextFence();
     bool updateFences();
 
 private:
     std::array<SyncObject, MaxFences> m_fences;
     int m_next;
 };
 
 SyncManager::SyncManager()
     : m_next(0)
 {
 }
 
 SyncManager::~SyncManager()
 {
 }
 
 SyncObject *SyncManager::nextFence()
 {
     SyncObject *fence = &m_fences[m_next];
     m_next = (m_next + 1) % MaxFences;
     return fence;
 }
 
 bool SyncManager::updateFences()
 {
     for (int i = 0; i < qMin(2, MaxFences - 1); i++) {
         const int index = (m_next + i) % MaxFences;
         SyncObject &fence = m_fences[index];
 
         switch (fence.state()) {
         case SyncObject::Ready:
             break;
 
         case SyncObject::TriggerSent:
         case SyncObject::Waiting:
             if (!fence.finish())
                 return false;
             fence.reset();
             break;
 
         // Should not happen in practice since we always reset the fence
         // after finishing it
         case SyncObject::Done:
             fence.reset();
             break;
 
         case SyncObject::Resetting:
             fence.finishResetting();
             break;
         }
     }
 
     return true;
 }
 
 
 // -----------------------------------------------------------------------
 
 /************************************************
  * SceneOpenGL
  ***********************************************/
 
 SceneOpenGL::SceneOpenGL(OpenGLBackend *backend, QObject *parent)
     : Scene(parent)
     , init_ok(true)
     , m_backend(backend)
     , m_syncManager(nullptr)
     , m_currentFence(nullptr)
 {
     if (m_backend->isFailed()) {
         init_ok = false;
         return;
     }
     if (!viewportLimitsMatched(screens()->size()))
         return;
 
     // perform Scene specific checks
     GLPlatform *glPlatform = GLPlatform::instance();
     if (!glPlatform->isGLES() && !hasGLExtension(QByteArrayLiteral("GL_ARB_texture_non_power_of_two"))
             && !hasGLExtension(QByteArrayLiteral("GL_ARB_texture_rectangle"))) {
         qCCritical(KWIN_OPENGL) << "GL_ARB_texture_non_power_of_two and GL_ARB_texture_rectangle missing";
         init_ok = false;
         return; // error
     }
     if (glPlatform->isMesaDriver() && glPlatform->mesaVersion() < kVersionNumber(10, 0)) {
         qCCritical(KWIN_OPENGL) << "KWin requires at least Mesa 10.0 for OpenGL compositing.";
         init_ok = false;
         return;
     }
 
     m_debug = qstrcmp(qgetenv("KWIN_GL_DEBUG"), "1") == 0;
     initDebugOutput();
 
     // set strict binding
     if (options->isGlStrictBindingFollowsDriver()) {
         options->setGlStrictBinding(!glPlatform->supports(LooseBinding));
     }
 
     bool haveSyncObjects = glPlatform->isGLES()
         ? hasGLVersion(3, 0)
         : hasGLVersion(3, 2) || hasGLExtension("GL_ARB_sync");
 
     if (hasGLExtension("GL_EXT_x11_sync_object") && haveSyncObjects && kwinApp()->operationMode() == Application::OperationModeX11) {
         const QByteArray useExplicitSync = qgetenv("KWIN_EXPLICIT_SYNC");
 
         if (useExplicitSync != "0") {
             qCDebug(KWIN_OPENGL) << "Initializing fences for synchronization with the X command stream";
             m_syncManager = new SyncManager;
         } else {
             qCDebug(KWIN_OPENGL) << "Explicit synchronization with the X command stream disabled by environment variable";
         }
     }
 }
 
 SceneOpenGL::~SceneOpenGL()
 {
     if (init_ok) {
         makeOpenGLContextCurrent();
     }
     SceneOpenGL::EffectFrame::cleanup();
 
     delete m_syncManager;
 
     // backend might be still needed for a different scene
     delete m_backend;
 }
 
 
 void SceneOpenGL::initDebugOutput()
 {
     const bool have_KHR_debug = hasGLExtension(QByteArrayLiteral("GL_KHR_debug"));
     const bool have_ARB_debug = hasGLExtension(QByteArrayLiteral("GL_ARB_debug_output"));
     if (!have_KHR_debug && !have_ARB_debug)
         return;
 
     if (!have_ARB_debug) {
         // if we don't have ARB debug, but only KHR debug we need to verify whether the context is a debug context
         // it should work without as well, but empirical tests show: no it doesn't
         if (GLPlatform::instance()->isGLES()) {
             if (!hasGLVersion(3, 2)) {
                 // empirical data shows extension doesn't work
                 return;
             }
         } else if (!hasGLVersion(3, 0)) {
             return;
         }
         // can only be queried with either OpenGL >= 3.0 or OpenGL ES of at least 3.1
         GLint value = 0;
         glGetIntegerv(GL_CONTEXT_FLAGS, &value);
         if (!(value & GL_CONTEXT_FLAG_DEBUG_BIT)) {
             return;
         }
     }
 
     // Set the callback function
     auto callback = [](GLenum source, GLenum type, GLuint id,
                        GLenum severity, GLsizei length,
                        const GLchar *message,
                        const GLvoid *userParam) {
         Q_UNUSED(source)
         Q_UNUSED(severity)
         Q_UNUSED(userParam)
         while (message[length] == '\n' || message[length] == '\r')
             --length;
 
         switch (type) {
         case GL_DEBUG_TYPE_ERROR:
         case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR:
             qCWarning(KWIN_OPENGL, "%#x: %.*s", id, length, message);
             break;
 
         case GL_DEBUG_TYPE_OTHER:
         case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR:
         case GL_DEBUG_TYPE_PORTABILITY:
         case GL_DEBUG_TYPE_PERFORMANCE:
         default:
             qCDebug(KWIN_OPENGL, "%#x: %.*s", id, length, message);
             break;
         }
     };
 
     glDebugMessageCallback(callback, nullptr);
 
     // This state exists only in GL_KHR_debug
     if (have_KHR_debug)
         glEnable(GL_DEBUG_OUTPUT);
 
 #if !defined(QT_NO_DEBUG)
     // Enable all debug messages
     glDebugMessageControl(GL_DONT_CARE, GL_DONT_CARE, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 #else
     // Enable error messages
     glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_ERROR, GL_DONT_CARE, 0, nullptr, GL_TRUE);
     glDebugMessageControl(GL_DONT_CARE, GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR, GL_DONT_CARE, 0, nullptr, GL_TRUE);
 #endif
 
     // Insert a test message
     const QByteArray message = QByteArrayLiteral("OpenGL debug output initialized");
     glDebugMessageInsert(GL_DEBUG_SOURCE_APPLICATION, GL_DEBUG_TYPE_OTHER, 0,
                          GL_DEBUG_SEVERITY_LOW, message.length(), message.constData());
 }
 
 SceneOpenGL *SceneOpenGL::createScene(QObject *parent)
 {
     OpenGLBackend *backend = kwinApp()->platform()->createOpenGLBackend();
     if (!backend) {
         return nullptr;
     }
     if (!backend->isFailed()) {
         backend->init();
     }
     if (backend->isFailed()) {
         delete backend;
         return nullptr;
     }
     SceneOpenGL *scene = nullptr;
     // first let's try an OpenGL 2 scene
     if (SceneOpenGL2::supported(backend)) {
         scene = new SceneOpenGL2(backend, parent);
         if (scene->initFailed()) {
             delete scene;
             scene = nullptr;
         } else {
             return scene;
         }
     }
     if (!scene) {
         if (GLPlatform::instance()->recommendedCompositor() == XRenderCompositing) {
             qCCritical(KWIN_OPENGL) << "OpenGL driver recommends XRender based compositing. Falling back to XRender.";
             qCCritical(KWIN_OPENGL) << "To overwrite the detection use the environment variable KWIN_COMPOSE";
             qCCritical(KWIN_OPENGL) << "For more information see https://community.kde.org/KWin/Environment_Variables#KWIN_COMPOSE";
         }
         delete backend;
     }
 
     return scene;
 }
 
 OverlayWindow *SceneOpenGL::overlayWindow() const
 {
     return m_backend->overlayWindow();
 }
 
 bool SceneOpenGL::syncsToVBlank() const
 {
     return m_backend->syncsToVBlank();
 }
 
 bool SceneOpenGL::blocksForRetrace() const
 {
     return m_backend->blocksForRetrace();
 }
 
 void SceneOpenGL::idle()
 {
     m_backend->idle();
     Scene::idle();
 }
 
 bool SceneOpenGL::initFailed() const
 {
     return !init_ok;
 }
 
 void SceneOpenGL::handleGraphicsReset(GLenum status)
 {
     switch (status) {
     case GL_GUILTY_CONTEXT_RESET:
         qCDebug(KWIN_OPENGL) << "A graphics reset attributable to the current GL context occurred.";
         break;
 
     case GL_INNOCENT_CONTEXT_RESET:
         qCDebug(KWIN_OPENGL) << "A graphics reset not attributable to the current GL context occurred.";
         break;
 
     case GL_UNKNOWN_CONTEXT_RESET:
         qCDebug(KWIN_OPENGL) << "A graphics reset of an unknown cause occurred.";
         break;
 
     default:
         break;
     }
 
     QElapsedTimer timer;
     timer.start();
 
     // Wait until the reset is completed or max 10 seconds
     while (timer.elapsed() < 10000 && glGetGraphicsResetStatus() != GL_NO_ERROR)
         usleep(50);
 
     qCDebug(KWIN_OPENGL) << "Attempting to reset compositing.";
     QMetaObject::invokeMethod(this, "resetCompositing", Qt::QueuedConnection);
 
     KNotification::event(QStringLiteral("graphicsreset"), i18n("Desktop effects were restarted due to a graphics reset"));
 }
 
 
 void SceneOpenGL::triggerFence()
 {
     if (m_syncManager) {
         m_currentFence = m_syncManager->nextFence();
         m_currentFence->trigger();
     }
 }
 
 void SceneOpenGL::insertWait()
 {
     if (m_currentFence && m_currentFence->state() != SyncObject::Waiting) {
         m_currentFence->wait();
     }
 }
 
 /**
  * Render cursor texture in case hardware cursor is disabled.
  * Useful for screen recording apps or backends that can't do planes.
  */
 void SceneOpenGL2::paintCursor()
 {
     Cursor* cursor = Cursors::self()->currentCursor();
 
     // don't paint if we use hardware cursor or the cursor is hidden
     if (!kwinApp()->platform()->usesSoftwareCursor() ||
         kwinApp()->platform()->isCursorHidden() ||
         cursor->image().isNull()) {
         return;
     }
 
     // lazy init texture cursor only in case we need software rendering
     if (!m_cursorTexture) {
         auto updateCursorTexture = [this] {
             // don't paint if no image for cursor is set
             const QImage img = Cursors::self()->currentCursor()->image();
             if (img.isNull()) {
                 return;
             }
             m_cursorTexture.reset(new GLTexture(img));
         };
 
         // init now
         updateCursorTexture();
 
         // handle shape update on case cursor image changed
         connect(Cursors::self(), &Cursors::currentCursorChanged, this, updateCursorTexture);
     }
 
     // get cursor position in projection coordinates
     const QPoint cursorPos = cursor->pos() - cursor->hotspot();
     const QRect cursorRect(0, 0, m_cursorTexture->width(), m_cursorTexture->height());
     QMatrix4x4 mvp = m_projectionMatrix;
     mvp.translate(cursorPos.x(), cursorPos.y());
 
     // handle transparence
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     // paint texture in cursor offset
     m_cursorTexture->bind();
     ShaderBinder binder(ShaderTrait::MapTexture);
     binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
     m_cursorTexture->render(QRegion(cursorRect), cursorRect);
     m_cursorTexture->unbind();
 
     cursor->markAsRendered();
 
     glDisable(GL_BLEND);
 }
 
 qint64 SceneOpenGL::paint(const QRegion &damage, const QList<Toplevel *> &toplevels)
 {
     // actually paint the frame, flushed with the NEXT frame
     createStackingOrder(toplevels);
 
     // After this call, updateRegion will contain the damaged region in the
     // back buffer. This is the region that needs to be posted to repair
     // the front buffer. It doesn't include the additional damage returned
     // by prepareRenderingFrame(). validRegion is the region that has been
     // repainted, and may be larger than updateRegion.
     QRegion updateRegion, validRegion;
     if (m_backend->perScreenRendering()) {
         // trigger start render timer
         m_backend->prepareRenderingFrame();
         for (int i = 0; i < screens()->count(); ++i) {
             const QRect &geo = screens()->geometry(i);
             QRegion update;
             QRegion valid;
             // prepare rendering makes context current on the output
             QRegion repaint = m_backend->prepareRenderingForScreen(i);
             GLVertexBuffer::setVirtualScreenGeometry(geo);
             GLRenderTarget::setVirtualScreenGeometry(geo);
             GLVertexBuffer::setVirtualScreenScale(screens()->scale(i));
             GLRenderTarget::setVirtualScreenScale(screens()->scale(i));
 
             const GLenum status = glGetGraphicsResetStatus();
             if (status != GL_NO_ERROR) {
                 handleGraphicsReset(status);
                 return 0;
             }
 
             int mask = 0;
             updateProjectionMatrix();
             paintScreen(&mask, damage.intersected(geo), repaint, &update, &valid, projectionMatrix(), geo, screens()->scale(i));   // call generic implementation
             paintCursor();
 
             GLVertexBuffer::streamingBuffer()->endOfFrame();
 
             m_backend->endRenderingFrameForScreen(i, valid, update);
 
             GLVertexBuffer::streamingBuffer()->framePosted();
         }
     } else {
         m_backend->makeCurrent();
         QRegion repaint = m_backend->prepareRenderingFrame();
 
         const GLenum status = glGetGraphicsResetStatus();
         if (status != GL_NO_ERROR) {
             handleGraphicsReset(status);
             return 0;
         }
         GLVertexBuffer::setVirtualScreenGeometry(screens()->geometry());
         GLRenderTarget::setVirtualScreenGeometry(screens()->geometry());
         GLVertexBuffer::setVirtualScreenScale(1);
         GLRenderTarget::setVirtualScreenScale(1);
 
         int mask = 0;
         updateProjectionMatrix();
         paintScreen(&mask, damage, repaint, &updateRegion, &validRegion, projectionMatrix());   // call generic implementation
 
         if (!GLPlatform::instance()->isGLES()) {
             const QSize &screenSize = screens()->size();
             const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
 
             // copy dirty parts from front to backbuffer
             if (!m_backend->supportsBufferAge() &&
                 options->glPreferBufferSwap() == Options::CopyFrontBuffer &&
                 validRegion != displayRegion) {
                 glReadBuffer(GL_FRONT);
                 m_backend->copyPixels(displayRegion - validRegion);
                 glReadBuffer(GL_BACK);
                 validRegion = displayRegion;
             }
         }
 
         GLVertexBuffer::streamingBuffer()->endOfFrame();
 
         m_backend->endRenderingFrame(validRegion, updateRegion);
 
         GLVertexBuffer::streamingBuffer()->framePosted();
     }
 
     if (m_currentFence) {
         if (!m_syncManager->updateFences()) {
             qCDebug(KWIN_OPENGL) << "Aborting explicit synchronization with the X command stream.";
             qCDebug(KWIN_OPENGL) << "Future frames will be rendered unsynchronized.";
             delete m_syncManager;
             m_syncManager = nullptr;
         }
         m_currentFence = nullptr;
     }
 
     // do cleanup
     clearStackingOrder();
     return m_backend->renderTime();
 }
 
 QMatrix4x4 SceneOpenGL::transformation(int mask, const ScreenPaintData &data) const
 {
     QMatrix4x4 matrix;
 
     if (!(mask & PAINT_SCREEN_TRANSFORMED))
         return matrix;
 
     matrix.translate(data.translation());
     data.scale().applyTo(&matrix);
 
     if (data.rotationAngle() == 0.0)
         return matrix;
 
     // Apply the rotation
     // cannot use data.rotation->applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
     matrix.translate(data.rotationOrigin());
     const QVector3D axis = data.rotationAxis();
     matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
     matrix.translate(-data.rotationOrigin());
 
     return matrix;
 }
 
 void SceneOpenGL::paintBackground(const QRegion &region)
 {
     PaintClipper pc(region);
     if (!PaintClipper::clip()) {
         glClearColor(0, 0, 0, 1);
         glClear(GL_COLOR_BUFFER_BIT);
         return;
     }
     if (pc.clip() && pc.paintArea().isEmpty())
         return; // no background to paint
     QVector<float> verts;
     for (PaintClipper::Iterator iterator; !iterator.isDone(); iterator.next()) {
         QRect r = iterator.boundingRect();
         verts << r.x() + r.width() << r.y();
         verts << r.x() << r.y();
         verts << r.x() << r.y() + r.height();
         verts << r.x() << r.y() + r.height();
         verts << r.x() + r.width() << r.y() + r.height();
         verts << r.x() + r.width() << r.y();
     }
     doPaintBackground(verts);
 }
 
 void SceneOpenGL::extendPaintRegion(QRegion &region, bool opaqueFullscreen)
 {
     if (m_backend->supportsBufferAge())
         return;
 
     const QSize &screenSize = screens()->size();
     if (options->glPreferBufferSwap() == Options::ExtendDamage) { // only Extend "large" repaints
         const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
         uint damagedPixels = 0;
         const uint fullRepaintLimit = (opaqueFullscreen?0.49f:0.748f)*screenSize.width()*screenSize.height();
         // 16:9 is 75% of 4:3 and 2.55:1 is 49.01% of 5:4
         // (5:4 is the most square format and 2.55:1 is Cinemascope55 - the widest ever shot
         // movie aspect - two times ;-) It's a Fox format, though, so maybe we want to restrict
         // to 2.20:1 - Panavision - which has actually been used for interesting movies ...)
         // would be 57% of 5/4
         for (const QRect &r : region) {
 //                 damagedPixels += r.width() * r.height(); // combined window damage test
             damagedPixels = r.width() * r.height(); // experimental single window damage testing
             if (damagedPixels > fullRepaintLimit) {
                 region = displayRegion;
                 return;
             }
         }
     } else if (options->glPreferBufferSwap() == Options::PaintFullScreen) { // forced full rePaint
         region = QRegion(0, 0, screenSize.width(), screenSize.height());
     }
 }
 
 SceneOpenGLTexture *SceneOpenGL::createTexture()
 {
     return new SceneOpenGLTexture(m_backend);
 }
 
 bool SceneOpenGL::viewportLimitsMatched(const QSize &size) const {
     if (kwinApp()->operationMode() != Application::OperationModeX11) {
         // TODO: On Wayland we can't suspend. Find a solution that works here as well!
         return true;
     }
     GLint limit[2];
     glGetIntegerv(GL_MAX_VIEWPORT_DIMS, limit);
     if (limit[0] < size.width() || limit[1] < size.height()) {
         auto compositor = static_cast<X11Compositor*>(Compositor::self());
         QMetaObject::invokeMethod(compositor, [compositor]() {
             qCDebug(KWIN_OPENGL) << "Suspending compositing because viewport limits are not met";
             compositor->suspend(X11Compositor::AllReasonSuspend);
         }, Qt::QueuedConnection);
         return false;
     }
     return true;
 }
 
 void SceneOpenGL::screenGeometryChanged(const QSize &size)
 {
     if (!viewportLimitsMatched(size))
         return;
     Scene::screenGeometryChanged(size);
     glViewport(0,0, size.width(), size.height());
     m_backend->screenGeometryChanged(size);
     GLRenderTarget::setVirtualScreenSize(size);
 }
 
 void SceneOpenGL::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
 {
     const QRect r = region.boundingRect();
     glEnable(GL_SCISSOR_TEST);
     glScissor(r.x(), screens()->size().height() - r.y() - r.height(), r.width(), r.height());
     KWin::Scene::paintDesktop(desktop, mask, region, data);
     glDisable(GL_SCISSOR_TEST);
 }
 
 void SceneOpenGL::paintEffectQuickView(EffectQuickView *w)
 {
     GLShader *shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
     const QRect rect = w->geometry();
 
     GLTexture *t = w->bufferAsTexture();
     if (!t) {
         return;
     }
 
     QMatrix4x4 mvp(projectionMatrix());
     mvp.translate(rect.x(), rect.y());
     shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
     t->bind();
     t->render(QRegion(infiniteRegion()), w->geometry());
     t->unbind();
     glDisable(GL_BLEND);
 
     ShaderManager::instance()->popShader();
 }
 
 bool SceneOpenGL::makeOpenGLContextCurrent()
 {
     return m_backend->makeCurrent();
 }
 
 void SceneOpenGL::doneOpenGLContextCurrent()
 {
     m_backend->doneCurrent();
 }
 
 Scene::EffectFrame *SceneOpenGL::createEffectFrame(EffectFrameImpl *frame)
 {
     return new SceneOpenGL::EffectFrame(frame, this);
 }
 
 Shadow *SceneOpenGL::createShadow(Toplevel *toplevel)
 {
     return new SceneOpenGLShadow(toplevel);
 }
 
 Decoration::Renderer *SceneOpenGL::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
 {
     return new SceneOpenGLDecorationRenderer(impl);
 }
 
 bool SceneOpenGL::animationsSupported() const
 {
     return !GLPlatform::instance()->isSoftwareEmulation();
 }
 
 QVector<QByteArray> SceneOpenGL::openGLPlatformInterfaceExtensions() const
 {
     return m_backend->extensions().toVector();
 }
 
 //****************************************
 // SceneOpenGL2
 //****************************************
 bool SceneOpenGL2::supported(OpenGLBackend *backend)
 {
     const QByteArray forceEnv = qgetenv("KWIN_COMPOSE");
     if (!forceEnv.isEmpty()) {
         if (qstrcmp(forceEnv, "O2") == 0 || qstrcmp(forceEnv, "O2ES") == 0) {
             qCDebug(KWIN_OPENGL) << "OpenGL 2 compositing enforced by environment variable";
             return true;
         } else {
             // OpenGL 2 disabled by environment variable
             return false;
         }
     }
     if (!backend->isDirectRendering()) {
         return false;
     }
     if (GLPlatform::instance()->recommendedCompositor() < OpenGL2Compositing) {
         qCDebug(KWIN_OPENGL) << "Driver does not recommend OpenGL 2 compositing";
         return false;
     }
     return true;
 }
 
 SceneOpenGL2::SceneOpenGL2(OpenGLBackend *backend, QObject *parent)
     : SceneOpenGL(backend, parent)
     , m_lanczosFilter(nullptr)
 {
     if (!init_ok) {
         // base ctor already failed
         return;
     }
 
     // We only support the OpenGL 2+ shader API, not GL_ARB_shader_objects
     if (!hasGLVersion(2, 0)) {
         qCDebug(KWIN_OPENGL) << "OpenGL 2.0 is not supported";
         init_ok = false;
         return;
     }
 
     const QSize &s = screens()->size();
     GLRenderTarget::setVirtualScreenSize(s);
     GLRenderTarget::setVirtualScreenGeometry(screens()->geometry());
 
     // push one shader on the stack so that one is always bound
     ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
     if (checkGLError("Init")) {
         qCCritical(KWIN_OPENGL) << "OpenGL 2 compositing setup failed";
         init_ok = false;
         return; // error
     }
 
     // It is not legal to not have a vertex array object bound in a core context
     if (!GLPlatform::instance()->isGLES() && hasGLExtension(QByteArrayLiteral("GL_ARB_vertex_array_object"))) {
         glGenVertexArrays(1, &vao);
         glBindVertexArray(vao);
     }
 
     if (!ShaderManager::instance()->selfTest()) {
         qCCritical(KWIN_OPENGL) << "ShaderManager self test failed";
         init_ok = false;
         return;
     }
 
     qCDebug(KWIN_OPENGL) << "OpenGL 2 compositing successfully initialized";
     init_ok = true;
 }
 
 SceneOpenGL2::~SceneOpenGL2()
 {
     if (m_lanczosFilter) {
         makeOpenGLContextCurrent();
         delete m_lanczosFilter;
         m_lanczosFilter = nullptr;
     }
 }
 
 QMatrix4x4 SceneOpenGL2::createProjectionMatrix() const
 {
     // Create a perspective projection with a 60° field-of-view,
     // and an aspect ratio of 1.0.
     const float fovY   =   60.0f;
     const float aspect =    1.0f;
     const float zNear  =    0.1f;
     const float zFar   =  100.0f;
 
     const float yMax   =  zNear * std::tan(fovY * M_PI / 360.0f);
     const float yMin   = -yMax;
     const float xMin   =  yMin * aspect;
     const float xMax   =  yMax * aspect;
 
     QMatrix4x4 projection;
     projection.frustum(xMin, xMax, yMin, yMax, zNear, zFar);
 
     // Create a second matrix that transforms screen coordinates
     // to world coordinates.
     const float scaleFactor = 1.1 * std::tan(fovY * M_PI / 360.0f) / yMax;
     const QSize size = screens()->size();
 
     QMatrix4x4 matrix;
     matrix.translate(xMin * scaleFactor, yMax * scaleFactor, -1.1);
     matrix.scale( (xMax - xMin) * scaleFactor / size.width(),
                  -(yMax - yMin) * scaleFactor / size.height(),
                   0.001);
 
     // Combine the matrices
     return projection * matrix;
 }
 
 void SceneOpenGL2::updateProjectionMatrix()
 {
     m_projectionMatrix = createProjectionMatrix();
 }
 
 void SceneOpenGL2::paintSimpleScreen(int mask, const QRegion &region)
 {
     m_screenProjectionMatrix = m_projectionMatrix;
 
     Scene::paintSimpleScreen(mask, region);
 }
 
 void SceneOpenGL2::paintGenericScreen(int mask, const ScreenPaintData &data)
 {
     const QMatrix4x4 screenMatrix = transformation(mask, data);
 
     m_screenProjectionMatrix = m_projectionMatrix * screenMatrix;
 
     Scene::paintGenericScreen(mask, data);
 }
 
 void SceneOpenGL2::doPaintBackground(const QVector< float >& vertices)
 {
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
     vbo->setUseColor(true);
     vbo->setData(vertices.count() / 2, 2, vertices.data(), nullptr);
 
     ShaderBinder binder(ShaderTrait::UniformColor);
     binder.shader()->setUniform(GLShader::ModelViewProjectionMatrix, m_projectionMatrix);
 
     vbo->render(GL_TRIANGLES);
 }
 
 Scene::Window *SceneOpenGL2::createWindow(Toplevel *t)
 {
     return new OpenGLWindow(t, this);
 }
 
 void SceneOpenGL2::finalDrawWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (waylandServer() && waylandServer()->isScreenLocked() && !w->window()->isLockScreen() && !w->window()->isInputMethod()) {
         return;
     }
     performPaintWindow(w, mask, region, data);
 }
 
 void SceneOpenGL2::performPaintWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (mask & PAINT_WINDOW_LANCZOS) {
         if (!m_lanczosFilter) {
             m_lanczosFilter = new LanczosFilter(this);
             // reset the lanczos filter when the screen gets resized
             // it will get created next paint
             connect(screens(), &Screens::changed, this, [this]() {
                 makeOpenGLContextCurrent();
                 delete m_lanczosFilter;
                 m_lanczosFilter = nullptr;
             });
         }
         m_lanczosFilter->performPaint(w, mask, region, data);
     } else
         w->sceneWindow()->performPaint(mask, region, data);
 }
 
 //****************************************
 // OpenGLWindow
 //****************************************
 
 OpenGLWindow::OpenGLWindow(Toplevel *toplevel, SceneOpenGL *scene)
     : Scene::Window(toplevel)
     , m_scene(scene)
 {
 }
 
 OpenGLWindow::~OpenGLWindow()
 {
 }
 
 static SceneOpenGLTexture *s_frameTexture = nullptr;
 // Bind the window pixmap to an OpenGL texture.
 bool OpenGLWindow::bindTexture()
 {
     s_frameTexture = nullptr;
     OpenGLWindowPixmap *pixmap = windowPixmap<OpenGLWindowPixmap>();
     if (!pixmap) {
         return false;
     }
     s_frameTexture = pixmap->texture();
     if (pixmap->isDiscarded()) {
         return !pixmap->texture()->isNull();
     }
 
     if (!window()->damage().isEmpty())
         m_scene->insertWait();
 
     return pixmap->bind();
 }
 
 QMatrix4x4 OpenGLWindow::transformation(int mask, const WindowPaintData &data) const
 {
     QMatrix4x4 matrix;
     matrix.translate(x(), y());
 
     if (!(mask & Scene::PAINT_WINDOW_TRANSFORMED))
         return matrix;
 
     matrix.translate(data.translation());
     data.scale().applyTo(&matrix);
 
     if (data.rotationAngle() == 0.0)
         return matrix;
 
     // Apply the rotation
     // cannot use data.rotation.applyTo(&matrix) as QGraphicsRotation uses projectedRotate to map back to 2D
     matrix.translate(data.rotationOrigin());
     const QVector3D axis = data.rotationAxis();
     matrix.rotate(data.rotationAngle(), axis.x(), axis.y(), axis.z());
     matrix.translate(-data.rotationOrigin());
 
     return matrix;
 }
 
 bool OpenGLWindow::beginRenderWindow(int mask, const QRegion &region, WindowPaintData &data)
 {
     if (region.isEmpty())
         return false;
 
     m_hardwareClipping = region != infiniteRegion() && (mask & Scene::PAINT_WINDOW_TRANSFORMED) && !(mask & Scene::PAINT_SCREEN_TRANSFORMED);
     if (region != infiniteRegion() && !m_hardwareClipping) {
         WindowQuadList quads;
         quads.reserve(data.quads.count());
 
         const QRegion filterRegion = region.translated(-x(), -y());
         // split all quads in bounding rect with the actual rects in the region
         foreach (const WindowQuad &quad, data.quads) {
             for (const QRect &r : filterRegion) {
                 const QRectF rf(r);
                 const QRectF quadRect(QPointF(quad.left(), quad.top()), QPointF(quad.right(), quad.bottom()));
                 const QRectF &intersected = rf.intersected(quadRect);
                 if (intersected.isValid()) {
                     if (quadRect == intersected) {
                         // case 1: completely contains, include and do not check other rects
                         quads << quad;
                         break;
                     }
                     // case 2: intersection
                     quads << quad.makeSubQuad(intersected.left(), intersected.top(), intersected.right(), intersected.bottom());
                 }
             }
         }
         data.quads = quads;
     }
 
     if (data.quads.isEmpty())
         return false;
 
     if (!bindTexture() || !s_frameTexture) {
         return false;
     }
 
     if (m_hardwareClipping) {
         glEnable(GL_SCISSOR_TEST);
     }
 
     // Update the texture filter
     if (waylandServer()) {
         filter = Scene::ImageFilterGood;
         s_frameTexture->setFilter(GL_LINEAR);
     } else {
         if (options->glSmoothScale() != 0 &&
             (mask & (Scene::PAINT_WINDOW_TRANSFORMED | Scene::PAINT_SCREEN_TRANSFORMED)))
             filter = Scene::ImageFilterGood;
         else
             filter = Scene::ImageFilterFast;
 
         s_frameTexture->setFilter(filter == Scene::ImageFilterGood ? GL_LINEAR : GL_NEAREST);
     }
 
     const GLVertexAttrib attribs[] = {
         { VA_Position, 2, GL_FLOAT, offsetof(GLVertex2D, position) },
         { VA_TexCoord, 2, GL_FLOAT, offsetof(GLVertex2D, texcoord) },
     };
 
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     vbo->reset();
     vbo->setAttribLayout(attribs, 2, sizeof(GLVertex2D));
 
     return true;
 }
 
 void OpenGLWindow::endRenderWindow()
 {
     if (m_hardwareClipping) {
         glDisable(GL_SCISSOR_TEST);
     }
 }
 
 GLTexture *OpenGLWindow::getDecorationTexture() const
 {
     if (AbstractClient *client = dynamic_cast<AbstractClient *>(toplevel)) {
         if (client->noBorder()) {
             return nullptr;
         }
 
         if (!client->isDecorated()) {
             return nullptr;
         }
         if (SceneOpenGLDecorationRenderer *renderer = static_cast<SceneOpenGLDecorationRenderer*>(client->decoratedClient()->renderer())) {
             renderer->render();
             return renderer->texture();
         }
     } else if (toplevel->isDeleted()) {
         Deleted *deleted = static_cast<Deleted *>(toplevel);
         if (!deleted->wasClient() || deleted->noBorder()) {
             return nullptr;
         }
         if (const SceneOpenGLDecorationRenderer *renderer = static_cast<const SceneOpenGLDecorationRenderer*>(deleted->decorationRenderer())) {
             return renderer->texture();
         }
     }
     return nullptr;
 }
 
 WindowPixmap *OpenGLWindow::createWindowPixmap()
 {
     return new OpenGLWindowPixmap(this, m_scene);
 }
 
 QVector4D OpenGLWindow::modulate(float opacity, float brightness) const
 {
     const float a = opacity;
     const float rgb = opacity * brightness;
 
     return QVector4D(rgb, rgb, rgb, a);
 }
 
 void OpenGLWindow::setBlendEnabled(bool enabled)
 {
     if (enabled && !m_blendingEnabled)
         glEnable(GL_BLEND);
     else if (!enabled && m_blendingEnabled)
         glDisable(GL_BLEND);
 
     m_blendingEnabled = enabled;
 }
 
 void OpenGLWindow::setupLeafNodes(LeafNode *nodes, const WindowQuadList *quads, const WindowPaintData &data)
 {
     if (!quads[ShadowLeaf].isEmpty()) {
         nodes[ShadowLeaf].texture = static_cast<SceneOpenGLShadow *>(m_shadow)->shadowTexture();
         nodes[ShadowLeaf].opacity = data.opacity();
         nodes[ShadowLeaf].hasAlpha = true;
         nodes[ShadowLeaf].coordinateType = NormalizedCoordinates;
     }
 
     if (!quads[DecorationLeaf].isEmpty()) {
         nodes[DecorationLeaf].texture = getDecorationTexture();
         nodes[DecorationLeaf].opacity = data.opacity();
         nodes[DecorationLeaf].hasAlpha = true;
         nodes[DecorationLeaf].coordinateType = UnnormalizedCoordinates;
     }
 
     nodes[ContentLeaf].texture = s_frameTexture;
     nodes[ContentLeaf].hasAlpha = !isOpaque();
     // TODO: ARGB crsoofading is atm. a hack, playing on opacities for two dumb SrcOver operations
     // Should be a shader
     if (data.crossFadeProgress() != 1.0 && (data.opacity() < 0.95 || toplevel->hasAlpha())) {
         const float opacity = 1.0 - data.crossFadeProgress();
         nodes[ContentLeaf].opacity = data.opacity() * (1 - pow(opacity, 1.0f + 2.0f * data.opacity()));
     } else {
         nodes[ContentLeaf].opacity = data.opacity();
     }
     nodes[ContentLeaf].coordinateType = UnnormalizedCoordinates;
 
     if (data.crossFadeProgress() != 1.0) {
         OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
         nodes[PreviousContentLeaf].texture = previous ? previous->texture() : nullptr;
         nodes[PreviousContentLeaf].hasAlpha = !isOpaque();
         nodes[PreviousContentLeaf].opacity = data.opacity() * (1.0 - data.crossFadeProgress());
         nodes[PreviousContentLeaf].coordinateType = NormalizedCoordinates;
     }
 }
 
 QMatrix4x4 OpenGLWindow::modelViewProjectionMatrix(int mask, const WindowPaintData &data) const
 {
     SceneOpenGL2 *scene = static_cast<SceneOpenGL2 *>(m_scene);
 
     const QMatrix4x4 pMatrix = data.projectionMatrix();
     const QMatrix4x4 mvMatrix = data.modelViewMatrix();
 
     // An effect may want to override the default projection matrix in some cases,
     // such as when it is rendering a window on a render target that doesn't have
     // the same dimensions as the default framebuffer.
     //
     // Note that the screen transformation is not applied here.
     if (!pMatrix.isIdentity())
         return pMatrix * mvMatrix;
 
     // If an effect has specified a model-view matrix, we multiply that matrix
     // with the default projection matrix.  If the effect hasn't specified a
     // model-view matrix, mvMatrix will be the identity matrix.
     if (mask & Scene::PAINT_SCREEN_TRANSFORMED)
         return scene->screenProjectionMatrix() * mvMatrix;
 
     return scene->projectionMatrix() * mvMatrix;
 }
 
 void OpenGLWindow::renderSubSurface(GLShader *shader, const QMatrix4x4 &mvp, const QMatrix4x4 &windowMatrix, OpenGLWindowPixmap *pixmap, const QRegion &region, bool hardwareClipping)
 {
     QMatrix4x4 newWindowMatrix = windowMatrix;
     newWindowMatrix.translate(pixmap->subSurface()->position().x(), pixmap->subSurface()->position().y());
 
     qreal scale = 1.0;
     if (pixmap->surface()) {
         scale = pixmap->surface()->scale();
     }
 
     if (!pixmap->texture()->isNull()) {
         setBlendEnabled(pixmap->buffer() && pixmap->buffer()->hasAlphaChannel());
         // render this texture
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp * newWindowMatrix);
         auto texture = pixmap->texture();
         texture->bind();
         texture->render(region, QRect(0, 0, texture->width() / scale, texture->height() / scale), hardwareClipping);
         texture->unbind();
     }
 
     const auto &children = pixmap->children();
     for (auto pixmap : children) {
         if (pixmap->subSurface().isNull() || pixmap->subSurface()->surface().isNull() || !pixmap->subSurface()->surface()->isMapped()) {
             continue;
         }
         renderSubSurface(shader, mvp, newWindowMatrix, static_cast<OpenGLWindowPixmap*>(pixmap), region, hardwareClipping);
     }
 }
 
 void OpenGLWindow::performPaint(int mask, const QRegion &region, const WindowPaintData &_data)
 {
     WindowPaintData data = _data;
     if (!beginRenderWindow(mask, region, data))
         return;
 
     QMatrix4x4 windowMatrix = transformation(mask, data);
     const QMatrix4x4 modelViewProjection = modelViewProjectionMatrix(mask, data);
     const QMatrix4x4 mvpMatrix = modelViewProjection * windowMatrix;
 
 
     bool useX11TextureClamp = false;
 
     GLShader *shader = data.shader;
     GLenum filter;
 
     if (waylandServer()) {
         filter = GL_LINEAR;
     } else {
         const bool isTransformed = mask & (Effect::PAINT_WINDOW_TRANSFORMED |
                                            Effect::PAINT_SCREEN_TRANSFORMED);
         useX11TextureClamp = isTransformed;
         if (isTransformed && options->glSmoothScale() != 0) {
             filter = GL_LINEAR;
         } else {
             filter = GL_NEAREST;
         }
     }
 
     if (!shader) {
         ShaderTraits traits = ShaderTrait::MapTexture;
         if (useX11TextureClamp) {
             traits |= ShaderTrait::ClampTexture;
         }
 
         if (data.opacity() != 1.0 || data.brightness() != 1.0 || data.crossFadeProgress() != 1.0)
             traits |= ShaderTrait::Modulate;
 
         if (data.saturation() != 1.0)
             traits |= ShaderTrait::AdjustSaturation;
 
         shader = ShaderManager::instance()->pushShader(traits);
     }
     shader->setUniform(GLShader::ModelViewProjectionMatrix, mvpMatrix);
 
     shader->setUniform(GLShader::Saturation, data.saturation());
 
     WindowQuadList quads[LeafCount];
 
     // Split the quads into separate lists for each type
     foreach (const WindowQuad &quad, data.quads) {
         switch (quad.type()) {
         case WindowQuadDecoration:
             quads[DecorationLeaf].append(quad);
             continue;
 
         case WindowQuadContents:
             quads[ContentLeaf].append(quad);
             continue;
 
         case WindowQuadShadow:
             quads[ShadowLeaf].append(quad);
             continue;
 
         default:
             continue;
         }
     }
 
     if (data.crossFadeProgress() != 1.0) {
         OpenGLWindowPixmap *previous = previousWindowPixmap<OpenGLWindowPixmap>();
         if (previous) {
             const QRect &oldGeometry = previous->contentsRect();
             for (const WindowQuad &quad : quads[ContentLeaf]) {
                 // we need to create new window quads with normalize texture coordinates
                 // normal quads divide the x/y position by width/height. This would not work as the texture
                 // is larger than the visible content in case of a decorated Client resulting in garbage being shown.
                 // So we calculate the normalized texture coordinate in the Client's new content space and map it to
                 // the previous Client's content space.
                 WindowQuad newQuad(WindowQuadContents);
                 for (int i = 0; i < 4; ++i) {
                     const qreal xFactor = qreal(quad[i].textureX() - toplevel->clientPos().x())/qreal(toplevel->clientSize().width());
                     const qreal yFactor = qreal(quad[i].textureY() - toplevel->clientPos().y())/qreal(toplevel->clientSize().height());
                     WindowVertex vertex(quad[i].x(), quad[i].y(),
                                         (xFactor * oldGeometry.width() + oldGeometry.x())/qreal(previous->size().width()),
                                         (yFactor * oldGeometry.height() + oldGeometry.y())/qreal(previous->size().height()));
                     newQuad[i] = vertex;
                 }
                 quads[PreviousContentLeaf].append(newQuad);
             }
         }
     }
 
     const bool indexedQuads = GLVertexBuffer::supportsIndexedQuads();
     const GLenum primitiveType = indexedQuads ? GL_QUADS : GL_TRIANGLES;
     const int verticesPerQuad = indexedQuads ? 4 : 6;
 
     const size_t size = verticesPerQuad *
         (quads[0].count() + quads[1].count() + quads[2].count() + quads[3].count()) * sizeof(GLVertex2D);
 
     GLVertexBuffer *vbo = GLVertexBuffer::streamingBuffer();
     GLVertex2D *map = (GLVertex2D *) vbo->map(size);
 
     LeafNode nodes[LeafCount];
     setupLeafNodes(nodes, quads, data);
 
     for (int i = 0, v = 0; i < LeafCount; i++) {
         if (quads[i].isEmpty() || !nodes[i].texture)
             continue;
 
         nodes[i].firstVertex = v;
         nodes[i].vertexCount = quads[i].count() * verticesPerQuad;
 
         const QMatrix4x4 matrix = nodes[i].texture->matrix(nodes[i].coordinateType);
 
         quads[i].makeInterleavedArrays(primitiveType, &map[v], matrix);
         v += quads[i].count() * verticesPerQuad;
     }
 
     vbo->unmap();
     vbo->bindArrays();
 
     // Make sure the blend function is set up correctly in case we will be doing blending
     glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
     float opacity = -1.0;
 
     for (int i = 0; i < LeafCount; i++) {
         if (nodes[i].vertexCount == 0)
             continue;
 
         setBlendEnabled(nodes[i].hasAlpha || nodes[i].opacity < 1.0);
 
         if (opacity != nodes[i].opacity) {
             shader->setUniform(GLShader::ModulationConstant,
                                modulate(nodes[i].opacity, data.brightness()));
             opacity = nodes[i].opacity;
         }
 
         nodes[i].texture->setFilter(filter);
         nodes[i].texture->setWrapMode(GL_CLAMP_TO_EDGE);
         nodes[i].texture->bind();
 
         if (i == ContentLeaf && useX11TextureClamp) {
             // X11 windows are reparented to have their buffer in the middle of a larger texture
             // holding the frame window.
             // This code passes the texture geometry to the fragment shader
             // any samples near the edge of the texture will be constrained to be
             // at least half a pixel in bounds, meaning we don't bleed the transparent border
             QRectF bufferContentRect = clientShape().boundingRect();
             bufferContentRect.adjust(0.5, 0.5, -0.5, -0.5);
             const QRect bufferGeometry = toplevel->bufferGeometry();
 
             float leftClamp = bufferContentRect.left() / bufferGeometry.width();
             float topClamp = bufferContentRect.top() / bufferGeometry.height();
             float rightClamp = bufferContentRect.right() / bufferGeometry.width();
             float bottomClamp = bufferContentRect.bottom() / bufferGeometry.height();
             shader->setUniform(GLShader::TextureClamp, QVector4D({leftClamp, topClamp, rightClamp, bottomClamp}));
         } else {
             shader->setUniform(GLShader::TextureClamp, QVector4D({0, 0, 1, 1}));
         }
 
         vbo->draw(region, primitiveType, nodes[i].firstVertex, nodes[i].vertexCount, m_hardwareClipping);
     }
 
     vbo->unbindArrays();
 
     // render sub-surfaces
     auto wp = windowPixmap<OpenGLWindowPixmap>();
     const auto &children = wp ? wp->children() : QVector<WindowPixmap*>();
     const QPoint mainSurfaceOffset = bufferOffset();
     windowMatrix.translate(mainSurfaceOffset.x(), mainSurfaceOffset.y());
     for (auto pixmap : children) {
         if (pixmap->subSurface().isNull() || pixmap->subSurface()->surface().isNull() || !pixmap->subSurface()->surface()->isMapped()) {
             continue;
         }
         renderSubSurface(shader, modelViewProjection, windowMatrix, static_cast<OpenGLWindowPixmap*>(pixmap), region, m_hardwareClipping);
     }
 
     setBlendEnabled(false);
 
     if (!data.shader)
         ShaderManager::instance()->popShader();
 
     endRenderWindow();
 }
 
 
 //****************************************
 // OpenGLWindowPixmap
 //****************************************
 
 OpenGLWindowPixmap::OpenGLWindowPixmap(Scene::Window *window, SceneOpenGL* scene)
     : WindowPixmap(window)
     , m_texture(scene->createTexture())
     , m_scene(scene)
 {
 }
 
-OpenGLWindowPixmap::OpenGLWindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent, SceneOpenGL *scene)
+OpenGLWindowPixmap::OpenGLWindowPixmap(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface, WindowPixmap *parent, SceneOpenGL *scene)
     : WindowPixmap(subSurface, parent)
     , m_texture(scene->createTexture())
     , m_scene(scene)
 {
 }
 
 OpenGLWindowPixmap::~OpenGLWindowPixmap()
 {
 }
 
 static bool needsPixmapUpdate(const OpenGLWindowPixmap *pixmap)
 {
     // That's a regular Wayland client.
     if (pixmap->surface()) {
         return !pixmap->surface()->trackedDamage().isEmpty();
     }
 
     // That's an internal client with a raster buffer attached.
     if (!pixmap->internalImage().isNull()) {
         return !pixmap->toplevel()->damage().isEmpty();
     }
 
     // That's an internal client with an opengl framebuffer object attached.
     if (!pixmap->fbo().isNull()) {
         return !pixmap->toplevel()->damage().isEmpty();
     }
 
     // That's an X11 client.
     return false;
 }
 
 bool OpenGLWindowPixmap::bind()
 {
     if (!m_texture->isNull()) {
         // always call updateBuffer to get the sub-surface tree updated
         if (subSurface().isNull() && !toplevel()->damage().isEmpty()) {
             updateBuffer();
         }
         if (needsPixmapUpdate(this)) {
             m_texture->updateFromPixmap(this);
             // mipmaps need to be updated
             m_texture->setDirty();
         }
         if (subSurface().isNull()) {
             toplevel()->resetDamage();
         }
         // also bind all children
         for (auto it = children().constBegin(); it != children().constEnd(); ++it) {
             static_cast<OpenGLWindowPixmap*>(*it)->bind();
         }
         return true;
     }
     // also bind all children, needs to be done before checking isValid
     // as there might be valid children to render, see https://bugreports.qt.io/browse/QTBUG-52192
     if (subSurface().isNull()) {
         updateBuffer();
     }
     for (auto it = children().constBegin(); it != children().constEnd(); ++it) {
         static_cast<OpenGLWindowPixmap*>(*it)->bind();
     }
     if (!isValid()) {
         return false;
     }
 
     bool success = m_texture->load(this);
 
     if (success) {
         if (subSurface().isNull()) {
             toplevel()->resetDamage();
         }
     } else
         qCDebug(KWIN_OPENGL) << "Failed to bind window";
     return success;
 }
 
-WindowPixmap *OpenGLWindowPixmap::createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface)
+WindowPixmap *OpenGLWindowPixmap::createChild(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface)
 {
     return new OpenGLWindowPixmap(subSurface, this, m_scene);
 }
 
 bool OpenGLWindowPixmap::isValid() const
 {
     if (!m_texture->isNull()) {
         return true;
     }
     return WindowPixmap::isValid();
 }
 
 //****************************************
 // SceneOpenGL::EffectFrame
 //****************************************
 
 GLTexture* SceneOpenGL::EffectFrame::m_unstyledTexture = nullptr;
 QPixmap* SceneOpenGL::EffectFrame::m_unstyledPixmap = nullptr;
 
 SceneOpenGL::EffectFrame::EffectFrame(EffectFrameImpl* frame, SceneOpenGL *scene)
     : Scene::EffectFrame(frame)
     , m_texture(nullptr)
     , m_textTexture(nullptr)
     , m_oldTextTexture(nullptr)
     , m_textPixmap(nullptr)
     , m_iconTexture(nullptr)
     , m_oldIconTexture(nullptr)
     , m_selectionTexture(nullptr)
     , m_unstyledVBO(nullptr)
     , m_scene(scene)
 {
     if (m_effectFrame->style() == EffectFrameUnstyled && !m_unstyledTexture) {
         updateUnstyledTexture();
     }
 }
 
 SceneOpenGL::EffectFrame::~EffectFrame()
 {
     delete m_texture;
     delete m_textTexture;
     delete m_textPixmap;
     delete m_oldTextTexture;
     delete m_iconTexture;
     delete m_oldIconTexture;
     delete m_selectionTexture;
     delete m_unstyledVBO;
 }
 
 void SceneOpenGL::EffectFrame::free()
 {
     glFlush();
     delete m_texture;
     m_texture = nullptr;
     delete m_textTexture;
     m_textTexture = nullptr;
     delete m_textPixmap;
     m_textPixmap = nullptr;
     delete m_iconTexture;
     m_iconTexture = nullptr;
     delete m_selectionTexture;
     m_selectionTexture = nullptr;
     delete m_unstyledVBO;
     m_unstyledVBO = nullptr;
     delete m_oldIconTexture;
     m_oldIconTexture = nullptr;
     delete m_oldTextTexture;
     m_oldTextTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::freeIconFrame()
 {
     delete m_iconTexture;
     m_iconTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::freeTextFrame()
 {
     delete m_textTexture;
     m_textTexture = nullptr;
     delete m_textPixmap;
     m_textPixmap = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::freeSelection()
 {
     delete m_selectionTexture;
     m_selectionTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::crossFadeIcon()
 {
     delete m_oldIconTexture;
     m_oldIconTexture = m_iconTexture;
     m_iconTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::crossFadeText()
 {
     delete m_oldTextTexture;
     m_oldTextTexture = m_textTexture;
     m_textTexture = nullptr;
 }
 
 void SceneOpenGL::EffectFrame::render(const QRegion &_region, double opacity, double frameOpacity)
 {
     if (m_effectFrame->geometry().isEmpty())
         return; // Nothing to display
 
     Q_UNUSED(_region);
     const QRegion region = infiniteRegion(); // TODO: Old region doesn't seem to work with OpenGL
 
     GLShader* shader = m_effectFrame->shader();
     if (!shader) {
         shader = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture | ShaderTrait::Modulate);
     } else if (shader) {
         ShaderManager::instance()->pushShader(shader);
     }
 
     if (shader) {
         shader->setUniform(GLShader::ModulationConstant, QVector4D(1.0, 1.0, 1.0, 1.0));
         shader->setUniform(GLShader::Saturation, 1.0f);
     }
     const QMatrix4x4 projection = m_scene->projectionMatrix();
 
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
     // Render the actual frame
     if (m_effectFrame->style() == EffectFrameUnstyled) {
         if (!m_unstyledVBO) {
             m_unstyledVBO = new GLVertexBuffer(GLVertexBuffer::Static);
             QRect area = m_effectFrame->geometry();
             area.moveTo(0, 0);
             area.adjust(-5, -5, 5, 5);
 
             const int roundness = 5;
             QVector<float> verts, texCoords;
             verts.reserve(84);
             texCoords.reserve(84);
 
             // top left
             verts << area.left() << area.top();
             texCoords << 0.0f << 0.0f;
             verts << area.left() << area.top() + roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() + roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.left() + roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() << area.top() + roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() + roundness << area.top();
             texCoords << 0.5f << 0.0f;
             // top
             verts << area.left() + roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.left() + roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.left() + roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.top();
             texCoords << 0.5f << 0.0f;
             // top right
             verts << area.right() - roundness << area.top();
             texCoords << 0.5f << 0.0f;
             verts << area.right() - roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() << area.top();
             texCoords << 1.0f << 0.0f;
             verts << area.right() - roundness << area.top() + roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() << area.top() + roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.right() << area.top();
             texCoords << 1.0f << 0.0f;
             // bottom left
             verts << area.left() << area.bottom() - roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() << area.bottom();
             texCoords << 0.0f << 1.0f;
             verts << area.left() + roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() + roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.left() << area.bottom();
             texCoords << 0.0f << 1.0f;
             verts << area.left() + roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             // bottom
             verts << area.left() + roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() + roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() - roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.left() + roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() - roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() - roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             // bottom right
             verts << area.right() - roundness << area.bottom() - roundness;
             texCoords << 0.5f << 0.5f;
             verts << area.right() - roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() << area.bottom() - roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.right() - roundness << area.bottom();
             texCoords << 0.5f << 1.0f;
             verts << area.right() << area.bottom();
             texCoords << 1.0f << 1.0f;
             verts << area.right() << area.bottom() - roundness;
             texCoords << 1.0f << 0.5f;
             // center
             verts << area.left() << area.top() + roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.left() << area.bottom() - roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.right() << area.top() + roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.left() << area.bottom() - roundness;
             texCoords << 0.0f << 0.5f;
             verts << area.right() << area.bottom() - roundness;
             texCoords << 1.0f << 0.5f;
             verts << area.right() << area.top() + roundness;
             texCoords << 1.0f << 0.5f;
 
             m_unstyledVBO->setData(verts.count() / 2, 2, verts.data(), texCoords.data());
         }
 
         if (shader) {
             const float a = opacity * frameOpacity;
             shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
         }
 
         m_unstyledTexture->bind();
         const QPoint pt = m_effectFrame->geometry().topLeft();
 
         QMatrix4x4 mvp(projection);
         mvp.translate(pt.x(), pt.y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
         m_unstyledVBO->render(region, GL_TRIANGLES);
         m_unstyledTexture->unbind();
     } else if (m_effectFrame->style() == EffectFrameStyled) {
         if (!m_texture)   // Lazy creation
             updateTexture();
 
         if (shader) {
             const float a = opacity * frameOpacity;
             shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
         }
         m_texture->bind();
         qreal left, top, right, bottom;
         m_effectFrame->frame().getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
         const QRect rect = m_effectFrame->geometry().adjusted(-left, -top, right, bottom);
 
         QMatrix4x4 mvp(projection);
         mvp.translate(rect.x(), rect.y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
         m_texture->render(region, rect);
         m_texture->unbind();
 
     }
     if (!m_effectFrame->selection().isNull()) {
         if (!m_selectionTexture) { // Lazy creation
             QPixmap pixmap = m_effectFrame->selectionFrame().framePixmap();
             if (!pixmap.isNull())
                 m_selectionTexture = new GLTexture(pixmap);
         }
         if (m_selectionTexture) {
             if (shader) {
                 const float a = opacity * frameOpacity;
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
             QMatrix4x4 mvp(projection);
             mvp.translate(m_effectFrame->selection().x(), m_effectFrame->selection().y());
             shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
             glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
             m_selectionTexture->bind();
             m_selectionTexture->render(region, m_effectFrame->selection());
             m_selectionTexture->unbind();
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
         }
     }
 
     // Render icon
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
         QPoint topLeft(m_effectFrame->geometry().x(),
                        m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
 
         QMatrix4x4 mvp(projection);
         mvp.translate(topLeft.x(), topLeft.y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
 
         if (m_effectFrame->isCrossFade() && m_oldIconTexture) {
             if (shader) {
                 const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
 
             m_oldIconTexture->bind();
             m_oldIconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
             m_oldIconTexture->unbind();
             if (shader) {
                 const float a = opacity * m_effectFrame->crossFadeProgress();
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
         } else {
             if (shader) {
                 const QVector4D constant(opacity, opacity, opacity, opacity);
                 shader->setUniform(GLShader::ModulationConstant, constant);
             }
         }
 
         if (!m_iconTexture) { // lazy creation
             m_iconTexture = new GLTexture(m_effectFrame->icon().pixmap(m_effectFrame->iconSize()));
         }
         m_iconTexture->bind();
         m_iconTexture->render(region, QRect(topLeft, m_effectFrame->iconSize()));
         m_iconTexture->unbind();
     }
 
     // Render text
     if (!m_effectFrame->text().isEmpty()) {
         QMatrix4x4 mvp(projection);
         mvp.translate(m_effectFrame->geometry().x(), m_effectFrame->geometry().y());
         shader->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
         if (m_effectFrame->isCrossFade() && m_oldTextTexture) {
             if (shader) {
                 const float a = opacity * (1.0 - m_effectFrame->crossFadeProgress());
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
 
             m_oldTextTexture->bind();
             m_oldTextTexture->render(region, m_effectFrame->geometry());
             m_oldTextTexture->unbind();
             if (shader) {
                 const float a = opacity * m_effectFrame->crossFadeProgress();
                 shader->setUniform(GLShader::ModulationConstant, QVector4D(a, a, a, a));
             }
         } else {
             if (shader) {
                 const QVector4D constant(opacity, opacity, opacity, opacity);
                 shader->setUniform(GLShader::ModulationConstant, constant);
             }
         }
         if (!m_textTexture)   // Lazy creation
             updateTextTexture();
 
         if (m_textTexture) {
             m_textTexture->bind();
             m_textTexture->render(region, m_effectFrame->geometry());
             m_textTexture->unbind();
         }
     }
 
     if (shader) {
         ShaderManager::instance()->popShader();
     }
     glDisable(GL_BLEND);
 }
 
 void SceneOpenGL::EffectFrame::updateTexture()
 {
     delete m_texture;
     m_texture = nullptr;
     if (m_effectFrame->style() == EffectFrameStyled) {
         QPixmap pixmap = m_effectFrame->frame().framePixmap();
         m_texture = new GLTexture(pixmap);
     }
 }
 
 void SceneOpenGL::EffectFrame::updateTextTexture()
 {
     delete m_textTexture;
     m_textTexture = nullptr;
     delete m_textPixmap;
     m_textPixmap = nullptr;
 
     if (m_effectFrame->text().isEmpty())
         return;
 
     // Determine position on texture to paint text
     QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty())
         rect.setLeft(m_effectFrame->iconSize().width());
 
     // If static size elide text as required
     QString text = m_effectFrame->text();
     if (m_effectFrame->isStatic()) {
         QFontMetrics metrics(m_effectFrame->font());
         text = metrics.elidedText(text, Qt::ElideRight, rect.width());
     }
 
     m_textPixmap = new QPixmap(m_effectFrame->geometry().size());
     m_textPixmap->fill(Qt::transparent);
     QPainter p(m_textPixmap);
     p.setFont(m_effectFrame->font());
     if (m_effectFrame->style() == EffectFrameStyled)
         p.setPen(m_effectFrame->styledTextColor());
     else // TODO: What about no frame? Custom color setting required
         p.setPen(Qt::white);
     p.drawText(rect, m_effectFrame->alignment(), text);
     p.end();
     m_textTexture = new GLTexture(*m_textPixmap);
 }
 
 void SceneOpenGL::EffectFrame::updateUnstyledTexture()
 {
     delete m_unstyledTexture;
     m_unstyledTexture = nullptr;
     delete m_unstyledPixmap;
     m_unstyledPixmap = nullptr;
     // Based off circle() from kwinxrenderutils.cpp
 #define CS 8
     m_unstyledPixmap = new QPixmap(2 * CS, 2 * CS);
     m_unstyledPixmap->fill(Qt::transparent);
     QPainter p(m_unstyledPixmap);
     p.setRenderHint(QPainter::Antialiasing);
     p.setPen(Qt::NoPen);
     p.setBrush(Qt::black);
     p.drawEllipse(m_unstyledPixmap->rect());
     p.end();
 #undef CS
     m_unstyledTexture = new GLTexture(*m_unstyledPixmap);
 }
 
 void SceneOpenGL::EffectFrame::cleanup()
 {
     delete m_unstyledTexture;
     m_unstyledTexture = nullptr;
     delete m_unstyledPixmap;
     m_unstyledPixmap = nullptr;
 }
 
 //****************************************
 // SceneOpenGL::Shadow
 //****************************************
 class DecorationShadowTextureCache
 {
 public:
     ~DecorationShadowTextureCache();
     DecorationShadowTextureCache(const DecorationShadowTextureCache&) = delete;
     static DecorationShadowTextureCache &instance();
 
     void unregister(SceneOpenGLShadow *shadow);
     QSharedPointer<GLTexture> getTexture(SceneOpenGLShadow *shadow);
 
 private:
     DecorationShadowTextureCache() = default;
     struct Data {
         QSharedPointer<GLTexture> texture;
         QVector<SceneOpenGLShadow*> shadows;
     };
     QHash<KDecoration2::DecorationShadow*, Data> m_cache;
 };
 
 DecorationShadowTextureCache &DecorationShadowTextureCache::instance()
 {
     static DecorationShadowTextureCache s_instance;
     return s_instance;
 }
 
 DecorationShadowTextureCache::~DecorationShadowTextureCache()
 {
     Q_ASSERT(m_cache.isEmpty());
 }
 
 void DecorationShadowTextureCache::unregister(SceneOpenGLShadow *shadow)
 {
     auto it = m_cache.begin();
     while (it != m_cache.end()) {
         auto &d = it.value();
         // check whether the Vector of Shadows contains our shadow and remove all of them
         auto glIt = d.shadows.begin();
         while (glIt != d.shadows.end()) {
             if (*glIt == shadow) {
                 glIt = d.shadows.erase(glIt);
             } else {
                 glIt++;
             }
         }
         // if there are no shadows any more we can erase the cache entry
         if (d.shadows.isEmpty()) {
             it = m_cache.erase(it);
         } else {
             it++;
         }
     }
 }
 
 QSharedPointer<GLTexture> DecorationShadowTextureCache::getTexture(SceneOpenGLShadow *shadow)
 {
     Q_ASSERT(shadow->hasDecorationShadow());
     unregister(shadow);
     const auto &decoShadow = shadow->decorationShadow().toStrongRef();
     Q_ASSERT(!decoShadow.isNull());
     auto it = m_cache.find(decoShadow.data());
     if (it != m_cache.end()) {
         Q_ASSERT(!it.value().shadows.contains(shadow));
         it.value().shadows << shadow;
         return it.value().texture;
     }
     Data d;
     d.shadows << shadow;
     d.texture = QSharedPointer<GLTexture>::create(shadow->decorationShadowImage());
     m_cache.insert(decoShadow.data(), d);
     return d.texture;
 }
 
 SceneOpenGLShadow::SceneOpenGLShadow(Toplevel *toplevel)
     : Shadow(toplevel)
 {
 }
 
 SceneOpenGLShadow::~SceneOpenGLShadow()
 {
     Scene *scene = Compositor::self()->scene();
     if (scene) {
         scene->makeOpenGLContextCurrent();
         DecorationShadowTextureCache::instance().unregister(this);
         m_texture.reset();
     }
 }
 
 static inline void distributeHorizontally(QRectF &leftRect, QRectF &rightRect)
 {
     if (leftRect.right() > rightRect.left()) {
         const qreal boundedRight = qMin(leftRect.right(), rightRect.right());
         const qreal boundedLeft = qMax(leftRect.left(), rightRect.left());
         const qreal halfOverlap = (boundedRight - boundedLeft) / 2.0;
         leftRect.setRight(boundedRight - halfOverlap);
         rightRect.setLeft(boundedLeft + halfOverlap);
     }
 }
 
 static inline void distributeVertically(QRectF &topRect, QRectF &bottomRect)
 {
     if (topRect.bottom() > bottomRect.top()) {
         const qreal boundedBottom = qMin(topRect.bottom(), bottomRect.bottom());
         const qreal boundedTop = qMax(topRect.top(), bottomRect.top());
         const qreal halfOverlap = (boundedBottom - boundedTop) / 2.0;
         topRect.setBottom(boundedBottom - halfOverlap);
         bottomRect.setTop(boundedTop + halfOverlap);
     }
 }
 
 void SceneOpenGLShadow::buildQuads()
 {
     // Do not draw shadows if window width or window height is less than
     // 5 px. 5 is an arbitrary choice.
     if (topLevel()->width() < 5 || topLevel()->height() < 5) {
         m_shadowQuads.clear();
         setShadowRegion(QRegion());
         return;
     }
 
     const QSizeF top(elementSize(ShadowElementTop));
     const QSizeF topRight(elementSize(ShadowElementTopRight));
     const QSizeF right(elementSize(ShadowElementRight));
     const QSizeF bottomRight(elementSize(ShadowElementBottomRight));
     const QSizeF bottom(elementSize(ShadowElementBottom));
     const QSizeF bottomLeft(elementSize(ShadowElementBottomLeft));
     const QSizeF left(elementSize(ShadowElementLeft));
     const QSizeF topLeft(elementSize(ShadowElementTopLeft));
 
     const QMarginsF shadowMargins(
         std::max({topLeft.width(), left.width(), bottomLeft.width()}),
         std::max({topLeft.height(), top.height(), topRight.height()}),
         std::max({topRight.width(), right.width(), bottomRight.width()}),
         std::max({bottomRight.height(), bottom.height(), bottomLeft.height()}));
 
     const QRectF outerRect(QPointF(-leftOffset(), -topOffset()),
                            QPointF(topLevel()->width() + rightOffset(),
                                    topLevel()->height() + bottomOffset()));
 
     const int width = shadowMargins.left() + std::max(top.width(), bottom.width()) + shadowMargins.right();
     const int height = shadowMargins.top() + std::max(left.height(), right.height()) + shadowMargins.bottom();
 
     QRectF topLeftRect;
     if (!topLeft.isEmpty()) {
         topLeftRect = QRectF(outerRect.topLeft(), topLeft);
     } else {
         topLeftRect = QRectF(
             outerRect.left() + shadowMargins.left(),
             outerRect.top() + shadowMargins.top(),
             0, 0);
     }
 
     QRectF topRightRect;
     if (!topRight.isEmpty()) {
         topRightRect = QRectF(
             outerRect.right() - topRight.width(), outerRect.top(),
             topRight.width(), topRight.height());
     } else {
         topRightRect = QRectF(
             outerRect.right() - shadowMargins.right(),
             outerRect.top() + shadowMargins.top(),
             0, 0);
     }
 
     QRectF bottomRightRect;
     if (!bottomRight.isEmpty()) {
         bottomRightRect = QRectF(
             outerRect.right() - bottomRight.width(),
             outerRect.bottom() - bottomRight.height(),
             bottomRight.width(), bottomRight.height());
     } else {
         bottomRightRect = QRectF(
             outerRect.right() - shadowMargins.right(),
             outerRect.bottom() - shadowMargins.bottom(),
             0, 0);
     }
 
     QRectF bottomLeftRect;
     if (!bottomLeft.isEmpty()) {
         bottomLeftRect = QRectF(
             outerRect.left(), outerRect.bottom() - bottomLeft.height(),
             bottomLeft.width(), bottomLeft.height());
     } else {
         bottomLeftRect = QRectF(
             outerRect.left() + shadowMargins.left(),
             outerRect.bottom() - shadowMargins.bottom(),
             0, 0);
     }
 
     // Re-distribute the corner tiles so no one of them is overlapping with others.
     // By doing this, we assume that shadow's corner tiles are symmetric
     // and it is OK to not draw top/right/bottom/left tile between corners.
     // For example, let's say top-left and top-right tiles are overlapping.
     // In that case, the right side of the top-left tile will be shifted to left,
     // the left side of the top-right tile will shifted to right, and the top
     // tile won't be rendered.
     distributeHorizontally(topLeftRect, topRightRect);
     distributeHorizontally(bottomLeftRect, bottomRightRect);
     distributeVertically(topLeftRect, bottomLeftRect);
     distributeVertically(topRightRect, bottomRightRect);
 
     qreal tx1 = 0.0,
           tx2 = 0.0,
           ty1 = 0.0,
           ty2 = 0.0;
 
     m_shadowQuads.clear();
 
     if (topLeftRect.isValid()) {
         tx1 = 0.0;
         ty1 = 0.0;
         tx2 = topLeftRect.width() / width;
         ty2 = topLeftRect.height() / height;
         WindowQuad topLeftQuad(WindowQuadShadow);
         topLeftQuad[0] = WindowVertex(topLeftRect.left(),  topLeftRect.top(),    tx1, ty1);
         topLeftQuad[1] = WindowVertex(topLeftRect.right(), topLeftRect.top(),    tx2, ty1);
         topLeftQuad[2] = WindowVertex(topLeftRect.right(), topLeftRect.bottom(), tx2, ty2);
         topLeftQuad[3] = WindowVertex(topLeftRect.left(),  topLeftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topLeftQuad);
     }
 
     if (topRightRect.isValid()) {
         tx1 = 1.0 - topRightRect.width() / width;
         ty1 = 0.0;
         tx2 = 1.0;
         ty2 = topRightRect.height() / height;
         WindowQuad topRightQuad(WindowQuadShadow);
         topRightQuad[0] = WindowVertex(topRightRect.left(),  topRightRect.top(),    tx1, ty1);
         topRightQuad[1] = WindowVertex(topRightRect.right(), topRightRect.top(),    tx2, ty1);
         topRightQuad[2] = WindowVertex(topRightRect.right(), topRightRect.bottom(), tx2, ty2);
         topRightQuad[3] = WindowVertex(topRightRect.left(),  topRightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topRightQuad);
     }
 
     if (bottomRightRect.isValid()) {
         tx1 = 1.0 - bottomRightRect.width() / width;
         tx2 = 1.0;
         ty1 = 1.0 - bottomRightRect.height() / height;
         ty2 = 1.0;
         WindowQuad bottomRightQuad(WindowQuadShadow);
         bottomRightQuad[0] = WindowVertex(bottomRightRect.left(),  bottomRightRect.top(),    tx1, ty1);
         bottomRightQuad[1] = WindowVertex(bottomRightRect.right(), bottomRightRect.top(),    tx2, ty1);
         bottomRightQuad[2] = WindowVertex(bottomRightRect.right(), bottomRightRect.bottom(), tx2, ty2);
         bottomRightQuad[3] = WindowVertex(bottomRightRect.left(),  bottomRightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomRightQuad);
     }
 
     if (bottomLeftRect.isValid()) {
         tx1 = 0.0;
         tx2 = bottomLeftRect.width() / width;
         ty1 = 1.0 - bottomLeftRect.height() / height;
         ty2 = 1.0;
         WindowQuad bottomLeftQuad(WindowQuadShadow);
         bottomLeftQuad[0] = WindowVertex(bottomLeftRect.left(),  bottomLeftRect.top(),    tx1, ty1);
         bottomLeftQuad[1] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.top(),    tx2, ty1);
         bottomLeftQuad[2] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.bottom(), tx2, ty2);
         bottomLeftQuad[3] = WindowVertex(bottomLeftRect.left(),  bottomLeftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomLeftQuad);
     }
 
     QRectF topRect(
         QPointF(topLeftRect.right(), outerRect.top()),
         QPointF(topRightRect.left(), outerRect.top() + top.height()));
 
     QRectF rightRect(
         QPointF(outerRect.right() - right.width(), topRightRect.bottom()),
         QPointF(outerRect.right(), bottomRightRect.top()));
 
     QRectF bottomRect(
         QPointF(bottomLeftRect.right(), outerRect.bottom() - bottom.height()),
         QPointF(bottomRightRect.left(), outerRect.bottom()));
 
     QRectF leftRect(
         QPointF(outerRect.left(), topLeftRect.bottom()),
         QPointF(outerRect.left() + left.width(), bottomLeftRect.top()));
 
     // Re-distribute left/right and top/bottom shadow tiles so they don't
     // overlap when the window is too small. Please notice that we don't
     // fix overlaps between left/top(left/bottom, right/top, and so on)
     // corner tiles because corresponding counter parts won't be valid when
     // the window is too small, which means they won't be rendered.
     distributeHorizontally(leftRect, rightRect);
     distributeVertically(topRect, bottomRect);
 
     if (topRect.isValid()) {
         tx1 = shadowMargins.left() / width;
         ty1 = 0.0;
         tx2 = tx1 + top.width() / width;
         ty2 = topRect.height() / height;
         WindowQuad topQuad(WindowQuadShadow);
         topQuad[0] = WindowVertex(topRect.left(),  topRect.top(),    tx1, ty1);
         topQuad[1] = WindowVertex(topRect.right(), topRect.top(),    tx2, ty1);
         topQuad[2] = WindowVertex(topRect.right(), topRect.bottom(), tx2, ty2);
         topQuad[3] = WindowVertex(topRect.left(),  topRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topQuad);
     }
 
     if (rightRect.isValid()) {
         tx1 = 1.0 - rightRect.width() / width;
         ty1 = shadowMargins.top() / height;
         tx2 = 1.0;
         ty2 = ty1 + right.height() / height;
         WindowQuad rightQuad(WindowQuadShadow);
         rightQuad[0] = WindowVertex(rightRect.left(),  rightRect.top(),    tx1, ty1);
         rightQuad[1] = WindowVertex(rightRect.right(), rightRect.top(),    tx2, ty1);
         rightQuad[2] = WindowVertex(rightRect.right(), rightRect.bottom(), tx2, ty2);
         rightQuad[3] = WindowVertex(rightRect.left(),  rightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(rightQuad);
     }
 
     if (bottomRect.isValid()) {
         tx1 = shadowMargins.left() / width;
         ty1 = 1.0 - bottomRect.height() / height;
         tx2 = tx1 + bottom.width() / width;
         ty2 = 1.0;
         WindowQuad bottomQuad(WindowQuadShadow);
         bottomQuad[0] = WindowVertex(bottomRect.left(),  bottomRect.top(),    tx1, ty1);
         bottomQuad[1] = WindowVertex(bottomRect.right(), bottomRect.top(),    tx2, ty1);
         bottomQuad[2] = WindowVertex(bottomRect.right(), bottomRect.bottom(), tx2, ty2);
         bottomQuad[3] = WindowVertex(bottomRect.left(),  bottomRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomQuad);
     }
 
     if (leftRect.isValid()) {
         tx1 = 0.0;
         ty1 = shadowMargins.top() / height;
         tx2 = leftRect.width() / width;
         ty2 = ty1 + left.height() / height;
         WindowQuad leftQuad(WindowQuadShadow);
         leftQuad[0] = WindowVertex(leftRect.left(),  leftRect.top(),    tx1, ty1);
         leftQuad[1] = WindowVertex(leftRect.right(), leftRect.top(),    tx2, ty1);
         leftQuad[2] = WindowVertex(leftRect.right(), leftRect.bottom(), tx2, ty2);
         leftQuad[3] = WindowVertex(leftRect.left(),  leftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(leftQuad);
     }
 }
 
 bool SceneOpenGLShadow::prepareBackend()
 {
     if (hasDecorationShadow()) {
         // simplifies a lot by going directly to
         Scene *scene = Compositor::self()->scene();
         scene->makeOpenGLContextCurrent();
         m_texture = DecorationShadowTextureCache::instance().getTexture(this);
 
         return true;
     }
     const QSize top(shadowPixmap(ShadowElementTop).size());
     const QSize topRight(shadowPixmap(ShadowElementTopRight).size());
     const QSize right(shadowPixmap(ShadowElementRight).size());
     const QSize bottom(shadowPixmap(ShadowElementBottom).size());
     const QSize bottomLeft(shadowPixmap(ShadowElementBottomLeft).size());
     const QSize left(shadowPixmap(ShadowElementLeft).size());
     const QSize topLeft(shadowPixmap(ShadowElementTopLeft).size());
     const QSize bottomRight(shadowPixmap(ShadowElementBottomRight).size());
 
     const int width = std::max({topLeft.width(), left.width(), bottomLeft.width()}) +
                       std::max(top.width(), bottom.width()) +
                       std::max({topRight.width(), right.width(), bottomRight.width()});
     const int height = std::max({topLeft.height(), top.height(), topRight.height()}) +
                        std::max(left.height(), right.height()) +
                        std::max({bottomLeft.height(), bottom.height(), bottomRight.height()});
 
     if (width == 0 || height == 0) {
         return false;
     }
 
     QImage image(width, height, QImage::Format_ARGB32);
     image.fill(Qt::transparent);
 
     const int innerRectTop = std::max({topLeft.height(), top.height(), topRight.height()});
     const int innerRectLeft = std::max({topLeft.width(), left.width(), bottomLeft.width()});
 
     QPainter p;
     p.begin(&image);
 
     p.drawPixmap(0, 0, shadowPixmap(ShadowElementTopLeft));
     p.drawPixmap(innerRectLeft, 0, shadowPixmap(ShadowElementTop));
     p.drawPixmap(width - topRight.width(), 0, shadowPixmap(ShadowElementTopRight));
 
     p.drawPixmap(0, innerRectTop, shadowPixmap(ShadowElementLeft));
     p.drawPixmap(width - right.width(), innerRectTop, shadowPixmap(ShadowElementRight));
 
     p.drawPixmap(0, height - bottomLeft.height(), shadowPixmap(ShadowElementBottomLeft));
     p.drawPixmap(innerRectLeft, height - bottom.height(), shadowPixmap(ShadowElementBottom));
     p.drawPixmap(width - bottomRight.width(), height - bottomRight.height(), shadowPixmap(ShadowElementBottomRight));
 
     p.end();
 
     // Check if the image is alpha-only in practice, and if so convert it to an 8-bpp format
     if (!GLPlatform::instance()->isGLES() && GLTexture::supportsSwizzle() && GLTexture::supportsFormatRG()) {
         QImage alphaImage(image.size(), QImage::Format_Indexed8); // Change to Format_Alpha8 w/ Qt 5.5
         bool alphaOnly = true;
 
         for (ptrdiff_t y = 0; alphaOnly && y < image.height(); y++) {
             const uint32_t * const src = reinterpret_cast<const uint32_t *>(image.scanLine(y));
             uint8_t * const dst = reinterpret_cast<uint8_t *>(alphaImage.scanLine(y));
 
             for (ptrdiff_t x = 0; x < image.width(); x++) {
                 if (src[x] & 0x00ffffff)
                     alphaOnly = false;
 
                 dst[x] = qAlpha(src[x]);
             }
         }
 
         if (alphaOnly) {
             image = alphaImage;
         }
     }
 
     Scene *scene = Compositor::self()->scene();
     scene->makeOpenGLContextCurrent();
     m_texture = QSharedPointer<GLTexture>::create(image);
 
     if (m_texture->internalFormat() == GL_R8) {
         // Swizzle red to alpha and all other channels to zero
         m_texture->bind();
         m_texture->setSwizzle(GL_ZERO, GL_ZERO, GL_ZERO, GL_RED);
     }
 
     return true;
 }
 
 SceneOpenGLDecorationRenderer::SceneOpenGLDecorationRenderer(Decoration::DecoratedClientImpl *client)
     : Renderer(client)
     , m_texture()
 {
     connect(this, &Renderer::renderScheduled, client->client(), static_cast<void (AbstractClient::*)(const QRect&)>(&AbstractClient::addRepaint));
 }
 
 SceneOpenGLDecorationRenderer::~SceneOpenGLDecorationRenderer()
 {
     if (Scene *scene = Compositor::self()->scene()) {
         scene->makeOpenGLContextCurrent();
     }
 }
 
 // Rotates the given source rect 90° counter-clockwise,
 // and flips it vertically
 static QImage rotate(const QImage &srcImage, const QRect &srcRect)
 {
     auto dpr = srcImage.devicePixelRatio();
     QImage image(srcRect.height() * dpr, srcRect.width() * dpr, srcImage.format());
     image.setDevicePixelRatio(dpr);
     const QPoint srcPoint(srcRect.x() * dpr, srcRect.y() * dpr);
 
     const uint32_t *src = reinterpret_cast<const uint32_t *>(srcImage.bits());
     uint32_t *dst = reinterpret_cast<uint32_t *>(image.bits());
 
     for (int x = 0; x < image.width(); x++) {
         const uint32_t *s = src + (srcPoint.y() + x) * srcImage.width() + srcPoint.x();
         uint32_t *d = dst + x;
 
         for (int y = 0; y < image.height(); y++) {
             *d = s[y];
             d += image.width();
         }
     }
 
     return image;
 }
 
 static void clamp_row(int left, int width, int right, const uint32_t *src, uint32_t *dest)
 {
     std::fill_n(dest, left, *src);
     std::copy(src, src + width, dest + left);
     std::fill_n(dest + left + width, right, *(src + width - 1));
 }
 
 static void clamp_sides(int left, int width, int right, const uint32_t *src, uint32_t *dest)
 {
     std::fill_n(dest, left, *src);
     std::fill_n(dest + left + width, right, *(src + width - 1));
 }
 
 static void clamp(QImage &image, const QRect &viewport)
 {
     Q_ASSERT(image.depth() == 32);
 
     const QRect rect = image.rect();
 
     const int left = viewport.left() - rect.left();
     const int top = viewport.top() - rect.top();
     const int right = rect.right() - viewport.right();
     const int bottom = rect.bottom() - viewport.bottom();
 
     const int width = rect.width() - left - right;
     const int height = rect.height() - top - bottom;
 
     const uint32_t *firstRow = reinterpret_cast<uint32_t *>(image.scanLine(top));
     const uint32_t *lastRow = reinterpret_cast<uint32_t *>(image.scanLine(top + height - 1));
 
     for (int i = 0; i < top; ++i) {
         uint32_t *dest = reinterpret_cast<uint32_t *>(image.scanLine(i));
         clamp_row(left, width, right, firstRow + left, dest);
     }
 
     for (int i = 0; i < height; ++i) {
         uint32_t *dest = reinterpret_cast<uint32_t *>(image.scanLine(top + i));
         clamp_sides(left, width, right, dest + left, dest);
     }
 
     for (int i = 0; i < bottom; ++i) {
         uint32_t *dest = reinterpret_cast<uint32_t *>(image.scanLine(top + height + i));
         clamp_row(left, width, right, lastRow + left, dest);
     }
 }
 
 void SceneOpenGLDecorationRenderer::render()
 {
     const QRegion scheduled = getScheduled();
     if (scheduled.isEmpty()) {
         return;
     }
     if (areImageSizesDirty()) {
         resizeTexture();
         resetImageSizesDirty();
     }
 
     if (!m_texture) {
         // for invalid sizes we get no texture, see BUG 361551
         return;
     }
 
     QRect left, top, right, bottom;
     client()->client()->layoutDecorationRects(left, top, right, bottom);
 
     // We pad each part in the decoration atlas in order to avoid texture bleeding.
     const int padding = 1;
 
     auto renderPart = [=](const QRect &geo, const QRect &partRect, const QPoint &position, bool rotated = false) {
         if (!geo.isValid()) {
             return;
         }
 
         QRect rect = geo;
 
         // We allow partial decoration updates and it might just so happen that the dirty region
         // is completely contained inside the decoration part, i.e. the dirty region doesn't touch
         // any of the decoration's edges. In that case, we should **not** pad the dirty region.
         if (rect.left() == partRect.left()) {
             rect.setLeft(rect.left() - padding);
         }
         if (rect.top() == partRect.top()) {
             rect.setTop(rect.top() - padding);
         }
         if (rect.right() == partRect.right()) {
             rect.setRight(rect.right() + padding);
         }
         if (rect.bottom() == partRect.bottom()) {
             rect.setBottom(rect.bottom() + padding);
         }
 
         QRect viewport = geo.translated(-rect.x(), -rect.y());
         const qreal devicePixelRatio = client()->client()->screenScale();
 
         QImage image(rect.size() * devicePixelRatio, QImage::Format_ARGB32_Premultiplied);
         image.setDevicePixelRatio(devicePixelRatio);
         image.fill(Qt::transparent);
 
         QPainter painter(&image);
         painter.setRenderHint(QPainter::Antialiasing);
         painter.setViewport(QRect(viewport.topLeft(), viewport.size() * devicePixelRatio));
         painter.setWindow(QRect(geo.topLeft(), geo.size() * devicePixelRatio));
         painter.setClipRect(geo);
         renderToPainter(&painter, geo);
         painter.end();
 
         clamp(image, QRect(viewport.topLeft(), viewport.size() * devicePixelRatio));
 
         if (rotated) {
             // TODO: get this done directly when rendering to the image
             image = rotate(image, QRect(QPoint(), rect.size()));
             viewport = QRect(viewport.y(), viewport.x(), viewport.height(), viewport.width());
         }
 
         const QPoint dirtyOffset = geo.topLeft() - partRect.topLeft();
         m_texture->update(image, (position + dirtyOffset - viewport.topLeft()) * image.devicePixelRatio());
     };
 
     const QRect geometry = scheduled.boundingRect();
 
     const QPoint topPosition(padding, padding);
     const QPoint bottomPosition(padding, topPosition.y() + top.height() + 2 * padding);
     const QPoint leftPosition(padding, bottomPosition.y() + bottom.height() + 2 * padding);
     const QPoint rightPosition(padding, leftPosition.y() + left.width() + 2 * padding);
 
     renderPart(left.intersected(geometry), left, leftPosition, true);
     renderPart(top.intersected(geometry), top, topPosition);
     renderPart(right.intersected(geometry), right, rightPosition, true);
     renderPart(bottom.intersected(geometry), bottom, bottomPosition);
 }
 
 static int align(int value, int align)
 {
     return (value + align - 1) & ~(align - 1);
 }
 
 void SceneOpenGLDecorationRenderer::resizeTexture()
 {
     QRect left, top, right, bottom;
     client()->client()->layoutDecorationRects(left, top, right, bottom);
     QSize size;
 
     size.rwidth() = qMax(qMax(top.width(), bottom.width()),
                          qMax(left.height(), right.height()));
     size.rheight() = top.height() + bottom.height() +
                      left.width() + right.width();
 
     // Reserve some space for padding. We pad decoration parts to avoid texture bleeding.
     const int padding = 1;
     size.rwidth() += 2 * padding;
     size.rheight() += 4 * 2 * padding;
 
     size.rwidth() = align(size.width(), 128);
 
     size *= client()->client()->screenScale();
     if (m_texture && m_texture->size() == size)
         return;
 
     if (!size.isEmpty()) {
         m_texture.reset(new GLTexture(GL_RGBA8, size.width(), size.height()));
         m_texture->setYInverted(true);
         m_texture->setWrapMode(GL_CLAMP_TO_EDGE);
         m_texture->clear();
     } else {
         m_texture.reset();
     }
 }
 
 void SceneOpenGLDecorationRenderer::reparent(Deleted *deleted)
 {
     render();
     Renderer::reparent(deleted);
 }
 
 
 OpenGLFactory::OpenGLFactory(QObject *parent)
     : SceneFactory(parent)
 {
 }
 
 OpenGLFactory::~OpenGLFactory() = default;
 
 Scene *OpenGLFactory::create(QObject *parent) const
 {
     qCDebug(KWIN_OPENGL) << "Initializing OpenGL compositing";
 
     // Some broken drivers crash on glXQuery() so to prevent constant KWin crashes:
     if (kwinApp()->platform()->openGLCompositingIsBroken()) {
         qCWarning(KWIN_OPENGL) << "KWin has detected that your OpenGL library is unsafe to use";
         return nullptr;
     }
     kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PreInit);
     auto s = SceneOpenGL::createScene(parent);
     kwinApp()->platform()->createOpenGLSafePoint(Platform::OpenGLSafePoint::PostInit);
     if (s && s->initFailed()) {
         delete s;
         return nullptr;
     }
     return s;
 }
 
 } // namespace
diff --git a/plugins/scenes/opengl/scene_opengl.h b/plugins/scenes/opengl/scene_opengl.h
index f72f0ba8a..d26a9f46a 100644
--- a/plugins/scenes/opengl/scene_opengl.h
+++ b/plugins/scenes/opengl/scene_opengl.h
@@ -1,333 +1,333 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2009, 2010, 2011 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SCENE_OPENGL_H
 #define KWIN_SCENE_OPENGL_H
 
 #include "scene.h"
 #include "shadow.h"
 
 #include "kwinglutils.h"
 
 #include "decorations/decorationrenderer.h"
 #include "platformsupport/scenes/opengl/backend.h"
 
 namespace KWin
 {
 class LanczosFilter;
 class OpenGLBackend;
 class SyncManager;
 class SyncObject;
 
 class KWIN_EXPORT SceneOpenGL
     : public Scene
 {
     Q_OBJECT
 public:
     class EffectFrame;
     ~SceneOpenGL() override;
     bool initFailed() const override;
     bool hasPendingFlush() const override;
     qint64 paint(const QRegion &damage, const QList<Toplevel *> &windows) override;
     Scene::EffectFrame *createEffectFrame(EffectFrameImpl *frame) override;
     Shadow *createShadow(Toplevel *toplevel) override;
     void screenGeometryChanged(const QSize &size) override;
     OverlayWindow *overlayWindow() const override;
     bool usesOverlayWindow() const override;
     bool blocksForRetrace() const override;
     bool syncsToVBlank() const override;
     bool makeOpenGLContextCurrent() override;
     void doneOpenGLContextCurrent() override;
     Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
     void triggerFence() override;
     virtual QMatrix4x4 projectionMatrix() const = 0;
     bool animationsSupported() const override;
 
     void insertWait();
 
     void idle() override;
 
     bool debug() const { return m_debug; }
     void initDebugOutput();
 
     /**
      * @brief Factory method to create a backend specific texture.
      *
      * @return :SceneOpenGL::Texture*
      */
     SceneOpenGLTexture *createTexture();
 
     OpenGLBackend *backend() const {
         return m_backend;
     }
 
     QVector<QByteArray> openGLPlatformInterfaceExtensions() const override;
 
     static SceneOpenGL *createScene(QObject *parent);
 
 protected:
     SceneOpenGL(OpenGLBackend *backend, QObject *parent = nullptr);
     void paintBackground(const QRegion &region) override;
     void extendPaintRegion(QRegion &region, bool opaqueFullscreen) override;
     QMatrix4x4 transformation(int mask, const ScreenPaintData &data) const;
     void paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data) override;
     void paintEffectQuickView(EffectQuickView *w) override;
 
     void handleGraphicsReset(GLenum status);
 
     virtual void doPaintBackground(const QVector<float> &vertices) = 0;
     virtual void updateProjectionMatrix() = 0;
 
 protected:
     bool init_ok;
 private:
     bool viewportLimitsMatched(const QSize &size) const;
 private:
     bool m_debug;
     OpenGLBackend *m_backend;
     SyncManager *m_syncManager;
     SyncObject *m_currentFence;
 };
 
 class SceneOpenGL2 : public SceneOpenGL
 {
     Q_OBJECT
 public:
     explicit SceneOpenGL2(OpenGLBackend *backend, QObject *parent = nullptr);
     ~SceneOpenGL2() override;
     CompositingType compositingType() const override {
         return OpenGL2Compositing;
     }
 
     static bool supported(OpenGLBackend *backend);
 
     QMatrix4x4 projectionMatrix() const override { return m_projectionMatrix; }
     QMatrix4x4 screenProjectionMatrix() const override { return m_screenProjectionMatrix; }
 
 protected:
     void paintSimpleScreen(int mask, const QRegion &region) override;
     void paintGenericScreen(int mask, const ScreenPaintData &data) override;
     void doPaintBackground(const QVector< float >& vertices) override;
     Scene::Window *createWindow(Toplevel *t) override;
     void finalDrawWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data) override;
     void updateProjectionMatrix() override;
     void paintCursor() override;
 
 private:
     void performPaintWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data);
     QMatrix4x4 createProjectionMatrix() const;
 
 private:
     LanczosFilter *m_lanczosFilter;
     QScopedPointer<GLTexture> m_cursorTexture;
     QMatrix4x4 m_projectionMatrix;
     QMatrix4x4 m_screenProjectionMatrix;
     GLuint vao;
 };
 
 class OpenGLWindowPixmap;
 
 class OpenGLWindow final : public Scene::Window
 {
 public:
     enum Leaf { ShadowLeaf = 0, DecorationLeaf, ContentLeaf, PreviousContentLeaf, LeafCount };
 
     struct LeafNode
     {
         LeafNode()
             : texture(nullptr),
               firstVertex(0),
               vertexCount(0),
               opacity(1.0),
               hasAlpha(false),
               coordinateType(UnnormalizedCoordinates)
         {
         }
 
         GLTexture *texture;
         int firstVertex;
         int vertexCount;
         float opacity;
         bool hasAlpha;
         TextureCoordinateType coordinateType;
     };
 
     OpenGLWindow(Toplevel *toplevel, SceneOpenGL *scene);
     ~OpenGLWindow() override;
 
     WindowPixmap *createWindowPixmap() override;
     void performPaint(int mask, const QRegion &region, const WindowPaintData &data) override;
 
 private:
     QMatrix4x4 transformation(int mask, const WindowPaintData &data) const;
     GLTexture *getDecorationTexture() const;
     QMatrix4x4 modelViewProjectionMatrix(int mask, const WindowPaintData &data) const;
     QVector4D modulate(float opacity, float brightness) const;
     void setBlendEnabled(bool enabled);
     void setupLeafNodes(LeafNode *nodes, const WindowQuadList *quads, const WindowPaintData &data);
     void renderSubSurface(GLShader *shader, const QMatrix4x4 &mvp, const QMatrix4x4 &windowMatrix,
                           OpenGLWindowPixmap *pixmap, const QRegion &region, bool hardwareClipping);
     bool beginRenderWindow(int mask, const QRegion &region, WindowPaintData &data);
     void endRenderWindow();
     bool bindTexture();
 
     SceneOpenGL *m_scene;
     bool m_hardwareClipping = false;
     bool m_blendingEnabled = false;
 };
 
 class OpenGLWindowPixmap : public WindowPixmap
 {
 public:
     explicit OpenGLWindowPixmap(Scene::Window *window, SceneOpenGL *scene);
     ~OpenGLWindowPixmap() override;
     SceneOpenGLTexture *texture() const;
     bool bind();
     bool isValid() const override;
 protected:
-    WindowPixmap *createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface) override;
+    WindowPixmap *createChild(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface) override;
 private:
-    explicit OpenGLWindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent, SceneOpenGL *scene);
+    explicit OpenGLWindowPixmap(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface, WindowPixmap *parent, SceneOpenGL *scene);
     QScopedPointer<SceneOpenGLTexture> m_texture;
     SceneOpenGL *m_scene;
 };
 
 class SceneOpenGL::EffectFrame
     : public Scene::EffectFrame
 {
 public:
     EffectFrame(EffectFrameImpl* frame, SceneOpenGL *scene);
     ~EffectFrame() override;
 
     void free() override;
     void freeIconFrame() override;
     void freeTextFrame() override;
     void freeSelection() override;
 
     void render(const QRegion &region, double opacity, double frameOpacity) override;
 
     void crossFadeIcon() override;
     void crossFadeText() override;
 
     static void cleanup();
 
 private:
     void updateTexture();
     void updateTextTexture();
 
     GLTexture *m_texture;
     GLTexture *m_textTexture;
     GLTexture *m_oldTextTexture;
     QPixmap *m_textPixmap; // need to keep the pixmap around to workaround some driver problems
     GLTexture *m_iconTexture;
     GLTexture *m_oldIconTexture;
     GLTexture *m_selectionTexture;
     GLVertexBuffer *m_unstyledVBO;
     SceneOpenGL *m_scene;
 
     static GLTexture* m_unstyledTexture;
     static QPixmap* m_unstyledPixmap; // need to keep the pixmap around to workaround some driver problems
     static void updateUnstyledTexture(); // Update OpenGL unstyled frame texture
 };
 
 /**
  * @short OpenGL implementation of Shadow.
  *
  * This class extends Shadow by the Elements required for OpenGL rendering.
  * @author Martin Gräßlin <mgraesslin@kde.org>
  */
 class SceneOpenGLShadow
     : public Shadow
 {
 public:
     explicit SceneOpenGLShadow(Toplevel *toplevel);
     ~SceneOpenGLShadow() override;
 
     GLTexture *shadowTexture() {
         return m_texture.data();
     }
 protected:
     void buildQuads() override;
     bool prepareBackend() override;
 private:
     QSharedPointer<GLTexture> m_texture;
 };
 
 class SceneOpenGLDecorationRenderer : public Decoration::Renderer
 {
     Q_OBJECT
 public:
     enum class DecorationPart : int {
         Left,
         Top,
         Right,
         Bottom,
         Count
     };
     explicit SceneOpenGLDecorationRenderer(Decoration::DecoratedClientImpl *client);
     ~SceneOpenGLDecorationRenderer() override;
 
     void render() override;
     void reparent(Deleted *deleted) override;
 
     GLTexture *texture() {
         return m_texture.data();
     }
     GLTexture *texture() const {
         return m_texture.data();
     }
 
 private:
     void resizeTexture();
     QScopedPointer<GLTexture> m_texture;
 };
 
 inline bool SceneOpenGL::hasPendingFlush() const
 {
     return m_backend->hasPendingFlush();
 }
 
 inline bool SceneOpenGL::usesOverlayWindow() const
 {
     return m_backend->usesOverlayWindow();
 }
 
 inline SceneOpenGLTexture* OpenGLWindowPixmap::texture() const
 {
     return m_texture.data();
 }
 
 class KWIN_EXPORT OpenGLFactory : public SceneFactory
 {
     Q_OBJECT
     Q_INTERFACES(KWin::SceneFactory)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Scene" FILE "opengl.json")
 
 public:
     explicit OpenGLFactory(QObject *parent = nullptr);
     ~OpenGLFactory() override;
 
     Scene *create(QObject *parent = nullptr) const override;
 };
 
 } // namespace
 
 #endif
diff --git a/plugins/scenes/qpainter/scene_qpainter.cpp b/plugins/scenes/qpainter/scene_qpainter.cpp
index 54118a515..d8159b379 100644
--- a/plugins/scenes/qpainter/scene_qpainter.cpp
+++ b/plugins/scenes/qpainter/scene_qpainter.cpp
@@ -1,920 +1,920 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "scene_qpainter.h"
 // KWin
 #include "x11client.h"
 #include "composite.h"
 #include "cursor.h"
 #include "deleted.h"
 #include "effects.h"
 #include "main.h"
 #include "screens.h"
 #include "toplevel.h"
 #include "platform.h"
 #include "wayland_server.h"
 
 #include <kwineffectquickview.h>
 
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/subcompositor_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/subcompositor_interface.h>
+#include <KWaylandServer/surface_interface.h>
 #include "decorations/decoratedclient.h"
 // Qt
 #include <QDebug>
 #include <QPainter>
 #include <KDecoration2/Decoration>
 
 #include <cmath>
 
 namespace KWin
 {
 
 //****************************************
 // SceneQPainter
 //****************************************
 SceneQPainter *SceneQPainter::createScene(QObject *parent)
 {
     QScopedPointer<QPainterBackend> backend(kwinApp()->platform()->createQPainterBackend());
     if (backend.isNull()) {
         return nullptr;
     }
     if (backend->isFailed()) {
         return nullptr;
     }
     return new SceneQPainter(backend.take(), parent);
 }
 
 SceneQPainter::SceneQPainter(QPainterBackend *backend, QObject *parent)
     : Scene(parent)
     , m_backend(backend)
     , m_painter(new QPainter())
 {
 }
 
 SceneQPainter::~SceneQPainter()
 {
 }
 
 CompositingType SceneQPainter::compositingType() const
 {
     return QPainterCompositing;
 }
 
 bool SceneQPainter::initFailed() const
 {
     return false;
 }
 
 void SceneQPainter::paintGenericScreen(int mask, const ScreenPaintData &data)
 {
     m_painter->save();
     m_painter->translate(data.xTranslation(), data.yTranslation());
     m_painter->scale(data.xScale(), data.yScale());
     Scene::paintGenericScreen(mask, data);
     m_painter->restore();
 }
 
 qint64 SceneQPainter::paint(const QRegion &_damage, const QList<Toplevel *> &toplevels)
 {
     QElapsedTimer renderTimer;
     renderTimer.start();
 
     createStackingOrder(toplevels);
     QRegion damage = _damage;
 
     int mask = 0;
     m_backend->prepareRenderingFrame();
     if (m_backend->perScreenRendering()) {
         const bool needsFullRepaint = m_backend->needsFullRepaint();
         if (needsFullRepaint) {
             mask |= Scene::PAINT_SCREEN_BACKGROUND_FIRST;
             damage = screens()->geometry();
         }
         QRegion overallUpdate;
         for (int i = 0; i < screens()->count(); ++i) {
             const QRect geometry = screens()->geometry(i);
             QImage *buffer = m_backend->bufferForScreen(i);
             if (!buffer || buffer->isNull()) {
                 continue;
             }
             m_painter->begin(buffer);
             m_painter->save();
             m_painter->setWindow(geometry);
 
             QRegion updateRegion, validRegion;
             paintScreen(&mask, damage.intersected(geometry), QRegion(), &updateRegion, &validRegion);
             overallUpdate = overallUpdate.united(updateRegion);
             paintCursor();
 
             m_painter->restore();
             m_painter->end();
         }
         m_backend->showOverlay();
         m_backend->present(mask, overallUpdate);
     } else {
         m_painter->begin(m_backend->buffer());
         m_painter->setClipping(true);
         m_painter->setClipRegion(damage);
         if (m_backend->needsFullRepaint()) {
             mask |= Scene::PAINT_SCREEN_BACKGROUND_FIRST;
             damage = screens()->geometry();
         }
         QRegion updateRegion, validRegion;
         paintScreen(&mask, damage, QRegion(), &updateRegion, &validRegion);
 
         paintCursor();
         m_backend->showOverlay();
 
         m_painter->end();
         m_backend->present(mask, updateRegion);
     }
 
     // do cleanup
     clearStackingOrder();
 
     emit frameRendered();
 
     return renderTimer.nsecsElapsed();
 }
 
 void SceneQPainter::paintBackground(const QRegion &region)
 {
     m_painter->setBrush(Qt::black);
     for (const QRect &rect : region) {
         m_painter->drawRect(rect);
     }
 }
 
 void SceneQPainter::paintCursor()
 {
     if (!kwinApp()->platform()->usesSoftwareCursor()) {
         return;
     }
 
     Cursor* cursor = Cursors::self()->currentCursor();
     const QImage img = cursor->image();
     if (img.isNull()) {
         return;
     }
     const QPoint cursorPos = cursor->pos();
     const QPoint hotspot = cursor->hotspot();
     m_painter->drawImage(cursorPos - hotspot, img);
     cursor->markAsRendered();
 }
 
 void SceneQPainter::paintEffectQuickView(EffectQuickView *w)
 {
     QPainter *painter = effects->scenePainter();
     const QImage buffer = w->bufferAsImage();
     if (buffer.isNull()) {
         return;
     }
     painter->drawImage(w->geometry(), buffer);
 }
 
 Scene::Window *SceneQPainter::createWindow(Toplevel *toplevel)
 {
     return new SceneQPainter::Window(this, toplevel);
 }
 
 Scene::EffectFrame *SceneQPainter::createEffectFrame(EffectFrameImpl *frame)
 {
     return new QPainterEffectFrame(frame, this);
 }
 
 Shadow *SceneQPainter::createShadow(Toplevel *toplevel)
 {
     return new SceneQPainterShadow(toplevel);
 }
 
 void SceneQPainter::screenGeometryChanged(const QSize &size)
 {
     Scene::screenGeometryChanged(size);
     m_backend->screenGeometryChanged(size);
 }
 
 QImage *SceneQPainter::qpainterRenderBuffer() const
 {
     return m_backend->buffer();
 }
 
 //****************************************
 // SceneQPainter::Window
 //****************************************
 SceneQPainter::Window::Window(SceneQPainter *scene, Toplevel *c)
     : Scene::Window(c)
     , m_scene(scene)
 {
 }
 
 SceneQPainter::Window::~Window()
 {
 }
 
 static void paintSubSurface(QPainter *painter, const QPoint &pos, QPainterWindowPixmap *pixmap)
 {
     QPoint p = pos;
     if (!pixmap->subSurface().isNull()) {
         p += pixmap->subSurface()->position();
     }
 
     painter->drawImage(QRect(pos, pixmap->size()), pixmap->image());
     const auto &children = pixmap->children();
     for (auto it = children.begin(); it != children.end(); ++it) {
         auto pixmap = static_cast<QPainterWindowPixmap*>(*it);
         if (pixmap->subSurface().isNull() || pixmap->subSurface()->surface().isNull() || !pixmap->subSurface()->surface()->isMapped()) {
             continue;
         }
         paintSubSurface(painter, p, pixmap);
     }
 }
 
 static bool isXwaylandClient(Toplevel *toplevel)
 {
     X11Client *client = qobject_cast<X11Client *>(toplevel);
     if (client) {
         return true;
     }
     Deleted *deleted = qobject_cast<Deleted *>(toplevel);
     if (deleted) {
         return deleted->wasX11Client();
     }
     return false;
 }
 
 void SceneQPainter::Window::performPaint(int mask, const QRegion &_region, const WindowPaintData &data)
 {
     QRegion region = _region;
     if (!(mask & (PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_TRANSFORMED)))
         region &= toplevel->visibleRect();
 
     if (region.isEmpty())
         return;
     QPainterWindowPixmap *pixmap = windowPixmap<QPainterWindowPixmap>();
     if (!pixmap || !pixmap->isValid()) {
         return;
     }
     if (!toplevel->damage().isEmpty()) {
         pixmap->updateBuffer();
         toplevel->resetDamage();
     }
 
     QPainter *scenePainter = m_scene->scenePainter();
     QPainter *painter = scenePainter;
     painter->save();
     painter->setClipRegion(region);
     painter->setClipping(true);
 
     painter->translate(x(), y());
     if (mask & PAINT_WINDOW_TRANSFORMED) {
         painter->translate(data.xTranslation(), data.yTranslation());
         painter->scale(data.xScale(), data.yScale());
     }
 
     const bool opaque = qFuzzyCompare(1.0, data.opacity());
     QImage tempImage;
     QPainter tempPainter;
     if (!opaque) {
         // need a temp render target which we later on blit to the screen
         tempImage = QImage(toplevel->visibleRect().size(), QImage::Format_ARGB32_Premultiplied);
         tempImage.fill(Qt::transparent);
         tempPainter.begin(&tempImage);
         tempPainter.save();
         tempPainter.translate(toplevel->frameGeometry().topLeft() - toplevel->visibleRect().topLeft());
         painter = &tempPainter;
     }
     renderShadow(painter);
     renderWindowDecorations(painter);
 
     // render content
     QRect source;
     QRect target;
     if (isXwaylandClient(toplevel)) {
         // special case for XWayland windows
         source = QRect(toplevel->clientPos(), toplevel->clientSize());
         target = source;
     } else {
         source = pixmap->image().rect();
         target = toplevel->bufferGeometry().translated(-pos());
     }
     painter->drawImage(target, pixmap->image(), source);
 
     // render subsurfaces
     const auto &children = pixmap->children();
     for (auto pixmap : children) {
         if (pixmap->subSurface().isNull() || pixmap->subSurface()->surface().isNull() || !pixmap->subSurface()->surface()->isMapped()) {
             continue;
         }
         paintSubSurface(painter, bufferOffset(), static_cast<QPainterWindowPixmap*>(pixmap));
     }
 
     if (!opaque) {
         tempPainter.restore();
         tempPainter.setCompositionMode(QPainter::CompositionMode_DestinationIn);
         QColor translucent(Qt::transparent);
         translucent.setAlphaF(data.opacity());
         tempPainter.fillRect(QRect(QPoint(0, 0), toplevel->visibleRect().size()), translucent);
         tempPainter.end();
         painter = scenePainter;
         painter->drawImage(toplevel->visibleRect().topLeft() - toplevel->frameGeometry().topLeft(), tempImage);
     }
 
     painter->restore();
 }
 
 void SceneQPainter::Window::renderShadow(QPainter* painter)
 {
     if (!toplevel->shadow()) {
         return;
     }
     SceneQPainterShadow *shadow = static_cast<SceneQPainterShadow *>(toplevel->shadow());
 
     const QImage &shadowTexture = shadow->shadowTexture();
     const WindowQuadList &shadowQuads = shadow->shadowQuads();
 
     for (const auto &q : shadowQuads) {
         auto topLeft = q[0];
         auto bottomRight = q[2];
         QRectF target(topLeft.x(), topLeft.y(),
                       bottomRight.x() - topLeft.x(),
                       bottomRight.y() - topLeft.y());
         QRectF source(topLeft.textureX(), topLeft.textureY(),
                       bottomRight.textureX() - topLeft.textureX(),
                       bottomRight.textureY() - topLeft.textureY());
         painter->drawImage(target, shadowTexture, source);
     }
 }
 
 void SceneQPainter::Window::renderWindowDecorations(QPainter *painter)
 {
     // TODO: custom decoration opacity
     AbstractClient *client = dynamic_cast<AbstractClient*>(toplevel);
     Deleted *deleted = dynamic_cast<Deleted*>(toplevel);
     if (!client && !deleted) {
         return;
     }
 
     bool noBorder = true;
     const SceneQPainterDecorationRenderer *renderer = nullptr;
     QRect dtr, dlr, drr, dbr;
     if (client && !client->noBorder()) {
         if (client->isDecorated()) {
             if (SceneQPainterDecorationRenderer *r = static_cast<SceneQPainterDecorationRenderer *>(client->decoratedClient()->renderer())) {
                 r->render();
                 renderer = r;
             }
         }
         client->layoutDecorationRects(dlr, dtr, drr, dbr);
         noBorder = false;
     } else if (deleted && !deleted->noBorder()) {
         noBorder = false;
         deleted->layoutDecorationRects(dlr, dtr, drr, dbr);
         renderer = static_cast<const SceneQPainterDecorationRenderer *>(deleted->decorationRenderer());
     }
     if (noBorder || !renderer) {
         return;
     }
 
     painter->drawImage(dtr, renderer->image(SceneQPainterDecorationRenderer::DecorationPart::Top));
     painter->drawImage(dlr, renderer->image(SceneQPainterDecorationRenderer::DecorationPart::Left));
     painter->drawImage(drr, renderer->image(SceneQPainterDecorationRenderer::DecorationPart::Right));
     painter->drawImage(dbr, renderer->image(SceneQPainterDecorationRenderer::DecorationPart::Bottom));
 }
 
 WindowPixmap *SceneQPainter::Window::createWindowPixmap()
 {
     return new QPainterWindowPixmap(this);
 }
 
 Decoration::Renderer *SceneQPainter::createDecorationRenderer(Decoration::DecoratedClientImpl *impl)
 {
     return new SceneQPainterDecorationRenderer(impl);
 }
 
 //****************************************
 // QPainterWindowPixmap
 //****************************************
 QPainterWindowPixmap::QPainterWindowPixmap(Scene::Window *window)
     : WindowPixmap(window)
 {
 }
 
-QPainterWindowPixmap::QPainterWindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent)
+QPainterWindowPixmap::QPainterWindowPixmap(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface, WindowPixmap *parent)
     : WindowPixmap(subSurface, parent)
 {
 }
 
 QPainterWindowPixmap::~QPainterWindowPixmap()
 {
 }
 
 void QPainterWindowPixmap::create()
 {
     if (isValid()) {
         return;
     }
     KWin::WindowPixmap::create();
     if (!isValid()) {
         return;
     }
     if (!surface()) {
         // That's an internal client.
         m_image = internalImage();
         return;
     }
     // performing deep copy, this could probably be improved
     m_image = buffer()->data().copy();
     if (auto s = surface()) {
         s->resetTrackedDamage();
     }
 }
 
-WindowPixmap *QPainterWindowPixmap::createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface)
+WindowPixmap *QPainterWindowPixmap::createChild(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface)
 {
     return new QPainterWindowPixmap(subSurface, this);
 }
 
 void QPainterWindowPixmap::updateBuffer()
 {
     const auto oldBuffer = buffer();
     WindowPixmap::updateBuffer();
     const auto &b = buffer();
     if (!surface()) {
         // That's an internal client.
         m_image = internalImage();
         return;
     }
     if (b.isNull()) {
         m_image = QImage();
         return;
     }
     if (b == oldBuffer) {
         return;
     }
     // perform deep copy
     m_image = b->data().copy();
     if (auto s = surface()) {
         s->resetTrackedDamage();
     }
 }
 
 bool QPainterWindowPixmap::isValid() const
 {
     if (!m_image.isNull()) {
         return true;
     }
     return WindowPixmap::isValid();
 }
 
 QPainterEffectFrame::QPainterEffectFrame(EffectFrameImpl *frame, SceneQPainter *scene)
     : Scene::EffectFrame(frame)
     , m_scene(scene)
 {
 }
 
 QPainterEffectFrame::~QPainterEffectFrame()
 {
 }
 
 void QPainterEffectFrame::render(const QRegion &region, double opacity, double frameOpacity)
 {
     Q_UNUSED(region)
     Q_UNUSED(opacity)
     // TODO: adjust opacity
     if (m_effectFrame->geometry().isEmpty()) {
         return; // Nothing to display
     }
     QPainter *painter = m_scene->scenePainter();
 
 
     // Render the actual frame
     if (m_effectFrame->style() == EffectFrameUnstyled) {
         painter->save();
         painter->setPen(Qt::NoPen);
         QColor color(Qt::black);
         color.setAlphaF(frameOpacity);
         painter->setBrush(color);
         painter->setRenderHint(QPainter::Antialiasing);
         painter->drawRoundedRect(m_effectFrame->geometry().adjusted(-5, -5, 5, 5), 5.0, 5.0);
         painter->restore();
     } else if (m_effectFrame->style() == EffectFrameStyled) {
         qreal left, top, right, bottom;
         m_effectFrame->frame().getMargins(left, top, right, bottom);   // m_geometry is the inner geometry
         QRect geom = m_effectFrame->geometry().adjusted(-left, -top, right, bottom);
         painter->drawPixmap(geom, m_effectFrame->frame().framePixmap());
     }
     if (!m_effectFrame->selection().isNull()) {
         painter->drawPixmap(m_effectFrame->selection(), m_effectFrame->selectionFrame().framePixmap());
     }
 
     // Render icon
     if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
         const QPoint topLeft(m_effectFrame->geometry().x(),
                              m_effectFrame->geometry().center().y() - m_effectFrame->iconSize().height() / 2);
 
         const QRect geom = QRect(topLeft, m_effectFrame->iconSize());
         painter->drawPixmap(geom, m_effectFrame->icon().pixmap(m_effectFrame->iconSize()));
     }
 
     // Render text
     if (!m_effectFrame->text().isEmpty()) {
         // Determine position on texture to paint text
         QRect rect(QPoint(0, 0), m_effectFrame->geometry().size());
         if (!m_effectFrame->icon().isNull() && !m_effectFrame->iconSize().isEmpty()) {
             rect.setLeft(m_effectFrame->iconSize().width());
         }
 
         // If static size elide text as required
         QString text = m_effectFrame->text();
         if (m_effectFrame->isStatic()) {
             QFontMetrics metrics(m_effectFrame->text());
             text = metrics.elidedText(text, Qt::ElideRight, rect.width());
         }
 
         painter->save();
         painter->setFont(m_effectFrame->font());
         if (m_effectFrame->style() == EffectFrameStyled) {
             painter->setPen(m_effectFrame->styledTextColor());
         } else {
             // TODO: What about no frame? Custom color setting required
             painter->setPen(Qt::white);
         }
         painter->drawText(rect.translated(m_effectFrame->geometry().topLeft()), m_effectFrame->alignment(), text);
         painter->restore();
     }
 }
 
 //****************************************
 // QPainterShadow
 //****************************************
 SceneQPainterShadow::SceneQPainterShadow(Toplevel* toplevel)
     : Shadow(toplevel)
 {
 }
 
 SceneQPainterShadow::~SceneQPainterShadow()
 {
 }
 
 void SceneQPainterShadow::buildQuads()
 {
     // Do not draw shadows if window width or window height is less than
     // 5 px. 5 is an arbitrary choice.
     if (topLevel()->width() < 5 || topLevel()->height() < 5) {
         m_shadowQuads.clear();
         setShadowRegion(QRegion());
         return;
     }
 
     const QSizeF top(elementSize(ShadowElementTop));
     const QSizeF topRight(elementSize(ShadowElementTopRight));
     const QSizeF right(elementSize(ShadowElementRight));
     const QSizeF bottomRight(elementSize(ShadowElementBottomRight));
     const QSizeF bottom(elementSize(ShadowElementBottom));
     const QSizeF bottomLeft(elementSize(ShadowElementBottomLeft));
     const QSizeF left(elementSize(ShadowElementLeft));
     const QSizeF topLeft(elementSize(ShadowElementTopLeft));
 
     const QRectF outerRect(QPointF(-leftOffset(), -topOffset()),
                            QPointF(topLevel()->width() + rightOffset(),
                                    topLevel()->height() + bottomOffset()));
 
     const int width = std::max({topLeft.width(), left.width(), bottomLeft.width()})
                     + std::max(top.width(), bottom.width())
                     + std::max({topRight.width(), right.width(), bottomRight.width()});
     const int height = std::max({topLeft.height(), top.height(), topRight.height()})
                      + std::max(left.height(), right.height())
                      + std::max({bottomLeft.height(), bottom.height(), bottomRight.height()});
 
     QRectF topLeftRect(outerRect.topLeft(), topLeft);
     QRectF topRightRect(outerRect.topRight() - QPointF(topRight.width(), 0), topRight);
     QRectF bottomRightRect(
         outerRect.bottomRight() - QPointF(bottomRight.width(), bottomRight.height()),
         bottomRight);
     QRectF bottomLeftRect(outerRect.bottomLeft() - QPointF(0, bottomLeft.height()), bottomLeft);
 
     // Re-distribute the corner tiles so no one of them is overlapping with others.
     // By doing this, we assume that shadow's corner tiles are symmetric
     // and it is OK to not draw top/right/bottom/left tile between corners.
     // For example, let's say top-left and top-right tiles are overlapping.
     // In that case, the right side of the top-left tile will be shifted to left,
     // the left side of the top-right tile will shifted to right, and the top
     // tile won't be rendered.
     bool drawTop = true;
     if (topLeftRect.right() >= topRightRect.left()) {
         const float halfOverlap = qAbs(topLeftRect.right() - topRightRect.left()) / 2;
         topLeftRect.setRight(topLeftRect.right() - std::floor(halfOverlap));
         topRightRect.setLeft(topRightRect.left() + std::ceil(halfOverlap));
         drawTop = false;
     }
 
     bool drawRight = true;
     if (topRightRect.bottom() >= bottomRightRect.top()) {
         const float halfOverlap = qAbs(topRightRect.bottom() - bottomRightRect.top()) / 2;
         topRightRect.setBottom(topRightRect.bottom() - std::floor(halfOverlap));
         bottomRightRect.setTop(bottomRightRect.top() + std::ceil(halfOverlap));
         drawRight = false;
     }
 
     bool drawBottom = true;
     if (bottomLeftRect.right() >= bottomRightRect.left()) {
         const float halfOverlap = qAbs(bottomLeftRect.right() - bottomRightRect.left()) / 2;
         bottomLeftRect.setRight(bottomLeftRect.right() - std::floor(halfOverlap));
         bottomRightRect.setLeft(bottomRightRect.left() + std::ceil(halfOverlap));
         drawBottom = false;
     }
 
     bool drawLeft = true;
     if (topLeftRect.bottom() >= bottomLeftRect.top()) {
         const float halfOverlap = qAbs(topLeftRect.bottom() - bottomLeftRect.top()) / 2;
         topLeftRect.setBottom(topLeftRect.bottom() - std::floor(halfOverlap));
         bottomLeftRect.setTop(bottomLeftRect.top() + std::ceil(halfOverlap));
         drawLeft = false;
     }
 
     qreal tx1 = 0.0,
           tx2 = 0.0,
           ty1 = 0.0,
           ty2 = 0.0;
 
     m_shadowQuads.clear();
 
     tx1 = 0.0;
     ty1 = 0.0;
     tx2 = topLeftRect.width();
     ty2 = topLeftRect.height();
     WindowQuad topLeftQuad(WindowQuadShadow);
     topLeftQuad[0] = WindowVertex(topLeftRect.left(),  topLeftRect.top(),    tx1, ty1);
     topLeftQuad[1] = WindowVertex(topLeftRect.right(), topLeftRect.top(),    tx2, ty1);
     topLeftQuad[2] = WindowVertex(topLeftRect.right(), topLeftRect.bottom(), tx2, ty2);
     topLeftQuad[3] = WindowVertex(topLeftRect.left(),  topLeftRect.bottom(), tx1, ty2);
     m_shadowQuads.append(topLeftQuad);
 
     tx1 = width - topRightRect.width();
     ty1 = 0.0;
     tx2 = width;
     ty2 = topRightRect.height();
     WindowQuad topRightQuad(WindowQuadShadow);
     topRightQuad[0] = WindowVertex(topRightRect.left(),  topRightRect.top(),    tx1, ty1);
     topRightQuad[1] = WindowVertex(topRightRect.right(), topRightRect.top(),    tx2, ty1);
     topRightQuad[2] = WindowVertex(topRightRect.right(), topRightRect.bottom(), tx2, ty2);
     topRightQuad[3] = WindowVertex(topRightRect.left(),  topRightRect.bottom(), tx1, ty2);
     m_shadowQuads.append(topRightQuad);
 
     tx1 = width - bottomRightRect.width();
     tx2 = width;
     ty1 = height - bottomRightRect.height();
     ty2 = height;
     WindowQuad bottomRightQuad(WindowQuadShadow);
     bottomRightQuad[0] = WindowVertex(bottomRightRect.left(),  bottomRightRect.top(),    tx1, ty1);
     bottomRightQuad[1] = WindowVertex(bottomRightRect.right(), bottomRightRect.top(),    tx2, ty1);
     bottomRightQuad[2] = WindowVertex(bottomRightRect.right(), bottomRightRect.bottom(), tx2, ty2);
     bottomRightQuad[3] = WindowVertex(bottomRightRect.left(),  bottomRightRect.bottom(), tx1, ty2);
     m_shadowQuads.append(bottomRightQuad);
 
     tx1 = 0.0;
     tx2 = bottomLeftRect.width();
     ty1 = height - bottomLeftRect.height();
     ty2 = height;
     WindowQuad bottomLeftQuad(WindowQuadShadow);
     bottomLeftQuad[0] = WindowVertex(bottomLeftRect.left(),  bottomLeftRect.top(),    tx1, ty1);
     bottomLeftQuad[1] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.top(),    tx2, ty1);
     bottomLeftQuad[2] = WindowVertex(bottomLeftRect.right(), bottomLeftRect.bottom(), tx2, ty2);
     bottomLeftQuad[3] = WindowVertex(bottomLeftRect.left(),  bottomLeftRect.bottom(), tx1, ty2);
     m_shadowQuads.append(bottomLeftQuad);
 
     if (drawTop) {
         QRectF topRect(
             topLeftRect.topRight(),
             topRightRect.bottomLeft());
         tx1 = topLeft.width();
         ty1 = 0.0;
         tx2 = width - topRight.width();
         ty2 = topRect.height();
         WindowQuad topQuad(WindowQuadShadow);
         topQuad[0] = WindowVertex(topRect.left(),  topRect.top(),    tx1, ty1);
         topQuad[1] = WindowVertex(topRect.right(), topRect.top(),    tx2, ty1);
         topQuad[2] = WindowVertex(topRect.right(), topRect.bottom(), tx2, ty2);
         topQuad[3] = WindowVertex(topRect.left(),  topRect.bottom(), tx1, ty2);
         m_shadowQuads.append(topQuad);
     }
 
     if (drawRight) {
         QRectF rightRect(
             topRightRect.bottomLeft(),
             bottomRightRect.topRight());
         tx1 = width - rightRect.width();
         ty1 = topRight.height();
         tx2 = width;
         ty2 = height - bottomRight.height();
         WindowQuad rightQuad(WindowQuadShadow);
         rightQuad[0] = WindowVertex(rightRect.left(),  rightRect.top(),    tx1, ty1);
         rightQuad[1] = WindowVertex(rightRect.right(), rightRect.top(),    tx2, ty1);
         rightQuad[2] = WindowVertex(rightRect.right(), rightRect.bottom(), tx2, ty2);
         rightQuad[3] = WindowVertex(rightRect.left(),  rightRect.bottom(), tx1, ty2);
         m_shadowQuads.append(rightQuad);
     }
 
     if (drawBottom) {
         QRectF bottomRect(
             bottomLeftRect.topRight(),
             bottomRightRect.bottomLeft());
         tx1 = bottomLeft.width();
         ty1 = height - bottomRect.height();
         tx2 = width - bottomRight.width();
         ty2 = height;
         WindowQuad bottomQuad(WindowQuadShadow);
         bottomQuad[0] = WindowVertex(bottomRect.left(),  bottomRect.top(),    tx1, ty1);
         bottomQuad[1] = WindowVertex(bottomRect.right(), bottomRect.top(),    tx2, ty1);
         bottomQuad[2] = WindowVertex(bottomRect.right(), bottomRect.bottom(), tx2, ty2);
         bottomQuad[3] = WindowVertex(bottomRect.left(),  bottomRect.bottom(), tx1, ty2);
         m_shadowQuads.append(bottomQuad);
     }
 
     if (drawLeft) {
         QRectF leftRect(
             topLeftRect.bottomLeft(),
             bottomLeftRect.topRight());
         tx1 = 0.0;
         ty1 = topLeft.height();
         tx2 = leftRect.width();
         ty2 = height - bottomRight.height();
         WindowQuad leftQuad(WindowQuadShadow);
         leftQuad[0] = WindowVertex(leftRect.left(),  leftRect.top(),    tx1, ty1);
         leftQuad[1] = WindowVertex(leftRect.right(), leftRect.top(),    tx2, ty1);
         leftQuad[2] = WindowVertex(leftRect.right(), leftRect.bottom(), tx2, ty2);
         leftQuad[3] = WindowVertex(leftRect.left(),  leftRect.bottom(), tx1, ty2);
         m_shadowQuads.append(leftQuad);
     }
 }
 
 bool SceneQPainterShadow::prepareBackend()
 {
     if (hasDecorationShadow()) {
         m_texture = decorationShadowImage();
         return true;
     }
 
     const QPixmap &topLeft     = shadowPixmap(ShadowElementTopLeft);
     const QPixmap &top         = shadowPixmap(ShadowElementTop);
     const QPixmap &topRight    = shadowPixmap(ShadowElementTopRight);
     const QPixmap &bottomLeft  = shadowPixmap(ShadowElementBottomLeft);
     const QPixmap &bottom      = shadowPixmap(ShadowElementBottom);
     const QPixmap &bottomRight = shadowPixmap(ShadowElementBottomRight);
     const QPixmap &left        = shadowPixmap(ShadowElementLeft);
     const QPixmap &right       = shadowPixmap(ShadowElementRight);
 
     const int width = std::max({topLeft.width(), left.width(), bottomLeft.width()})
                     + std::max(top.width(), bottom.width())
                     + std::max({topRight.width(), right.width(), bottomRight.width()});
     const int height = std::max({topLeft.height(), top.height(), topRight.height()})
                      + std::max(left.height(), right.height())
                      + std::max({bottomLeft.height(), bottom.height(), bottomRight.height()});
 
     if (width == 0 || height == 0) {
         return false;
     }
 
     QImage image(width, height, QImage::Format_ARGB32_Premultiplied);
     image.fill(Qt::transparent);
 
     QPainter painter;
     painter.begin(&image);
     painter.drawPixmap(0, 0, topLeft);
     painter.drawPixmap(topLeft.width(), 0, top);
     painter.drawPixmap(width - topRight.width(), 0, topRight);
     painter.drawPixmap(0, height - bottomLeft.height(), bottomLeft);
     painter.drawPixmap(bottomLeft.width(), height - bottom.height(), bottom);
     painter.drawPixmap(width - bottomRight.width(), height - bottomRight.height(), bottomRight);
     painter.drawPixmap(0, topLeft.height(), left);
     painter.drawPixmap(width - right.width(), topRight.height(), right);
     painter.end();
 
     m_texture = image;
 
     return true;
 }
 
 //****************************************
 // QPainterDecorationRenderer
 //****************************************
 SceneQPainterDecorationRenderer::SceneQPainterDecorationRenderer(Decoration::DecoratedClientImpl *client)
     : Renderer(client)
 {
     connect(this, &Renderer::renderScheduled, client->client(), static_cast<void (AbstractClient::*)(const QRect&)>(&AbstractClient::addRepaint));
 }
 
 SceneQPainterDecorationRenderer::~SceneQPainterDecorationRenderer() = default;
 
 QImage SceneQPainterDecorationRenderer::image(SceneQPainterDecorationRenderer::DecorationPart part) const
 {
     Q_ASSERT(part != DecorationPart::Count);
     return m_images[int(part)];
 }
 
 void SceneQPainterDecorationRenderer::render()
 {
     const QRegion scheduled = getScheduled();
     if (scheduled.isEmpty()) {
         return;
     }
     if (areImageSizesDirty()) {
         resizeImages();
         resetImageSizesDirty();
     }
 
     auto imageSize = [this](DecorationPart part) {
         return m_images[int(part)].size() / m_images[int(part)].devicePixelRatio();
     };
 
     const QRect top(QPoint(0, 0), imageSize(DecorationPart::Top));
     const QRect left(QPoint(0, top.height()), imageSize(DecorationPart::Left));
     const QRect right(QPoint(top.width() - imageSize(DecorationPart::Right).width(), top.height()), imageSize(DecorationPart::Right));
     const QRect bottom(QPoint(0, left.y() + left.height()), imageSize(DecorationPart::Bottom));
 
     const QRect geometry = scheduled.boundingRect();
     auto renderPart = [this](const QRect &rect, const QRect &partRect, int index) {
         if (rect.isEmpty()) {
             return;
         }
         QPainter painter(&m_images[index]);
         painter.setRenderHint(QPainter::Antialiasing);
         painter.setWindow(QRect(partRect.topLeft(), partRect.size() * m_images[index].devicePixelRatio()));
         painter.setClipRect(rect);
         painter.save();
         // clear existing part
         painter.setCompositionMode(QPainter::CompositionMode_Source);
         painter.fillRect(rect, Qt::transparent);
         painter.restore();
         client()->decoration()->paint(&painter, rect);
     };
 
     renderPart(left.intersected(geometry), left, int(DecorationPart::Left));
     renderPart(top.intersected(geometry), top, int(DecorationPart::Top));
     renderPart(right.intersected(geometry), right, int(DecorationPart::Right));
     renderPart(bottom.intersected(geometry), bottom, int(DecorationPart::Bottom));
 }
 
 void SceneQPainterDecorationRenderer::resizeImages()
 {
     QRect left, top, right, bottom;
     client()->client()->layoutDecorationRects(left, top, right, bottom);
 
     auto checkAndCreate = [this](int index, const QSize &size) {
         auto dpr = client()->client()->screenScale();
         if (m_images[index].size() != size * dpr ||
             m_images[index].devicePixelRatio() != dpr)
         {
             m_images[index] = QImage(size * dpr, QImage::Format_ARGB32_Premultiplied);
             m_images[index].setDevicePixelRatio(dpr);
             m_images[index].fill(Qt::transparent);
         }
     };
     checkAndCreate(int(DecorationPart::Left), left.size());
     checkAndCreate(int(DecorationPart::Right), right.size());
     checkAndCreate(int(DecorationPart::Top), top.size());
     checkAndCreate(int(DecorationPart::Bottom), bottom.size());
 }
 
 void SceneQPainterDecorationRenderer::reparent(Deleted *deleted)
 {
     render();
     Renderer::reparent(deleted);
 }
 
 
 QPainterFactory::QPainterFactory(QObject *parent)
     : SceneFactory(parent)
 {
 }
 
 QPainterFactory::~QPainterFactory() = default;
 
 Scene *QPainterFactory::create(QObject *parent) const
 {
     auto s = SceneQPainter::createScene(parent);
     if (s && s->initFailed()) {
         delete s;
         s = nullptr;
     }
     return s;
 }
 
 } // KWin
diff --git a/plugins/scenes/qpainter/scene_qpainter.h b/plugins/scenes/qpainter/scene_qpainter.h
index 94f7adb23..9e325499e 100644
--- a/plugins/scenes/qpainter/scene_qpainter.h
+++ b/plugins/scenes/qpainter/scene_qpainter.h
@@ -1,203 +1,203 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_SCENE_QPAINTER_H
 #define KWIN_SCENE_QPAINTER_H
 
 #include "scene.h"
 #include <platformsupport/scenes/qpainter/backend.h>
 #include "shadow.h"
 
 #include "decorations/decorationrenderer.h"
 
 namespace KWin {
 
 class KWIN_EXPORT SceneQPainter : public Scene
 {
     Q_OBJECT
 
 public:
     ~SceneQPainter() override;
     bool usesOverlayWindow() const override;
     OverlayWindow* overlayWindow() const override;
     qint64 paint(const QRegion &damage, const QList<Toplevel *> &windows) override;
     void paintGenericScreen(int mask, const ScreenPaintData &data) override;
     CompositingType compositingType() const override;
     bool initFailed() const override;
     EffectFrame *createEffectFrame(EffectFrameImpl *frame) override;
     Shadow *createShadow(Toplevel *toplevel) override;
     Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *impl) override;
     void screenGeometryChanged(const QSize &size) override;
 
     bool animationsSupported() const override {
         return false;
     }
 
     QPainter *scenePainter() const override;
     QImage *qpainterRenderBuffer() const override;
 
     QPainterBackend *backend() const {
         return m_backend.data();
     }
 
     static SceneQPainter *createScene(QObject *parent);
 
 protected:
     void paintBackground(const QRegion &region) override;
     Scene::Window *createWindow(Toplevel *toplevel) override;
     void paintCursor() override;
     void paintEffectQuickView(EffectQuickView *w) override;
 
 private:
     explicit SceneQPainter(QPainterBackend *backend, QObject *parent = nullptr);
     QScopedPointer<QPainterBackend> m_backend;
     QScopedPointer<QPainter> m_painter;
     class Window;
 };
 
 class SceneQPainter::Window : public Scene::Window
 {
 public:
     Window(SceneQPainter *scene, Toplevel *c);
     ~Window() override;
     void performPaint(int mask, const QRegion &region, const WindowPaintData &data) override;
 protected:
     WindowPixmap *createWindowPixmap() override;
 private:
     void renderShadow(QPainter *painter);
     void renderWindowDecorations(QPainter *painter);
     SceneQPainter *m_scene;
 };
 
 class QPainterWindowPixmap : public WindowPixmap
 {
 public:
     explicit QPainterWindowPixmap(Scene::Window *window);
     ~QPainterWindowPixmap() override;
     void create() override;
     bool isValid() const override;
 
     void updateBuffer() override;
     const QImage &image();
 
 protected:
-    WindowPixmap *createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface) override;
+    WindowPixmap *createChild(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface) override;
 private:
-    explicit QPainterWindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent);
+    explicit QPainterWindowPixmap(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface, WindowPixmap *parent);
     QImage m_image;
 };
 
 class QPainterEffectFrame : public Scene::EffectFrame
 {
 public:
     QPainterEffectFrame(EffectFrameImpl *frame, SceneQPainter *scene);
     ~QPainterEffectFrame() override;
     void crossFadeIcon() override {}
     void crossFadeText() override {}
     void free() override {}
     void freeIconFrame() override {}
     void freeTextFrame() override {}
     void freeSelection() override {}
     void render(const QRegion &region, double opacity, double frameOpacity) override;
 private:
     SceneQPainter *m_scene;
 };
 
 class SceneQPainterShadow : public Shadow
 {
 public:
     SceneQPainterShadow(Toplevel* toplevel);
     ~SceneQPainterShadow() override;
 
     QImage &shadowTexture() {
         return m_texture;
     }
 
 protected:
     void buildQuads() override;
     bool prepareBackend() override;
 
 private:
     QImage m_texture;
 };
 
 class SceneQPainterDecorationRenderer : public Decoration::Renderer
 {
     Q_OBJECT
 public:
     enum class DecorationPart : int {
         Left,
         Top,
         Right,
         Bottom,
         Count
     };
     explicit SceneQPainterDecorationRenderer(Decoration::DecoratedClientImpl *client);
     ~SceneQPainterDecorationRenderer() override;
 
     void render() override;
     void reparent(Deleted *deleted) override;
 
     QImage image(DecorationPart part) const;
 
 private:
     void resizeImages();
     QImage m_images[int(DecorationPart::Count)];
 };
 
 class KWIN_EXPORT QPainterFactory : public SceneFactory
 {
     Q_OBJECT
     Q_INTERFACES(KWin::SceneFactory)
     Q_PLUGIN_METADATA(IID "org.kde.kwin.Scene" FILE "qpainter.json")
 
 public:
     explicit QPainterFactory(QObject *parent = nullptr);
     ~QPainterFactory() override;
 
     Scene *create(QObject *parent = nullptr) const override;
 };
 
 inline
 bool SceneQPainter::usesOverlayWindow() const
 {
     return m_backend->usesOverlayWindow();
 }
 
 inline
 OverlayWindow* SceneQPainter::overlayWindow() const
 {
     return m_backend->overlayWindow();
 }
 
 inline
 QPainter* SceneQPainter::scenePainter() const
 {
     return m_painter.data();
 }
 
 inline
 const QImage &QPainterWindowPixmap::image()
 {
     return m_image;
 }
 
 } // KWin
 
 #endif // KWIN_SCENEQPAINTER_H
diff --git a/pointer_input.cpp b/pointer_input.cpp
index 2d3a29b6a..ed4b1e464 100644
--- a/pointer_input.cpp
+++ b/pointer_input.cpp
@@ -1,1468 +1,1468 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "pointer_input.h"
 #include "platform.h"
 #include "x11client.h"
 #include "effects.h"
 #include "input_event.h"
 #include "input_event_spy.h"
 #include "osd.h"
 #include "screens.h"
 #include "wayland_cursor_theme.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "decorations/decoratedclient.h"
 // KDecoration
 #include <KDecoration2/Decoration>
 // KWayland
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/buffer.h>
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/pointerconstraints_interface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/pointerconstraints_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/surface_interface.h>
 // screenlocker
 #include <KScreenLocker/KsldApp>
 
 #include <KLocalizedString>
 
 #include <QHoverEvent>
 #include <QWindow>
 #include <QPainter>
 // Wayland
 #include <wayland-cursor.h>
 
 #include <linux/input.h>
 
 namespace KWin
 {
 
 static const QHash<uint32_t, Qt::MouseButton> s_buttonToQtMouseButton = {
     { BTN_LEFT , Qt::LeftButton },
     { BTN_MIDDLE , Qt::MiddleButton },
     { BTN_RIGHT , Qt::RightButton },
     // in QtWayland mapped like that
     { BTN_SIDE , Qt::ExtraButton1 },
     // in QtWayland mapped like that
     { BTN_EXTRA , Qt::ExtraButton2 },
     { BTN_BACK , Qt::BackButton },
     { BTN_FORWARD , Qt::ForwardButton },
     { BTN_TASK , Qt::TaskButton },
     // mapped like that in QtWayland
     { 0x118 , Qt::ExtraButton6 },
     { 0x119 , Qt::ExtraButton7 },
     { 0x11a , Qt::ExtraButton8 },
     { 0x11b , Qt::ExtraButton9 },
     { 0x11c , Qt::ExtraButton10 },
     { 0x11d , Qt::ExtraButton11 },
     { 0x11e , Qt::ExtraButton12 },
     { 0x11f , Qt::ExtraButton13 },
 };
 
 uint32_t qtMouseButtonToButton(Qt::MouseButton button)
 {
     return s_buttonToQtMouseButton.key(button);
 }
 
 static Qt::MouseButton buttonToQtMouseButton(uint32_t button)
 {
     // all other values get mapped to ExtraButton24
     // this is actually incorrect but doesn't matter in our usage
     // KWin internally doesn't use these high extra buttons anyway
     // it's only needed for recognizing whether buttons are pressed
     // if multiple buttons are mapped to the value the evaluation whether
     // buttons are pressed is correct and that's all we care about.
     return s_buttonToQtMouseButton.value(button, Qt::ExtraButton24);
 }
 
 static bool screenContainsPos(const QPointF &pos)
 {
     for (int i = 0; i < screens()->count(); ++i) {
         if (screens()->geometry(i).contains(pos.toPoint())) {
             return true;
         }
     }
     return false;
 }
 
 static QPointF confineToBoundingBox(const QPointF &pos, const QRectF &boundingBox)
 {
     return QPointF(
         qBound(boundingBox.left(), pos.x(), boundingBox.right() - 1.0),
         qBound(boundingBox.top(), pos.y(), boundingBox.bottom() - 1.0)
     );
 }
 
 PointerInputRedirection::PointerInputRedirection(InputRedirection* parent)
     : InputDeviceHandler(parent)
     , m_cursor(nullptr)
     , m_supportsWarping(Application::usesLibinput())
 {
 }
 
 PointerInputRedirection::~PointerInputRedirection() = default;
 
 void PointerInputRedirection::init()
 {
     Q_ASSERT(!inited());
     m_cursor = new CursorImage(this);
     setInited(true);
     InputDeviceHandler::init();
 
     connect(m_cursor, &CursorImage::changed, Cursors::self()->mouse(), [this] {
         auto cursor = Cursors::self()->mouse();
         cursor->updateCursor(m_cursor->image(), m_cursor->hotSpot());
     });
     emit m_cursor->changed();
 
     connect(Cursors::self()->mouse(), &Cursor::rendered, m_cursor, &CursorImage::markAsRendered);
 
     connect(screens(), &Screens::changed, this, &PointerInputRedirection::updateAfterScreenChange);
     if (waylandServer()->hasScreenLockerIntegration()) {
         connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this,
             [this] {
                 waylandServer()->seat()->cancelPointerPinchGesture();
                 waylandServer()->seat()->cancelPointerSwipeGesture();
                 update();
             }
         );
     }
     connect(workspace(), &QObject::destroyed, this, [this] { setInited(false); });
     connect(waylandServer(), &QObject::destroyed, this, [this] { setInited(false); });
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this,
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::dragEnded, this,
         [this] {
             // need to force a focused pointer change
             waylandServer()->seat()->setFocusedPointerSurface(nullptr);
             setFocus(nullptr);
             update();
         }
     );
     // connect the move resize of all window
     auto setupMoveResizeConnection = [this] (AbstractClient *c) {
         connect(c, &AbstractClient::clientStartUserMovedResized, this, &PointerInputRedirection::updateOnStartMoveResize);
         connect(c, &AbstractClient::clientFinishUserMovedResized, this, &PointerInputRedirection::update);
     };
     const auto clients = workspace()->allClientList();
     std::for_each(clients.begin(), clients.end(), setupMoveResizeConnection);
     connect(workspace(), &Workspace::clientAdded, this, setupMoveResizeConnection);
     connect(waylandServer(), &WaylandServer::shellClientAdded, this, setupMoveResizeConnection);
 
     // warp the cursor to center of screen
     warp(screens()->geometry().center());
     updateAfterScreenChange();
 }
 
 void PointerInputRedirection::updateOnStartMoveResize()
 {
     breakPointerConstraints(focus() ? focus()->surface() : nullptr);
     disconnectPointerConstraintsConnection();
     setFocus(nullptr);
     waylandServer()->seat()->setFocusedPointerSurface(nullptr);
 }
 
 void PointerInputRedirection::updateToReset()
 {
     if (internalWindow()) {
         disconnect(m_internalWindowConnection);
         m_internalWindowConnection = QMetaObject::Connection();
         QEvent event(QEvent::Leave);
         QCoreApplication::sendEvent(internalWindow().data(), &event);
         setInternalWindow(nullptr);
     }
     if (decoration()) {
         QHoverEvent event(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::instance()->sendEvent(decoration()->decoration(), &event);
         setDecoration(nullptr);
     }
     if (focus()) {
         if (AbstractClient *c = qobject_cast<AbstractClient*>(focus().data())) {
             c->leaveEvent();
         }
         disconnect(m_focusGeometryConnection);
         m_focusGeometryConnection = QMetaObject::Connection();
         breakPointerConstraints(focus()->surface());
         disconnectPointerConstraintsConnection();
         setFocus(nullptr);
     }
     waylandServer()->seat()->setFocusedPointerSurface(nullptr);
 }
 
 void PointerInputRedirection::processMotion(const QPointF &pos, uint32_t time, LibInput::Device *device)
 {
     processMotion(pos, QSizeF(), QSizeF(), time, 0, device);
 }
 
 class PositionUpdateBlocker
 {
 public:
     PositionUpdateBlocker(PointerInputRedirection *pointer)
         : m_pointer(pointer)
     {
         s_counter++;
     }
     ~PositionUpdateBlocker() {
         s_counter--;
         if (s_counter == 0) {
             if (!s_scheduledPositions.isEmpty()) {
                 const auto pos = s_scheduledPositions.takeFirst();
                 m_pointer->processMotion(pos.pos, pos.delta, pos.deltaNonAccelerated, pos.time, pos.timeUsec, nullptr);
             }
         }
     }
 
     static bool isPositionBlocked() {
         return s_counter > 0;
     }
 
     static void schedulePosition(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec) {
         s_scheduledPositions.append({pos, delta, deltaNonAccelerated, time, timeUsec});
     }
 
 private:
     static int s_counter;
     struct ScheduledPosition {
         QPointF pos;
         QSizeF delta;
         QSizeF deltaNonAccelerated;
         quint32 time;
         quint64 timeUsec;
     };
     static QVector<ScheduledPosition> s_scheduledPositions;
 
     PointerInputRedirection *m_pointer;
 };
 
 int PositionUpdateBlocker::s_counter = 0;
 QVector<PositionUpdateBlocker::ScheduledPosition> PositionUpdateBlocker::s_scheduledPositions;
 
 void PointerInputRedirection::processMotion(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec, LibInput::Device *device)
 {
     if (!inited()) {
         return;
     }
     if (PositionUpdateBlocker::isPositionBlocked()) {
         PositionUpdateBlocker::schedulePosition(pos, delta, deltaNonAccelerated, time, timeUsec);
         return;
     }
 
     PositionUpdateBlocker blocker(this);
     updatePosition(pos);
     MouseEvent event(QEvent::MouseMove, m_pos, Qt::NoButton, m_qtButtons,
                      input()->keyboardModifiers(), time,
                      delta, deltaNonAccelerated, timeUsec, device);
     event.setModifiersRelevantForGlobalShortcuts(input()->modifiersRelevantForGlobalShortcuts());
 
     update();
     input()->processSpies(std::bind(&InputEventSpy::pointerEvent, std::placeholders::_1, &event));
     input()->processFilters(std::bind(&InputEventFilter::pointerEvent, std::placeholders::_1, &event, 0));
 }
 
 void PointerInputRedirection::processButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time, LibInput::Device *device)
 {
     QEvent::Type type;
     switch (state) {
     case InputRedirection::PointerButtonReleased:
         type = QEvent::MouseButtonRelease;
         break;
     case InputRedirection::PointerButtonPressed:
         type = QEvent::MouseButtonPress;
         update();
         break;
     default:
         Q_UNREACHABLE();
         return;
     }
 
     updateButton(button, state);
 
     MouseEvent event(type, m_pos, buttonToQtMouseButton(button), m_qtButtons,
                      input()->keyboardModifiers(), time, QSizeF(), QSizeF(), 0, device);
     event.setModifiersRelevantForGlobalShortcuts(input()->modifiersRelevantForGlobalShortcuts());
     event.setNativeButton(button);
 
     input()->processSpies(std::bind(&InputEventSpy::pointerEvent, std::placeholders::_1, &event));
 
     if (!inited()) {
         return;
     }
 
     input()->processFilters(std::bind(&InputEventFilter::pointerEvent, std::placeholders::_1, &event, button));
 
     if (state == InputRedirection::PointerButtonReleased) {
         update();
     }
 }
 
 void PointerInputRedirection::processAxis(InputRedirection::PointerAxis axis, qreal delta, qint32 discreteDelta,
     InputRedirection::PointerAxisSource source, uint32_t time, LibInput::Device *device)
 {
     update();
 
     emit input()->pointerAxisChanged(axis, delta);
 
     WheelEvent wheelEvent(m_pos, delta, discreteDelta,
                            (axis == InputRedirection::PointerAxisHorizontal) ? Qt::Horizontal : Qt::Vertical,
                            m_qtButtons, input()->keyboardModifiers(), source, time, device);
     wheelEvent.setModifiersRelevantForGlobalShortcuts(input()->modifiersRelevantForGlobalShortcuts());
 
     input()->processSpies(std::bind(&InputEventSpy::wheelEvent, std::placeholders::_1, &wheelEvent));
 
     if (!inited()) {
         return;
     }
     input()->processFilters(std::bind(&InputEventFilter::wheelEvent, std::placeholders::_1, &wheelEvent));
 }
 
 void PointerInputRedirection::processSwipeGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureBegin, std::placeholders::_1, fingerCount, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureBegin, std::placeholders::_1, fingerCount, time));
 }
 
 void PointerInputRedirection::processSwipeGestureUpdate(const QSizeF &delta, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureUpdate, std::placeholders::_1, delta, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureUpdate, std::placeholders::_1, delta, time));
 }
 
 void PointerInputRedirection::processSwipeGestureEnd(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureEnd, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureEnd, std::placeholders::_1, time));
 }
 
 void PointerInputRedirection::processSwipeGestureCancelled(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::swipeGestureCancelled, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::swipeGestureCancelled, std::placeholders::_1, time));
 }
 
 void PointerInputRedirection::processPinchGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureBegin, std::placeholders::_1, fingerCount, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureBegin, std::placeholders::_1, fingerCount, time));
 }
 
 void PointerInputRedirection::processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureUpdate, std::placeholders::_1, scale, angleDelta, delta, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureUpdate, std::placeholders::_1, scale, angleDelta, delta, time));
 }
 
 void PointerInputRedirection::processPinchGestureEnd(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureEnd, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureEnd, std::placeholders::_1, time));
 }
 
 void PointerInputRedirection::processPinchGestureCancelled(quint32 time, KWin::LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     update();
 
     input()->processSpies(std::bind(&InputEventSpy::pinchGestureCancelled, std::placeholders::_1, time));
     input()->processFilters(std::bind(&InputEventFilter::pinchGestureCancelled, std::placeholders::_1, time));
 }
 
 bool PointerInputRedirection::areButtonsPressed() const
 {
     for (auto state : m_buttons) {
         if (state == InputRedirection::PointerButtonPressed) {
             return true;
         }
     }
     return false;
 }
 
 bool PointerInputRedirection::focusUpdatesBlocked()
 {
     if (!inited()) {
         return true;
     }
     if (waylandServer()->seat()->isDragPointer()) {
         // ignore during drag and drop
         return true;
     }
     if (waylandServer()->seat()->isTouchSequence()) {
         // ignore during touch operations
         return true;
     }
     if (input()->isSelectingWindow()) {
         return true;
     }
     if (areButtonsPressed()) {
         return true;
     }
     return false;
 }
 
 void PointerInputRedirection::cleanupInternalWindow(QWindow *old, QWindow *now)
 {
     disconnect(m_internalWindowConnection);
     m_internalWindowConnection = QMetaObject::Connection();
 
     if (old) {
         // leave internal window
         QEvent leaveEvent(QEvent::Leave);
         QCoreApplication::sendEvent(old, &leaveEvent);
     }
 
     if (now) {
         m_internalWindowConnection = connect(internalWindow().data(), &QWindow::visibleChanged, this,
             [this] (bool visible) {
                 if (!visible) {
                     update();
                 }
             }
         );
     }
 }
 
 void PointerInputRedirection::cleanupDecoration(Decoration::DecoratedClientImpl *old, Decoration::DecoratedClientImpl *now)
 {
     disconnect(m_decorationGeometryConnection);
     m_decorationGeometryConnection = QMetaObject::Connection();
     workspace()->updateFocusMousePosition(position().toPoint());
 
     if (old) {
         // send leave event to old decoration
         QHoverEvent event(QEvent::HoverLeave, QPointF(), QPointF());
         QCoreApplication::instance()->sendEvent(old->decoration(), &event);
     }
     if (!now) {
         // left decoration
         return;
     }
 
     waylandServer()->seat()->setFocusedPointerSurface(nullptr);
 
     auto pos = m_pos - now->client()->pos();
     QHoverEvent event(QEvent::HoverEnter, pos, pos);
     QCoreApplication::instance()->sendEvent(now->decoration(), &event);
     now->client()->processDecorationMove(pos.toPoint(), m_pos.toPoint());
 
     m_decorationGeometryConnection = connect(decoration()->client(), &AbstractClient::frameGeometryChanged, this,
         [this] {
             // ensure maximize button gets the leave event when maximizing/restore a window, see BUG 385140
             const auto oldDeco = decoration();
             update();
             if (oldDeco &&
                     oldDeco == decoration() &&
                     !decoration()->client()->isMove() &&
                     !decoration()->client()->isResize() &&
                     !areButtonsPressed()) {
                 // position of window did not change, we need to send HoverMotion manually
                 const QPointF p = m_pos - decoration()->client()->pos();
                 QHoverEvent event(QEvent::HoverMove, p, p);
                 QCoreApplication::instance()->sendEvent(decoration()->decoration(), &event);
             }
         }, Qt::QueuedConnection);
 }
 
 static bool s_cursorUpdateBlocking = false;
 
 void PointerInputRedirection::focusUpdate(Toplevel *focusOld, Toplevel *focusNow)
 {
     if (AbstractClient *ac = qobject_cast<AbstractClient*>(focusOld)) {
         ac->leaveEvent();
         breakPointerConstraints(ac->surface());
         disconnectPointerConstraintsConnection();
     }
     disconnect(m_focusGeometryConnection);
     m_focusGeometryConnection = QMetaObject::Connection();
 
     if (AbstractClient *ac = qobject_cast<AbstractClient*>(focusNow)) {
         ac->enterEvent(m_pos.toPoint());
         workspace()->updateFocusMousePosition(m_pos.toPoint());
     }
 
     if (internalWindow()) {
         // enter internal window
         const auto pos = at()->pos();
         QEnterEvent enterEvent(pos, pos, m_pos);
         QCoreApplication::sendEvent(internalWindow().data(), &enterEvent);
     }
 
     auto seat = waylandServer()->seat();
     if (!focusNow || !focusNow->surface() || decoration()) {
         // Clean up focused pointer surface if there's no client to take focus,
         // or the pointer is on a client without surface or on a decoration.
         warpXcbOnSurfaceLeft(nullptr);
         seat->setFocusedPointerSurface(nullptr);
         return;
     }
 
     // TODO: add convenient API to update global pos together with updating focused surface
     warpXcbOnSurfaceLeft(focusNow->surface());
 
     // TODO: why? in order to reset the cursor icon?
     s_cursorUpdateBlocking = true;
     seat->setFocusedPointerSurface(nullptr);
     s_cursorUpdateBlocking = false;
 
     seat->setPointerPos(m_pos.toPoint());
     seat->setFocusedPointerSurface(focusNow->surface(), focusNow->inputTransformation());
 
     m_focusGeometryConnection = connect(focusNow, &Toplevel::frameGeometryChanged, this,
         [this] {
             // TODO: why no assert possible?
             if (!focus()) {
                 return;
             }
             // TODO: can we check on the client instead?
             if (workspace()->moveResizeClient()) {
                 // don't update while moving
                 return;
             }
             auto seat = waylandServer()->seat();
             if (focus()->surface() != seat->focusedPointerSurface()) {
                 return;
             }
             seat->setFocusedPointerSurfaceTransformation(focus()->inputTransformation());
         }
     );
 
-    m_constraintsConnection = connect(focusNow->surface(), &KWayland::Server::SurfaceInterface::pointerConstraintsChanged,
+    m_constraintsConnection = connect(focusNow->surface(), &KWaylandServer::SurfaceInterface::pointerConstraintsChanged,
                                       this, &PointerInputRedirection::updatePointerConstraints);
     m_constraintsActivatedConnection = connect(workspace(), &Workspace::clientActivated,
                                                this, &PointerInputRedirection::updatePointerConstraints);
     updatePointerConstraints();
 }
 
-void PointerInputRedirection::breakPointerConstraints(KWayland::Server::SurfaceInterface *surface)
+void PointerInputRedirection::breakPointerConstraints(KWaylandServer::SurfaceInterface *surface)
 {
     // cancel pointer constraints
     if (surface) {
         auto c = surface->confinedPointer();
         if (c && c->isConfined()) {
             c->setConfined(false);
         }
         auto l = surface->lockedPointer();
         if (l && l->isLocked()) {
             l->setLocked(false);
         }
     }
     disconnectConfinedPointerRegionConnection();
     m_confined = false;
     m_locked = false;
 }
 
 void PointerInputRedirection::disconnectConfinedPointerRegionConnection()
 {
     disconnect(m_confinedPointerRegionConnection);
     m_confinedPointerRegionConnection = QMetaObject::Connection();
 }
 
 void PointerInputRedirection::disconnectLockedPointerAboutToBeUnboundConnection()
 {
     disconnect(m_lockedPointerAboutToBeUnboundConnection);
     m_lockedPointerAboutToBeUnboundConnection = QMetaObject::Connection();
 }
 
 void PointerInputRedirection::disconnectPointerConstraintsConnection()
 {
     disconnect(m_constraintsConnection);
     m_constraintsConnection = QMetaObject::Connection();
 
     disconnect(m_constraintsActivatedConnection);
     m_constraintsActivatedConnection = QMetaObject::Connection();
 }
 
 template <typename T>
 static QRegion getConstraintRegion(Toplevel *t, T *constraint)
 {
     const QRegion windowShape = t->inputShape();
     const QRegion windowRegion = windowShape.isEmpty() ? QRegion(0, 0, t->clientSize().width(), t->clientSize().height()) : windowShape;
     const QRegion intersected = constraint->region().isEmpty() ? windowRegion : windowRegion.intersected(constraint->region());
     return intersected.translated(t->pos() + t->clientPos());
 }
 
 void PointerInputRedirection::setEnableConstraints(bool set)
 {
     if (m_enableConstraints == set) {
         return;
     }
     m_enableConstraints = set;
     updatePointerConstraints();
 }
 
 void PointerInputRedirection::updatePointerConstraints()
 {
     if (focus().isNull()) {
         return;
     }
     const auto s = focus()->surface();
     if (!s) {
         return;
     }
     if (s != waylandServer()->seat()->focusedPointerSurface()) {
         return;
     }
     if (!supportsWarping()) {
         return;
     }
     const bool canConstrain = m_enableConstraints && focus() == workspace()->activeClient();
     const auto cf = s->confinedPointer();
     if (cf) {
         if (cf->isConfined()) {
             if (!canConstrain) {
                 cf->setConfined(false);
                 m_confined = false;
                 disconnectConfinedPointerRegionConnection();
             }
             return;
         }
         const QRegion r = getConstraintRegion(focus().data(), cf.data());
         if (canConstrain && r.contains(m_pos.toPoint())) {
             cf->setConfined(true);
             m_confined = true;
-            m_confinedPointerRegionConnection = connect(cf.data(), &KWayland::Server::ConfinedPointerInterface::regionChanged, this,
+            m_confinedPointerRegionConnection = connect(cf.data(), &KWaylandServer::ConfinedPointerInterface::regionChanged, this,
                 [this] {
                     if (!focus()) {
                         return;
                     }
                     const auto s = focus()->surface();
                     if (!s) {
                         return;
                     }
                     const auto cf = s->confinedPointer();
                     if (!getConstraintRegion(focus().data(), cf.data()).contains(m_pos.toPoint())) {
                         // pointer no longer in confined region, break the confinement
                         cf->setConfined(false);
                         m_confined = false;
                     } else {
                         if (!cf->isConfined()) {
                             cf->setConfined(true);
                             m_confined = true;
                         }
                     }
                 }
             );
             return;
         }
     } else {
         m_confined = false;
         disconnectConfinedPointerRegionConnection();
     }
     const auto lock = s->lockedPointer();
     if (lock) {
         if (lock->isLocked()) {
             if (!canConstrain) {
                 const auto hint = lock->cursorPositionHint();
                 lock->setLocked(false);
                 m_locked = false;
                 disconnectLockedPointerAboutToBeUnboundConnection();
                 if (! (hint.x() < 0 || hint.y() < 0) && focus()) {
                     processMotion(focus()->pos() - focus()->clientContentPos() + hint, waylandServer()->seat()->timestamp());
                 }
             }
             return;
         }
         const QRegion r = getConstraintRegion(focus().data(), lock.data());
         if (canConstrain && r.contains(m_pos.toPoint())) {
             lock->setLocked(true);
             m_locked = true;
 
             // The client might cancel pointer locking from its side by unbinding the LockedPointerInterface.
             // In this case the cached cursor position hint must be fetched before the resource goes away
-            m_lockedPointerAboutToBeUnboundConnection = connect(lock.data(), &KWayland::Server::LockedPointerInterface::aboutToBeUnbound, this,
+            m_lockedPointerAboutToBeUnboundConnection = connect(lock.data(), &KWaylandServer::LockedPointerInterface::aboutToBeUnbound, this,
                 [this, lock]() {
                     const auto hint = lock->cursorPositionHint();
                     if (hint.x() < 0 || hint.y() < 0 || !focus()) {
                         return;
                     }
                     auto globalHint = focus()->pos() - focus()->clientContentPos() + hint;
 
                     // When the resource finally goes away, reposition the cursor according to the hint
-                    connect(lock.data(), &KWayland::Server::LockedPointerInterface::unbound, this,
+                    connect(lock.data(), &KWaylandServer::LockedPointerInterface::unbound, this,
                         [this, globalHint]() {
                             processMotion(globalHint, waylandServer()->seat()->timestamp());
                     });
                 }
             );
             // TODO: connect to region change - is it needed at all? If the pointer is locked it's always in the region
         }
     } else {
         m_locked = false;
         disconnectLockedPointerAboutToBeUnboundConnection();
     }
 }
 
-void PointerInputRedirection::warpXcbOnSurfaceLeft(KWayland::Server::SurfaceInterface *newSurface)
+void PointerInputRedirection::warpXcbOnSurfaceLeft(KWaylandServer::SurfaceInterface *newSurface)
 {
     auto xc = waylandServer()->xWaylandConnection();
     if (!xc) {
         // No XWayland, no point in warping the x cursor
         return;
     }
     const auto c = kwinApp()->x11Connection();
     if (!c) {
         return;
     }
     static bool s_hasXWayland119 = xcb_get_setup(c)->release_number >= 11900000;
     if (s_hasXWayland119) {
         return;
     }
     if (newSurface && newSurface->client() == xc) {
         // new window is an X window
         return;
     }
     auto s = waylandServer()->seat()->focusedPointerSurface();
     if (!s || s->client() != xc) {
         // pointer was not on an X window
         return;
     }
     // warp pointer to 0/0 to trigger leave events on previously focused X window
     xcb_warp_pointer(c, XCB_WINDOW_NONE, kwinApp()->x11RootWindow(), 0, 0, 0, 0, 0, 0),
     xcb_flush(c);
 }
 
 QPointF PointerInputRedirection::applyPointerConfinement(const QPointF &pos) const
 {
     if (!focus()) {
         return pos;
     }
     auto s = focus()->surface();
     if (!s) {
         return pos;
     }
     auto cf = s->confinedPointer();
     if (!cf) {
         return pos;
     }
     if (!cf->isConfined()) {
         return pos;
     }
 
     const QRegion confinementRegion = getConstraintRegion(focus().data(), cf.data());
     if (confinementRegion.contains(pos.toPoint())) {
         return pos;
     }
     QPointF p = pos;
     // allow either x or y to pass
     p = QPointF(m_pos.x(), pos.y());
     if (confinementRegion.contains(p.toPoint())) {
         return p;
     }
     p = QPointF(pos.x(), m_pos.y());
     if (confinementRegion.contains(p.toPoint())) {
         return p;
     }
 
     return m_pos;
 }
 
 void PointerInputRedirection::updatePosition(const QPointF &pos)
 {
     if (m_locked) {
         // locked pointer should not move
         return;
     }
     // verify that at least one screen contains the pointer position
     QPointF p = pos;
     if (!screenContainsPos(p)) {
         const QRectF unitedScreensGeometry = screens()->geometry();
         p = confineToBoundingBox(p, unitedScreensGeometry);
         if (!screenContainsPos(p)) {
             const QRectF currentScreenGeometry = screens()->geometry(screens()->number(m_pos.toPoint()));
             p = confineToBoundingBox(p, currentScreenGeometry);
         }
     }
     p = applyPointerConfinement(p);
     if (p == m_pos) {
         // didn't change due to confinement
         return;
     }
     // verify screen confinement
     if (!screenContainsPos(p)) {
         return;
     }
     m_pos = p;
     emit input()->globalPointerChanged(m_pos);
 }
 
 void PointerInputRedirection::updateButton(uint32_t button, InputRedirection::PointerButtonState state)
 {
     m_buttons[button] = state;
 
     // update Qt buttons
     m_qtButtons = Qt::NoButton;
     for (auto it = m_buttons.constBegin(); it != m_buttons.constEnd(); ++it) {
         if (it.value() == InputRedirection::PointerButtonReleased) {
             continue;
         }
         m_qtButtons |= buttonToQtMouseButton(it.key());
     }
 
     emit input()->pointerButtonStateChanged(button, state);
 }
 
 void PointerInputRedirection::warp(const QPointF &pos)
 {
     if (supportsWarping()) {
         kwinApp()->platform()->warpPointer(pos);
         processMotion(pos, waylandServer()->seat()->timestamp());
     }
 }
 
 bool PointerInputRedirection::supportsWarping() const
 {
     if (!inited()) {
         return false;
     }
     if (m_supportsWarping) {
         return true;
     }
     if (kwinApp()->platform()->supportsPointerWarping()) {
         return true;
     }
     return false;
 }
 
 void PointerInputRedirection::updateAfterScreenChange()
 {
     if (!inited()) {
         return;
     }
     if (screenContainsPos(m_pos)) {
         // pointer still on a screen
         return;
     }
     // pointer no longer on a screen, reposition to closes screen
     const QPointF pos = screens()->geometry(screens()->number(m_pos.toPoint())).center();
     // TODO: better way to get timestamps
     processMotion(pos, waylandServer()->seat()->timestamp());
 }
 
 QPointF PointerInputRedirection::position() const
 {
     return m_pos.toPoint();
 }
 
 void PointerInputRedirection::setEffectsOverrideCursor(Qt::CursorShape shape)
 {
     if (!inited()) {
         return;
     }
     // current pointer focus window should get a leave event
     update();
     m_cursor->setEffectsOverrideCursor(shape);
 }
 
 void PointerInputRedirection::removeEffectsOverrideCursor()
 {
     if (!inited()) {
         return;
     }
     // cursor position might have changed while there was an effect in place
     update();
     m_cursor->removeEffectsOverrideCursor();
 }
 
 void PointerInputRedirection::setWindowSelectionCursor(const QByteArray &shape)
 {
     if (!inited()) {
         return;
     }
     // send leave to current pointer focus window
     updateToReset();
     m_cursor->setWindowSelectionCursor(shape);
 }
 
 void PointerInputRedirection::removeWindowSelectionCursor()
 {
     if (!inited()) {
         return;
     }
     update();
     m_cursor->removeWindowSelectionCursor();
 }
 
 CursorImage::CursorImage(PointerInputRedirection *parent)
     : QObject(parent)
     , m_pointer(parent)
 {
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::focusedPointerChanged, this, &CursorImage::update);
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragStarted, this, &CursorImage::updateDrag);
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this,
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::focusedPointerChanged, this, &CursorImage::update);
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::dragStarted, this, &CursorImage::updateDrag);
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::dragEnded, this,
         [this] {
             disconnect(m_drag.connection);
             reevaluteSource();
         }
     );
     if (waylandServer()->hasScreenLockerIntegration()) {
         connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this, &CursorImage::reevaluteSource);
     }
     connect(m_pointer, &PointerInputRedirection::decorationChanged, this, &CursorImage::updateDecoration);
     // connect the move resize of all window
     auto setupMoveResizeConnection = [this] (AbstractClient *c) {
         connect(c, &AbstractClient::moveResizedChanged, this, &CursorImage::updateMoveResize);
         connect(c, &AbstractClient::moveResizeCursorChanged, this, &CursorImage::updateMoveResize);
     };
     const auto clients = workspace()->allClientList();
     std::for_each(clients.begin(), clients.end(), setupMoveResizeConnection);
     connect(workspace(), &Workspace::clientAdded, this, setupMoveResizeConnection);
     connect(waylandServer(), &WaylandServer::shellClientAdded, this, setupMoveResizeConnection);
     loadThemeCursor(Qt::ArrowCursor, &m_fallbackCursor);
 
     m_surfaceRenderedTimer.start();
 
     connect(&m_waylandImage, &WaylandCursorImage::themeChanged, this, [this] {
         m_cursors.clear();
         m_cursorsByName.clear();
         loadThemeCursor(Qt::ArrowCursor, &m_fallbackCursor);
         updateDecorationCursor();
         updateMoveResize();
         // TODO: update effects
     });
 }
 
 CursorImage::~CursorImage() = default;
 
 void CursorImage::markAsRendered()
 {
     if (m_currentSource == CursorSource::DragAndDrop) {
         // always sending a frame rendered to the drag icon surface to not freeze QtWayland (see https://bugreports.qt.io/browse/QTBUG-51599 )
         if (auto ddi = waylandServer()->seat()->dragSource()) {
             if (auto s = ddi->icon()) {
                 s->frameRendered(m_surfaceRenderedTimer.elapsed());
             }
         }
         auto p = waylandServer()->seat()->dragPointer();
         if (!p) {
             return;
         }
         auto c = p->cursor();
         if (!c) {
             return;
         }
         auto cursorSurface = c->surface();
         if (cursorSurface.isNull()) {
             return;
         }
         cursorSurface->frameRendered(m_surfaceRenderedTimer.elapsed());
         return;
     }
     if (m_currentSource != CursorSource::LockScreen && m_currentSource != CursorSource::PointerSurface) {
         return;
     }
     auto p = waylandServer()->seat()->focusedPointer();
     if (!p) {
         return;
     }
     auto c = p->cursor();
     if (!c) {
         return;
     }
     auto cursorSurface = c->surface();
     if (cursorSurface.isNull()) {
         return;
     }
     cursorSurface->frameRendered(m_surfaceRenderedTimer.elapsed());
 }
 
 void CursorImage::update()
 {
     if (s_cursorUpdateBlocking) {
         return;
     }
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     disconnect(m_serverCursor.connection);
     auto p = waylandServer()->seat()->focusedPointer();
     if (p) {
         m_serverCursor.connection = connect(p, &PointerInterface::cursorChanged, this, &CursorImage::updateServerCursor);
     } else {
         m_serverCursor.connection = QMetaObject::Connection();
         reevaluteSource();
     }
 }
 
 void CursorImage::updateDecoration()
 {
     disconnect(m_decorationConnection);
     auto deco = m_pointer->decoration();
     AbstractClient *c = deco.isNull() ? nullptr : deco->client();
     if (c) {
         m_decorationConnection = connect(c, &AbstractClient::moveResizeCursorChanged, this, &CursorImage::updateDecorationCursor);
     } else {
         m_decorationConnection = QMetaObject::Connection();
     }
     updateDecorationCursor();
 }
 
 void CursorImage::updateDecorationCursor()
 {
     m_decorationCursor = {};
     auto deco = m_pointer->decoration();
     if (AbstractClient *c = deco.isNull() ? nullptr : deco->client()) {
         loadThemeCursor(c->cursor(), &m_decorationCursor);
         if (m_currentSource == CursorSource::Decoration) {
             emit changed();
         }
     }
     reevaluteSource();
 }
 
 void CursorImage::updateMoveResize()
 {
     m_moveResizeCursor = {};
     if (AbstractClient *c = workspace()->moveResizeClient()) {
         loadThemeCursor(c->cursor(), &m_moveResizeCursor);
         if (m_currentSource == CursorSource::MoveResize) {
             emit changed();
         }
     }
     reevaluteSource();
 }
 
 void CursorImage::updateServerCursor()
 {
     m_serverCursor.cursor = {};
     reevaluteSource();
     const bool needsEmit = m_currentSource == CursorSource::LockScreen || m_currentSource == CursorSource::PointerSurface;
     auto p = waylandServer()->seat()->focusedPointer();
     if (!p) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto c = p->cursor();
     if (!c) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto cursorSurface = c->surface();
     if (cursorSurface.isNull()) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto buffer = cursorSurface.data()->buffer();
     if (!buffer) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     m_serverCursor.cursor.hotspot = c->hotspot();
     m_serverCursor.cursor.image = buffer->data().copy();
     m_serverCursor.cursor.image.setDevicePixelRatio(cursorSurface->scale());
     if (needsEmit) {
         emit changed();
     }
 }
 
 void WaylandCursorImage::loadTheme()
 {
     if (m_cursorTheme) {
         return;
     }
     // check whether we can create it
     if (waylandServer()->internalShmPool()) {
         m_cursorTheme = new WaylandCursorTheme(waylandServer()->internalShmPool(), this);
         connect(waylandServer(), &WaylandServer::terminatingInternalClientConnection, this,
             [this] {
                 delete m_cursorTheme;
                 m_cursorTheme = nullptr;
             }
         );
     }
 }
 
 void CursorImage::setEffectsOverrideCursor(Qt::CursorShape shape)
 {
     loadThemeCursor(shape, &m_effectsCursor);
     if (m_currentSource == CursorSource::EffectsOverride) {
         emit changed();
     }
     reevaluteSource();
 }
 
 void CursorImage::removeEffectsOverrideCursor()
 {
     reevaluteSource();
 }
 
 void CursorImage::setWindowSelectionCursor(const QByteArray &shape)
 {
     if (shape.isEmpty()) {
         loadThemeCursor(Qt::CrossCursor, &m_windowSelectionCursor);
     } else {
         loadThemeCursor(shape, &m_windowSelectionCursor);
     }
     if (m_currentSource == CursorSource::WindowSelector) {
         emit changed();
     }
     reevaluteSource();
 }
 
 void CursorImage::removeWindowSelectionCursor()
 {
     reevaluteSource();
 }
 
 void CursorImage::updateDrag()
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     disconnect(m_drag.connection);
     m_drag.cursor = {};
     reevaluteSource();
     if (auto p = waylandServer()->seat()->dragPointer()) {
         m_drag.connection = connect(p, &PointerInterface::cursorChanged, this, &CursorImage::updateDragCursor);
     } else {
         m_drag.connection = QMetaObject::Connection();
     }
     updateDragCursor();
 }
 
 void CursorImage::updateDragCursor()
 {
     m_drag.cursor = {};
     const bool needsEmit = m_currentSource == CursorSource::DragAndDrop;
     QImage additionalIcon;
     if (auto ddi = waylandServer()->seat()->dragSource()) {
         if (auto dragIcon = ddi->icon()) {
             if (auto buffer = dragIcon->buffer()) {
                 additionalIcon = buffer->data().copy();
                 additionalIcon.setOffset(dragIcon->offset());
             }
         }
     }
     auto p = waylandServer()->seat()->dragPointer();
     if (!p) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto c = p->cursor();
     if (!c) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto cursorSurface = c->surface();
     if (cursorSurface.isNull()) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     auto buffer = cursorSurface.data()->buffer();
     if (!buffer) {
         if (needsEmit) {
             emit changed();
         }
         return;
     }
     m_drag.cursor.hotspot = c->hotspot();
 
     if (additionalIcon.isNull()) {
         m_drag.cursor.image = buffer->data().copy();
     } else {
         QRect cursorRect = buffer->data().rect();
         QRect iconRect = additionalIcon.rect();
 
         if (-m_drag.cursor.hotspot.x() < additionalIcon.offset().x()) {
             iconRect.moveLeft(m_drag.cursor.hotspot.x() - additionalIcon.offset().x());
         } else {
             cursorRect.moveLeft(-additionalIcon.offset().x() - m_drag.cursor.hotspot.x());
         }
         if (-m_drag.cursor.hotspot.y() < additionalIcon.offset().y()) {
             iconRect.moveTop(m_drag.cursor.hotspot.y() - additionalIcon.offset().y());
         } else {
             cursorRect.moveTop(-additionalIcon.offset().y() - m_drag.cursor.hotspot.y());
         }
 
         m_drag.cursor.image = QImage(cursorRect.united(iconRect).size(), QImage::Format_ARGB32_Premultiplied);
         m_drag.cursor.image.fill(Qt::transparent);
         QPainter p(&m_drag.cursor.image);
         p.drawImage(iconRect, additionalIcon);
         p.drawImage(cursorRect, buffer->data());
         p.end();
     }
 
     if (needsEmit) {
         emit changed();
     }
     // TODO: add the cursor image
 }
 
 void CursorImage::loadThemeCursor(CursorShape shape, WaylandCursorImage::Image *image)
 {
     m_waylandImage.loadThemeCursor(shape, m_cursors, image);
 }
 
 void CursorImage::loadThemeCursor(const QByteArray &shape, WaylandCursorImage::Image *image)
 {
     m_waylandImage.loadThemeCursor(shape, m_cursorsByName, image);
 }
 
 template <typename T>
 void WaylandCursorImage::loadThemeCursor(const T &shape, Image *image)
 {
     loadTheme();
     if (!m_cursorTheme) {
         return;
     }
 
     image->image = {};
     wl_cursor_image *cursor = m_cursorTheme->get(shape);
     if (!cursor) {
         qDebug() << "Could not find cursor" << shape;
         return;
     }
     wl_buffer *b = wl_cursor_image_get_buffer(cursor);
     if (!b) {
         return;
     }
     waylandServer()->internalClientConection()->flush();
     waylandServer()->dispatch();
-    auto buffer = KWayland::Server::BufferInterface::get(waylandServer()->internalConnection()->getResource(KWayland::Client::Buffer::getId(b)));
+    auto buffer = KWaylandServer::BufferInterface::get(waylandServer()->internalConnection()->getResource(KWayland::Client::Buffer::getId(b)));
     if (!buffer) {
         return;
     }
     auto scale = screens()->maxScale();
     int hotSpotX = qRound(cursor->hotspot_x / scale);
     int hotSpotY = qRound(cursor->hotspot_y / scale);
     QImage img = buffer->data().copy();
     img.setDevicePixelRatio(scale);
     *image = {img, QPoint(hotSpotX, hotSpotY)};
 }
 
 template <typename T>
 void WaylandCursorImage::loadThemeCursor(const T &shape, QHash<T, Image> &cursors, Image *image)
 {
     auto it = cursors.constFind(shape);
     if (it == cursors.constEnd()) {
         loadThemeCursor(shape, image);
         cursors.insert(shape, *image);
     } else {
         *image = it.value();
     }
 }
 
 void CursorImage::reevaluteSource()
 {
     if (waylandServer()->seat()->isDragPointer()) {
         // TODO: touch drag?
         setSource(CursorSource::DragAndDrop);
         return;
     }
     if (waylandServer()->isScreenLocked()) {
         setSource(CursorSource::LockScreen);
         return;
     }
     if (input()->isSelectingWindow()) {
         setSource(CursorSource::WindowSelector);
         return;
     }
     if (effects && static_cast<EffectsHandlerImpl*>(effects)->isMouseInterception()) {
         setSource(CursorSource::EffectsOverride);
         return;
     }
     if (workspace() && workspace()->moveResizeClient()) {
         setSource(CursorSource::MoveResize);
         return;
     }
     if (!m_pointer->decoration().isNull()) {
         setSource(CursorSource::Decoration);
         return;
     }
     if (!m_pointer->focus().isNull() && waylandServer()->seat()->focusedPointer()) {
         setSource(CursorSource::PointerSurface);
         return;
     }
     setSource(CursorSource::Fallback);
 }
 
 void CursorImage::setSource(CursorSource source)
 {
     if (m_currentSource == source) {
         return;
     }
     m_currentSource = source;
     emit changed();
 }
 
 QImage CursorImage::image() const
 {
     switch (m_currentSource) {
     case CursorSource::EffectsOverride:
         return m_effectsCursor.image;
     case CursorSource::MoveResize:
         return m_moveResizeCursor.image;
     case CursorSource::LockScreen:
     case CursorSource::PointerSurface:
         // lockscreen also uses server cursor image
         return m_serverCursor.cursor.image;
     case CursorSource::Decoration:
         return m_decorationCursor.image;
     case CursorSource::DragAndDrop:
         return m_drag.cursor.image;
     case CursorSource::Fallback:
         return m_fallbackCursor.image;
     case CursorSource::WindowSelector:
         return m_windowSelectionCursor.image;
     default:
         Q_UNREACHABLE();
     }
 }
 
 QPoint CursorImage::hotSpot() const
 {
     switch (m_currentSource) {
     case CursorSource::EffectsOverride:
         return m_effectsCursor.hotspot;
     case CursorSource::MoveResize:
         return m_moveResizeCursor.hotspot;
     case CursorSource::LockScreen:
     case CursorSource::PointerSurface:
         // lockscreen also uses server cursor image
         return m_serverCursor.cursor.hotspot;
     case CursorSource::Decoration:
         return m_decorationCursor.hotspot;
     case CursorSource::DragAndDrop:
         return m_drag.cursor.hotspot;
     case CursorSource::Fallback:
         return m_fallbackCursor.hotspot;
     case CursorSource::WindowSelector:
         return m_windowSelectionCursor.hotspot;
     default:
         Q_UNREACHABLE();
     }
 }
 
 InputRedirectionCursor::InputRedirectionCursor(QObject *parent)
     : Cursor(parent)
     , m_currentButtons(Qt::NoButton)
 {
     Cursors::self()->setMouse(this);
     connect(input(), SIGNAL(globalPointerChanged(QPointF)), SLOT(slotPosChanged(QPointF)));
     connect(input(), SIGNAL(pointerButtonStateChanged(uint32_t,InputRedirection::PointerButtonState)),
             SLOT(slotPointerButtonChanged()));
 #ifndef KCMRULES
     connect(input(), &InputRedirection::keyboardModifiersChanged,
             this, &InputRedirectionCursor::slotModifiersChanged);
 #endif
 }
 
 InputRedirectionCursor::~InputRedirectionCursor()
 {
 }
 
 void InputRedirectionCursor::doSetPos()
 {
     if (input()->supportsPointerWarping()) {
         input()->warpPointer(currentPos());
     }
     slotPosChanged(input()->globalPointer());
     emit posChanged(currentPos());
 }
 
 void InputRedirectionCursor::slotPosChanged(const QPointF &pos)
 {
     const QPoint oldPos = currentPos();
     updatePos(pos.toPoint());
     emit mouseChanged(pos.toPoint(), oldPos, m_currentButtons, m_currentButtons,
                       input()->keyboardModifiers(), input()->keyboardModifiers());
 }
 
 void InputRedirectionCursor::slotModifiersChanged(Qt::KeyboardModifiers mods, Qt::KeyboardModifiers oldMods)
 {
     emit mouseChanged(currentPos(), currentPos(), m_currentButtons, m_currentButtons, mods, oldMods);
 }
 
 void InputRedirectionCursor::slotPointerButtonChanged()
 {
     const Qt::MouseButtons oldButtons = m_currentButtons;
     m_currentButtons = input()->qtButtonStates();
     const QPoint pos = currentPos();
     emit mouseChanged(pos, pos, m_currentButtons, oldButtons, input()->keyboardModifiers(), input()->keyboardModifiers());
 }
 
 void InputRedirectionCursor::doStartCursorTracking()
 {
 #ifndef KCMRULES
 //     connect(Cursors::self(), &Cursors::currentCursorChanged, this, &Cursor::cursorChanged);
 #endif
 }
 
 void InputRedirectionCursor::doStopCursorTracking()
 {
 #ifndef KCMRULES
 //     disconnect(kwinApp()->platform(), &Platform::cursorChanged, this, &Cursor::cursorChanged);
 #endif
 }
 
 }
diff --git a/pointer_input.h b/pointer_input.h
index 8c19b8caa..1ae6a7505 100644
--- a/pointer_input.h
+++ b/pointer_input.h
@@ -1,297 +1,294 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_POINTER_INPUT_H
 #define KWIN_POINTER_INPUT_H
 
 #include "input.h"
 #include "cursor.h"
 
 #include <QElapsedTimer>
 #include <QObject>
 #include <QPointer>
 #include <QPointF>
 
 class QWindow;
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class SurfaceInterface;
 }
-}
 
 namespace KWin
 {
 class CursorImage;
 class InputRedirection;
 class Toplevel;
 class WaylandCursorTheme;
 class CursorShape;
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 }
 
 namespace LibInput
 {
 class Device;
 }
 
 uint32_t qtMouseButtonToButton(Qt::MouseButton button);
 
 class KWIN_EXPORT PointerInputRedirection : public InputDeviceHandler
 {
     Q_OBJECT
 public:
     explicit PointerInputRedirection(InputRedirection *parent);
     ~PointerInputRedirection() override;
 
     void init() override;
 
     void updateAfterScreenChange();
     bool supportsWarping() const;
     void warp(const QPointF &pos);
 
     QPointF pos() const {
         return m_pos;
     }
     Qt::MouseButtons buttons() const {
         return m_qtButtons;
     }
     bool areButtonsPressed() const;
 
     void setEffectsOverrideCursor(Qt::CursorShape shape);
     void removeEffectsOverrideCursor();
     void setWindowSelectionCursor(const QByteArray &shape);
     void removeWindowSelectionCursor();
 
     void updatePointerConstraints();
 
     void setEnableConstraints(bool set);
 
     bool isConstrained() const {
         return m_confined || m_locked;
     }
 
     bool focusUpdatesBlocked() override;
 
     /**
      * @internal
      */
     void processMotion(const QPointF &pos, uint32_t time, LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processMotion(const QPointF &pos, const QSizeF &delta, const QSizeF &deltaNonAccelerated, uint32_t time, quint64 timeUsec, LibInput::Device *device);
     /**
      * @internal
      */
     void processButton(uint32_t button, InputRedirection::PointerButtonState state, uint32_t time, LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processAxis(InputRedirection::PointerAxis axis, qreal delta, qint32 discreteDelta, InputRedirection::PointerAxisSource source, uint32_t time, LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processSwipeGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processSwipeGestureUpdate(const QSizeF &delta, quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processSwipeGestureEnd(quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processSwipeGestureCancelled(quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processPinchGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processPinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processPinchGestureEnd(quint32 time, KWin::LibInput::Device *device = nullptr);
     /**
      * @internal
      */
     void processPinchGestureCancelled(quint32 time, KWin::LibInput::Device *device = nullptr);
 
 private:
     void cleanupInternalWindow(QWindow *old, QWindow *now) override;
     void cleanupDecoration(Decoration::DecoratedClientImpl *old, Decoration::DecoratedClientImpl *now) override;
 
     void focusUpdate(Toplevel *focusOld, Toplevel *focusNow) override;
 
     QPointF position() const override;
 
     void updateOnStartMoveResize();
     void updateToReset();
     void updatePosition(const QPointF &pos);
     void updateButton(uint32_t button, InputRedirection::PointerButtonState state);
-    void warpXcbOnSurfaceLeft(KWayland::Server::SurfaceInterface *surface);
+    void warpXcbOnSurfaceLeft(KWaylandServer::SurfaceInterface *surface);
     QPointF applyPointerConfinement(const QPointF &pos) const;
     void disconnectConfinedPointerRegionConnection();
     void disconnectLockedPointerAboutToBeUnboundConnection();
     void disconnectPointerConstraintsConnection();
-    void breakPointerConstraints(KWayland::Server::SurfaceInterface *surface);
+    void breakPointerConstraints(KWaylandServer::SurfaceInterface *surface);
     CursorImage *m_cursor;
     bool m_supportsWarping;
     QPointF m_pos;
     QHash<uint32_t, InputRedirection::PointerButtonState> m_buttons;
     Qt::MouseButtons m_qtButtons;
     QMetaObject::Connection m_focusGeometryConnection;
     QMetaObject::Connection m_internalWindowConnection;
     QMetaObject::Connection m_constraintsConnection;
     QMetaObject::Connection m_constraintsActivatedConnection;
     QMetaObject::Connection m_confinedPointerRegionConnection;
     QMetaObject::Connection m_lockedPointerAboutToBeUnboundConnection;
     QMetaObject::Connection m_decorationGeometryConnection;
     bool m_confined = false;
     bool m_locked = false;
     bool m_enableConstraints = true;
 };
 
 class WaylandCursorImage : public QObject
 {
     Q_OBJECT
 public:
     void loadTheme();
     struct Image {
         QImage image;
         QPoint hotspot;
     };
     template <typename T>
     void loadThemeCursor(const T &shape, Image *image);
 
     template <typename T>
     void loadThemeCursor(const T &shape, QHash<T, Image> &cursors, Image *image);
 
 Q_SIGNALS:
     void themeChanged();
 
 private:
     WaylandCursorTheme *m_cursorTheme = nullptr;
 };
 
 class CursorImage : public QObject
 {
     Q_OBJECT
 public:
     explicit CursorImage(PointerInputRedirection *parent = nullptr);
     ~CursorImage() override;
 
     void setEffectsOverrideCursor(Qt::CursorShape shape);
     void removeEffectsOverrideCursor();
     void setWindowSelectionCursor(const QByteArray &shape);
     void removeWindowSelectionCursor();
 
     QImage image() const;
     QPoint hotSpot() const;
     void markAsRendered();
 
 Q_SIGNALS:
     void changed();
 
 private:
     void reevaluteSource();
     void update();
     void updateServerCursor();
     void updateDecoration();
     void updateDecorationCursor();
     void updateMoveResize();
     void updateDrag();
     void updateDragCursor();
 
     void loadThemeCursor(CursorShape shape, WaylandCursorImage::Image *image);
     void loadThemeCursor(const QByteArray &shape, WaylandCursorImage::Image *image);
 
     enum class CursorSource {
         LockScreen,
         EffectsOverride,
         MoveResize,
         PointerSurface,
         Decoration,
         DragAndDrop,
         Fallback,
         WindowSelector
     };
     void setSource(CursorSource source);
 
     PointerInputRedirection *m_pointer;
     CursorSource m_currentSource = CursorSource::Fallback;
     WaylandCursorImage m_waylandImage;
 
     WaylandCursorImage::Image m_effectsCursor;
     WaylandCursorImage::Image m_decorationCursor;
     QMetaObject::Connection m_decorationConnection;
     WaylandCursorImage::Image m_fallbackCursor;
     WaylandCursorImage::Image m_moveResizeCursor;
     WaylandCursorImage::Image m_windowSelectionCursor;
     QHash<CursorShape, WaylandCursorImage::Image> m_cursors;
     QHash<QByteArray, WaylandCursorImage::Image> m_cursorsByName;
     QElapsedTimer m_surfaceRenderedTimer;
     struct {
         WaylandCursorImage::Image cursor;
         QMetaObject::Connection connection;
     } m_drag;
     struct {
         QMetaObject::Connection connection;
         WaylandCursorImage::Image cursor;
     } m_serverCursor;
 };
 
 /**
  * @brief Implementation using the InputRedirection framework to get pointer positions.
  *
  * Does not support warping of cursor.
  */
 class InputRedirectionCursor : public KWin::Cursor
 {
     Q_OBJECT
 public:
     explicit InputRedirectionCursor(QObject *parent);
     ~InputRedirectionCursor() override;
 protected:
     void doSetPos() override;
     void doStartCursorTracking() override;
     void doStopCursorTracking() override;
 private Q_SLOTS:
     void slotPosChanged(const QPointF &pos);
     void slotPointerButtonChanged();
     void slotModifiersChanged(Qt::KeyboardModifiers mods, Qt::KeyboardModifiers oldMods);
 private:
     Qt::MouseButtons m_currentButtons;
 };
 
 }
 
 #endif
diff --git a/scene.cpp b/scene.cpp
index 4d26fe225..2ccd75c95 100644
--- a/scene.cpp
+++ b/scene.cpp
@@ -1,1200 +1,1200 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 /*
  The base class for compositing, implementing shared functionality
  between the OpenGL and XRender backends.
 
  Design:
 
  When compositing is turned on, XComposite extension is used to redirect
  drawing of windows to pixmaps and XDamage extension is used to get informed
  about damage (changes) to window contents. This code is mostly in composite.cpp .
 
  Compositor::performCompositing() starts one painting pass. Painting is done
  by painting the screen, which in turn paints every window. Painting can be affected
  using effects, which are chained. E.g. painting a screen means that actually
  paintScreen() of the first effect is called, which possibly does modifications
  and calls next effect's paintScreen() and so on, until Scene::finalPaintScreen()
  is called.
 
  There are 3 phases of every paint (not necessarily done together):
  The pre-paint phase, the paint phase and the post-paint phase.
 
  The pre-paint phase is used to find out about how the painting will be actually
  done (i.e. what the effects will do). For example when only a part of the screen
  needs to be updated and no effect will do any transformation it is possible to use
  an optimized paint function. How the painting will be done is controlled
  by the mask argument, see PAINT_WINDOW_* and PAINT_SCREEN_* flags in scene.h .
  For example an effect that decides to paint a normal windows as translucent
  will need to modify the mask in its prePaintWindow() to include
  the PAINT_WINDOW_TRANSLUCENT flag. The paintWindow() function will then get
  the mask with this flag turned on and will also paint using transparency.
 
  The paint pass does the actual painting, based on the information collected
  using the pre-paint pass. After running through the effects' paintScreen()
  either paintGenericScreen() or optimized paintSimpleScreen() are called.
  Those call paintWindow() on windows (not necessarily all), possibly using
  clipping to optimize performance and calling paintWindow() first with only
  PAINT_WINDOW_OPAQUE to paint the opaque parts and then later
  with PAINT_WINDOW_TRANSLUCENT to paint the transparent parts. Function
  paintWindow() again goes through effects' paintWindow() until
  finalPaintWindow() is called, which calls the window's performPaint() to
  do the actual painting.
 
  The post-paint can be used for cleanups and is also used for scheduling
  repaints during the next painting pass for animations. Effects wanting to
  repaint certain parts can manually damage them during post-paint and repaint
  of these parts will be done during the next paint pass.
 
 */
 
 #include "scene.h"
 
 #include <QQuickWindow>
 #include <QVector2D>
 
 #include "x11client.h"
 #include "deleted.h"
 #include "effects.h"
 #include "overlaywindow.h"
 #include "screens.h"
 #include "shadow.h"
 #include "wayland_server.h"
 
 #include "thumbnailitem.h"
 
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/subcompositor_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/subcompositor_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 namespace KWin
 {
 
 //****************************************
 // Scene
 //****************************************
 
 Scene::Scene(QObject *parent)
     : QObject(parent)
 {
     last_time.invalidate(); // Initialize the timer
 }
 
 Scene::~Scene()
 {
     Q_ASSERT(m_windows.isEmpty());
 }
 
 // returns mask and possibly modified region
 void Scene::paintScreen(int* mask, const QRegion &damage, const QRegion &repaint,
                         QRegion *updateRegion, QRegion *validRegion, const QMatrix4x4 &projection, const QRect &outputGeometry, const qreal screenScale)
 {
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     *mask = (damage == displayRegion) ? 0 : PAINT_SCREEN_REGION;
 
     updateTimeDiff();
     // preparation step
     static_cast<EffectsHandlerImpl*>(effects)->startPaint();
 
     QRegion region = damage;
 
     ScreenPrePaintData pdata;
     pdata.mask = *mask;
     pdata.paint = region;
 
     effects->prePaintScreen(pdata, time_diff);
     *mask = pdata.mask;
     region = pdata.paint;
 
     if (*mask & (PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS)) {
         // Region painting is not possible with transformations,
         // because screen damage doesn't match transformed positions.
         *mask &= ~PAINT_SCREEN_REGION;
         region = infiniteRegion();
     } else if (*mask & PAINT_SCREEN_REGION) {
         // make sure not to go outside visible screen
         region &= displayRegion;
     } else {
         // whole screen, not transformed, force region to be full
         region = displayRegion;
     }
 
     painted_region = region;
     repaint_region = repaint;
 
     if (*mask & PAINT_SCREEN_BACKGROUND_FIRST) {
         paintBackground(region);
     }
 
     ScreenPaintData data(projection, outputGeometry, screenScale);
     effects->paintScreen(*mask, region, data);
 
     foreach (Window *w, stacking_order) {
         effects->postPaintWindow(effectWindow(w));
     }
 
     effects->postPaintScreen();
 
     // make sure not to go outside of the screen area
     *updateRegion = damaged_region;
     *validRegion = (region | painted_region) & displayRegion;
 
     repaint_region = QRegion();
     damaged_region = QRegion();
 
     // make sure all clipping is restored
     Q_ASSERT(!PaintClipper::clip());
 }
 
 // Compute time since the last painting pass.
 void Scene::updateTimeDiff()
 {
     if (!last_time.isValid()) {
         // Painting has been idle (optimized out) for some time,
         // which means time_diff would be huge and would break animations.
         // Simply set it to one (zero would mean no change at all and could
         // cause problems).
         time_diff = 1;
         last_time.start();
     } else
 
     time_diff = last_time.restart();
 
     if (time_diff < 0)   // check time rollback
         time_diff = 1;
 }
 
 // Painting pass is optimized away.
 void Scene::idle()
 {
     // Don't break time since last paint for the next pass.
     last_time.invalidate();
 }
 
 // the function that'll be eventually called by paintScreen() above
 void Scene::finalPaintScreen(int mask, const QRegion &region, ScreenPaintData& data)
 {
     if (mask & (PAINT_SCREEN_TRANSFORMED | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS))
         paintGenericScreen(mask, data);
     else
         paintSimpleScreen(mask, region);
 }
 
 // The generic painting code that can handle even transformations.
 // It simply paints bottom-to-top.
 void Scene::paintGenericScreen(int orig_mask, const ScreenPaintData &)
 {
     if (!(orig_mask & PAINT_SCREEN_BACKGROUND_FIRST)) {
         paintBackground(infiniteRegion());
     }
     QVector<Phase2Data> phase2;
     phase2.reserve(stacking_order.size());
     foreach (Window * w, stacking_order) { // bottom to top
         Toplevel* topw = w->window();
 
         // Reset the repaint_region.
         // This has to be done here because many effects schedule a repaint for
         // the next frame within Effects::prePaintWindow.
         topw->resetRepaints();
 
         WindowPrePaintData data;
         data.mask = orig_mask | (w->isOpaque() ? PAINT_WINDOW_OPAQUE : PAINT_WINDOW_TRANSLUCENT);
         w->resetPaintingEnabled();
         data.paint = infiniteRegion(); // no clipping, so doesn't really matter
         data.clip = QRegion();
         data.quads = w->buildQuads();
         // preparation step
         effects->prePaintWindow(effectWindow(w), data, time_diff);
 #if !defined(QT_NO_DEBUG)
         if (data.quads.isTransformed()) {
             qFatal("Pre-paint calls are not allowed to transform quads!");
         }
 #endif
         if (!w->isPaintingEnabled()) {
             continue;
         }
         phase2.append({w, infiniteRegion(), data.clip, data.mask, data.quads});
     }
 
     foreach (const Phase2Data & d, phase2) {
         paintWindow(d.window, d.mask, d.region, d.quads);
     }
 
     const QSize &screenSize = screens()->size();
     damaged_region = QRegion(0, 0, screenSize.width(), screenSize.height());
 }
 
 // The optimized case without any transformations at all.
 // It can paint only the requested region and can use clipping
 // to reduce painting and improve performance.
 void Scene::paintSimpleScreen(int orig_mask, const QRegion &region)
 {
     Q_ASSERT((orig_mask & (PAINT_SCREEN_TRANSFORMED
                          | PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS)) == 0);
     QVector<Phase2Data> phase2data;
     phase2data.reserve(stacking_order.size());
 
     QRegion dirtyArea = region;
     bool opaqueFullscreen = false;
 
     // Traverse the scene windows from bottom to top.
     for (int i = 0; i < stacking_order.count(); ++i) {
         Window *window = stacking_order[i];
         Toplevel *toplevel = window->window();
         WindowPrePaintData data;
         data.mask = orig_mask | (window->isOpaque() ? PAINT_WINDOW_OPAQUE : PAINT_WINDOW_TRANSLUCENT);
         window->resetPaintingEnabled();
         data.paint = region;
         data.paint |= toplevel->repaints();
 
         // Reset the repaint_region.
         // This has to be done here because many effects schedule a repaint for
         // the next frame within Effects::prePaintWindow.
         toplevel->resetRepaints();
 
         // Clip out the decoration for opaque windows; the decoration is drawn in the second pass
         opaqueFullscreen = false; // TODO: do we care about unmanged windows here (maybe input windows?)
         if (window->isOpaque()) {
             AbstractClient *client = dynamic_cast<AbstractClient *>(toplevel);
             if (client) {
                 opaqueFullscreen = client->isFullScreen();
             }
             if (!(client && client->decorationHasAlpha())) {
                 data.clip = window->decorationShape().translated(window->pos());
             }
             data.clip |= window->clientShape().translated(window->pos() + window->bufferOffset());
         } else if (toplevel->hasAlpha() && toplevel->opacity() == 1.0) {
             const QRegion clientShape = window->clientShape().translated(window->pos() + window->bufferOffset());
             const QRegion opaqueShape = toplevel->opaqueRegion().translated(window->pos() + toplevel->clientPos());
             data.clip = clientShape & opaqueShape;
         } else {
             data.clip = QRegion();
         }
         data.quads = window->buildQuads();
         // preparation step
         effects->prePaintWindow(effectWindow(window), data, time_diff);
 #if !defined(QT_NO_DEBUG)
         if (data.quads.isTransformed()) {
             qFatal("Pre-paint calls are not allowed to transform quads!");
         }
 #endif
         if (!window->isPaintingEnabled()) {
             continue;
         }
         dirtyArea |= data.paint;
         // Schedule the window for painting
         phase2data.append({ window, data.paint, data.clip, data.mask, data.quads });
     }
 
     // Save the part of the repaint region that's exclusively rendered to
     // bring a reused back buffer up to date. Then union the dirty region
     // with the repaint region.
     const QRegion repaintClip = repaint_region - dirtyArea;
     dirtyArea |= repaint_region;
 
     const QSize &screenSize = screens()->size();
     const QRegion displayRegion(0, 0, screenSize.width(), screenSize.height());
     bool fullRepaint(dirtyArea == displayRegion); // spare some expensive region operations
     if (!fullRepaint) {
         extendPaintRegion(dirtyArea, opaqueFullscreen);
         fullRepaint = (dirtyArea == displayRegion);
     }
 
     QRegion allclips, upperTranslucentDamage;
     upperTranslucentDamage = repaint_region;
 
     // This is the occlusion culling pass
     for (int i = phase2data.count() - 1; i >= 0; --i) {
         Phase2Data *data = &phase2data[i];
 
         if (fullRepaint) {
             data->region = displayRegion;
         } else {
             data->region |= upperTranslucentDamage;
         }
 
         // subtract the parts which will possibly been drawn as part of
         // a higher opaque window
         data->region -= allclips;
 
         // Here we rely on WindowPrePaintData::setTranslucent() to remove
         // the clip if needed.
         if (!data->clip.isEmpty() && !(data->mask & PAINT_WINDOW_TRANSLUCENT)) {
             // clip away the opaque regions for all windows below this one
             allclips |= data->clip;
             // extend the translucent damage for windows below this by remaining (translucent) regions
             if (!fullRepaint) {
                 upperTranslucentDamage |= data->region - data->clip;
             }
         } else if (!fullRepaint) {
             upperTranslucentDamage |= data->region;
         }
     }
 
     QRegion paintedArea;
     // Fill any areas of the root window not covered by opaque windows
     if (!(orig_mask & PAINT_SCREEN_BACKGROUND_FIRST)) {
         paintedArea = dirtyArea - allclips;
         paintBackground(paintedArea);
     }
 
     // Now walk the list bottom to top and draw the windows.
     for (int i = 0; i < phase2data.count(); ++i) {
         Phase2Data *data = &phase2data[i];
 
         // add all regions which have been drawn so far
         paintedArea |= data->region;
         data->region = paintedArea;
 
         paintWindow(data->window, data->mask, data->region, data->quads);
     }
 
     if (fullRepaint) {
         painted_region = displayRegion;
         damaged_region = displayRegion - repaintClip;
     } else {
         painted_region |= paintedArea;
 
         // Clip the repainted region from the damaged region.
         // It's important that we don't add the union of the damaged region
         // and the repainted region to the damage history. Otherwise the
         // repaint region will grow with every frame until it eventually
         // covers the whole back buffer, at which point we're always doing
         // full repaints.
         damaged_region = paintedArea - repaintClip;
     }
 }
 
 void Scene::addToplevel(Toplevel *c)
 {
     Q_ASSERT(!m_windows.contains(c));
     Scene::Window *w = createWindow(c);
     m_windows[ c ] = w;
     connect(c, SIGNAL(geometryShapeChanged(KWin::Toplevel*,QRect)), SLOT(windowGeometryShapeChanged(KWin::Toplevel*)));
     connect(c, SIGNAL(windowClosed(KWin::Toplevel*,KWin::Deleted*)), SLOT(windowClosed(KWin::Toplevel*,KWin::Deleted*)));
     //A change of scale won't affect the geometry in compositor co-ordinates, but will affect the window quads.
     if (c->surface()) {
-        connect(c->surface(), &KWayland::Server::SurfaceInterface::scaleChanged, this, std::bind(&Scene::windowGeometryShapeChanged, this, c));
+        connect(c->surface(), &KWaylandServer::SurfaceInterface::scaleChanged, this, std::bind(&Scene::windowGeometryShapeChanged, this, c));
     }
     connect(c, &Toplevel::screenScaleChanged, this,
         [this, c] {
             windowGeometryShapeChanged(c);
         }
     );
     c->effectWindow()->setSceneWindow(w);
     c->updateShadow();
     w->updateShadow(c->shadow());
     connect(c, &Toplevel::shadowChanged, this,
         [w] {
             w->invalidateQuadsCache();
         }
     );
 }
 
 void Scene::removeToplevel(Toplevel *toplevel)
 {
     Q_ASSERT(m_windows.contains(toplevel));
     delete m_windows.take(toplevel);
     toplevel->effectWindow()->setSceneWindow(nullptr);
 }
 
 void Scene::windowClosed(Toplevel *toplevel, Deleted *deleted)
 {
     if (!deleted) {
         removeToplevel(toplevel);
         return;
     }
 
     Q_ASSERT(m_windows.contains(toplevel));
     Window *window = m_windows.take(toplevel);
     window->updateToplevel(deleted);
     if (window->shadow()) {
         window->shadow()->setToplevel(deleted);
     }
     m_windows[deleted] = window;
 }
 
 void Scene::windowGeometryShapeChanged(Toplevel *c)
 {
     if (!m_windows.contains(c))    // this is ok, shape is not valid by default
         return;
     Window *w = m_windows[ c ];
     w->discardShape();
 }
 
 void Scene::createStackingOrder(const QList<Toplevel *> &toplevels)
 {
     // TODO: cache the stacking_order in case it has not changed
     foreach (Toplevel *c, toplevels) {
         Q_ASSERT(m_windows.contains(c));
         stacking_order.append(m_windows[ c ]);
     }
 }
 
 void Scene::clearStackingOrder()
 {
     stacking_order.clear();
 }
 
 static Scene::Window *s_recursionCheck = nullptr;
 
 void Scene::paintWindow(Window* w, int mask, const QRegion &_region, const WindowQuadList &quads)
 {
     // no painting outside visible screen (and no transformations)
     const QRegion region = _region & QRect({0, 0}, screens()->size());
     if (region.isEmpty())  // completely clipped
         return;
     if (w->window()->isDeleted() && w->window()->skipsCloseAnimation()) {
         // should not get painted
         return;
     }
 
     if (s_recursionCheck == w) {
         return;
     }
 
     WindowPaintData data(w->window()->effectWindow(), screenProjectionMatrix());
     data.quads = quads;
     effects->paintWindow(effectWindow(w), mask, region, data);
     // paint thumbnails on top of window
     paintWindowThumbnails(w, region, data.opacity(), data.brightness(), data.saturation());
     // and desktop thumbnails
     paintDesktopThumbnails(w);
 }
 
 static void adjustClipRegion(AbstractThumbnailItem *item, QRegion &clippingRegion)
 {
     if (item->clip() && item->clipTo()) {
         // the x/y positions of the parent item are not correct. The margins are added, though the size seems fine
         // that's why we have to get the offset by inspecting the anchors properties
         QQuickItem *parentItem = item->clipTo();
         QPointF offset;
         QVariant anchors = parentItem->property("anchors");
         if (anchors.isValid()) {
             if (QObject *anchorsObject = anchors.value<QObject*>()) {
                 offset.setX(anchorsObject->property("leftMargin").toReal());
                 offset.setY(anchorsObject->property("topMargin").toReal());
             }
         }
         QRectF rect = QRectF(parentItem->position() - offset, QSizeF(parentItem->width(), parentItem->height()));
         if (QQuickItem *p = parentItem->parentItem()) {
             rect = p->mapRectToScene(rect);
         }
         clippingRegion &= rect.adjusted(0,0,-1,-1).translated(item->window()->position()).toRect();
     }
 }
 
 void Scene::paintWindowThumbnails(Scene::Window *w, const QRegion &region, qreal opacity, qreal brightness, qreal saturation)
 {
     EffectWindowImpl *wImpl = static_cast<EffectWindowImpl*>(effectWindow(w));
     for (QHash<WindowThumbnailItem*, QPointer<EffectWindowImpl> >::const_iterator it = wImpl->thumbnails().constBegin();
             it != wImpl->thumbnails().constEnd();
             ++it) {
         if (it.value().isNull()) {
             continue;
         }
         WindowThumbnailItem *item = it.key();
         if (!item->isVisible()) {
             continue;
         }
         EffectWindowImpl *thumb = it.value().data();
         WindowPaintData thumbData(thumb, screenProjectionMatrix());
         thumbData.setOpacity(opacity);
         thumbData.setBrightness(brightness * item->brightness());
         thumbData.setSaturation(saturation * item->saturation());
 
         const QRect visualThumbRect(thumb->expandedGeometry());
 
         QSizeF size = QSizeF(visualThumbRect.size());
         size.scale(QSizeF(item->width(), item->height()), Qt::KeepAspectRatio);
         if (size.width() > visualThumbRect.width() || size.height() > visualThumbRect.height()) {
             size = QSizeF(visualThumbRect.size());
         }
         thumbData.setXScale(size.width() / static_cast<qreal>(visualThumbRect.width()));
         thumbData.setYScale(size.height() / static_cast<qreal>(visualThumbRect.height()));
 
         if (!item->window()) {
             continue;
         }
         const QPointF point = item->mapToScene(QPointF(0,0));
         qreal x = point.x() + w->x() + (item->width() - size.width())/2;
         qreal y = point.y() + w->y() + (item->height() - size.height()) / 2;
         x -= thumb->x();
         y -= thumb->y();
         // compensate shadow topleft padding
         x += (thumb->x()-visualThumbRect.x())*thumbData.xScale();
         y += (thumb->y()-visualThumbRect.y())*thumbData.yScale();
         thumbData.setXTranslation(x);
         thumbData.setYTranslation(y);
         int thumbMask = PAINT_WINDOW_TRANSFORMED | PAINT_WINDOW_LANCZOS;
         if (thumbData.opacity() == 1.0) {
             thumbMask |= PAINT_WINDOW_OPAQUE;
         } else {
             thumbMask |= PAINT_WINDOW_TRANSLUCENT;
         }
         QRegion clippingRegion = region;
         clippingRegion &= QRegion(wImpl->x(), wImpl->y(), wImpl->width(), wImpl->height());
         adjustClipRegion(item, clippingRegion);
         effects->drawWindow(thumb, thumbMask, clippingRegion, thumbData);
     }
 }
 
 void Scene::paintDesktopThumbnails(Scene::Window *w)
 {
     EffectWindowImpl *wImpl = static_cast<EffectWindowImpl*>(effectWindow(w));
     for (QList<DesktopThumbnailItem*>::const_iterator it = wImpl->desktopThumbnails().constBegin();
             it != wImpl->desktopThumbnails().constEnd();
             ++it) {
         DesktopThumbnailItem *item = *it;
         if (!item->isVisible()) {
             continue;
         }
         if (!item->window()) {
             continue;
         }
         s_recursionCheck = w;
 
         ScreenPaintData data;
         const QSize &screenSize = screens()->size();
         QSize size = screenSize;
 
         size.scale(item->width(), item->height(), Qt::KeepAspectRatio);
         data *= QVector2D(size.width() / double(screenSize.width()),
                           size.height() / double(screenSize.height()));
         const QPointF point = item->mapToScene(item->position());
         const qreal x = point.x() + w->x() + (item->width() - size.width())/2;
         const qreal y = point.y() + w->y() + (item->height() - size.height()) / 2;
         const QRect region = QRect(x, y, item->width(), item->height());
         QRegion clippingRegion = region;
         clippingRegion &= QRegion(wImpl->x(), wImpl->y(), wImpl->width(), wImpl->height());
         adjustClipRegion(item, clippingRegion);
         data += QPointF(x, y);
         const int desktopMask = PAINT_SCREEN_TRANSFORMED | PAINT_WINDOW_TRANSFORMED | PAINT_SCREEN_BACKGROUND_FIRST;
         paintDesktop(item->desktop(), desktopMask, clippingRegion, data);
         s_recursionCheck = nullptr;
     }
 }
 
 void Scene::paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data)
 {
     static_cast<EffectsHandlerImpl*>(effects)->paintDesktop(desktop, mask, region, data);
 }
 
 // the function that'll be eventually called by paintWindow() above
 void Scene::finalPaintWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     effects->drawWindow(w, mask, region, data);
 }
 
 // will be eventually called from drawWindow()
 void Scene::finalDrawWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data)
 {
     if (waylandServer() && waylandServer()->isScreenLocked() && !w->window()->isLockScreen() && !w->window()->isInputMethod()) {
         return;
     }
     w->sceneWindow()->performPaint(mask, region, data);
 }
 
 void Scene::extendPaintRegion(QRegion &region, bool opaqueFullscreen)
 {
     Q_UNUSED(region);
     Q_UNUSED(opaqueFullscreen);
 }
 
 bool Scene::blocksForRetrace() const
 {
     return false;
 }
 
 bool Scene::syncsToVBlank() const
 {
     return false;
 }
 
 void Scene::screenGeometryChanged(const QSize &size)
 {
     if (!overlayWindow()) {
         return;
     }
     overlayWindow()->resize(size);
 }
 
 bool Scene::makeOpenGLContextCurrent()
 {
     return false;
 }
 
 void Scene::doneOpenGLContextCurrent()
 {
 }
 
 void Scene::triggerFence()
 {
 }
 
 QMatrix4x4 Scene::screenProjectionMatrix() const
 {
     return QMatrix4x4();
 }
 
 xcb_render_picture_t Scene::xrenderBufferPicture() const
 {
     return XCB_RENDER_PICTURE_NONE;
 }
 
 QPainter *Scene::scenePainter() const
 {
     return nullptr;
 }
 
 QImage *Scene::qpainterRenderBuffer() const
 {
     return nullptr;
 }
 
 QVector<QByteArray> Scene::openGLPlatformInterfaceExtensions() const
 {
     return QVector<QByteArray>{};
 }
 
 //****************************************
 // Scene::Window
 //****************************************
 
 Scene::Window::Window(Toplevel * c)
     : toplevel(c)
     , filter(ImageFilterFast)
     , m_shadow(nullptr)
     , m_currentPixmap()
     , m_previousPixmap()
     , m_referencePixmapCounter(0)
     , disable_painting(0)
     , cached_quad_list(nullptr)
 {
 }
 
 Scene::Window::~Window()
 {
     delete m_shadow;
 }
 
 void Scene::Window::referencePreviousPixmap()
 {
     if (!m_previousPixmap.isNull() && m_previousPixmap->isDiscarded()) {
         m_referencePixmapCounter++;
     }
 }
 
 void Scene::Window::unreferencePreviousPixmap()
 {
     if (m_previousPixmap.isNull() || !m_previousPixmap->isDiscarded()) {
         return;
     }
     m_referencePixmapCounter--;
     if (m_referencePixmapCounter == 0) {
         m_previousPixmap.reset();
     }
 }
 
 void Scene::Window::discardPixmap()
 {
     if (!m_currentPixmap.isNull()) {
         if (m_currentPixmap->isValid()) {
             m_previousPixmap.reset(m_currentPixmap.take());
             m_previousPixmap->markAsDiscarded();
         } else {
             m_currentPixmap.reset();
         }
     }
 }
 
 void Scene::Window::updatePixmap()
 {
     if (m_currentPixmap.isNull()) {
         m_currentPixmap.reset(createWindowPixmap());
     }
     if (!m_currentPixmap->isValid()) {
         m_currentPixmap->create();
     }
 }
 
 void Scene::Window::discardShape()
 {
     // it is created on-demand and cached, simply
     // reset the flag
     m_bufferShapeIsValid = false;
     invalidateQuadsCache();
 }
 
 QRegion Scene::Window::bufferShape() const
 {
     if (m_bufferShapeIsValid) {
         return m_bufferShape;
     }
 
     const QRect bufferGeometry = toplevel->bufferGeometry();
 
     if (toplevel->shape()) {
         auto cookie = xcb_shape_get_rectangles_unchecked(connection(), toplevel->frameId(), XCB_SHAPE_SK_BOUNDING);
         ScopedCPointer<xcb_shape_get_rectangles_reply_t> reply(xcb_shape_get_rectangles_reply(connection(), cookie, nullptr));
         if (!reply.isNull()) {
             m_bufferShape = QRegion();
             const xcb_rectangle_t *rects = xcb_shape_get_rectangles_rectangles(reply.data());
             const int rectCount = xcb_shape_get_rectangles_rectangles_length(reply.data());
             for (int i = 0; i < rectCount; ++i) {
                 m_bufferShape += QRegion(rects[i].x, rects[i].y, rects[i].width, rects[i].height);
             }
             // make sure the shape is sane (X is async, maybe even XShape is broken)
             m_bufferShape &= QRegion(0, 0, bufferGeometry.width(), bufferGeometry.height());
         } else {
             m_bufferShape = QRegion();
         }
     } else {
         m_bufferShape = QRegion(0, 0, bufferGeometry.width(), bufferGeometry.height());
     }
 
     m_bufferShapeIsValid = true;
 
     return m_bufferShape;
 }
 
 QRegion Scene::Window::clientShape() const
 {
     if (AbstractClient *client = qobject_cast<AbstractClient *>(toplevel)) {
         if (client->isShade()) {
             return QRegion();
         }
     }
 
     const QRegion shape = bufferShape();
     const QMargins bufferMargins = toplevel->bufferMargins();
     if (bufferMargins.isNull()) {
         return shape;
     }
 
     const QRect clippingRect = QRect(QPoint(0, 0), toplevel->bufferGeometry().size()) - toplevel->bufferMargins();
     return shape & clippingRect;
 }
 
 QRegion Scene::Window::decorationShape() const
 {
     return QRegion(toplevel->rect()) - toplevel->transparentRect();
 }
 
 QPoint Scene::Window::bufferOffset() const
 {
     const QRect bufferGeometry = toplevel->bufferGeometry();
     const QRect frameGeometry = toplevel->frameGeometry();
     return bufferGeometry.topLeft() - frameGeometry.topLeft();
 }
 
 bool Scene::Window::isVisible() const
 {
     if (toplevel->isDeleted())
         return false;
     if (!toplevel->isOnCurrentDesktop())
         return false;
     if (!toplevel->isOnCurrentActivity())
         return false;
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(toplevel))
         return c->isShown(true);
     return true; // Unmanaged is always visible
 }
 
 bool Scene::Window::isOpaque() const
 {
     return toplevel->opacity() == 1.0 && !toplevel->hasAlpha();
 }
 
 bool Scene::Window::isPaintingEnabled() const
 {
     return !disable_painting;
 }
 
 void Scene::Window::resetPaintingEnabled()
 {
     disable_painting = 0;
     if (toplevel->isDeleted())
         disable_painting |= PAINT_DISABLED_BY_DELETE;
     if (static_cast<EffectsHandlerImpl*>(effects)->isDesktopRendering()) {
         if (!toplevel->isOnDesktop(static_cast<EffectsHandlerImpl*>(effects)->currentRenderedDesktop())) {
             disable_painting |= PAINT_DISABLED_BY_DESKTOP;
         }
     } else {
         if (!toplevel->isOnCurrentDesktop())
             disable_painting |= PAINT_DISABLED_BY_DESKTOP;
     }
     if (!toplevel->isOnCurrentActivity())
         disable_painting |= PAINT_DISABLED_BY_ACTIVITY;
     if (AbstractClient *c = dynamic_cast<AbstractClient*>(toplevel)) {
         if (c->isMinimized())
             disable_painting |= PAINT_DISABLED_BY_MINIMIZE;
         if (c->isHiddenInternal()) {
             disable_painting |= PAINT_DISABLED;
         }
     }
 }
 
 void Scene::Window::enablePainting(int reason)
 {
     disable_painting &= ~reason;
 }
 
 void Scene::Window::disablePainting(int reason)
 {
     disable_painting |= reason;
 }
 
 WindowQuadList Scene::Window::buildQuads(bool force) const
 {
     if (cached_quad_list != nullptr && !force)
         return *cached_quad_list;
 
     WindowQuadList ret = makeContentsQuads();
 
     if (!toplevel->frameMargins().isNull()) {
         AbstractClient *client = dynamic_cast<AbstractClient*>(toplevel);
         QRegion center = toplevel->transparentRect();
         const QRegion decoration = decorationShape();
         qreal decorationScale = 1.0;
 
         QRect rects[4];
         bool isShadedClient = false;
 
         if (client) {
             client->layoutDecorationRects(rects[0], rects[1], rects[2], rects[3]);
             decorationScale = client->screenScale();
             isShadedClient = client->isShade() || center.isEmpty();
         }
 
         if (isShadedClient) {
             const QRect bounding = rects[0] | rects[1] | rects[2] | rects[3];
             ret += makeDecorationQuads(rects, bounding, decorationScale);
         } else {
             ret += makeDecorationQuads(rects, decoration, decorationScale);
         }
 
     }
     if (m_shadow && toplevel->wantsShadowToBeRendered()) {
         ret << m_shadow->shadowQuads();
     }
     effects->buildQuads(toplevel->effectWindow(), ret);
     cached_quad_list.reset(new WindowQuadList(ret));
     return ret;
 }
 
 WindowQuadList Scene::Window::makeDecorationQuads(const QRect *rects, const QRegion &region, qreal textureScale) const
 {
     WindowQuadList list;
 
     const int padding = 1;
 
     const QPoint topSpritePosition(padding, padding);
     const QPoint bottomSpritePosition(padding, topSpritePosition.y() + rects[1].height() + 2 * padding);
     const QPoint leftSpritePosition(bottomSpritePosition.y() + rects[3].height() + 2 * padding, padding);
     const QPoint rightSpritePosition(leftSpritePosition.x() + rects[0].width() + 2 * padding, padding);
 
     const QPoint offsets[4] = {
         QPoint(-rects[0].x(), -rects[0].y()) + leftSpritePosition,
         QPoint(-rects[1].x(), -rects[1].y()) + topSpritePosition,
         QPoint(-rects[2].x(), -rects[2].y()) + rightSpritePosition,
         QPoint(-rects[3].x(), -rects[3].y()) + bottomSpritePosition,
     };
 
     const Qt::Orientation orientations[4] = {
         Qt::Vertical,   // Left
         Qt::Horizontal, // Top
         Qt::Vertical,   // Right
         Qt::Horizontal, // Bottom
     };
 
     for (int i = 0; i < 4; i++) {
         const QRegion intersectedRegion = (region & rects[i]);
         for (const QRect &r : intersectedRegion) {
             if (!r.isValid())
                 continue;
 
             const bool swap = orientations[i] == Qt::Vertical;
 
             const int x0 = r.x();
             const int y0 = r.y();
             const int x1 = r.x() + r.width();
             const int y1 = r.y() + r.height();
 
             const int u0 = (x0 + offsets[i].x()) * textureScale;
             const int v0 = (y0 + offsets[i].y()) * textureScale;
             const int u1 = (x1 + offsets[i].x()) * textureScale;
             const int v1 = (y1 + offsets[i].y()) * textureScale;
 
             WindowQuad quad(WindowQuadDecoration);
             quad.setUVAxisSwapped(swap);
 
             if (swap) {
                 quad[0] = WindowVertex(x0, y0, v0, u0); // Top-left
                 quad[1] = WindowVertex(x1, y0, v0, u1); // Top-right
                 quad[2] = WindowVertex(x1, y1, v1, u1); // Bottom-right
                 quad[3] = WindowVertex(x0, y1, v1, u0); // Bottom-left
             } else {
                 quad[0] = WindowVertex(x0, y0, u0, v0); // Top-left
                 quad[1] = WindowVertex(x1, y0, u1, v0); // Top-right
                 quad[2] = WindowVertex(x1, y1, u1, v1); // Bottom-right
                 quad[3] = WindowVertex(x0, y1, u0, v1); // Bottom-left
             }
 
             list.append(quad);
         }
     }
 
     return list;
 }
 
 WindowQuadList Scene::Window::makeContentsQuads() const
 {
     const QRegion contentsRegion = clientShape();
     if (contentsRegion.isEmpty()) {
         return WindowQuadList();
     }
 
     const QPointF geometryOffset = bufferOffset();
     const qreal textureScale = toplevel->bufferScale();
 
     WindowQuadList quads;
     quads.reserve(contentsRegion.rectCount());
 
     for (const QRectF &rect : contentsRegion) {
         WindowQuad quad(WindowQuadContents);
 
         const qreal x0 = rect.left() + geometryOffset.x();
         const qreal y0 = rect.top() + geometryOffset.y();
         const qreal x1 = rect.right() + geometryOffset.x();
         const qreal y1 = rect.bottom() + geometryOffset.y();
 
         const qreal u0 = rect.left() * textureScale;
         const qreal v0 = rect.top() * textureScale;
         const qreal u1 = rect.right() * textureScale;
         const qreal v1 = rect.bottom() * textureScale;
 
         quad[0] = WindowVertex(QPointF(x0, y0), QPointF(u0, v0));
         quad[1] = WindowVertex(QPointF(x1, y0), QPointF(u1, v0));
         quad[2] = WindowVertex(QPointF(x1, y1), QPointF(u1, v1));
         quad[3] = WindowVertex(QPointF(x0, y1), QPointF(u0, v1));
 
         quads << quad;
     }
 
     return quads;
 }
 
 void Scene::Window::invalidateQuadsCache()
 {
     cached_quad_list.reset();
 }
 
 void Scene::Window::updateShadow(Shadow* shadow)
 {
     if (m_shadow == shadow) {
         return;
     }
     delete m_shadow;
     m_shadow = shadow;
 }
 
 //****************************************
 // WindowPixmap
 //****************************************
 WindowPixmap::WindowPixmap(Scene::Window *window)
     : m_window(window)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_discarded(false)
 {
 }
 
-WindowPixmap::WindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent)
+WindowPixmap::WindowPixmap(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface, WindowPixmap *parent)
     : m_window(parent->m_window)
     , m_pixmap(XCB_PIXMAP_NONE)
     , m_discarded(false)
     , m_parent(parent)
     , m_subSurface(subSurface)
 {
 }
 
 WindowPixmap::~WindowPixmap()
 {
     qDeleteAll(m_children);
 
     if (m_pixmap != XCB_WINDOW_NONE) {
         xcb_free_pixmap(connection(), m_pixmap);
     }
     if (m_buffer) {
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
         QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
         m_buffer->unref();
     }
 }
 
 void WindowPixmap::create()
 {
     if (isValid() || toplevel()->isDeleted()) {
         return;
     }
     // always update from Buffer on Wayland, don't try using XPixmap
     if (kwinApp()->shouldUseWaylandForCompositing()) {
         // use Buffer
         updateBuffer();
         if ((m_buffer || !m_fbo.isNull()) && m_subSurface.isNull()) {
             m_window->unreferencePreviousPixmap();
         }
         return;
     }
     XServerGrabber grabber;
     xcb_pixmap_t pix = xcb_generate_id(connection());
     xcb_void_cookie_t namePixmapCookie = xcb_composite_name_window_pixmap_checked(connection(), toplevel()->frameId(), pix);
     Xcb::WindowAttributes windowAttributes(toplevel()->frameId());
     Xcb::WindowGeometry windowGeometry(toplevel()->frameId());
     if (xcb_generic_error_t *error = xcb_request_check(connection(), namePixmapCookie)) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << error->error_code;
         free(error);
         return;
     }
     // check that the received pixmap is valid and actually matches what we
     // know about the window (i.e. size)
     if (!windowAttributes || windowAttributes->map_state != XCB_MAP_STATE_VIEWABLE) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << this;
         xcb_free_pixmap(connection(), pix);
         return;
     }
     const QRect bufferGeometry = toplevel()->bufferGeometry();
     if (windowGeometry.size() != bufferGeometry.size()) {
         qCDebug(KWIN_CORE) << "Creating window pixmap failed: " << this;
         xcb_free_pixmap(connection(), pix);
         return;
     }
     m_pixmap = pix;
     m_pixmapSize = bufferGeometry.size();
     m_contentsRect = QRect(toplevel()->clientPos(), toplevel()->clientSize());
     m_window->unreferencePreviousPixmap();
 }
 
-WindowPixmap *WindowPixmap::createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface)
+WindowPixmap *WindowPixmap::createChild(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface)
 {
     Q_UNUSED(subSurface)
     return nullptr;
 }
 
 bool WindowPixmap::isValid() const
 {
     if (!m_buffer.isNull() || !m_fbo.isNull() || !m_internalImage.isNull()) {
         return true;
     }
     return m_pixmap != XCB_PIXMAP_NONE;
 }
 
 void WindowPixmap::updateBuffer()
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     if (SurfaceInterface *s = surface()) {
         QVector<WindowPixmap*> oldTree = m_children;
         QVector<WindowPixmap*> children;
-        using namespace KWayland::Server;
+        using namespace KWaylandServer;
         const auto subSurfaces = s->childSubSurfaces();
         for (const auto &subSurface : subSurfaces) {
             if (subSurface.isNull()) {
                 continue;
             }
             auto it = std::find_if(oldTree.begin(), oldTree.end(), [subSurface] (WindowPixmap *p) { return p->m_subSurface == subSurface; });
             if (it != oldTree.end()) {
                 children << *it;
                 (*it)->updateBuffer();
                 oldTree.erase(it);
             } else {
                 WindowPixmap *p = createChild(subSurface);
                 if (p) {
                     p->create();
                     children << p;
                 }
             }
         }
         setChildren(children);
         qDeleteAll(oldTree);
         if (auto b = s->buffer()) {
             if (b == m_buffer) {
                 // no change
                 return;
             }
             if (m_buffer) {
                 QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
                 m_buffer->unref();
             }
             m_buffer = b;
             m_buffer->ref();
             QObject::connect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
         } else if (m_subSurface) {
             if (m_buffer) {
                 QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
                 m_buffer->unref();
                 m_buffer.clear();
             }
         }
     } else if (toplevel()->internalFramebufferObject()) {
         m_fbo = toplevel()->internalFramebufferObject();
     } else if (!toplevel()->internalImageObject().isNull()) {
         m_internalImage = toplevel()->internalImageObject();
     } else {
         if (m_buffer) {
             QObject::disconnect(m_buffer.data(), &BufferInterface::aboutToBeDestroyed, m_buffer.data(), &BufferInterface::unref);
             m_buffer->unref();
             m_buffer.clear();
         }
     }
 }
 
-KWayland::Server::SurfaceInterface *WindowPixmap::surface() const
+KWaylandServer::SurfaceInterface *WindowPixmap::surface() const
 {
     if (!m_subSurface.isNull()) {
         return m_subSurface->surface().data();
     } else {
         return toplevel()->surface();
     }
 }
 
 //****************************************
 // Scene::EffectFrame
 //****************************************
 Scene::EffectFrame::EffectFrame(EffectFrameImpl* frame)
     : m_effectFrame(frame)
 {
 }
 
 Scene::EffectFrame::~EffectFrame()
 {
 }
 
 SceneFactory::SceneFactory(QObject *parent)
     : QObject(parent)
 {
 }
 
 SceneFactory::~SceneFactory()
 {
 }
 
 } // namespace
diff --git a/scene.h b/scene.h
index 5ab668114..bfc3ef1b4 100644
--- a/scene.h
+++ b/scene.h
@@ -1,701 +1,698 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_SCENE_H
 #define KWIN_SCENE_H
 
 #include "toplevel.h"
 #include "utils.h"
 #include "kwineffects.h"
 
 #include <QElapsedTimer>
 #include <QMatrix4x4>
 
 class QOpenGLFramebufferObject;
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class BufferInterface;
 class SubSurfaceInterface;
 }
-}
 
 namespace KWin
 {
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 class Renderer;
 }
 
 class AbstractThumbnailItem;
 class Deleted;
 class EffectFrameImpl;
 class EffectWindowImpl;
 class OverlayWindow;
 class Shadow;
 class WindowPixmap;
 
 // The base class for compositing backends.
 class KWIN_EXPORT Scene : public QObject
 {
     Q_OBJECT
 public:
     explicit Scene(QObject *parent = nullptr);
     ~Scene() override = 0;
     class EffectFrame;
     class Window;
 
     // Returns true if the ctor failed to properly initialize.
     virtual bool initFailed() const = 0;
     virtual CompositingType compositingType() const = 0;
 
     virtual bool hasPendingFlush() const { return false; }
 
     // Repaints the given screen areas, windows provides the stacking order.
     // The entry point for the main part of the painting pass.
     // returns the time since the last vblank signal - if there's one
     // ie. "what of this frame is lost to painting"
     virtual qint64 paint(const QRegion &damage, const QList<Toplevel *> &windows) = 0;
 
     /**
      * Adds the Toplevel to the Scene.
      *
      * If the toplevel gets deleted, then the scene will try automatically
      * to re-bind an underlying scene window to the corresponding Deleted.
      *
      * @param toplevel The window to be added.
      * @note You can add a toplevel to scene only once.
      */
     void addToplevel(Toplevel *toplevel);
 
     /**
      * Removes the Toplevel from the Scene.
      *
      * @param toplevel The window to be removed.
      * @note You can remove a toplevel from the scene only once.
      */
     void removeToplevel(Toplevel *toplevel);
 
     /**
      * @brief Creates the Scene backend of an EffectFrame.
      *
      * @param frame The EffectFrame this Scene::EffectFrame belongs to.
      */
     virtual Scene::EffectFrame *createEffectFrame(EffectFrameImpl *frame) = 0;
     /**
      * @brief Creates the Scene specific Shadow subclass.
      *
      * An implementing class has to create a proper instance. It is not allowed to
      * return @c null.
      *
      * @param toplevel The Toplevel for which the Shadow needs to be created.
      */
     virtual Shadow *createShadow(Toplevel *toplevel) = 0;
     /**
      * Method invoked when the screen geometry is changed.
      * Reimplementing classes should also invoke the parent method
      * as it takes care of resizing the overlay window.
      * @param size The new screen geometry size
      */
     virtual void screenGeometryChanged(const QSize &size);
     // Flags controlling how painting is done.
     enum {
         // Window (or at least part of it) will be painted opaque.
         PAINT_WINDOW_OPAQUE         = 1 << 0,
         // Window (or at least part of it) will be painted translucent.
         PAINT_WINDOW_TRANSLUCENT    = 1 << 1,
         // Window will be painted with transformed geometry.
         PAINT_WINDOW_TRANSFORMED    = 1 << 2,
         // Paint only a region of the screen (can be optimized, cannot
         // be used together with TRANSFORMED flags).
         PAINT_SCREEN_REGION         = 1 << 3,
         // Whole screen will be painted with transformed geometry.
         PAINT_SCREEN_TRANSFORMED    = 1 << 4,
         // At least one window will be painted with transformed geometry.
         PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS = 1 << 5,
         // Clear whole background as the very first step, without optimizing it
         PAINT_SCREEN_BACKGROUND_FIRST = 1 << 6,
         // PAINT_DECORATION_ONLY = 1 << 7 has been removed
         // Window will be painted with a lanczos filter.
         PAINT_WINDOW_LANCZOS = 1 << 8
         // PAINT_SCREEN_WITH_TRANSFORMED_WINDOWS_WITHOUT_FULL_REPAINTS = 1 << 9 has been removed
     };
     // types of filtering available
     enum ImageFilterType { ImageFilterFast, ImageFilterGood };
     // there's nothing to paint (adjust time_diff later)
     virtual void idle();
     virtual bool blocksForRetrace() const;
     virtual bool syncsToVBlank() const;
     virtual OverlayWindow* overlayWindow() const = 0;
 
     virtual bool makeOpenGLContextCurrent();
     virtual void doneOpenGLContextCurrent();
 
     virtual QMatrix4x4 screenProjectionMatrix() const;
 
     /**
      * Whether the Scene uses an X11 overlay window to perform compositing.
      */
     virtual bool usesOverlayWindow() const = 0;
 
     virtual void triggerFence();
 
     virtual Decoration::Renderer *createDecorationRenderer(Decoration::DecoratedClientImpl *) = 0;
 
     /**
      * Whether the Scene is able to drive animations.
      * This is used as a hint to the effects system which effects can be supported.
      * If the Scene performs software rendering it is supposed to return @c false,
      * if rendering is hardware accelerated it should return @c true.
      */
     virtual bool animationsSupported() const = 0;
 
     /**
      * The render buffer used by an XRender based compositor scene.
      * Default implementation returns XCB_RENDER_PICTURE_NONE
      */
     virtual xcb_render_picture_t xrenderBufferPicture() const;
 
     /**
      * The QPainter used by a QPainter based compositor scene.
      * Default implementation returns @c nullptr;
      */
     virtual QPainter *scenePainter() const;
 
     /**
      * The render buffer used by a QPainter based compositor.
      * Default implementation returns @c nullptr.
      */
     virtual QImage *qpainterRenderBuffer() const;
 
     /**
      * The backend specific extensions (e.g. EGL/GLX extensions).
      *
      * Not the OpenGL (ES) extension!
      *
      * Default implementation returns empty list
      */
     virtual QVector<QByteArray> openGLPlatformInterfaceExtensions() const;
 
 Q_SIGNALS:
     void frameRendered();
     void resetCompositing();
 
 public Q_SLOTS:
     // shape/size of a window changed
     void windowGeometryShapeChanged(KWin::Toplevel* c);
     // a window has been closed
     void windowClosed(KWin::Toplevel* c, KWin::Deleted* deleted);
 protected:
     virtual Window *createWindow(Toplevel *toplevel) = 0;
     void createStackingOrder(const QList<Toplevel *> &toplevels);
     void clearStackingOrder();
     // shared implementation, starts painting the screen
     void paintScreen(int *mask, const QRegion &damage, const QRegion &repaint,
                      QRegion *updateRegion, QRegion *validRegion, const QMatrix4x4 &projection = QMatrix4x4(), const QRect &outputGeometry = QRect(), const qreal screenScale = 1.0);
     // Render cursor texture in case hardware cursor is disabled/non-applicable
     virtual void paintCursor() = 0;
     friend class EffectsHandlerImpl;
     // called after all effects had their paintScreen() called
     void finalPaintScreen(int mask, const QRegion &region, ScreenPaintData& data);
     // shared implementation of painting the screen in the generic
     // (unoptimized) way
     virtual void paintGenericScreen(int mask, const ScreenPaintData &data);
     // shared implementation of painting the screen in an optimized way
     virtual void paintSimpleScreen(int mask, const QRegion &region);
     // paint the background (not the desktop background - the whole background)
     virtual void paintBackground(const QRegion &region) = 0;
     // called after all effects had their paintWindow() called
     void finalPaintWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data);
     // shared implementation, starts painting the window
     virtual void paintWindow(Window* w, int mask, const QRegion &region, const WindowQuadList &quads);
     // called after all effects had their drawWindow() called
     virtual void finalDrawWindow(EffectWindowImpl* w, int mask, const QRegion &region, WindowPaintData& data);
     // let the scene decide whether it's better to paint more of the screen, eg. in order to allow a buffer swap
     // the default is NOOP
     virtual void extendPaintRegion(QRegion &region, bool opaqueFullscreen);
     virtual void paintDesktop(int desktop, int mask, const QRegion &region, ScreenPaintData &data);
 
     virtual void paintEffectQuickView(EffectQuickView *w) = 0;
 
     // compute time since the last repaint
     void updateTimeDiff();
     // saved data for 2nd pass of optimized screen painting
     struct Phase2Data {
         Window *window = nullptr;
         QRegion region;
         QRegion clip;
         int mask = 0;
         WindowQuadList quads;
     };
     // The region which actually has been painted by paintScreen() and should be
     // copied from the buffer to the screen. I.e. the region returned from Scene::paintScreen().
     // Since prePaintWindow() can extend areas to paint, these changes would have to propagate
     // up all the way from paintSimpleScreen() up to paintScreen(), so save them here rather
     // than propagate them up in arguments.
     QRegion painted_region;
     // Additional damage that needs to be repaired to bring a reused back buffer up to date
     QRegion repaint_region;
     // The dirty region before it was unioned with repaint_region
     QRegion damaged_region;
     // time since last repaint
     int time_diff;
     QElapsedTimer last_time;
 private:
     void paintWindowThumbnails(Scene::Window *w, const QRegion &region, qreal opacity, qreal brightness, qreal saturation);
     void paintDesktopThumbnails(Scene::Window *w);
     QHash< Toplevel*, Window* > m_windows;
     // windows in their stacking order
     QVector< Window* > stacking_order;
 };
 
 /**
  * Factory class to create a Scene. Needs to be implemented by the plugins.
  */
 class KWIN_EXPORT SceneFactory : public QObject
 {
     Q_OBJECT
 public:
     ~SceneFactory() override;
 
     /**
      * @returns The created Scene, may be @c nullptr.
      */
     virtual Scene *create(QObject *parent = nullptr) const = 0;
 
 protected:
     explicit SceneFactory(QObject *parent);
 };
 
 // The base class for windows representations in composite backends
 class Scene::Window
 {
 public:
     Window(Toplevel* c);
     virtual ~Window();
     // perform the actual painting of the window
     virtual void performPaint(int mask, const QRegion &region, const WindowPaintData &data) = 0;
     // do any cleanup needed when the window's composite pixmap is discarded
     void discardPixmap();
     void updatePixmap();
     int x() const;
     int y() const;
     int width() const;
     int height() const;
     QRect geometry() const;
     QPoint pos() const;
     QSize size() const;
     QRect rect() const;
     // access to the internal window class
     // TODO eventually get rid of this
     Toplevel* window() const;
     // should the window be painted
     bool isPaintingEnabled() const;
     void resetPaintingEnabled();
     // Flags explaining why painting should be disabled
     enum {
         // Window will not be painted
         PAINT_DISABLED                 = 1 << 0,
         // Window will not be painted because it is deleted
         PAINT_DISABLED_BY_DELETE       = 1 << 1,
         // Window will not be painted because of which desktop it's on
         PAINT_DISABLED_BY_DESKTOP      = 1 << 2,
         // Window will not be painted because it is minimized
         PAINT_DISABLED_BY_MINIMIZE     = 1 << 3,
         // Window will not be painted because it's not on the current activity
         PAINT_DISABLED_BY_ACTIVITY     = 1 << 5
     };
     void enablePainting(int reason);
     void disablePainting(int reason);
     // is the window visible at all
     bool isVisible() const;
     // is the window fully opaque
     bool isOpaque() const;
     // shape of the window
     QRegion bufferShape() const;
     QRegion clientShape() const;
     QRegion decorationShape() const;
     QPoint bufferOffset() const;
     void discardShape();
     void updateToplevel(Toplevel* c);
     // creates initial quad list for the window
     virtual WindowQuadList buildQuads(bool force = false) const;
     void updateShadow(Shadow* shadow);
     const Shadow* shadow() const;
     Shadow* shadow();
     void referencePreviousPixmap();
     void unreferencePreviousPixmap();
     void invalidateQuadsCache();
 protected:
     WindowQuadList makeDecorationQuads(const QRect *rects, const QRegion &region, qreal textureScale = 1.0) const;
     WindowQuadList makeContentsQuads() const;
     /**
      * @brief Returns the WindowPixmap for this Window.
      *
      * If the WindowPixmap does not yet exist, this method will invoke createWindowPixmap.
      * If the WindowPixmap is not valid it tries to create it, in case this succeeds the WindowPixmap is
      * returned. In case it fails, the previous (and still valid) WindowPixmap is returned.
      *
      * @note This method can return @c NULL as there might neither be a valid previous nor current WindowPixmap
      * around.
      *
      * The WindowPixmap gets casted to the type passed in as a template parameter. That way this class does not
      * need to know the actual WindowPixmap subclass used by the concrete Scene implementations.
      *
      * @return The WindowPixmap casted to T* or @c NULL if there is no valid window pixmap.
      */
     template<typename T> T *windowPixmap();
     template<typename T> T *previousWindowPixmap();
     /**
      * @brief Factory method to create a WindowPixmap.
      *
      * The inheriting classes need to implement this method to create a new instance of their WindowPixmap subclass.
      * @note Do not use WindowPixmap::create on the created instance. The Scene will take care of that.
      */
     virtual WindowPixmap *createWindowPixmap() = 0;
     Toplevel* toplevel;
     ImageFilterType filter;
     Shadow *m_shadow;
 private:
     QScopedPointer<WindowPixmap> m_currentPixmap;
     QScopedPointer<WindowPixmap> m_previousPixmap;
     int m_referencePixmapCounter;
     int disable_painting;
     mutable QRegion m_bufferShape;
     mutable bool m_bufferShapeIsValid = false;
     mutable QScopedPointer<WindowQuadList> cached_quad_list;
     Q_DISABLE_COPY(Window)
 };
 
 /**
  * @brief Wrapper for a pixmap of the Scene::Window.
  *
  * This class encapsulates the functionality to get the pixmap for a window. When initialized the pixmap is not yet
  * mapped to the window and isValid will return @c false. The pixmap mapping to the window can be established
  * through @ref create. If it succeeds isValid will return @c true, otherwise it will keep in the non valid
  * state and it can be tried to create the pixmap mapping again (e.g. in the next frame).
  *
  * This class is not intended to be updated when the pixmap is no longer valid due to e.g. resizing the window.
  * Instead a new instance of this class should be instantiated. The idea behind this is that a valid pixmap does not
  * get destroyed, but can continue to be used. To indicate that a newer pixmap should in generally be around, one can
  * use markAsDiscarded.
  *
  * This class is intended to be inherited for the needs of the compositor backends which need further mapping from
  * the native pixmap to the respective rendering format.
  */
 class KWIN_EXPORT WindowPixmap
 {
 public:
     virtual ~WindowPixmap();
     /**
      * @brief Tries to create the mapping between the Window and the pixmap.
      *
      * In case this method succeeds in creating the pixmap for the window, isValid will return @c true otherwise
      * @c false.
      *
      * Inheriting classes should re-implement this method in case they need to add further functionality for mapping the
      * native pixmap to the rendering format.
      */
     virtual void create();
     /**
      * @return @c true if the pixmap has been created and is valid, @c false otherwise
      */
     virtual bool isValid() const;
     /**
      * @return The native X11 pixmap handle
      */
     xcb_pixmap_t pixmap() const;
     /**
      * @return The Wayland BufferInterface for this WindowPixmap.
      */
-    QPointer<KWayland::Server::BufferInterface> buffer() const;
+    QPointer<KWaylandServer::BufferInterface> buffer() const;
     const QSharedPointer<QOpenGLFramebufferObject> &fbo() const;
     QImage internalImage() const;
     /**
      * @brief Whether this WindowPixmap is considered as discarded. This means the window has changed in a way that a new
      * WindowPixmap should have been created already.
      *
      * @return @c true if this WindowPixmap is considered as discarded, @c false otherwise.
      * @see markAsDiscarded
      */
     bool isDiscarded() const;
     /**
      * @brief Marks this WindowPixmap as discarded. From now on isDiscarded will return @c true. This method should
      * only be used by the Window when it changes in a way that a new pixmap is required.
      *
      * @see isDiscarded
      */
     void markAsDiscarded();
     /**
      * The size of the pixmap.
      */
     const QSize &size() const;
     /**
      * The geometry of the Client's content inside the pixmap. In case of a decorated Client the
      * pixmap also contains the decoration which is not rendered into this pixmap, though. This
      * contentsRect tells where inside the complete pixmap the real content is.
      */
     const QRect &contentsRect() const;
     /**
      * @brief Returns the Toplevel this WindowPixmap belongs to.
      * Note: the Toplevel can change over the lifetime of the WindowPixmap in case the Toplevel is copied to Deleted.
      */
     Toplevel *toplevel() const;
 
     /**
      * @returns the parent WindowPixmap in the sub-surface tree
      */
     WindowPixmap *parent() const {
         return m_parent;
     }
 
     /**
      * @returns the current sub-surface tree
      */
     QVector<WindowPixmap*> children() const {
         return m_children;
     }
 
     /**
      * @returns the subsurface this WindowPixmap is for if it is not for a root window
      */
-    QPointer<KWayland::Server::SubSurfaceInterface> subSurface() const {
+    QPointer<KWaylandServer::SubSurfaceInterface> subSurface() const {
         return m_subSurface;
     }
 
     /**
      * @returns the surface this WindowPixmap references, might be @c null.
      */
-    KWayland::Server::SurfaceInterface *surface() const;
+    KWaylandServer::SurfaceInterface *surface() const;
 
 protected:
     explicit WindowPixmap(Scene::Window *window);
-    explicit WindowPixmap(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface, WindowPixmap *parent);
-    virtual WindowPixmap *createChild(const QPointer<KWayland::Server::SubSurfaceInterface> &subSurface);
+    explicit WindowPixmap(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface, WindowPixmap *parent);
+    virtual WindowPixmap *createChild(const QPointer<KWaylandServer::SubSurfaceInterface> &subSurface);
     /**
      * @return The Window this WindowPixmap belongs to
      */
     Scene::Window *window();
 
     /**
      * Should be called by the implementing subclasses when the Wayland Buffer changed and needs
      * updating.
      */
     virtual void updateBuffer();
 
     /**
      * Sets the sub-surface tree to @p children.
      */
     void setChildren(const QVector<WindowPixmap*> &children) {
         m_children = children;
     }
 
 private:
     Scene::Window *m_window;
     xcb_pixmap_t m_pixmap;
     QSize m_pixmapSize;
     bool m_discarded;
     QRect m_contentsRect;
-    QPointer<KWayland::Server::BufferInterface> m_buffer;
+    QPointer<KWaylandServer::BufferInterface> m_buffer;
     QSharedPointer<QOpenGLFramebufferObject> m_fbo;
     QImage m_internalImage;
     WindowPixmap *m_parent = nullptr;
     QVector<WindowPixmap*> m_children;
-    QPointer<KWayland::Server::SubSurfaceInterface> m_subSurface;
+    QPointer<KWaylandServer::SubSurfaceInterface> m_subSurface;
 };
 
 class Scene::EffectFrame
 {
 public:
     EffectFrame(EffectFrameImpl* frame);
     virtual ~EffectFrame();
     virtual void render(const QRegion &region, double opacity, double frameOpacity) = 0;
     virtual void free() = 0;
     virtual void freeIconFrame() = 0;
     virtual void freeTextFrame() = 0;
     virtual void freeSelection() = 0;
     virtual void crossFadeIcon() = 0;
     virtual void crossFadeText() = 0;
 
 protected:
     EffectFrameImpl* m_effectFrame;
 };
 
 inline
 int Scene::Window::x() const
 {
     return toplevel->x();
 }
 
 inline
 int Scene::Window::y() const
 {
     return toplevel->y();
 }
 
 inline
 int Scene::Window::width() const
 {
     return toplevel->width();
 }
 
 inline
 int Scene::Window::height() const
 {
     return toplevel->height();
 }
 
 inline
 QRect Scene::Window::geometry() const
 {
     return toplevel->frameGeometry();
 }
 
 inline
 QSize Scene::Window::size() const
 {
     return toplevel->size();
 }
 
 inline
 QPoint Scene::Window::pos() const
 {
     return toplevel->pos();
 }
 
 inline
 QRect Scene::Window::rect() const
 {
     return toplevel->rect();
 }
 
 inline
 Toplevel* Scene::Window::window() const
 {
     return toplevel;
 }
 
 inline
 void Scene::Window::updateToplevel(Toplevel* c)
 {
     toplevel = c;
 }
 
 inline
 const Shadow* Scene::Window::shadow() const
 {
     return m_shadow;
 }
 
 inline
 Shadow* Scene::Window::shadow()
 {
     return m_shadow;
 }
 
 inline
-QPointer<KWayland::Server::BufferInterface> WindowPixmap::buffer() const
+QPointer<KWaylandServer::BufferInterface> WindowPixmap::buffer() const
 {
     return m_buffer;
 }
 
 inline
 const QSharedPointer<QOpenGLFramebufferObject> &WindowPixmap::fbo() const
 {
     return m_fbo;
 }
 
 inline
 QImage WindowPixmap::internalImage() const
 {
     return m_internalImage;
 }
 
 template <typename T>
 inline
 T* Scene::Window::windowPixmap()
 {
     if (m_currentPixmap.isNull()) {
         m_currentPixmap.reset(createWindowPixmap());
     }
     if (m_currentPixmap->isValid()) {
         return static_cast<T*>(m_currentPixmap.data());
     }
     m_currentPixmap->create();
     if (m_currentPixmap->isValid()) {
         return static_cast<T*>(m_currentPixmap.data());
     } else {
         return static_cast<T*>(m_previousPixmap.data());
     }
 }
 
 template <typename T>
 inline
 T* Scene::Window::previousWindowPixmap()
 {
     return static_cast<T*>(m_previousPixmap.data());
 }
 
 inline
 Toplevel* WindowPixmap::toplevel() const
 {
     return m_window->window();
 }
 
 inline
 xcb_pixmap_t WindowPixmap::pixmap() const
 {
     return m_pixmap;
 }
 
 inline
 bool WindowPixmap::isDiscarded() const
 {
     return m_discarded;
 }
 
 inline
 void WindowPixmap::markAsDiscarded()
 {
     m_discarded = true;
     m_window->referencePreviousPixmap();
 }
 
 inline
 const QRect &WindowPixmap::contentsRect() const
 {
     return m_contentsRect;
 }
 
 inline
 const QSize &WindowPixmap::size() const
 {
     return m_pixmapSize;
 }
 
 } // namespace
 
 Q_DECLARE_INTERFACE(KWin::SceneFactory, "org.kde.kwin.Scene")
 
 #endif
diff --git a/shadow.cpp b/shadow.cpp
index 85e9b2f46..ccb0dafd5 100644
--- a/shadow.cpp
+++ b/shadow.cpp
@@ -1,501 +1,501 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2011 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "shadow.h"
 // kwin
 #include "atoms.h"
 #include "abstract_client.h"
 #include "composite.h"
 #include "effects.h"
 #include "internal_client.h"
 #include "toplevel.h"
 #include "wayland_server.h"
 
 #include <KDecoration2/Decoration>
 #include <KDecoration2/DecorationShadow>
 
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/shadow_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/shadow_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <QWindow>
 
 Q_DECLARE_METATYPE(QMargins)
 
 namespace KWin
 {
 
 Shadow::Shadow(Toplevel *toplevel)
     : m_topLevel(toplevel)
     , m_cachedSize(toplevel->size())
     , m_decorationShadow(nullptr)
 {
     connect(m_topLevel, &Toplevel::frameGeometryChanged, this, &Shadow::geometryChanged);
 }
 
 Shadow::~Shadow()
 {
 }
 
 Shadow *Shadow::createShadow(Toplevel *toplevel)
 {
     if (!effects) {
         return nullptr;
     }
     Shadow *shadow = createShadowFromDecoration(toplevel);
     if (!shadow && waylandServer()) {
         shadow = createShadowFromWayland(toplevel);
     }
     if (!shadow && kwinApp()->x11Connection()) {
         shadow = createShadowFromX11(toplevel);
     }
     if (!shadow) {
         shadow = createShadowFromInternalWindow(toplevel);
     }
     if (!shadow) {
         return nullptr;
     }
     if (toplevel->effectWindow() && toplevel->effectWindow()->sceneWindow()) {
         toplevel->effectWindow()->sceneWindow()->updateShadow(shadow);
         emit toplevel->shadowChanged();
     }
     return shadow;
 }
 
 Shadow *Shadow::createShadowFromX11(Toplevel *toplevel)
 {
     auto data = Shadow::readX11ShadowProperty(toplevel->window());
     if (!data.isEmpty()) {
         Shadow *shadow = Compositor::self()->scene()->createShadow(toplevel);
 
         if (!shadow->init(data)) {
             delete shadow;
             return nullptr;
         }
         return shadow;
     } else {
         return nullptr;
     }
 }
 
 Shadow *Shadow::createShadowFromDecoration(Toplevel *toplevel)
 {
     AbstractClient *c = qobject_cast<AbstractClient*>(toplevel);
     if (!c) {
         return nullptr;
     }
     if (!c->decoration()) {
         return nullptr;
     }
     Shadow *shadow = Compositor::self()->scene()->createShadow(toplevel);
     if (!shadow->init(c->decoration())) {
         delete shadow;
         return nullptr;
     }
     return shadow;
 }
 
 Shadow *Shadow::createShadowFromWayland(Toplevel *toplevel)
 {
     auto surface = toplevel->surface();
     if (!surface) {
         return nullptr;
     }
     const auto s = surface->shadow();
     if (!s) {
         return nullptr;
     }
     Shadow *shadow = Compositor::self()->scene()->createShadow(toplevel);
     if (!shadow->init(s)) {
         delete shadow;
         return nullptr;
     }
     return shadow;
 }
 
 Shadow *Shadow::createShadowFromInternalWindow(Toplevel *toplevel)
 {
     const InternalClient *client = qobject_cast<InternalClient *>(toplevel);
     if (!client) {
         return nullptr;
     }
     const QWindow *window = client->internalWindow();
     if (!window) {
         return nullptr;
     }
     Shadow *shadow = Compositor::self()->scene()->createShadow(toplevel);
     if (!shadow->init(window)) {
         delete shadow;
         return nullptr;
     }
     return shadow;
 }
 
 QVector< uint32_t > Shadow::readX11ShadowProperty(xcb_window_t id)
 {
     QVector<uint32_t> ret;
     if (id != XCB_WINDOW_NONE) {
         Xcb::Property property(false, id, atoms->kde_net_wm_shadow, XCB_ATOM_CARDINAL, 0, 12);
         uint32_t *shadow = property.value<uint32_t*>();
         if (shadow) {
             ret.reserve(12);
             for (int i=0; i<12; ++i) {
                 ret << shadow[i];
             }
         }
     }
     return ret;
 }
 
 bool Shadow::init(const QVector< uint32_t > &data)
 {
     QVector<Xcb::WindowGeometry> pixmapGeometries(ShadowElementsCount);
     QVector<xcb_get_image_cookie_t> getImageCookies(ShadowElementsCount);
     auto *c = connection();
     for (int i = 0; i < ShadowElementsCount; ++i) {
         pixmapGeometries[i] = Xcb::WindowGeometry(data[i]);
     }
     auto discardReplies = [&getImageCookies](int start) {
         for (int i = start; i < getImageCookies.size(); ++i) {
             xcb_discard_reply(connection(), getImageCookies.at(i).sequence);
         }
     };
     for (int i = 0; i < ShadowElementsCount; ++i) {
         auto &geo = pixmapGeometries[i];
         if (geo.isNull()) {
             discardReplies(0);
             return false;
         }
         getImageCookies[i] = xcb_get_image_unchecked(c, XCB_IMAGE_FORMAT_Z_PIXMAP, data[i],
                                                      0, 0, geo->width, geo->height, ~0);
     }
     for (int i = 0; i < ShadowElementsCount; ++i) {
         auto *reply = xcb_get_image_reply(c, getImageCookies.at(i), nullptr);
         if (!reply) {
             discardReplies(i+1);
             return false;
         }
         auto &geo = pixmapGeometries[i];
         QImage image(xcb_get_image_data(reply), geo->width, geo->height, QImage::Format_ARGB32);
         m_shadowElements[i] = QPixmap::fromImage(image);
         free(reply);
     }
     m_topOffset = data[ShadowElementsCount];
     m_rightOffset = data[ShadowElementsCount+1];
     m_bottomOffset = data[ShadowElementsCount+2];
     m_leftOffset = data[ShadowElementsCount+3];
     updateShadowRegion();
     if (!prepareBackend()) {
         return false;
     }
     buildQuads();
     return true;
 }
 
 bool Shadow::init(KDecoration2::Decoration *decoration)
 {
     if (m_decorationShadow) {
         // disconnect previous connections
         disconnect(m_decorationShadow.data(), &KDecoration2::DecorationShadow::innerShadowRectChanged, m_topLevel, &Toplevel::updateShadow);
         disconnect(m_decorationShadow.data(), &KDecoration2::DecorationShadow::shadowChanged,        m_topLevel, &Toplevel::updateShadow);
         disconnect(m_decorationShadow.data(), &KDecoration2::DecorationShadow::paddingChanged,       m_topLevel, &Toplevel::updateShadow);
     }
     m_decorationShadow = decoration->shadow();
     if (!m_decorationShadow) {
         return false;
     }
     // setup connections - all just mapped to recreate
     connect(m_decorationShadow.data(), &KDecoration2::DecorationShadow::innerShadowRectChanged, m_topLevel, &Toplevel::updateShadow);
     connect(m_decorationShadow.data(), &KDecoration2::DecorationShadow::shadowChanged,        m_topLevel, &Toplevel::updateShadow);
     connect(m_decorationShadow.data(), &KDecoration2::DecorationShadow::paddingChanged,       m_topLevel, &Toplevel::updateShadow);
 
     const QMargins &p = m_decorationShadow->padding();
     m_topOffset    = p.top();
     m_rightOffset  = p.right();
     m_bottomOffset = p.bottom();
     m_leftOffset   = p.left();
     updateShadowRegion();
     if (!prepareBackend()) {
         return false;
     }
     buildQuads();
     return true;
 }
 
-bool Shadow::init(const QPointer< KWayland::Server::ShadowInterface > &shadow)
+bool Shadow::init(const QPointer< KWaylandServer::ShadowInterface > &shadow)
 {
     if (!shadow) {
         return false;
     }
 
     m_shadowElements[ShadowElementTop] = shadow->top() ? QPixmap::fromImage(shadow->top()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementTopRight] = shadow->topRight() ? QPixmap::fromImage(shadow->topRight()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementRight] = shadow->right() ? QPixmap::fromImage(shadow->right()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementBottomRight] = shadow->bottomRight() ? QPixmap::fromImage(shadow->bottomRight()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementBottom] = shadow->bottom() ? QPixmap::fromImage(shadow->bottom()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementBottomLeft] = shadow->bottomLeft() ? QPixmap::fromImage(shadow->bottomLeft()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementLeft] = shadow->left() ? QPixmap::fromImage(shadow->left()->data().copy()) : QPixmap();
     m_shadowElements[ShadowElementTopLeft] = shadow->topLeft() ? QPixmap::fromImage(shadow->topLeft()->data().copy()) : QPixmap();
 
     const QMarginsF &p = shadow->offset();
     m_topOffset    = p.top();
     m_rightOffset  = p.right();
     m_bottomOffset = p.bottom();
     m_leftOffset   = p.left();
     updateShadowRegion();
     if (!prepareBackend()) {
         return false;
     }
     buildQuads();
     return true;
 }
 
 bool Shadow::init(const QWindow *window)
 {
     const bool isEnabled = window->property("kwin_shadow_enabled").toBool();
     if (!isEnabled) {
         return false;
     }
 
     const QImage leftTile = window->property("kwin_shadow_left_tile").value<QImage>();
     const QImage topLeftTile = window->property("kwin_shadow_top_left_tile").value<QImage>();
     const QImage topTile = window->property("kwin_shadow_top_tile").value<QImage>();
     const QImage topRightTile = window->property("kwin_shadow_top_right_tile").value<QImage>();
     const QImage rightTile = window->property("kwin_shadow_right_tile").value<QImage>();
     const QImage bottomRightTile = window->property("kwin_shadow_bottom_right_tile").value<QImage>();
     const QImage bottomTile = window->property("kwin_shadow_bottom_tile").value<QImage>();
     const QImage bottomLeftTile = window->property("kwin_shadow_bottom_left_tile").value<QImage>();
 
     m_shadowElements[ShadowElementLeft] = QPixmap::fromImage(leftTile);
     m_shadowElements[ShadowElementTopLeft] = QPixmap::fromImage(topLeftTile);
     m_shadowElements[ShadowElementTop] = QPixmap::fromImage(topTile);
     m_shadowElements[ShadowElementTopRight] = QPixmap::fromImage(topRightTile);
     m_shadowElements[ShadowElementRight] = QPixmap::fromImage(rightTile);
     m_shadowElements[ShadowElementBottomRight] = QPixmap::fromImage(bottomRightTile);
     m_shadowElements[ShadowElementBottom] = QPixmap::fromImage(bottomTile);
     m_shadowElements[ShadowElementBottomLeft] = QPixmap::fromImage(bottomLeftTile);
 
     const QMargins padding = window->property("kwin_shadow_padding").value<QMargins>();
 
     m_leftOffset = padding.left();
     m_topOffset = padding.top();
     m_rightOffset = padding.right();
     m_bottomOffset = padding.bottom();
 
     updateShadowRegion();
 
     if (!prepareBackend()) {
         return false;
     }
 
     buildQuads();
 
     return true;
 }
 
 void Shadow::updateShadowRegion()
 {
     const QRect top(0, - m_topOffset, m_topLevel->width(), m_topOffset);
     const QRect right(m_topLevel->width(), - m_topOffset, m_rightOffset, m_topLevel->height() + m_topOffset + m_bottomOffset);
     const QRect bottom(0, m_topLevel->height(), m_topLevel->width(), m_bottomOffset);
     const QRect left(- m_leftOffset, - m_topOffset, m_leftOffset, m_topLevel->height() + m_topOffset + m_bottomOffset);
     m_shadowRegion = QRegion(top).united(right).united(bottom).united(left);
 }
 
 void Shadow::buildQuads()
 {
     // prepare window quads
     m_shadowQuads.clear();
     const QSize top(m_shadowElements[ShadowElementTop].size());
     const QSize topRight(m_shadowElements[ShadowElementTopRight].size());
     const QSize right(m_shadowElements[ShadowElementRight].size());
     const QSize bottomRight(m_shadowElements[ShadowElementBottomRight].size());
     const QSize bottom(m_shadowElements[ShadowElementBottom].size());
     const QSize bottomLeft(m_shadowElements[ShadowElementBottomLeft].size());
     const QSize left(m_shadowElements[ShadowElementLeft].size());
     const QSize topLeft(m_shadowElements[ShadowElementTopLeft].size());
     if ((left.width() - m_leftOffset > m_topLevel->width()) ||
         (right.width() - m_rightOffset > m_topLevel->width()) ||
         (top.height() - m_topOffset > m_topLevel->height()) ||
         (bottom.height() - m_bottomOffset > m_topLevel->height())) {
         // if our shadow is bigger than the window, we don't render the shadow
         m_shadowRegion = QRegion();
         return;
     }
 
     const QRect outerRect(QPoint(-m_leftOffset, -m_topOffset), QPoint(m_topLevel->width() + m_rightOffset, m_topLevel->height() + m_bottomOffset));
 
     WindowQuad topLeftQuad(WindowQuadShadowTopLeft);
     topLeftQuad[ 0 ] = WindowVertex(outerRect.x(),                      outerRect.y(), 0.0, 0.0);
     topLeftQuad[ 1 ] = WindowVertex(outerRect.x() + topLeft.width(),    outerRect.y(), 1.0, 0.0);
     topLeftQuad[ 2 ] = WindowVertex(outerRect.x() + topLeft.width(),    outerRect.y() + topLeft.height(), 1.0, 1.0);
     topLeftQuad[ 3 ] = WindowVertex(outerRect.x(),                      outerRect.y() + topLeft.height(), 0.0, 1.0);
     m_shadowQuads.append(topLeftQuad);
 
     WindowQuad topQuad(WindowQuadShadowTop);
     topQuad[ 0 ] = WindowVertex(outerRect.x() + topLeft.width(),        outerRect.y(), 0.0, 0.0);
     topQuad[ 1 ] = WindowVertex(outerRect.right() - topRight.width(),   outerRect.y(), 1.0, 0.0);
     topQuad[ 2 ] = WindowVertex(outerRect.right() - topRight.width(),   outerRect.y() + top.height(), 1.0, 1.0);
     topQuad[ 3 ] = WindowVertex(outerRect.x() + topLeft.width(),        outerRect.y() + top.height(), 0.0, 1.0);
     m_shadowQuads.append(topQuad);
 
     WindowQuad topRightQuad(WindowQuadShadowTopRight);
     topRightQuad[ 0 ] = WindowVertex(outerRect.right() - topRight.width(),  outerRect.y(), 0.0, 0.0);
     topRightQuad[ 1 ] = WindowVertex(outerRect.right(),                     outerRect.y(), 1.0, 0.0);
     topRightQuad[ 2 ] = WindowVertex(outerRect.right(),                     outerRect.y() + topRight.height(), 1.0, 1.0);
     topRightQuad[ 3 ] = WindowVertex(outerRect.right() - topRight.width(),  outerRect.y() + topRight.height(), 0.0, 1.0);
     m_shadowQuads.append(topRightQuad);
 
     WindowQuad rightQuad(WindowQuadShadowRight);
     rightQuad[ 0 ] = WindowVertex(outerRect.right() - right.width(),    outerRect.y() + topRight.height(), 0.0, 0.0);
     rightQuad[ 1 ] = WindowVertex(outerRect.right(),                    outerRect.y() + topRight.height(), 1.0, 0.0);
     rightQuad[ 2 ] = WindowVertex(outerRect.right(),                    outerRect.bottom() - bottomRight.height(), 1.0, 1.0);
     rightQuad[ 3 ] = WindowVertex(outerRect.right() - right.width(),    outerRect.bottom() - bottomRight.height(), 0.0, 1.0);
     m_shadowQuads.append(rightQuad);
 
     WindowQuad bottomRightQuad(WindowQuadShadowBottomRight);
     bottomRightQuad[ 0 ] = WindowVertex(outerRect.right() - bottomRight.width(),    outerRect.bottom() - bottomRight.height(), 0.0, 0.0);
     bottomRightQuad[ 1 ] = WindowVertex(outerRect.right(),                          outerRect.bottom() - bottomRight.height(), 1.0, 0.0);
     bottomRightQuad[ 2 ] = WindowVertex(outerRect.right(),                          outerRect.bottom(), 1.0, 1.0);
     bottomRightQuad[ 3 ] = WindowVertex(outerRect.right() - bottomRight.width(),    outerRect.bottom(), 0.0, 1.0);
     m_shadowQuads.append(bottomRightQuad);
 
     WindowQuad bottomQuad(WindowQuadShadowBottom);
     bottomQuad[ 0 ] = WindowVertex(outerRect.x() + bottomLeft.width(),      outerRect.bottom() - bottom.height(), 0.0, 0.0);
     bottomQuad[ 1 ] = WindowVertex(outerRect.right() - bottomRight.width(), outerRect.bottom() - bottom.height(), 1.0, 0.0);
     bottomQuad[ 2 ] = WindowVertex(outerRect.right() - bottomRight.width(), outerRect.bottom(), 1.0, 1.0);
     bottomQuad[ 3 ] = WindowVertex(outerRect.x() + bottomLeft.width(),      outerRect.bottom(), 0.0, 1.0);
     m_shadowQuads.append(bottomQuad);
 
     WindowQuad bottomLeftQuad(WindowQuadShadowBottomLeft);
     bottomLeftQuad[ 0 ] = WindowVertex(outerRect.x(),                       outerRect.bottom() - bottomLeft.height(), 0.0, 0.0);
     bottomLeftQuad[ 1 ] = WindowVertex(outerRect.x() + bottomLeft.width(),  outerRect.bottom() - bottomLeft.height(), 1.0, 0.0);
     bottomLeftQuad[ 2 ] = WindowVertex(outerRect.x() + bottomLeft.width(),  outerRect.bottom(), 1.0, 1.0);
     bottomLeftQuad[ 3 ] = WindowVertex(outerRect.x(),                       outerRect.bottom(), 0.0, 1.0);
     m_shadowQuads.append(bottomLeftQuad);
 
     WindowQuad leftQuad(WindowQuadShadowLeft);
     leftQuad[ 0 ] = WindowVertex(outerRect.x(),                 outerRect.y() + topLeft.height(), 0.0, 0.0);
     leftQuad[ 1 ] = WindowVertex(outerRect.x() + left.width(),  outerRect.y() + topLeft.height(), 1.0, 0.0);
     leftQuad[ 2 ] = WindowVertex(outerRect.x() + left.width(),  outerRect.bottom() - bottomLeft.height(), 1.0, 1.0);
     leftQuad[ 3 ] = WindowVertex(outerRect.x(),                 outerRect.bottom() - bottomLeft.height(), 0.0, 1.0);
     m_shadowQuads.append(leftQuad);
 }
 
 bool Shadow::updateShadow()
 {
     if (!m_topLevel) {
         return false;
     }
 
     if (m_decorationShadow) {
         if (AbstractClient *c = qobject_cast<AbstractClient*>(m_topLevel)) {
             if (c->decoration()) {
                 if (init(c->decoration())) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     if (waylandServer()) {
         if (m_topLevel && m_topLevel->surface()) {
             if (const auto &s = m_topLevel->surface()->shadow()) {
                 if (init(s)) {
                     return true;
                 }
             }
         }
     }
 
     if (InternalClient *client = qobject_cast<InternalClient *>(m_topLevel)) {
         if (init(client->internalWindow())) {
             return true;
         }
     }
 
     auto data = Shadow::readX11ShadowProperty(m_topLevel->window());
     if (data.isEmpty()) {
         return false;
     }
 
     init(data);
 
     return true;
 }
 
 void Shadow::setToplevel(Toplevel *topLevel)
 {
     m_topLevel = topLevel;
     connect(m_topLevel, &Toplevel::frameGeometryChanged, this, &Shadow::geometryChanged);
 }
 void Shadow::geometryChanged()
 {
     if (m_cachedSize == m_topLevel->size()) {
         return;
     }
     m_cachedSize = m_topLevel->size();
     updateShadowRegion();
     buildQuads();
 }
 
 QImage Shadow::decorationShadowImage() const
 {
     if (!m_decorationShadow) {
         return QImage();
     }
     return m_decorationShadow->shadow();
 }
 
 QSize Shadow::elementSize(Shadow::ShadowElements element) const
 {
     if (m_decorationShadow) {
         switch (element) {
         case ShadowElementTop:
             return m_decorationShadow->topGeometry().size();
         case ShadowElementTopRight:
             return m_decorationShadow->topRightGeometry().size();
         case ShadowElementRight:
             return m_decorationShadow->rightGeometry().size();
         case ShadowElementBottomRight:
             return m_decorationShadow->bottomRightGeometry().size();
         case ShadowElementBottom:
             return m_decorationShadow->bottomGeometry().size();
         case ShadowElementBottomLeft:
             return m_decorationShadow->bottomLeftGeometry().size();
         case ShadowElementLeft:
             return m_decorationShadow->leftGeometry().size();
         case ShadowElementTopLeft:
             return m_decorationShadow->topLeftGeometry().size();
         default:
             return QSize();
         }
     } else {
         return m_shadowElements[element].size();
     }
 }
 
 void Shadow::setShadowElement(const QPixmap &shadow, Shadow::ShadowElements element)
 {
     m_shadowElements[element] = shadow;
 }
 
 } // namespace
diff --git a/shadow.h b/shadow.h
index 9214ef760..5f2e6195b 100644
--- a/shadow.h
+++ b/shadow.h
@@ -1,195 +1,192 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2011 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_SHADOW_H
 #define KWIN_SHADOW_H
 
 #include <QObject>
 #include <QPixmap>
 #include <kwineffects.h>
 
 namespace KDecoration2
 {
 class Decoration;
 class DecorationShadow;
 }
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class ShadowInterface;
 }
-}
 
 namespace KWin {
 
 class Toplevel;
 
 /**
  * @short Class representing a Window's Shadow to be rendered by the Compositor.
  *
  * This class holds all information about the Shadow to be rendered together with the
  * window during the Compositing stage. The Shadow consists of several pixmaps and offsets.
  * For a complete description please refer to https://community.kde.org/KWin/Shadow
  *
  * To create a Shadow instance use the static factory method createShadow which will
  * create an instance for the currently used Compositing Backend. It will read the X11 Property
  * and create the Shadow and all required data (such as WindowQuads). If there is no Shadow
  * defined for the Toplevel the factory method returns @c NULL.
  * 
  * @author Martin Gräßlin <mgraesslin@kde.org>
  * @todo React on Toplevel size changes.
  */
 class KWIN_EXPORT Shadow : public QObject
 {
     Q_OBJECT
 public:
     ~Shadow() override;
 
     /**
      * @return Region of the shadow.
      */
     const QRegion &shadowRegion() const {
         return m_shadowRegion;
     };
     /**
      * @return Cached Shadow Quads
      */
     const WindowQuadList &shadowQuads() const {
         return m_shadowQuads;
     };
     WindowQuadList &shadowQuads() {
         return m_shadowQuads;
     };
 
     /**
      * This method updates the Shadow when the property has been changed.
      * It is the responsibility of the owner of the Shadow to call this method
      * whenever the owner receives a PropertyNotify event.
      * This method will invoke a re-read of the Property. In case the Property has
      * been withdrawn the method returns @c false. In that case the owner should
      * delete the Shadow.
      * @returns @c true when the shadow has been updated, @c false if the property is not set anymore.
      */
     virtual bool updateShadow();
 
     /**
      * Factory Method to create the shadow from the property.
      * This method takes care of creating an instance of the
      * Shadow class for the current Compositing Backend.
      *
      * If there is no shadow defined for @p toplevel this method
      * will return @c NULL.
      * @param toplevel The Toplevel for which the shadow should be created
      * @return Created Shadow or @c NULL in case there is no shadow defined.
      */
     static Shadow *createShadow(Toplevel *toplevel);
 
     /**
      * Reparents the shadow to @p toplevel.
      * Used when a window is deleted.
      * @param toplevel The new parent
      */
     void setToplevel(Toplevel *toplevel);
 
     bool hasDecorationShadow() const {
         return !m_decorationShadow.isNull();
     }
     QImage decorationShadowImage() const;
 
     QWeakPointer<KDecoration2::DecorationShadow> decorationShadow() const {
         return m_decorationShadow.toWeakRef();
     }
 
 public Q_SLOTS:
     void geometryChanged();
 
 protected:
     Shadow(Toplevel *toplevel);
     enum ShadowElements {
         ShadowElementTop,
         ShadowElementTopRight,
         ShadowElementRight,
         ShadowElementBottomRight,
         ShadowElementBottom,
         ShadowElementBottomLeft,
         ShadowElementLeft,
         ShadowElementTopLeft,
         ShadowElementsCount
     };
 
     inline const QPixmap &shadowPixmap(ShadowElements element) const {
         return m_shadowElements[element];
     };
     QSize elementSize(ShadowElements element) const;
 
     int topOffset() const {
         return m_topOffset;
     };
     int rightOffset() const {
         return m_rightOffset;
     };
     int bottomOffset() const {
         return m_bottomOffset;
     };
     int leftOffset() const {
         return m_leftOffset;
     };
     virtual void buildQuads();
     void updateShadowRegion();
     Toplevel *topLevel() {
         return m_topLevel;
     };
     void setShadowRegion(const QRegion &region) {
         m_shadowRegion = region;
     };
     virtual bool prepareBackend() = 0;
     WindowQuadList m_shadowQuads;
     void setShadowElement(const QPixmap &shadow, ShadowElements element);
 
 private:
     static Shadow *createShadowFromX11(Toplevel *toplevel);
     static Shadow *createShadowFromDecoration(Toplevel *toplevel);
     static Shadow *createShadowFromWayland(Toplevel *toplevel);
     static Shadow *createShadowFromInternalWindow(Toplevel *toplevel);
     static QVector<uint32_t> readX11ShadowProperty(xcb_window_t id);
     bool init(const QVector<uint32_t> &data);
     bool init(KDecoration2::Decoration *decoration);
-    bool init(const QPointer<KWayland::Server::ShadowInterface> &shadow);
+    bool init(const QPointer<KWaylandServer::ShadowInterface> &shadow);
     bool init(const QWindow *window);
     Toplevel *m_topLevel;
     // shadow pixmaps
     QPixmap m_shadowElements[ShadowElementsCount];
     // shadow offsets
     int m_topOffset;
     int m_rightOffset;
     int m_bottomOffset;
     int m_leftOffset;
     // caches
     QRegion m_shadowRegion;
     QSize m_cachedSize;
     // Decoration based shadows
     QSharedPointer<KDecoration2::DecorationShadow> m_decorationShadow;
 };
 
 }
 
 #endif // KWIN_SHADOW_H
diff --git a/tablet_input.cpp b/tablet_input.cpp
index be18ada44..1b9de52e6 100644
--- a/tablet_input.cpp
+++ b/tablet_input.cpp
@@ -1,166 +1,166 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2019 Aleix Pol Gonzalez <aleixpol@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 "tablet_input.h"
 #include "abstract_client.h"
 #include "decorations/decoratedclient.h"
 #include "input.h"
 #include "input_event.h"
 #include "input_event_spy.h"
 #include "libinput/device.h"
 #include "pointer_input.h"
 #include "toplevel.h"
 #include "wayland_server.h"
 #include "workspace.h"
 // KDecoration
 #include <KDecoration2/Decoration>
 // KWayland
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 // screenlocker
 #include <KScreenLocker/KsldApp>
 // Qt
 #include <QHoverEvent>
 #include <QWindow>
 
 namespace KWin
 {
 TabletInputRedirection::TabletInputRedirection(InputRedirection *parent)
     : InputDeviceHandler(parent)
 {
 }
 
 TabletInputRedirection::~TabletInputRedirection() = default;
 
 void TabletInputRedirection::init()
 {
     Q_ASSERT(!inited());
     setInited(true);
     InputDeviceHandler::init();
 
     connect(workspace(), &QObject::destroyed, this, [this] { setInited(false); });
     connect(waylandServer(), &QObject::destroyed, this, [this] { setInited(false); });
 }
 
 void TabletInputRedirection::tabletToolEvent(KWin::InputRedirection::TabletEventType type,
                                              const QPointF &pos, qreal pressure,
                                              int xTilt, int yTilt, qreal rotation,
                                              bool tipDown, bool tipNear, quint64 serialId,
                                              quint64 toolId,
                                              InputRedirection::TabletToolType toolType,
                                              const QVector<InputRedirection::Capability> &capabilities,
                                              quint32 time, LibInput::Device *device)
 {
     if (!inited()) {
         return;
     }
     m_lastPosition = pos;
 
     QEvent::Type t;
     switch (type) {
     case InputRedirection::Axis:
         t = QEvent::TabletMove;
         break;
     case InputRedirection::Tip:
         t = tipDown ? QEvent::TabletPress : QEvent::TabletRelease;
         break;
     case InputRedirection::Proximity:
         t = tipNear ? QEvent::TabletEnterProximity : QEvent::TabletLeaveProximity;
         break;
     }
 
     const auto button = m_tipDown ? Qt::LeftButton : Qt::NoButton;
     TabletEvent ev(t, pos, pos, QTabletEvent::Stylus, QTabletEvent::Pen, pressure,
                     xTilt, yTilt,
                     0, // tangentialPressure
                     rotation,
                     0, // z
                     Qt::NoModifier, toolId, button, button, toolType, capabilities, serialId, device->sysName());
 
     ev.setTimestamp(time);
     input()->processSpies(std::bind(&InputEventSpy::tabletToolEvent, std::placeholders::_1, &ev));
     input()->processFilters(
         std::bind(&InputEventFilter::tabletToolEvent, std::placeholders::_1, &ev));
 
     m_tipDown = tipDown;
     m_tipNear = tipNear;
 }
 
 void KWin::TabletInputRedirection::tabletToolButtonEvent(uint button, bool isPressed)
 {
     if (isPressed)
         m_toolPressedButtons.insert(button);
     else
         m_toolPressedButtons.remove(button);
 
     input()->processSpies(std::bind(&InputEventSpy::tabletToolButtonEvent,
                                     std::placeholders::_1, m_toolPressedButtons));
     input()->processFilters(std::bind( &InputEventFilter::tabletToolButtonEvent,
                                       std::placeholders::_1, m_toolPressedButtons));
 }
 
 void KWin::TabletInputRedirection::tabletPadButtonEvent(uint button, bool isPressed)
 {
     if (isPressed) {
         m_padPressedButtons.insert(button);
     } else {
         m_padPressedButtons.remove(button);
     }
 
     input()->processSpies(std::bind( &InputEventSpy::tabletPadButtonEvent,
                                      std::placeholders::_1, m_padPressedButtons));
     input()->processFilters(std::bind( &InputEventFilter::tabletPadButtonEvent,
                                        std::placeholders::_1, m_padPressedButtons));
 }
 
 void KWin::TabletInputRedirection::tabletPadStripEvent(int number, int position, bool isFinger)
 {
     input()->processSpies(std::bind( &InputEventSpy::tabletPadStripEvent,
                                      std::placeholders::_1, number, position, isFinger));
     input()->processFilters(std::bind( &InputEventFilter::tabletPadStripEvent,
                                        std::placeholders::_1, number, position, isFinger));
 }
 
 void KWin::TabletInputRedirection::tabletPadRingEvent(int number, int position, bool isFinger)
 {
     input()->processSpies(std::bind( &InputEventSpy::tabletPadRingEvent,
                                      std::placeholders::_1, number, position, isFinger));
     input()->processFilters(std::bind( &InputEventFilter::tabletPadRingEvent,
                                        std::placeholders::_1, number, position, isFinger));
 }
 
 void TabletInputRedirection::cleanupDecoration(Decoration::DecoratedClientImpl *old,
                                                Decoration::DecoratedClientImpl *now)
 {
     Q_UNUSED(old)
     Q_UNUSED(now)
 }
 
 void TabletInputRedirection::cleanupInternalWindow(QWindow *old, QWindow *now)
 {
     Q_UNUSED(old)
     Q_UNUSED(now)
 }
 
 void TabletInputRedirection::focusUpdate(KWin::Toplevel *old, KWin::Toplevel *now)
 {
     Q_UNUSED(old)
     Q_UNUSED(now)
 }
 
 }
diff --git a/toplevel.cpp b/toplevel.cpp
index 2ad1f5b4d..15f4350ce 100644
--- a/toplevel.cpp
+++ b/toplevel.cpp
@@ -1,807 +1,807 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "toplevel.h"
 
 #ifdef KWIN_BUILD_ACTIVITIES
 #include "activities.h"
 #endif
 #include "atoms.h"
 #include "client_machine.h"
 #include "composite.h"
 #include "effects.h"
 #include "screens.h"
 #include "shadow.h"
 #include "workspace.h"
 #include "xcbutils.h"
 
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <QDebug>
 
 namespace KWin
 {
 
 Toplevel::Toplevel()
     : m_visual(XCB_NONE)
     , bit_depth(24)
     , info(nullptr)
     , ready_for_painting(false)
     , m_isDamaged(false)
     , m_internalId(QUuid::createUuid())
     , m_client()
     , damage_handle(XCB_NONE)
     , is_shape(false)
     , effect_window(nullptr)
     , m_clientMachine(new ClientMachine(this))
     , m_wmClientLeader(XCB_WINDOW_NONE)
     , m_damageReplyPending(false)
     , m_screen(0)
     , m_skipCloseAnimation(false)
 {
     connect(this, SIGNAL(damaged(KWin::Toplevel*,QRect)), SIGNAL(needsRepaint()));
     connect(screens(), SIGNAL(changed()), SLOT(checkScreen()));
     connect(screens(), SIGNAL(countChanged(int,int)), SLOT(checkScreen()));
     setupCheckScreenConnection();
 
     // Only for compatibility reasons, drop in the next major release.
     connect(this, &Toplevel::frameGeometryChanged, this, &Toplevel::geometryChanged);
 }
 
 Toplevel::~Toplevel()
 {
     Q_ASSERT(damage_handle == XCB_NONE);
     delete info;
 }
 
 QDebug& operator<<(QDebug& stream, const Toplevel* cl)
 {
     if (cl == nullptr)
         return stream << "\'NULL\'";
     cl->debug(stream);
     return stream;
 }
 
 void Toplevel::detectShape(xcb_window_t id)
 {
     const bool wasShape = is_shape;
     is_shape = Xcb::Extensions::self()->hasShape(id);
     if (wasShape != is_shape) {
         emit shapedChanged();
     }
 }
 
 // used only by Deleted::copy()
 void Toplevel::copyToDeleted(Toplevel* c)
 {
     m_internalId = c->internalId();
     m_frameGeometry = c->m_frameGeometry;
     m_visual = c->m_visual;
     bit_depth = c->bit_depth;
     info = c->info;
     m_client.reset(c->m_client, false);
     ready_for_painting = c->ready_for_painting;
     damage_handle = XCB_NONE;
     damage_region = c->damage_region;
     repaints_region = c->repaints_region;
     layer_repaints_region = c->layer_repaints_region;
     is_shape = c->is_shape;
     effect_window = c->effect_window;
     if (effect_window != nullptr)
         effect_window->setWindow(this);
     resource_name = c->resourceName();
     resource_class = c->resourceClass();
     m_clientMachine = c->m_clientMachine;
     m_clientMachine->setParent(this);
     m_wmClientLeader = c->wmClientLeader();
     opaque_region = c->opaqueRegion();
     m_screen = c->m_screen;
     m_skipCloseAnimation = c->m_skipCloseAnimation;
     m_internalFBO = c->m_internalFBO;
     m_internalImage = c->m_internalImage;
 }
 
 // before being deleted, remove references to everything that's now
 // owner by Deleted
 void Toplevel::disownDataPassedToDeleted()
 {
     info = nullptr;
 }
 
 QRect Toplevel::visibleRect() const
 {
     // There's no strict order between frame geometry and buffer geometry.
     QRect rect = frameGeometry() | bufferGeometry();
 
     if (shadow() && !shadow()->shadowRegion().isEmpty()) {
         rect |= shadow()->shadowRegion().boundingRect().translated(pos());
     }
 
     return rect;
 }
 
 Xcb::Property Toplevel::fetchWmClientLeader() const
 {
     return Xcb::Property(false, window(), atoms->wm_client_leader, XCB_ATOM_WINDOW, 0, 10000);
 }
 
 void Toplevel::readWmClientLeader(Xcb::Property &prop)
 {
     m_wmClientLeader = prop.value<xcb_window_t>(window());
 }
 
 void Toplevel::getWmClientLeader()
 {
     auto prop = fetchWmClientLeader();
     readWmClientLeader(prop);
 }
 
 /**
  * Returns sessionId for this client,
  * taken either from its window or from the leader window.
  */
 QByteArray Toplevel::sessionId() const
 {
     QByteArray result = Xcb::StringProperty(window(), atoms->sm_client_id);
     if (result.isEmpty() && m_wmClientLeader && m_wmClientLeader != window()) {
         result = Xcb::StringProperty(m_wmClientLeader, atoms->sm_client_id);
     }
     return result;
 }
 
 /**
  * Returns command property for this client,
  * taken either from its window or from the leader window.
  */
 QByteArray Toplevel::wmCommand()
 {
     QByteArray result = Xcb::StringProperty(window(), XCB_ATOM_WM_COMMAND);
     if (result.isEmpty() && m_wmClientLeader && m_wmClientLeader != window()) {
         result = Xcb::StringProperty(m_wmClientLeader, XCB_ATOM_WM_COMMAND);
     }
     result.replace(0, ' ');
     return result;
 }
 
 void Toplevel::getWmClientMachine()
 {
     m_clientMachine->resolve(window(), wmClientLeader());
 }
 
 /**
  * Returns client machine for this client,
  * taken either from its window or from the leader window.
  */
 QByteArray Toplevel::wmClientMachine(bool use_localhost) const
 {
     if (!m_clientMachine) {
         // this should never happen
         return QByteArray();
     }
     if (use_localhost && m_clientMachine->isLocal()) {
         // special name for the local machine (localhost)
         return ClientMachine::localhost();
     }
     return m_clientMachine->hostName();
 }
 
 /**
  * Returns client leader window for this client.
  * Returns the client window itself if no leader window is defined.
  */
 xcb_window_t Toplevel::wmClientLeader() const
 {
     if (m_wmClientLeader != XCB_WINDOW_NONE) {
         return m_wmClientLeader;
     }
     return window();
 }
 
 void Toplevel::getResourceClass()
 {
     if (!info) {
         return;
     }
     setResourceClass(QByteArray(info->windowClassName()).toLower(), QByteArray(info->windowClassClass()).toLower());
 }
 
 void Toplevel::setResourceClass(const QByteArray &name, const QByteArray &className)
 {
     resource_name  = name;
     resource_class = className;
     emit windowClassChanged();
 }
 
 bool Toplevel::resourceMatch(const Toplevel *c1, const Toplevel *c2)
 {
     return c1->resourceClass() == c2->resourceClass();
 }
 
 double Toplevel::opacity() const
 {
     if (!info) {
         return 1.0;
     }
     if (info->opacity() == 0xffffffff)
         return 1.0;
     return info->opacity() * 1.0 / 0xffffffff;
 }
 
 void Toplevel::setOpacity(double new_opacity)
 {
     if (!info) {
         return;
     }
 
     double old_opacity = opacity();
     new_opacity = qBound(0.0, new_opacity, 1.0);
     if (old_opacity == new_opacity)
         return;
     info->setOpacity(static_cast< unsigned long >(new_opacity * 0xffffffff));
     if (compositing()) {
         addRepaintFull();
         emit opacityChanged(this, old_opacity);
     }
 }
 
 bool Toplevel::setupCompositing()
 {
     if (!compositing())
         return false;
 
     if (damage_handle != XCB_NONE)
         return false;
 
     if (kwinApp()->operationMode() == Application::OperationModeX11 && !surface()) {
         damage_handle = xcb_generate_id(connection());
         xcb_damage_create(connection(), damage_handle, frameId(), XCB_DAMAGE_REPORT_LEVEL_NON_EMPTY);
     }
 
     damage_region = QRegion(0, 0, width(), height());
     effect_window = new EffectWindowImpl(this);
 
     Compositor::self()->scene()->addToplevel(this);
 
     return true;
 }
 
 void Toplevel::finishCompositing(ReleaseReason releaseReason)
 {
     if (kwinApp()->operationMode() == Application::OperationModeX11 && damage_handle == XCB_NONE)
         return;
     if (effect_window->window() == this) { // otherwise it's already passed to Deleted, don't free data
         discardWindowPixmap();
         delete effect_window;
     }
 
     if (damage_handle != XCB_NONE &&
             releaseReason != ReleaseReason::Destroyed) {
         xcb_damage_destroy(connection(), damage_handle);
     }
 
     damage_handle = XCB_NONE;
     damage_region = QRegion();
     repaints_region = QRegion();
     effect_window = nullptr;
 }
 
 void Toplevel::discardWindowPixmap()
 {
     addDamageFull();
     if (effectWindow() != nullptr && effectWindow()->sceneWindow() != nullptr)
         effectWindow()->sceneWindow()->discardPixmap();
 }
 
 void Toplevel::damageNotifyEvent()
 {
     m_isDamaged = true;
 
     // Note: The rect is supposed to specify the damage extents,
     //       but we don't know it at this point. No one who connects
     //       to this signal uses the rect however.
     emit damaged(this, QRect());
 }
 
 bool Toplevel::compositing() const
 {
     if (!Workspace::self()) {
         return false;
     }
     return Workspace::self()->compositing();
 }
 
 bool Toplevel::resetAndFetchDamage()
 {
     if (!m_isDamaged)
         return false;
 
     if (damage_handle == XCB_NONE) {
         m_isDamaged = false;
         return true;
     }
 
     xcb_connection_t *conn = connection();
 
     // Create a new region and copy the damage region to it,
     // resetting the damaged state.
     xcb_xfixes_region_t region = xcb_generate_id(conn);
     xcb_xfixes_create_region(conn, region, 0, nullptr);
     xcb_damage_subtract(conn, damage_handle, 0, region);
 
     // Send a fetch-region request and destroy the region
     m_regionCookie = xcb_xfixes_fetch_region_unchecked(conn, region);
     xcb_xfixes_destroy_region(conn, region);
 
     m_isDamaged = false;
     m_damageReplyPending = true;
 
     return m_damageReplyPending;
 }
 
 void Toplevel::getDamageRegionReply()
 {
     if (!m_damageReplyPending)
         return;
 
     m_damageReplyPending = false;
 
     // Get the fetch-region reply
     xcb_xfixes_fetch_region_reply_t *reply =
             xcb_xfixes_fetch_region_reply(connection(), m_regionCookie, nullptr);
 
     if (!reply)
         return;
 
     // Convert the reply to a QRegion
     int count = xcb_xfixes_fetch_region_rectangles_length(reply);
     QRegion region;
 
     if (count > 1 && count < 16) {
         xcb_rectangle_t *rects = xcb_xfixes_fetch_region_rectangles(reply);
 
         QVector<QRect> qrects;
         qrects.reserve(count);
 
         for (int i = 0; i < count; i++)
             qrects << QRect(rects[i].x, rects[i].y, rects[i].width, rects[i].height);
 
         region.setRects(qrects.constData(), count);
     } else
         region += QRect(reply->extents.x, reply->extents.y,
                         reply->extents.width, reply->extents.height);
 
     const QRect bufferRect = bufferGeometry();
     const QRect frameRect = frameGeometry();
 
     damage_region += region;
     repaints_region += region.translated(bufferRect.topLeft() - frameRect.topLeft());
 
     free(reply);
 }
 
 void Toplevel::addDamageFull()
 {
     if (!compositing())
         return;
 
     const QRect bufferRect = bufferGeometry();
     const QRect frameRect = frameGeometry();
 
     const int offsetX = bufferRect.x() - frameRect.x();
     const int offsetY = bufferRect.y() - frameRect.y();
 
     const QRect damagedRect = QRect(0, 0, bufferRect.width(), bufferRect.height());
 
     damage_region = damagedRect;
     repaints_region |= damagedRect.translated(offsetX, offsetY);
 
     emit damaged(this, damagedRect);
 }
 
 void Toplevel::resetDamage()
 {
     damage_region = QRegion();
 }
 
 void Toplevel::addRepaint(const QRect& r)
 {
     if (!compositing()) {
         return;
     }
     repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addRepaint(int x, int y, int w, int h)
 {
     QRect r(x, y, w, h);
     addRepaint(r);
 }
 
 void Toplevel::addRepaint(const QRegion& r)
 {
     if (!compositing()) {
         return;
     }
     repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addLayerRepaint(const QRect& r)
 {
     if (!compositing()) {
         return;
     }
     layer_repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addLayerRepaint(int x, int y, int w, int h)
 {
     QRect r(x, y, w, h);
     addLayerRepaint(r);
 }
 
 void Toplevel::addLayerRepaint(const QRegion& r)
 {
     if (!compositing())
         return;
     layer_repaints_region += r;
     emit needsRepaint();
 }
 
 void Toplevel::addRepaintFull()
 {
     repaints_region = visibleRect().translated(-pos());
     emit needsRepaint();
 }
 
 void Toplevel::resetRepaints()
 {
     repaints_region = QRegion();
     layer_repaints_region = QRegion();
 }
 
 void Toplevel::addWorkspaceRepaint(int x, int y, int w, int h)
 {
     addWorkspaceRepaint(QRect(x, y, w, h));
 }
 
 void Toplevel::addWorkspaceRepaint(const QRect& r2)
 {
     if (!compositing())
         return;
     Compositor::self()->addRepaint(r2);
 }
 
 void Toplevel::setReadyForPainting()
 {
     if (!ready_for_painting) {
         ready_for_painting = true;
         if (compositing()) {
             addRepaintFull();
             emit windowShown(this);
         }
     }
 }
 
 void Toplevel::deleteEffectWindow()
 {
     delete effect_window;
     effect_window = nullptr;
 }
 
 void Toplevel::checkScreen()
 {
     if (screens()->count() == 1) {
         if (m_screen != 0) {
             m_screen = 0;
             emit screenChanged();
         }
     } else {
         const int s = screens()->number(frameGeometry().center());
         if (s != m_screen) {
             m_screen = s;
             emit screenChanged();
         }
     }
     qreal newScale = screens()->scale(m_screen);
     if (newScale != m_screenScale) {
         m_screenScale = newScale;
         emit screenScaleChanged();
     }
 }
 
 void Toplevel::setupCheckScreenConnection()
 {
     connect(this, &Toplevel::frameGeometryChanged, this, &Toplevel::checkScreen);
     checkScreen();
 }
 
 void Toplevel::removeCheckScreenConnection()
 {
     disconnect(this, &Toplevel::frameGeometryChanged, this, &Toplevel::checkScreen);
 }
 
 int Toplevel::screen() const
 {
     return m_screen;
 }
 
 qreal Toplevel::screenScale() const
 {
     return m_screenScale;
 }
 
 qreal Toplevel::bufferScale() const
 {
     return surface() ? surface()->scale() : 1;
 }
 
 bool Toplevel::isOnScreen(int screen) const
 {
     return screens()->geometry(screen).intersects(frameGeometry());
 }
 
 bool Toplevel::isOnActiveScreen() const
 {
     return isOnScreen(screens()->current());
 }
 
 void Toplevel::updateShadow()
 {
     QRect dirtyRect;  // old & new shadow region
     const QRect oldVisibleRect = visibleRect();
     if (shadow()) {
         dirtyRect = shadow()->shadowRegion().boundingRect();
         if (!effectWindow()->sceneWindow()->shadow()->updateShadow()) {
             effectWindow()->sceneWindow()->updateShadow(nullptr);
         }
         emit shadowChanged();
     } else {
         Shadow::createShadow(this);
     }
     if (shadow())
         dirtyRect |= shadow()->shadowRegion().boundingRect();
     if (oldVisibleRect != visibleRect())
         emit paddingChanged(this, oldVisibleRect);
     if (dirtyRect.isValid()) {
         dirtyRect.translate(pos());
         addLayerRepaint(dirtyRect);
     }
 }
 
 Shadow *Toplevel::shadow()
 {
     if (effectWindow() && effectWindow()->sceneWindow()) {
         return effectWindow()->sceneWindow()->shadow();
     } else {
         return nullptr;
     }
 }
 
 const Shadow *Toplevel::shadow() const
 {
     if (effectWindow() && effectWindow()->sceneWindow()) {
         return effectWindow()->sceneWindow()->shadow();
     } else {
         return nullptr;
     }
 }
 
 bool Toplevel::wantsShadowToBeRendered() const
 {
     return true;
 }
 
 void Toplevel::getWmOpaqueRegion()
 {
     if (!info) {
         return;
     }
 
     const auto rects = info->opaqueRegion();
     QRegion new_opaque_region;
     for (const auto &r : rects) {
         new_opaque_region += QRect(r.pos.x, r.pos.y, r.size.width, r.size.height);
     }
 
     opaque_region = new_opaque_region;
 }
 
 bool Toplevel::isClient() const
 {
     return false;
 }
 
 bool Toplevel::isDeleted() const
 {
     return false;
 }
 
 bool Toplevel::isOnCurrentActivity() const
 {
 #ifdef KWIN_BUILD_ACTIVITIES
     if (!Activities::self()) {
         return true;
     }
     return isOnActivity(Activities::self()->current());
 #else
     return true;
 #endif
 }
 
 void Toplevel::elevate(bool elevate)
 {
     if (!effectWindow()) {
         return;
     }
     effectWindow()->elevate(elevate);
     addWorkspaceRepaint(visibleRect());
 }
 
 pid_t Toplevel::pid() const
 {
     if (!info) {
         return -1;
     }
     return info->pid();
 }
 
 xcb_window_t Toplevel::frameId() const
 {
     return m_client;
 }
 
 Xcb::Property Toplevel::fetchSkipCloseAnimation() const
 {
     return Xcb::Property(false, window(), atoms->kde_skip_close_animation, XCB_ATOM_CARDINAL, 0, 1);
 }
 
 void Toplevel::readSkipCloseAnimation(Xcb::Property &property)
 {
     setSkipCloseAnimation(property.toBool());
 }
 
 void Toplevel::getSkipCloseAnimation()
 {
     Xcb::Property property = fetchSkipCloseAnimation();
     readSkipCloseAnimation(property);
 }
 
 bool Toplevel::skipsCloseAnimation() const
 {
     return m_skipCloseAnimation;
 }
 
 void Toplevel::setSkipCloseAnimation(bool set)
 {
     if (set == m_skipCloseAnimation) {
         return;
     }
     m_skipCloseAnimation = set;
     emit skipCloseAnimationChanged();
 }
 
-void Toplevel::setSurface(KWayland::Server::SurfaceInterface *surface)
+void Toplevel::setSurface(KWaylandServer::SurfaceInterface *surface)
 {
     if (m_surface == surface) {
         return;
     }
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     if (m_surface) {
         disconnect(m_surface, &SurfaceInterface::damaged, this, &Toplevel::addDamage);
         disconnect(m_surface, &SurfaceInterface::sizeChanged, this, &Toplevel::discardWindowPixmap);
     }
     m_surface = surface;
     connect(m_surface, &SurfaceInterface::damaged, this, &Toplevel::addDamage);
     connect(m_surface, &SurfaceInterface::sizeChanged, this, &Toplevel::discardWindowPixmap);
     connect(m_surface, &SurfaceInterface::subSurfaceTreeChanged, this,
         [this] {
             // TODO improve to only update actual visual area
             if (ready_for_painting) {
                 addDamageFull();
                 m_isDamaged = true;
             }
         }
     );
     connect(m_surface, &SurfaceInterface::destroyed, this,
         [this] {
             m_surface = nullptr;
         }
     );
     emit surfaceChanged();
 }
 
 void Toplevel::addDamage(const QRegion &damage)
 {
     m_isDamaged = true;
     damage_region += damage;
     for (const QRect &r : damage) {
         emit damaged(this, r);
     }
 }
 
 QByteArray Toplevel::windowRole() const
 {
     if (!info) {
         return {};
     }
     return QByteArray(info->windowRole());
 }
 
 void Toplevel::setDepth(int depth)
 {
     if (bit_depth == depth) {
         return;
     }
     const bool oldAlpha = hasAlpha();
     bit_depth = depth;
     if (oldAlpha != hasAlpha()) {
         emit hasAlphaChanged();
     }
 }
 
 QRegion Toplevel::inputShape() const
 {
     if (m_surface) {
         return m_surface->input();
     } else {
         // TODO: maybe also for X11?
         return QRegion();
     }
 }
 
 QMatrix4x4 Toplevel::inputTransformation() const
 {
     QMatrix4x4 m;
     m.translate(-x(), -y());
     return m;
 }
 
 quint32 Toplevel::windowId() const
 {
     return window();
 }
 
 QRect Toplevel::inputGeometry() const
 {
     return frameGeometry();
 }
 
 bool Toplevel::isLocalhost() const
 {
     if (!m_clientMachine) {
         return true;
     }
     return m_clientMachine->isLocal();
 }
 
 QMargins Toplevel::bufferMargins() const
 {
     return QMargins();
 }
 
 QMargins Toplevel::frameMargins() const
 {
     return QMargins();
 }
 
 } // namespace
 
diff --git a/toplevel.h b/toplevel.h
index b5c43dab6..131b0ce43 100644
--- a/toplevel.h
+++ b/toplevel.h
@@ -1,1052 +1,1049 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_TOPLEVEL_H
 #define KWIN_TOPLEVEL_H
 
 // kwin
 #include "input.h"
 #include "utils.h"
 #include "virtualdesktops.h"
 #include "xcbutils.h"
 // KDE
 #include <NETWM>
 // Qt
 #include <QObject>
 #include <QMatrix4x4>
 #include <QUuid>
 // xcb
 #include <xcb/damage.h>
 #include <xcb/xfixes.h>
 // c++
 #include <functional>
 
 class QOpenGLFramebufferObject;
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class SurfaceInterface;
 }
-}
 
 namespace KWin
 {
 
 class ClientMachine;
 class Deleted;
 class EffectWindowImpl;
 class Shadow;
 
 /**
  * Enum to describe the reason why a Toplevel has to be released.
  */
 enum class ReleaseReason {
     Release, ///< Normal Release after e.g. an Unmap notify event (window still valid)
     Destroyed, ///< Release after an Destroy notify event (window no longer valid)
     KWinShutsDown ///< Release on KWin Shutdown (window still valid)
 };
 
 class KWIN_EXPORT Toplevel : public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(bool alpha READ hasAlpha NOTIFY hasAlphaChanged)
     Q_PROPERTY(qulonglong frameId READ frameId)
 
     /**
      * This property holds the geometry of the Toplevel, excluding invisible
      * portions, e.g. client-side and server-side drop-shadows, etc.
      *
      * @deprecated Use frameGeometry property instead.
      */
     Q_PROPERTY(QRect geometry READ frameGeometry NOTIFY frameGeometryChanged)
 
     /**
      * This property holds rectangle that the pixmap or buffer of this Toplevel
      * occupies on the screen. This rectangle includes invisible portions of the
      * client, e.g. client-side drop shadows, etc.
      */
     Q_PROPERTY(QRect bufferGeometry READ bufferGeometry)
 
     /**
      * This property holds the geometry of the Toplevel, excluding invisible
      * portions, e.g. server-side and client-side drop-shadows, etc.
      */
     Q_PROPERTY(QRect frameGeometry READ frameGeometry NOTIFY frameGeometryChanged)
 
     /**
      * This property holds the position of the Toplevel's frame geometry.
      */
     Q_PROPERTY(QPoint pos READ pos)
 
     /**
      * This property holds the size of the Toplevel's frame geometry.
      */
     Q_PROPERTY(QSize size READ size)
 
     /**
      * This property holds the x position of the Toplevel's frame geometry.
      */
     Q_PROPERTY(int x READ x)
 
     /**
      * This property holds the y position of the Toplevel's frame geometry.
      */
     Q_PROPERTY(int y READ y)
 
     /**
      * This property holds the width of the Toplevel's frame geometry.
      */
     Q_PROPERTY(int width READ width)
 
     /**
      * This property holds the height of the Toplevel's frame geometry.
      */
     Q_PROPERTY(int height READ height)
 
     Q_PROPERTY(QRect visibleRect READ visibleRect)
     Q_PROPERTY(qreal opacity READ opacity WRITE setOpacity NOTIFY opacityChanged)
     Q_PROPERTY(int screen READ screen NOTIFY screenChanged)
     Q_PROPERTY(qulonglong windowId READ windowId CONSTANT)
     Q_PROPERTY(int desktop READ desktop)
 
     /**
      * Whether the window is on all desktops. That is desktop is -1.
      */
     Q_PROPERTY(bool onAllDesktops READ isOnAllDesktops)
 
     Q_PROPERTY(QRect rect READ rect)
     Q_PROPERTY(QPoint clientPos READ clientPos)
     Q_PROPERTY(QSize clientSize READ clientSize)
     Q_PROPERTY(QByteArray resourceName READ resourceName NOTIFY windowClassChanged)
     Q_PROPERTY(QByteArray resourceClass READ resourceClass NOTIFY windowClassChanged)
     Q_PROPERTY(QByteArray windowRole READ windowRole NOTIFY windowRoleChanged)
 
     /**
      * Returns whether the window is a desktop background window (the one with wallpaper).
      * See _NET_WM_WINDOW_TYPE_DESKTOP at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool desktopWindow READ isDesktop)
 
     /**
      * Returns whether the window is a dock (i.e. a panel).
      * See _NET_WM_WINDOW_TYPE_DOCK at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dock READ isDock)
 
     /**
      * Returns whether the window is a standalone (detached) toolbar window.
      * See _NET_WM_WINDOW_TYPE_TOOLBAR at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool toolbar READ isToolbar)
 
     /**
      * Returns whether the window is a torn-off menu.
      * See _NET_WM_WINDOW_TYPE_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool menu READ isMenu)
 
     /**
      * Returns whether the window is a "normal" window, i.e. an application or any other window
      * for which none of the specialized window types fit.
      * See _NET_WM_WINDOW_TYPE_NORMAL at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool normalWindow READ isNormalWindow)
 
     /**
      * Returns whether the window is a dialog window.
      * See _NET_WM_WINDOW_TYPE_DIALOG at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dialog READ isDialog)
 
     /**
      * Returns whether the window is a splashscreen. Note that many (especially older) applications
      * do not support marking their splash windows with this type.
      * See _NET_WM_WINDOW_TYPE_SPLASH at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool splash READ isSplash)
 
     /**
      * Returns whether the window is a utility window, such as a tool window.
      * See _NET_WM_WINDOW_TYPE_UTILITY at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool utility READ isUtility)
 
     /**
      * Returns whether the window is a dropdown menu (i.e. a popup directly or indirectly open
      * from the applications menubar).
      * See _NET_WM_WINDOW_TYPE_DROPDOWN_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dropdownMenu READ isDropdownMenu)
 
     /**
      * Returns whether the window is a popup menu (that is not a torn-off or dropdown menu).
      * See _NET_WM_WINDOW_TYPE_POPUP_MENU at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool popupMenu READ isPopupMenu)
 
     /**
      * Returns whether the window is a tooltip.
      * See _NET_WM_WINDOW_TYPE_TOOLTIP at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool tooltip READ isTooltip)
 
     /**
      * Returns whether the window is a window with a notification.
      * See _NET_WM_WINDOW_TYPE_NOTIFICATION at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool notification READ isNotification)
 
     /**
      * Returns whether the window is a window with a critical notification.
      */
     Q_PROPERTY(bool criticalNotification READ isCriticalNotification)
 
     /**
      * Returns whether the window is an On Screen Display.
      */
     Q_PROPERTY(bool onScreenDisplay READ isOnScreenDisplay)
 
     /**
      * Returns whether the window is a combobox popup.
      * See _NET_WM_WINDOW_TYPE_COMBO at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool comboBox READ isComboBox)
 
     /**
      * Returns whether the window is a Drag&Drop icon.
      * See _NET_WM_WINDOW_TYPE_DND at https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(bool dndIcon READ isDNDIcon)
 
     /**
      * Returns the NETWM window type
      * See https://standards.freedesktop.org/wm-spec/wm-spec-latest.html .
      */
     Q_PROPERTY(int windowType READ windowType)
 
     Q_PROPERTY(QStringList activities READ activities NOTIFY activitiesChanged)
 
     /**
      * Whether this Toplevel is managed by KWin (it has control over its placement and other
      * aspects, as opposed to override-redirect windows that are entirely handled by the application).
      */
     Q_PROPERTY(bool managed READ isClient CONSTANT)
 
     /**
      * Whether this Toplevel represents an already deleted window and only kept for the compositor for animations.
      */
     Q_PROPERTY(bool deleted READ isDeleted CONSTANT)
 
     /**
      * Whether the window has an own shape
      */
     Q_PROPERTY(bool shaped READ shape NOTIFY shapedChanged)
 
     /**
      * Whether the window does not want to be animated on window close.
      * There are legit reasons for this like a screenshot application which does not want it's
      * window being captured.
      */
     Q_PROPERTY(bool skipsCloseAnimation READ skipsCloseAnimation WRITE setSkipCloseAnimation NOTIFY skipCloseAnimationChanged)
 
     /**
      * The Id of the Wayland Surface associated with this Toplevel.
      * On X11 only setups the value is @c 0.
      */
     Q_PROPERTY(quint32 surfaceId READ surfaceId NOTIFY surfaceIdChanged)
 
     /**
      * Interface to the Wayland Surface.
      * Relevant only in Wayland, in X11 it will be nullptr
      */
-    Q_PROPERTY(KWayland::Server::SurfaceInterface *surface READ surface)
+    Q_PROPERTY(KWaylandServer::SurfaceInterface *surface READ surface)
 
     /**
      * Whether the window is a popup.
      */
     Q_PROPERTY(bool popupWindow READ isPopupWindow)
 
     /**
      * Whether this Toplevel represents the outline.
      *
      * @note It's always @c false if compositing is turned off.
      */
     Q_PROPERTY(bool outline READ isOutline)
 
     /**
      * This property holds a UUID to uniquely identify this Toplevel.
      */
     Q_PROPERTY(QUuid internalId READ internalId CONSTANT)
 
 public:
     explicit Toplevel();
     virtual xcb_window_t frameId() const;
     xcb_window_t window() const;
     /**
      * @return a unique identifier for the Toplevel. On X11 same as @ref window
      */
     virtual quint32 windowId() const;
     /**
      * Returns the geometry of the pixmap or buffer attached to this Toplevel.
      *
      * For X11 clients, this method returns server-side geometry of the Toplevel.
      *
      * For Wayland clients, this method returns rectangle that the main surface
      * occupies on the screen, in global screen coordinates.
      */
     virtual QRect bufferGeometry() const = 0;
     /**
      * Returns the extents of invisible portions in the pixmap.
      *
      * An X11 pixmap may contain invisible space around the actual contents of the
      * client. That space is reserved for server-side decoration, which we usually
      * want to skip when building contents window quads.
      *
      * Default implementation returns a margins object with all margins set to 0.
      */
     virtual QMargins bufferMargins() const;
     /**
      * Returns the geometry of the Toplevel, excluding invisible portions, e.g.
      * server-side and client-side drop shadows, etc.
      */
     QRect frameGeometry() const;
     /**
      * Returns the extents of the server-side decoration.
      *
      * Note that the returned margins object will have all margins set to 0 if
      * the client doesn't have a server-side decoration.
      *
      * Default implementation returns a margins object with all margins set to 0.
      */
     virtual QMargins frameMargins() const;
     /**
      * The geometry of the Toplevel which accepts input events. This might be larger
      * than the actual geometry, e.g. to support resizing outside the window.
      *
      * Default implementation returns same as geometry.
      */
     virtual QRect inputGeometry() const;
     QSize size() const;
     QPoint pos() const;
     QRect rect() const;
     int x() const;
     int y() const;
     int width() const;
     int height() const;
     bool isOnScreen(int screen) const;   // true if it's at least partially there
     bool isOnActiveScreen() const;
     int screen() const; // the screen where the center is
     /**
      * The scale of the screen this window is currently on
      * @note The buffer scale can be different.
      * @since 5.12
      */
     qreal screenScale() const; //
     /**
      * Returns the ratio between physical pixels and device-independent pixels for
      * the attached buffer (or pixmap).
      *
      * For X11 clients, this method always returns 1.
      */
     virtual qreal bufferScale() const;
     virtual QPoint clientPos() const = 0; // inside of geometry()
     /**
      * Describes how the client's content maps to the window geometry including the frame.
      * The default implementation is a 1:1 mapping meaning the frame is part of the content.
      */
     virtual QPoint clientContentPos() const;
     virtual QSize clientSize() const = 0;
     /**
      * Returns a rectangle that the window occupies on the screen, including drop-shadows.
      */
     virtual QRect visibleRect() const;
     virtual QRect transparentRect() const = 0;
     virtual bool isClient() const;
     virtual bool isDeleted() const;
 
     // prefer isXXX() instead
     // 0 for supported types means default for managed/unmanaged types
     virtual NET::WindowType windowType(bool direct = false, int supported_types = 0) const = 0;
     bool hasNETSupport() const;
     bool isDesktop() const;
     bool isDock() const;
     bool isToolbar() const;
     bool isMenu() const;
     bool isNormalWindow() const; // normal as in 'NET::Normal or NET::Unknown non-transient'
     bool isDialog() const;
     bool isSplash() const;
     bool isUtility() const;
     bool isDropdownMenu() const;
     bool isPopupMenu() const; // a context popup, not dropdown, not torn-off
     bool isTooltip() const;
     bool isNotification() const;
     bool isCriticalNotification() const;
     bool isOnScreenDisplay() const;
     bool isComboBox() const;
     bool isDNDIcon() const;
 
     virtual bool isLockScreen() const;
     virtual bool isInputMethod() const;
     virtual bool isOutline() const;
 
     /**
      * Returns the virtual desktop within the workspace() the client window
      * is located in, 0 if it isn't located on any special desktop (not mapped yet),
      * or NET::OnAllDesktops. Do not use desktop() directly, use
      * isOnDesktop() instead.
      */
     virtual int desktop() const = 0;
     virtual QVector<VirtualDesktop *> desktops() const = 0;
     virtual QStringList activities() const = 0;
     bool isOnDesktop(int d) const;
     bool isOnActivity(const QString &activity) const;
     bool isOnCurrentDesktop() const;
     bool isOnCurrentActivity() const;
     bool isOnAllDesktops() const;
     bool isOnAllActivities() const;
 
     virtual QByteArray windowRole() const;
     QByteArray sessionId() const;
     QByteArray resourceName() const;
     QByteArray resourceClass() const;
     QByteArray wmCommand();
     QByteArray wmClientMachine(bool use_localhost) const;
     const ClientMachine *clientMachine() const;
     virtual bool isLocalhost() const;
     xcb_window_t wmClientLeader() const;
     virtual pid_t pid() const;
     static bool resourceMatch(const Toplevel* c1, const Toplevel* c2);
 
     bool readyForPainting() const; // true if the window has been already painted its contents
     xcb_visualid_t visual() const;
     bool shape() const;
     QRegion inputShape() const;
     virtual void setOpacity(double opacity);
     virtual double opacity() const;
     int depth() const;
     bool hasAlpha() const;
     virtual bool setupCompositing();
     virtual void finishCompositing(ReleaseReason releaseReason = ReleaseReason::Release);
     Q_INVOKABLE void addRepaint(const QRect& r);
     Q_INVOKABLE void addRepaint(const QRegion& r);
     Q_INVOKABLE void addRepaint(int x, int y, int w, int h);
     Q_INVOKABLE void addLayerRepaint(const QRect& r);
     Q_INVOKABLE void addLayerRepaint(const QRegion& r);
     Q_INVOKABLE void addLayerRepaint(int x, int y, int w, int h);
     Q_INVOKABLE virtual void addRepaintFull();
     // these call workspace->addRepaint(), but first transform the damage if needed
     void addWorkspaceRepaint(const QRect& r);
     void addWorkspaceRepaint(int x, int y, int w, int h);
     QRegion repaints() const;
     void resetRepaints();
     QRegion damage() const;
     void resetDamage();
     EffectWindowImpl* effectWindow();
     const EffectWindowImpl* effectWindow() const;
     /**
      * Window will be temporarily painted as if being at the top of the stack.
      * Only available if Compositor is active, if not active, this method is a no-op.
      */
     void elevate(bool elevate);
 
     /**
      * Returns the pointer to the Toplevel's Shadow. A Shadow
      * is only available if Compositing is enabled and the corresponding X window
      * has the Shadow property set.
      * @returns The Shadow belonging to this Toplevel, @c null if there's no Shadow.
      */
     const Shadow *shadow() const;
     Shadow *shadow();
     /**
      * Updates the Shadow associated with this Toplevel from X11 Property.
      * Call this method when the Property changes or Compositing is started.
      */
     void updateShadow();
     /**
      * Whether the Toplevel currently wants the shadow to be rendered. Default
      * implementation always returns @c true.
      */
     virtual bool wantsShadowToBeRendered() const;
 
     /**
      * This method returns the area that the Toplevel window reports to be opaque.
      * It is supposed to only provide valuable information if hasAlpha is @c true .
      * @see hasAlpha
      */
     const QRegion& opaqueRegion() const;
 
     virtual Layer layer() const = 0;
 
     /**
      * Resets the damage state and sends a request for the damage region.
      * A call to this function must be followed by a call to getDamageRegionReply(),
      * or the reply will be leaked.
      *
      * Returns true if the window was damaged, and false otherwise.
      */
     bool resetAndFetchDamage();
 
     /**
      * Gets the reply from a previous call to resetAndFetchDamage().
      * Calling this function is a no-op if there is no pending reply.
      * Call damage() to return the fetched region.
      */
     void getDamageRegionReply();
 
     bool skipsCloseAnimation() const;
     void setSkipCloseAnimation(bool set);
 
     quint32 surfaceId() const;
-    KWayland::Server::SurfaceInterface *surface() const;
-    void setSurface(KWayland::Server::SurfaceInterface *surface);
+    KWaylandServer::SurfaceInterface *surface() const;
+    void setSurface(KWaylandServer::SurfaceInterface *surface);
 
     const QSharedPointer<QOpenGLFramebufferObject> &internalFramebufferObject() const;
     QImage internalImageObject() const;
 
     /**
      * @returns Transformation to map from global to window coordinates.
      *
      * Default implementation returns a translation on negative pos().
      * @see pos
      */
     virtual QMatrix4x4 inputTransformation() const;
 
     /**
      * The window has a popup grab. This means that when it got mapped the
      * parent window had an implicit (pointer) grab.
      *
      * Normally this is only relevant for transient windows.
      *
      * Once the popup grab ends (e.g. pointer press outside of any Toplevel of
      * the client), the method popupDone should be invoked.
      *
      * The default implementation returns @c false.
      * @see popupDone
      * @since 5.10
      */
     virtual bool hasPopupGrab() const {
         return false;
     }
     /**
      * This method should be invoked for Toplevels with a popup grab when
      * the grab ends.
      *
      * The default implementation does nothing.
      * @see hasPopupGrab
      * @since 5.10
      */
     virtual void popupDone() {};
 
     /**
      * @brief Finds the Toplevel matching the condition expressed in @p func in @p list.
      *
      * The method is templated to operate on either a list of Toplevels or on a list of
      * a subclass type of Toplevel.
      * @param list The list to search in
      * @param func The condition function (compare std::find_if)
      * @return T* The found Toplevel or @c null if there is no matching Toplevel
      */
     template <class T, class U>
     static T *findInList(const QList<T*> &list, std::function<bool (const U*)> func);
 
     /**
      * Whether the window is a popup.
      *
      * Popups can be used to implement popup menus, tooltips, combo boxes, etc.
      *
      * @since 5.15
      */
     virtual bool isPopupWindow() const;
 
     /**
      * A UUID to uniquely identify this Toplevel independent of windowing system.
      */
     QUuid internalId() const
     {
         return m_internalId;
     }
 
 Q_SIGNALS:
     void opacityChanged(KWin::Toplevel* toplevel, qreal oldOpacity);
     void damaged(KWin::Toplevel* toplevel, const QRect& damage);
     /**
      * This signal is emitted when the Toplevel's frame geometry changes.
      * @deprecated since 5.19, use frameGeometryChanged instead
      */
     void geometryChanged();
     void geometryShapeChanged(KWin::Toplevel* toplevel, const QRect& old);
     void paddingChanged(KWin::Toplevel* toplevel, const QRect& old);
     void windowClosed(KWin::Toplevel* toplevel, KWin::Deleted* deleted);
     void windowShown(KWin::Toplevel* toplevel);
     void windowHidden(KWin::Toplevel* toplevel);
     /**
      * Signal emitted when the window's shape state changed. That is if it did not have a shape
      * and received one or if the shape was withdrawn. Think of Chromium enabling/disabling KWin's
      * decoration.
      */
     void shapedChanged();
     /**
      * Emitted whenever the state changes in a way, that the Compositor should
      * schedule a repaint of the scene.
      */
     void needsRepaint();
     void activitiesChanged(KWin::Toplevel* toplevel);
     /**
      * Emitted whenever the Toplevel's screen changes. This can happen either in consequence to
      * a screen being removed/added or if the Toplevel's geometry changes.
      * @since 4.11
      */
     void screenChanged();
     void skipCloseAnimationChanged();
     /**
      * Emitted whenever the window role of the window changes.
      * @since 5.0
      */
     void windowRoleChanged();
     /**
      * Emitted whenever the window class name or resource name of the window changes.
      * @since 5.0
      */
     void windowClassChanged();
     /**
      * Emitted when a Wayland Surface gets associated with this Toplevel.
      * @since 5.3
      */
     void surfaceIdChanged(quint32);
     /**
      * @since 5.4
      */
     void hasAlphaChanged();
 
     /**
      * Emitted whenever the Surface for this Toplevel changes.
      */
     void surfaceChanged();
 
     /*
      * Emitted when the client's screen changes onto a screen of a different scale
      * or the screen we're on changes
      * @since 5.12
      */
     void screenScaleChanged();
 
     /**
      * Emitted whenever the client's shadow changes.
      * @since 5.15
      */
     void shadowChanged();
 
     /**
      * This signal is emitted when the Toplevel's frame geometry changes.
      */
     void frameGeometryChanged(KWin::Toplevel *toplevel, const QRect &oldGeometry);
 
 protected Q_SLOTS:
     /**
      * Checks whether the screen number for this Toplevel changed and updates if needed.
      * Any method changing the geometry of the Toplevel should call this method.
      */
     void checkScreen();
     void setupCheckScreenConnection();
     void removeCheckScreenConnection();
     void setReadyForPainting();
 
 protected:
     ~Toplevel() override;
     void setWindowHandles(xcb_window_t client);
     void detectShape(xcb_window_t id);
     virtual void propertyNotifyEvent(xcb_property_notify_event_t *e);
     virtual void damageNotifyEvent();
     virtual void clientMessageEvent(xcb_client_message_event_t *e);
     void discardWindowPixmap();
     void addDamageFull();
     virtual void addDamage(const QRegion &damage);
     Xcb::Property fetchWmClientLeader() const;
     void readWmClientLeader(Xcb::Property &p);
     void getWmClientLeader();
     void getWmClientMachine();
     /**
      * @returns Whether there is a compositor and it is active.
      */
     bool compositing() const;
 
     /**
      * This function fetches the opaque region from this Toplevel.
      * Will only be called on corresponding property changes and for initialization.
      */
     void getWmOpaqueRegion();
 
     void getResourceClass();
     void setResourceClass(const QByteArray &name, const QByteArray &className = QByteArray());
     Xcb::Property fetchSkipCloseAnimation() const;
     void readSkipCloseAnimation(Xcb::Property &prop);
     void getSkipCloseAnimation();
     virtual void debug(QDebug& stream) const = 0;
     void copyToDeleted(Toplevel* c);
     void disownDataPassedToDeleted();
     friend QDebug& operator<<(QDebug& stream, const Toplevel*);
     void deleteEffectWindow();
     void setDepth(int depth);
     QRect m_frameGeometry;
     xcb_visualid_t m_visual;
     int bit_depth;
     NETWinInfo* info;
     bool ready_for_painting;
     QRegion repaints_region; // updating, repaint just requires repaint of that area
     QRegion layer_repaints_region;
     /**
      * An FBO object KWin internal windows might render to.
      */
     QSharedPointer<QOpenGLFramebufferObject> m_internalFBO;
     QImage m_internalImage;
 
 protected:
     bool m_isDamaged;
 
 private:
     // when adding new data members, check also copyToDeleted()
     QUuid m_internalId;
     Xcb::Window m_client;
     xcb_damage_damage_t damage_handle;
     QRegion damage_region; // damage is really damaged window (XDamage) and texture needs
     bool is_shape;
     EffectWindowImpl* effect_window;
     QByteArray resource_name;
     QByteArray resource_class;
     ClientMachine *m_clientMachine;
     xcb_window_t m_wmClientLeader;
     bool m_damageReplyPending;
     QRegion opaque_region;
     xcb_xfixes_fetch_region_cookie_t m_regionCookie;
     int m_screen;
     bool m_skipCloseAnimation;
     quint32 m_surfaceId = 0;
-    KWayland::Server::SurfaceInterface *m_surface = nullptr;
+    KWaylandServer::SurfaceInterface *m_surface = nullptr;
     // when adding new data members, check also copyToDeleted()
     qreal m_screenScale = 1.0;
 };
 
 inline xcb_window_t Toplevel::window() const
 {
     return m_client;
 }
 
 inline void Toplevel::setWindowHandles(xcb_window_t w)
 {
     Q_ASSERT(!m_client.isValid() && w != XCB_WINDOW_NONE);
     m_client.reset(w, false);
 }
 
 inline QRect Toplevel::frameGeometry() const
 {
     return m_frameGeometry;
 }
 
 inline QSize Toplevel::size() const
 {
     return m_frameGeometry.size();
 }
 
 inline QPoint Toplevel::pos() const
 {
     return m_frameGeometry.topLeft();
 }
 
 inline int Toplevel::x() const
 {
     return m_frameGeometry.x();
 }
 
 inline int Toplevel::y() const
 {
     return m_frameGeometry.y();
 }
 
 inline int Toplevel::width() const
 {
     return m_frameGeometry.width();
 }
 
 inline int Toplevel::height() const
 {
     return m_frameGeometry.height();
 }
 
 inline QRect Toplevel::rect() const
 {
     return QRect(0, 0, width(), height());
 }
 
 inline bool Toplevel::readyForPainting() const
 {
     return ready_for_painting;
 }
 
 inline xcb_visualid_t Toplevel::visual() const
 {
     return m_visual;
 }
 
 inline bool Toplevel::isDesktop() const
 {
     return windowType() == NET::Desktop;
 }
 
 inline bool Toplevel::isDock() const
 {
     return windowType() == NET::Dock;
 }
 
 inline bool Toplevel::isMenu() const
 {
     return windowType() == NET::Menu;
 }
 
 inline bool Toplevel::isToolbar() const
 {
     return windowType() == NET::Toolbar;
 }
 
 inline bool Toplevel::isSplash() const
 {
     return windowType() == NET::Splash;
 }
 
 inline bool Toplevel::isUtility() const
 {
     return windowType() == NET::Utility;
 }
 
 inline bool Toplevel::isDialog() const
 {
     return windowType() == NET::Dialog;
 }
 
 inline bool Toplevel::isNormalWindow() const
 {
     return windowType() == NET::Normal;
 }
 
 inline bool Toplevel::isDropdownMenu() const
 {
     return windowType() == NET::DropdownMenu;
 }
 
 inline bool Toplevel::isPopupMenu() const
 {
     return windowType() == NET::PopupMenu;
 }
 
 inline bool Toplevel::isTooltip() const
 {
     return windowType() == NET::Tooltip;
 }
 
 inline bool Toplevel::isNotification() const
 {
     return windowType() == NET::Notification;
 }
 
 inline bool Toplevel::isCriticalNotification() const
 {
     return windowType() == NET::CriticalNotification;
 }
 
 inline bool Toplevel::isOnScreenDisplay() const
 {
     return windowType() == NET::OnScreenDisplay;
 }
 
 inline bool Toplevel::isComboBox() const
 {
     return windowType() == NET::ComboBox;
 }
 
 inline bool Toplevel::isDNDIcon() const
 {
     return windowType() == NET::DNDIcon;
 }
 
 inline bool Toplevel::isLockScreen() const
 {
     return false;
 }
 
 inline bool Toplevel::isInputMethod() const
 {
     return false;
 }
 
 inline bool Toplevel::isOutline() const
 {
     return false;
 }
 
 inline QRegion Toplevel::damage() const
 {
     return damage_region;
 }
 
 inline QRegion Toplevel::repaints() const
 {
     return repaints_region.translated(pos()) | layer_repaints_region;
 }
 
 inline bool Toplevel::shape() const
 {
     return is_shape;
 }
 
 inline int Toplevel::depth() const
 {
     return bit_depth;
 }
 
 inline bool Toplevel::hasAlpha() const
 {
     return depth() == 32;
 }
 
 inline const QRegion& Toplevel::opaqueRegion() const
 {
     return opaque_region;
 }
 
 inline
 EffectWindowImpl* Toplevel::effectWindow()
 {
     return effect_window;
 }
 
 inline
 const EffectWindowImpl* Toplevel::effectWindow() const
 {
     return effect_window;
 }
 
 inline bool Toplevel::isOnAllDesktops() const
 {
     return kwinApp()->operationMode() == Application::OperationModeWaylandOnly ||
            kwinApp()->operationMode() == Application::OperationModeXwayland
         //Wayland
         ? desktops().isEmpty()
         //X11
         : desktop() == NET::OnAllDesktops;
 }
 
 inline bool Toplevel::isOnAllActivities() const
 {
     return activities().isEmpty();
 }
 
 inline bool Toplevel::isOnDesktop(int d) const
 {
     return (kwinApp()->operationMode() == Application::OperationModeWaylandOnly ||
             kwinApp()->operationMode() == Application::OperationModeXwayland
             ? desktops().contains(VirtualDesktopManager::self()->desktopForX11Id(d))
             : desktop() == d
            ) || isOnAllDesktops();
 }
 
 inline bool Toplevel::isOnActivity(const QString &activity) const
 {
     return activities().isEmpty() || activities().contains(activity);
 }
 
 inline bool Toplevel::isOnCurrentDesktop() const
 {
     return isOnDesktop(VirtualDesktopManager::self()->current());
 }
 
 inline QByteArray Toplevel::resourceName() const
 {
     return resource_name; // it is always lowercase
 }
 
 inline QByteArray Toplevel::resourceClass() const
 {
     return resource_class; // it is always lowercase
 }
 
 inline const ClientMachine *Toplevel::clientMachine() const
 {
     return m_clientMachine;
 }
 
 inline quint32 Toplevel::surfaceId() const
 {
     return m_surfaceId;
 }
 
-inline KWayland::Server::SurfaceInterface *Toplevel::surface() const
+inline KWaylandServer::SurfaceInterface *Toplevel::surface() const
 {
     return m_surface;
 }
 
 inline const QSharedPointer<QOpenGLFramebufferObject> &Toplevel::internalFramebufferObject() const
 {
     return m_internalFBO;
 }
 
 inline QImage Toplevel::internalImageObject() const
 {
     return m_internalImage;
 }
 
 inline QPoint Toplevel::clientContentPos() const
 {
     return QPoint(0, 0);
 }
 
 template <class T, class U>
 inline T *Toplevel::findInList(const QList<T*> &list, std::function<bool (const U*)> func)
 {
     static_assert(std::is_base_of<U, T>::value,
                  "U must be derived from T");
     const auto it = std::find_if(list.begin(), list.end(), func);
     if (it == list.end()) {
         return nullptr;
     }
     return *it;
 }
 
 inline bool Toplevel::isPopupWindow() const
 {
     switch (windowType()) {
     case NET::ComboBox:
     case NET::DropdownMenu:
     case NET::PopupMenu:
     case NET::Tooltip:
         return true;
 
     default:
         return false;
     }
 }
 
 QDebug& operator<<(QDebug& stream, const Toplevel*);
 
 } // namespace
 Q_DECLARE_METATYPE(KWin::Toplevel*)
 
 #endif
diff --git a/touch_input.cpp b/touch_input.cpp
index 22ff287e9..21273c04c 100644
--- a/touch_input.cpp
+++ b/touch_input.cpp
@@ -1,233 +1,233 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 Roman Gilg <subdiff@gmail.com>
 
 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 "touch_input.h"
 #include "abstract_client.h"
 #include "input.h"
 #include "pointer_input.h"
 #include "input_event_spy.h"
 #include "toplevel.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "decorations/decoratedclient.h"
 // KDecoration
 #include <KDecoration2/Decoration>
 // KWayland
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 // screenlocker
 #include <KScreenLocker/KsldApp>
 // Qt
 #include <QHoverEvent>
 #include <QWindow>
 
 namespace KWin
 {
 
 TouchInputRedirection::TouchInputRedirection(InputRedirection *parent)
     : InputDeviceHandler(parent)
 {
 }
 
 TouchInputRedirection::~TouchInputRedirection() = default;
 
 void TouchInputRedirection::init()
 {
     Q_ASSERT(!inited());
     setInited(true);
     InputDeviceHandler::init();
 
     if (waylandServer()->hasScreenLockerIntegration()) {
         connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::lockStateChanged, this,
             [this] {
                 cancel();
                 // position doesn't matter
                 update();
             }
         );
     }
     connect(workspace(), &QObject::destroyed, this, [this] { setInited(false); });
     connect(waylandServer(), &QObject::destroyed, this, [this] { setInited(false); });
 }
 
 bool TouchInputRedirection::focusUpdatesBlocked()
 {
     if (!inited()) {
         return true;
     }
     if (m_windowUpdatedInCycle) {
         return true;
     }
     m_windowUpdatedInCycle = true;
     if (waylandServer()->seat()->isDragTouch()) {
         return true;
     }
     if (m_touches > 1) {
         // first touch defines focus
         return true;
     }
     return false;
 }
 
 bool TouchInputRedirection::positionValid() const
 {
     Q_ASSERT(m_touches >= 0);
     // we can only determine a position with at least one touch point
     return m_touches == 0;
 }
 
 void TouchInputRedirection::focusUpdate(Toplevel *focusOld, Toplevel *focusNow)
 {
     // TODO: handle pointer grab aka popups
 
     if (AbstractClient *ac = qobject_cast<AbstractClient*>(focusOld)) {
         ac->leaveEvent();
     }
     disconnect(m_focusGeometryConnection);
     m_focusGeometryConnection = QMetaObject::Connection();
 
     if (AbstractClient *ac = qobject_cast<AbstractClient*>(focusNow)) {
         ac->enterEvent(m_lastPosition.toPoint());
         workspace()->updateFocusMousePosition(m_lastPosition.toPoint());
     }
 
     auto seat = waylandServer()->seat();
     if (!focusNow || !focusNow->surface() || decoration()) {
         // no new surface or internal window or on decoration -> cleanup
         seat->setFocusedTouchSurface(nullptr);
         return;
     }
 
     // TODO: invalidate pointer focus?
 
-    // FIXME: add input transformation API to KWayland::Server::SeatInterface for touch input
+    // FIXME: add input transformation API to KWaylandServer::SeatInterface for touch input
     seat->setFocusedTouchSurface(focusNow->surface(), -1 * focusNow->inputTransformation().map(focusNow->pos()) + focusNow->pos());
     m_focusGeometryConnection = connect(focusNow, &Toplevel::frameGeometryChanged, this,
         [this] {
             if (focus().isNull()) {
                 return;
             }
             auto seat = waylandServer()->seat();
             if (focus().data()->surface() != seat->focusedTouchSurface()) {
                 return;
             }
             seat->setFocusedTouchSurfacePosition(-1 * focus()->inputTransformation().map(focus()->pos()) + focus()->pos());
         }
     );
 }
 
 void TouchInputRedirection::cleanupInternalWindow(QWindow *old, QWindow *now)
 {
     Q_UNUSED(old);
     Q_UNUSED(now);
 
     // nothing to do
 }
 
 void TouchInputRedirection::cleanupDecoration(Decoration::DecoratedClientImpl *old, Decoration::DecoratedClientImpl *now)
 {
     Q_UNUSED(old);
     Q_UNUSED(now);
 
     // nothing to do
 }
 
 void TouchInputRedirection::insertId(qint32 internalId, qint32 kwaylandId)
 {
     m_idMapper.insert(internalId, kwaylandId);
 }
 
 qint32 TouchInputRedirection::mappedId(qint32 internalId)
 {
     auto it = m_idMapper.constFind(internalId);
     if (it != m_idMapper.constEnd()) {
         return it.value();
     }
     return -1;
 }
 
 void TouchInputRedirection::removeId(qint32 internalId)
 {
     m_idMapper.remove(internalId);
 }
 
 void TouchInputRedirection::processDown(qint32 id, const QPointF &pos, quint32 time, LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     m_lastPosition = pos;
     m_windowUpdatedInCycle = false;
     m_touches++;
     if (m_touches == 1) {
         update();
     }
     input()->processSpies(std::bind(&InputEventSpy::touchDown, std::placeholders::_1, id, pos, time));
     input()->processFilters(std::bind(&InputEventFilter::touchDown, std::placeholders::_1, id, pos, time));
     m_windowUpdatedInCycle = false;
 }
 
 void TouchInputRedirection::processUp(qint32 id, quint32 time, LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     m_windowUpdatedInCycle = false;
     input()->processSpies(std::bind(&InputEventSpy::touchUp, std::placeholders::_1, id, time));
     input()->processFilters(std::bind(&InputEventFilter::touchUp, std::placeholders::_1, id, time));
     m_windowUpdatedInCycle = false;
     m_touches--;
     if (m_touches == 0) {
         update();
     }
 }
 
 void TouchInputRedirection::processMotion(qint32 id, const QPointF &pos, quint32 time, LibInput::Device *device)
 {
     Q_UNUSED(device)
     if (!inited()) {
         return;
     }
     m_lastPosition = pos;
     m_windowUpdatedInCycle = false;
     input()->processSpies(std::bind(&InputEventSpy::touchMotion, std::placeholders::_1, id, pos, time));
     input()->processFilters(std::bind(&InputEventFilter::touchMotion, std::placeholders::_1, id, pos, time));
     m_windowUpdatedInCycle = false;
 }
 
 void TouchInputRedirection::cancel()
 {
     if (!inited()) {
         return;
     }
     waylandServer()->seat()->cancelTouchSequence();
     m_idMapper.clear();
 }
 
 void TouchInputRedirection::frame()
 {
     if (!inited()) {
         return;
     }
     waylandServer()->seat()->touchFrame();
 }
 
 }
diff --git a/virtualdesktops.cpp b/virtualdesktops.cpp
index 8a2f981c4..a5d61a491 100644
--- a/virtualdesktops.cpp
+++ b/virtualdesktops.cpp
@@ -1,939 +1,939 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtualdesktops.h"
 #include "input.h"
 // KDE
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <NETWM>
 
-#include <KWayland/Server/plasmavirtualdesktop_interface.h>
+#include <KWaylandServer/plasmavirtualdesktop_interface.h>
 // Qt
 #include <QAction>
 #include <QUuid>
 
 #include <algorithm>
 #include <QDebug>
 namespace KWin {
 
 extern int screen_number;
 static bool s_loadingDesktopSettings = false;
 
 static QByteArray generateDesktopId()
 {
     return QUuid::createUuid().toString(QUuid::WithoutBraces).toUtf8();
 }
 
 VirtualDesktop::VirtualDesktop(QObject *parent)
     : QObject(parent)
 {
 }
 
 VirtualDesktop::~VirtualDesktop()
 {
     emit aboutToBeDestroyed();
 }
 
-void VirtualDesktopManager::setVirtualDesktopManagement(KWayland::Server::PlasmaVirtualDesktopManagementInterface *management)
+void VirtualDesktopManager::setVirtualDesktopManagement(KWaylandServer::PlasmaVirtualDesktopManagementInterface *management)
 {
-    using namespace KWayland::Server;
+    using namespace KWaylandServer;
     Q_ASSERT(!m_virtualDesktopManagement);
     m_virtualDesktopManagement = management;
 
     auto createPlasmaVirtualDesktop = [this](VirtualDesktop *desktop) {
         PlasmaVirtualDesktopInterface *pvd = m_virtualDesktopManagement->createDesktop(desktop->id(), desktop->x11DesktopNumber() - 1);
         pvd->setName(desktop->name());
         pvd->sendDone();
 
         connect(desktop, &VirtualDesktop::nameChanged, pvd,
             [desktop, pvd] {
                 pvd->setName(desktop->name());
                 pvd->sendDone();
             }
         );
         connect(pvd, &PlasmaVirtualDesktopInterface::activateRequested, this,
             [this, desktop] {
                 setCurrent(desktop);
             }
         );
     };
 
     connect(this, &VirtualDesktopManager::desktopCreated, m_virtualDesktopManagement, createPlasmaVirtualDesktop);
 
     connect(this, &VirtualDesktopManager::rowsChanged, m_virtualDesktopManagement,
         [this](uint rows) {
             m_virtualDesktopManagement->setRows(rows);
             m_virtualDesktopManagement->sendDone();
         }
     );
 
     //handle removed: from VirtualDesktopManager to the wayland interface
     connect(this, &VirtualDesktopManager::desktopRemoved, m_virtualDesktopManagement,
         [this](VirtualDesktop *desktop) {
             m_virtualDesktopManagement->removeDesktop(desktop->id());
         }
     );
 
     //create a new desktop when the client asks to
     connect (m_virtualDesktopManagement, &PlasmaVirtualDesktopManagementInterface::desktopCreateRequested, this,
         [this](const QString &name, quint32 position) {
             createVirtualDesktop(position, name);
         }
     );
 
     //remove when the client asks to
     connect (m_virtualDesktopManagement, &PlasmaVirtualDesktopManagementInterface::desktopRemoveRequested, this,
         [this](const QString &id) {
             //here there can be some nice kauthorized check?
             //remove only from VirtualDesktopManager, the other connections will remove it from m_virtualDesktopManagement as well
             removeVirtualDesktop(id.toUtf8());
         }
     );
 
     std::for_each(m_desktops.constBegin(), m_desktops.constEnd(), createPlasmaVirtualDesktop);
 
     //Now we are sure all ids are there
     save();
 
     connect(this, &VirtualDesktopManager::currentChanged, m_virtualDesktopManagement,
         [this]() {
             for (auto *deskInt : m_virtualDesktopManagement->desktops()) {
                 if (deskInt->id() == currentDesktop()->id()) {
                     deskInt->setActive(true);
                 } else {
                     deskInt->setActive(false);
                 }
             }
         }
     );
 }
 
 void VirtualDesktop::setId(const QByteArray &id)
 {
     Q_ASSERT(m_id.isEmpty());
     m_id = id;
 }
 
 void VirtualDesktop::setX11DesktopNumber(uint number)
 {
     //x11DesktopNumber can be changed now
     if (static_cast<uint>(m_x11DesktopNumber) == number) {
         return;
     }
 
     m_x11DesktopNumber = number;
 
     if (m_x11DesktopNumber != 0) {
         emit x11DesktopNumberChanged();
     }
 }
 
 void VirtualDesktop::setName(const QString &name)
 {
     if (m_name == name) {
         return;
     }
     m_name = name;
     emit nameChanged();
 }
 
 VirtualDesktopGrid::VirtualDesktopGrid()
     : m_size(1, 2) // Default to tow rows
     , m_grid(QVector<QVector<VirtualDesktop*>>{QVector<VirtualDesktop*>{}, QVector<VirtualDesktop*>{}})
 {    
 }
 
 VirtualDesktopGrid::~VirtualDesktopGrid() = default;
 
 void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop*> &desktops)
 {
     // Set private variables
     m_size = size;
     const uint width = size.width();
     const uint height = size.height();
 
     m_grid.clear();
     auto it = desktops.begin();
     auto end = desktops.end();
     if (orientation == Qt::Horizontal) {
         for (uint y = 0; y < height; ++y) {
             QVector<VirtualDesktop*> row;
             for (uint x = 0; x < width && it != end; ++x) {
                 row << *it;
                 it++;
             }
             m_grid << row;
         }
     } else {
         for (uint y = 0; y < height; ++y) {
             m_grid << QVector<VirtualDesktop*>();
         }
         for (uint x = 0; x < width; ++x) {
             for (uint y = 0; y < height && it != end; ++y) {
                 auto &row = m_grid[y];
                 row << *it;
                 it++;
             }
         }
     }
 }
 
 QPoint VirtualDesktopGrid::gridCoords(uint id) const
 {
     return gridCoords(VirtualDesktopManager::self()->desktopForX11Id(id));
 }
 
 QPoint VirtualDesktopGrid::gridCoords(VirtualDesktop *vd) const
 {
     for (int y = 0; y < m_grid.count(); ++y) {
         const auto &row = m_grid.at(y);
         for (int x = 0; x < row.count(); ++x) {
             if (row.at(x) == vd) {
                 return QPoint(x, y);
             }
         }
     }
     return QPoint(-1, -1);
 }
 
 VirtualDesktop *VirtualDesktopGrid::at(const QPoint &coords) const
 {
     if (coords.y() >= m_grid.count()) {
         return nullptr;
     }
     const auto &row = m_grid.at(coords.y());
     if (coords.x() >= row.count()) {
         return nullptr;
     }
     return row.at(coords.x());
 }
 
 KWIN_SINGLETON_FACTORY_VARIABLE(VirtualDesktopManager, s_manager)
 
 VirtualDesktopManager::VirtualDesktopManager(QObject *parent)
     : QObject(parent)
     , m_navigationWrapsAround(false)
     , m_rootInfo(nullptr)
 {
 }
 
 VirtualDesktopManager::~VirtualDesktopManager()
 {
     s_manager = nullptr;
 }
 
 void VirtualDesktopManager::setRootInfo(NETRootInfo *info)
 {
     m_rootInfo = info;
 
     // Nothing will be connected to rootInfo
     if (m_rootInfo) {
         for (auto *vd : m_desktops) {
             m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
         }
     }
 }
 
 QString VirtualDesktopManager::name(uint desktop) const
 {
     if (uint(m_desktops.length()) > desktop - 1) {
         return m_desktops[desktop - 1]->name();
     }
 
     if (!m_rootInfo) {
         return defaultName(desktop);
     }
     return QString::fromUtf8(m_rootInfo->desktopName(desktop));
 }
 
 uint VirtualDesktopManager::above(uint id, bool wrap) const
 {
     auto vd = above(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::above(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.ry()--;
         if (coords.y() < 0) {
             if (wrap) {
                 coords.setY(m_grid.height() - 1);
             } else {
                 return desktop; // Already at the top-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::toRight(uint id, bool wrap) const
 {
     auto vd = toRight(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::toRight(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.rx()++;
         if (coords.x() >= m_grid.width()) {
             if (wrap) {
                 coords.setX(0);
             } else {
                 return desktop; // Already at the right-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::below(uint id, bool wrap) const
 {
     auto vd = below(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::below(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.ry()++;
         if (coords.y() >= m_grid.height()) {
             if (wrap) {
                 coords.setY(0);
             } else {
                 // Already at the bottom-most desktop
                 return desktop;
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::toLeft(uint id, bool wrap) const
 {
     auto vd = toLeft(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::toLeft(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.rx()--;
         if (coords.x() < 0) {
             if (wrap) {
                 coords.setX(m_grid.width() - 1);
             } else {
                 return desktop; // Already at the left-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 VirtualDesktop *VirtualDesktopManager::next(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     auto it = std::find(m_desktops.begin(), m_desktops.end(), desktop);
     Q_ASSERT(it != m_desktops.end());
     it++;
     if (it == m_desktops.end()) {
         if (wrap) {
             return m_desktops.first();
         } else {
             return desktop;
         }
     }
     return *it;
 }
 
 VirtualDesktop *VirtualDesktopManager::previous(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     auto it = std::find(m_desktops.begin(), m_desktops.end(), desktop);
     Q_ASSERT(it != m_desktops.end());
     if (it == m_desktops.begin()) {
         if (wrap) {
             return m_desktops.last();
         } else {
             return desktop;
         }
     }
     it--;
     return *it;
 }
 
 VirtualDesktop *VirtualDesktopManager::desktopForX11Id(uint id) const
 {
     if (id == 0 || id > count()) {
         return nullptr;
     }
     return m_desktops.at(id - 1);
 }
 
 VirtualDesktop *VirtualDesktopManager::desktopForId(const QByteArray &id) const
 {
     auto desk = std::find_if(
         m_desktops.constBegin(),
         m_desktops.constEnd(),
         [id] (const VirtualDesktop *desk ) {
             return desk->id() == id;
         }
     );
 
     if (desk != m_desktops.constEnd()) {
         return *desk;
     }
 
     return nullptr;
 }
 
 VirtualDesktop *VirtualDesktopManager::createVirtualDesktop(uint position, const QString &name)
 {
     //too many, can't insert new ones
     if ((uint)m_desktops.count() == VirtualDesktopManager::maximum()) {
         return nullptr;
     }
 
     position = qBound(0u, position, static_cast<uint>(m_desktops.count()));
 
     auto *vd = new VirtualDesktop(this);
     vd->setX11DesktopNumber(position + 1);
     vd->setId(generateDesktopId());
     vd->setName(name);
 
     connect(vd, &VirtualDesktop::nameChanged, this,
         [this, vd]() {
             if (m_rootInfo) {
                 m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
             }
         }
     );
 
     if (m_rootInfo) {
         m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
     }
 
     m_desktops.insert(position, vd);
 
     //update the id of displaced desktops
     for (uint i = position + 1; i < (uint)m_desktops.count(); ++i) {
         m_desktops[i]->setX11DesktopNumber(i + 1);
         if (m_rootInfo) {
             m_rootInfo->setDesktopName(i + 1, m_desktops[i]->name().toUtf8().data());
         }
     }
 
     save();
 
     updateRootInfo();
     emit desktopCreated(vd);
     emit countChanged(m_desktops.count()-1, m_desktops.count());
     return vd;
 }
 
 void VirtualDesktopManager::removeVirtualDesktop(const QByteArray &id)
 {
     //don't end up without any desktop
     if (m_desktops.count() == 1) {
         return;
     }
     auto desktop = desktopForId(id);
     if (!desktop) {
         return;
     }
 
     const uint oldCurrent = m_current->x11DesktopNumber();
     const uint i = desktop->x11DesktopNumber() - 1;
     m_desktops.remove(i);
 
     for (uint j = i; j < (uint)m_desktops.count(); ++j) {
         m_desktops[j]->setX11DesktopNumber(j + 1);
         if (m_rootInfo) {
             m_rootInfo->setDesktopName(j + 1, m_desktops[j]->name().toUtf8().data());
         }
     }
 
     const uint newCurrent = qMin(oldCurrent, (uint)m_desktops.count());
     m_current = m_desktops.at(newCurrent - 1);
     if (oldCurrent != newCurrent) {
         emit currentChanged(oldCurrent, newCurrent);
     }
 
     save();
 
     updateRootInfo();
     emit desktopRemoved(desktop);
     emit countChanged(m_desktops.count()+1, m_desktops.count());
 
     desktop->deleteLater();
 }
 
 uint VirtualDesktopManager::current() const
 {
     return m_current ? m_current->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::currentDesktop() const
 {
     return m_current;
 }
 
 bool VirtualDesktopManager::setCurrent(uint newDesktop)
 {
     if (newDesktop < 1 || newDesktop > count() || newDesktop == current()) {
         return false;
     }
     auto d = desktopForX11Id(newDesktop);
     Q_ASSERT(d);
     return setCurrent(d);
 }
 
 bool VirtualDesktopManager::setCurrent(VirtualDesktop *newDesktop)
 {
     Q_ASSERT(newDesktop);
     if (m_current == newDesktop) {
         return false;
     }
     const uint oldDesktop = current();
     m_current = newDesktop;
     emit currentChanged(oldDesktop, newDesktop->x11DesktopNumber());
     return true;
 }
 
 void VirtualDesktopManager::setCount(uint count)
 {
     count = qBound<uint>(1, count, VirtualDesktopManager::maximum());
     if (count == uint(m_desktops.count())) {
         // nothing to change
         return;
     }
     QList<VirtualDesktop *> newDesktops;
     const uint oldCount = m_desktops.count();
     //this explicit check makes it more readable
     if ((uint)m_desktops.count() > count) {
         const auto desktopsToRemove = m_desktops.mid(count);
         m_desktops.resize(count);
         if (m_current) {
             uint oldCurrent = current();
             uint newCurrent = qMin(oldCurrent, count);
             m_current = m_desktops.at(newCurrent - 1);
             if (oldCurrent != newCurrent) {
                 emit currentChanged(oldCurrent, newCurrent);
             }
         }
         for (auto desktop : desktopsToRemove) {
             emit desktopRemoved(desktop);
             desktop->deleteLater();
         }
     } else {
         while (uint(m_desktops.count()) < count) {
             auto vd = new VirtualDesktop(this);
             const int x11Number = m_desktops.count() + 1;
             vd->setX11DesktopNumber(x11Number);
             vd->setName(defaultName(x11Number));
             if (!s_loadingDesktopSettings) {
                 vd->setId(generateDesktopId());
             }
             m_desktops << vd;
             newDesktops << vd;
             connect(vd, &VirtualDesktop::nameChanged, this,
                 [this, vd] {
                     if (m_rootInfo) {
                         m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
                     }
                 }
             );
             if (m_rootInfo) {
                 m_rootInfo->setDesktopName(vd->x11DesktopNumber(), vd->name().toUtf8().data());
             }
         }
     }
 
     updateRootInfo();
 
     if (!s_loadingDesktopSettings) {
         save();
     }
     for (auto vd : newDesktops) {
         emit desktopCreated(vd);
     }
     emit countChanged(oldCount, m_desktops.count());
 }
 
 
 uint VirtualDesktopManager::rows() const
 {
     return m_rows;
 }
 
 void VirtualDesktopManager::setRows(uint rows)
 {
     if (rows == 0 || rows > count() || rows == m_rows) {
         return;
     }
 
     m_rows = rows;
 
     int columns = count() / m_rows;
     if (count() % m_rows > 0) {
         columns++;
     }
     if (m_rootInfo) {
         m_rootInfo->setDesktopLayout(NET::OrientationHorizontal, columns, m_rows, NET::DesktopLayoutCornerTopLeft);
         m_rootInfo->activate();
     }
 
     updateLayout();
 
     //rowsChanged will be emitted by setNETDesktopLayout called by updateLayout
 }
 
 void VirtualDesktopManager::updateRootInfo()
 {
     if (!m_rootInfo) {
         // Make sure the layout is still valid
         updateLayout();
         return;
     }
     const int n = count();
     m_rootInfo->setNumberOfDesktops(n);
     NETPoint *viewports = new NETPoint[n];
     m_rootInfo->setDesktopViewport(n, *viewports);
     delete[] viewports;
     // Make sure the layout is still valid
     updateLayout();
 }
 
 void VirtualDesktopManager::updateLayout()
 {
     m_rows = qMin(m_rows, count());
     int columns = count() / m_rows;
     Qt::Orientation orientation = Qt::Horizontal;
     if (m_rootInfo) {
         // TODO: Is there a sane way to avoid overriding the existing grid?
         columns = m_rootInfo->desktopLayoutColumnsRows().width();
         m_rows = qMax(1, m_rootInfo->desktopLayoutColumnsRows().height());
         orientation = m_rootInfo->desktopLayoutOrientation() == NET::OrientationHorizontal ? Qt::Horizontal : Qt::Vertical;
     }
 
     if (columns == 0) {
         // Not given, set default layout
         m_rows = count() == 1u ? 1 : 2;
         columns = count() / m_rows;
     }
     setNETDesktopLayout(orientation,
         columns, m_rows, 0 //rootInfo->desktopLayoutCorner() // Not really worth implementing right now.
     );
 }
 
 void VirtualDesktopManager::load()
 {
     s_loadingDesktopSettings = true;
     if (!m_config) {
         return;
     }
     QString groupname;
     if (screen_number == 0) {
         groupname = QStringLiteral("Desktops");
     } else {
         groupname = QStringLiteral("Desktops-screen-%1").arg(screen_number);
     }
     KConfigGroup group(m_config, groupname);
     const int n = group.readEntry("Number", 1);
     setCount(n);
 
     for (int i = 1; i <= n; i++) {
         QString s = group.readEntry(QStringLiteral("Name_%1").arg(i), i18n("Desktop %1", i));
         if (m_rootInfo) {
             m_rootInfo->setDesktopName(i, s.toUtf8().data());
         }
         m_desktops[i-1]->setName(s.toUtf8().data());
 
         const QString sId = group.readEntry(QStringLiteral("Id_%1").arg(i), QString());
 
         //load gets called 2 times, see workspace.cpp line 416 and BUG 385260
         if (m_desktops[i-1]->id().isEmpty()) {
             m_desktops[i-1]->setId(sId.isEmpty() ? generateDesktopId() : sId.toUtf8());
         } else {
             Q_ASSERT(sId.isEmpty() || m_desktops[i-1]->id() == sId.toUtf8().data());
         }
 
         // TODO: update desktop focus chain, why?
 //         m_desktopFocusChain.value()[i-1] = i;
     }
 
     int rows = group.readEntry<int>("Rows", 2);
     m_rows = qBound(1, rows, n);
 
     if (m_rootInfo) {
         // avoid weird cases like having 3 rows for 4 desktops, where the last row is unused
         int columns = n / m_rows;
         if (n % m_rows > 0) {
             columns++;
         }
         m_rootInfo->setDesktopLayout(NET::OrientationHorizontal, columns, m_rows, NET::DesktopLayoutCornerTopLeft);
         m_rootInfo->activate();
     }
 
     s_loadingDesktopSettings = false;
 }
 
 void VirtualDesktopManager::save()
 {
     if (s_loadingDesktopSettings) {
         return;
     }
     if (!m_config) {
         return;
     }
     QString groupname;
     if (screen_number == 0) {
         groupname = QStringLiteral("Desktops");
     } else {
         groupname = QStringLiteral("Desktops-screen-%1").arg(screen_number);
     }
     KConfigGroup group(m_config, groupname);
 
     for (int i = count() + 1;  group.hasKey(QStringLiteral("Id_%1").arg(i)); i++) {
         group.deleteEntry(QStringLiteral("Id_%1").arg(i));
         group.deleteEntry(QStringLiteral("Name_%1").arg(i));
     }
 
     group.writeEntry("Number", count());
     for (uint i = 1; i <= count(); ++i) {
         QString s = name(i);
         const QString defaultvalue = defaultName(i);
         if (s.isEmpty()) {
             s = defaultvalue;
             if (m_rootInfo) {
                 m_rootInfo->setDesktopName(i, s.toUtf8().data());
             }
         }
 
         if (s != defaultvalue) {
             group.writeEntry(QStringLiteral("Name_%1").arg(i), s);
         } else {
             QString currentvalue = group.readEntry(QStringLiteral("Name_%1").arg(i), QString());
             if (currentvalue != defaultvalue) {
                 group.deleteEntry(QStringLiteral("Name_%1").arg(i));
             }
         }
         group.writeEntry(QStringLiteral("Id_%1").arg(i), m_desktops[i-1]->id());
     }
 
     group.writeEntry("Rows", m_rows);
 
     // Save to disk
     group.sync();
 }
 
 QString VirtualDesktopManager::defaultName(int desktop) const
 {
     return i18n("Desktop %1", desktop);
 }
 
 void VirtualDesktopManager::setNETDesktopLayout(Qt::Orientation orientation, uint width, uint height, int startingCorner)
 {
     Q_UNUSED(startingCorner);   // Not really worth implementing right now.
     const uint count = m_desktops.count();
 
     // Calculate valid grid size
     Q_ASSERT(width > 0 || height > 0);
     if ((width <= 0) && (height > 0)) {
         width = (count + height - 1) / height;
     } else if ((height <= 0) && (width > 0)) {
         height = (count + width - 1) / width;
     }
     while (width * height < count) {
         if (orientation == Qt::Horizontal) {
             ++width;
         } else {
             ++height;
         }
     }
 
     m_rows = qMax(1u, height);
 
     m_grid.update(QSize(width, height), orientation, m_desktops);
     // TODO: why is there no call to m_rootInfo->setDesktopLayout?
     emit layoutChanged(width, height);
     emit rowsChanged(height);
 }
 
 void VirtualDesktopManager::initShortcuts()
 {
     initSwitchToShortcuts();
 
     QAction *nextAction = addAction(QStringLiteral("Switch to Next Desktop"), i18n("Switch to Next Desktop"), &VirtualDesktopManager::slotNext);
     input()->registerTouchpadSwipeShortcut(SwipeDirection::Right, nextAction);
     QAction *previousAction = addAction(QStringLiteral("Switch to Previous Desktop"), i18n("Switch to Previous Desktop"), &VirtualDesktopManager::slotPrevious);
     input()->registerTouchpadSwipeShortcut(SwipeDirection::Left, previousAction);
     QAction *slotRightAction = addAction(QStringLiteral("Switch One Desktop to the Right"), i18n("Switch One Desktop to the Right"), &VirtualDesktopManager::slotRight);
     KGlobalAccel::setGlobalShortcut(slotRightAction, QKeySequence(Qt::CTRL + Qt::META + Qt::Key_Right));
     QAction *slotLeftAction = addAction(QStringLiteral("Switch One Desktop to the Left"), i18n("Switch One Desktop to the Left"), &VirtualDesktopManager::slotLeft);
     KGlobalAccel::setGlobalShortcut(slotLeftAction, QKeySequence(Qt::CTRL + Qt::META + Qt::Key_Left));
     QAction *slotUpAction = addAction(QStringLiteral("Switch One Desktop Up"), i18n("Switch One Desktop Up"), &VirtualDesktopManager::slotUp);
     KGlobalAccel::setGlobalShortcut(slotUpAction, QKeySequence(Qt::CTRL + Qt::META + Qt::Key_Up));
     QAction *slotDownAction = addAction(QStringLiteral("Switch One Desktop Down"), i18n("Switch One Desktop Down"), &VirtualDesktopManager::slotDown);
     KGlobalAccel::setGlobalShortcut(slotDownAction, QKeySequence(Qt::CTRL + Qt::META + Qt::Key_Down));
 
     // axis events
     input()->registerAxisShortcut(Qt::ControlModifier | Qt::AltModifier, PointerAxisDown,
                                   findChild<QAction*>(QStringLiteral("Switch to Next Desktop")));
     input()->registerAxisShortcut(Qt::ControlModifier | Qt::AltModifier, PointerAxisUp,
                                   findChild<QAction*>(QStringLiteral("Switch to Previous Desktop")));
 }
 
 void VirtualDesktopManager::initSwitchToShortcuts()
 {
     const QString toDesktop = QStringLiteral("Switch to Desktop %1");
     const KLocalizedString toDesktopLabel = ki18n("Switch to Desktop %1");
     addAction(toDesktop, toDesktopLabel, 1, QKeySequence(Qt::CTRL + Qt::Key_F1), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 2, QKeySequence(Qt::CTRL + Qt::Key_F2), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 3, QKeySequence(Qt::CTRL + Qt::Key_F3), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 4, QKeySequence(Qt::CTRL + Qt::Key_F4), &VirtualDesktopManager::slotSwitchTo);
 
     for (uint i = 5; i <= maximum(); ++i) {
         addAction(toDesktop, toDesktopLabel, i, QKeySequence(), &VirtualDesktopManager::slotSwitchTo);
     }
 }
 
 QAction *VirtualDesktopManager::addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)())
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(name.arg(value));
     a->setText(label.subs(value).toString());
     a->setData(value);
     KGlobalAccel::setGlobalShortcut(a, key);
     input()->registerShortcut(key, a, this, slot);
     return a;
 }
 
 QAction *VirtualDesktopManager::addAction(const QString &name, const QString &label, void (VirtualDesktopManager::*slot)())
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(name);
     a->setText(label);
     KGlobalAccel::setGlobalShortcut(a, QKeySequence());
     input()->registerShortcut(QKeySequence(), a, this, slot);
     return a;
 }
 
 void VirtualDesktopManager::slotSwitchTo()
 {
     QAction *act = qobject_cast<QAction*>(sender());
     if (!act) {
         return;
     }
     bool ok = false;
     const uint i = act->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     setCurrent(i);
 }
 
 void VirtualDesktopManager::setNavigationWrappingAround(bool enabled)
 {
     if (enabled == m_navigationWrapsAround) {
         return;
     }
     m_navigationWrapsAround = enabled;
     emit navigationWrappingAroundChanged();
 }
 
 void VirtualDesktopManager::slotDown()
 {
     moveTo<DesktopBelow>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotLeft()
 {
     moveTo<DesktopLeft>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotPrevious()
 {
     moveTo<DesktopPrevious>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotNext()
 {
     moveTo<DesktopNext>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotRight()
 {
     moveTo<DesktopRight>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotUp()
 {
     moveTo<DesktopAbove>(isNavigationWrappingAround());
 }
 
 } // KWin
diff --git a/virtualdesktops.h b/virtualdesktops.h
index e7490f685..6d3494739 100644
--- a/virtualdesktops.h
+++ b/virtualdesktops.h
@@ -1,730 +1,727 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_VIRTUAL_DESKTOPS_H
 #define KWIN_VIRTUAL_DESKTOPS_H
 // KWin
 #include <kwinglobals.h>
 #include <kwin_export.h>
 // Qt includes
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <QSize>
 
 // KDE includes
 #include <KConfig>
 #include <KSharedConfig>
 
 class KLocalizedString;
 class NETRootInfo;
 class QAction;
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class PlasmaVirtualDesktopManagementInterface;
 }
-}
 
 namespace KWin {
 
 class KWIN_EXPORT VirtualDesktop : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QByteArray id READ id CONSTANT)
     Q_PROPERTY(uint x11DesktopNumber READ x11DesktopNumber NOTIFY x11DesktopNumberChanged)
     Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
 public:
     explicit VirtualDesktop(QObject *parent = nullptr);
     ~VirtualDesktop() override;
 
     void setId(const QByteArray &id);
     QByteArray id() const {
         return m_id;
     }
 
     void setName(const QString &name);
     QString name() const {
         return m_name;
     }
 
     void setX11DesktopNumber(uint number);
     uint x11DesktopNumber() const {
         return m_x11DesktopNumber;
     }
 
 Q_SIGNALS:
     void nameChanged();
     void x11DesktopNumberChanged();
     /**
      * Emitted just before the desktop gets destroyed.
      */
     void aboutToBeDestroyed();
 
 private:
     QByteArray m_id;
     QString m_name;
     int m_x11DesktopNumber = 0;
 
 };
 
 /**
  * @brief Two dimensional grid containing the ID of the virtual desktop at a specific position
  * in the grid.
  *
  * The VirtualDesktopGrid represents a visual layout of the Virtual Desktops as they are in e.g.
  * a Pager. This grid is used for getting a desktop next to a given desktop in any direction by
  * making use of the layout information. This allows navigation like move to desktop on left.
  */
 class VirtualDesktopGrid
 {
 public:
     VirtualDesktopGrid();
     ~VirtualDesktopGrid();
     void update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop*> &desktops);
     /**
      * @returns The coords of desktop @a id in grid units.
      */
     QPoint gridCoords(uint id) const;
     /**
      * @returns The coords of desktop @a vd in grid units.
      */
     QPoint gridCoords(VirtualDesktop *vd) const;
     /**
      * @returns The desktop at the point @a coords or 0 if no desktop exists at that
      * point. @a coords is to be in grid units.
      */
     VirtualDesktop *at(const QPoint &coords) const;
     int width() const;
     int height() const;
     const QSize &size() const;
 private:
     QSize m_size;
     QVector<QVector<VirtualDesktop*>> m_grid;
 };
 
 /**
  * @brief Manages the number of available virtual desktops, the layout of those and which virtual
  * desktop is the current one.
  *
  * This manager is responsible for Virtual Desktop handling inside KWin. It has a property for the
  * count of available virtual desktops and a property for the currently active virtual desktop. All
  * changes to the number of virtual desktops and the current virtual desktop need to go through this
  * manager.
  *
  * On all changes a signal is emitted and interested parties should connect to the signal. The manager
  * itself does not interact with other parts of the system. E.g. it does not hide/show windows of
  * desktop changes. This is outside the scope of this manager.
  *
  * Internally the manager organizes the virtual desktops in a grid allowing to navigate over the
  * virtual desktops. For this a set of convenient methods are available which allow to get the id
  * of an adjacent desktop or to switch to an adjacent desktop. Interested parties should make use of
  * these methods and not replicate the logic to switch to the next desktop.
  */
 class KWIN_EXPORT VirtualDesktopManager : public QObject
 {
     Q_OBJECT
     /**
      * The number of virtual desktops currently available.
      * The ids of the virtual desktops are in the range [1, VirtualDesktopManager::maximum()].
      */
     Q_PROPERTY(uint count READ count WRITE setCount NOTIFY countChanged)
     /**
      * The id of the virtual desktop which is currently in use.
      */
     Q_PROPERTY(uint current READ current WRITE setCurrent NOTIFY currentChanged)
     /**
      * Whether navigation in the desktop layout wraps around at the borders.
      */
     Q_PROPERTY(bool navigationWrappingAround READ isNavigationWrappingAround WRITE setNavigationWrappingAround NOTIFY navigationWrappingAroundChanged)
 public:
     ~VirtualDesktopManager() override;
     /**
      * @internal, for X11 case
      */
     void setRootInfo(NETRootInfo *info);
     /**
      * @internal, for Wayland case
      */
-    void setVirtualDesktopManagement(KWayland::Server::PlasmaVirtualDesktopManagementInterface *management);
+    void setVirtualDesktopManagement(KWaylandServer::PlasmaVirtualDesktopManagementInterface *management);
     /**
      * @internal
      */
     void setConfig(KSharedConfig::Ptr config);
     /**
      * @returns Total number of desktops currently in existence.
      * @see setCount
      * @see countChanged
      */
     uint count() const;
     /**
      * @returns the number of rows the layout has.
      * @see setRows
      * @see rowsChanged
      */
     uint rows() const;
     /**
      * @returns The ID of the current desktop.
      * @see setCurrent
      * @see currentChanged
      */
     uint current() const;
     /**
      * @returns The current desktop
      * @see setCurrent
      * @see currentChanged
      */
     VirtualDesktop *currentDesktop() const;
     /**
      * Moves to the desktop through the algorithm described by Direction.
      * @param wrap If @c true wraps around to the other side of the layout
      * @see setCurrent
      */
     template <typename Direction>
     void moveTo(bool wrap = false);
 
     /**
      * @returns The name of the @p desktop
      */
     QString name(uint desktop) const;
 
     /**
      * @returns @c true if navigation at borders of layout wraps around, @c false otherwise
      * @see setNavigationWrappingAround
      * @see navigationWrappingAroundChanged
      */
     bool isNavigationWrappingAround() const;
 
     /**
      * @returns The layout aware virtual desktop grid used by this manager.
      */
     const VirtualDesktopGrid &grid() const;
 
     /**
      * @returns The ID of the desktop above desktop @a id. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint above(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop above desktop @a desktop. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *above(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop to the right of desktop @a id. Wraps around to the
      * left of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint toRight(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop to the right of desktop @a desktop. Wraps around to the
      * left of the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *toRight(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop below desktop @a id. Wraps around to the top of the
      * layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint below(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop below desktop @a desktop. Wraps around to the top of the
      * layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *below(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop to the left of desktop @a id. Wraps around to the
      * right of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint toLeft(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop to the left of desktop @a desktop. Wraps around to the
      * right of the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *toLeft(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The desktop after the desktop @a desktop. Wraps around to the first
      * desktop if @a wrap is set. If @a desktop is @c null use the current desktop.
      */
     VirtualDesktop *next(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
     /**
      * @returns The desktop in front of the desktop @a desktop. Wraps around to the
      * last desktop if @a wrap is set. If @a desktop is @c null use the current desktop.
      */
     VirtualDesktop *previous(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
 
     void initShortcuts();
 
     /**
      * @returns all currently managed VirtualDesktops
      */
     QVector<VirtualDesktop*> desktops() const {
         return m_desktops;
     }
 
     /**
      * @returns The VirtualDesktop for the x11 @p id, if no such VirtualDesktop @c null is returned
      */
     VirtualDesktop *desktopForX11Id(uint id) const;
 
     /**
      * @returns The VirtualDesktop for the internal desktop string @p id, if no such VirtualDesktop @c null is returned
      */
     VirtualDesktop *desktopForId(const QByteArray &id) const;
 
     /**
      * Create a new virtual desktop at the requested position.
      * The difference with setCount is that setCount always adds new desktops at the end of the chain. The Id is automatically generated.
      * @param position The position of the desktop. It should be in range [0, count].
      * @param name The name for the new desktop, if empty the default name will be used.
      * @returns the new VirtualDesktop, nullptr if we reached the maximum number of desktops
      */
      VirtualDesktop *createVirtualDesktop(uint position, const QString &name = QString());
 
     /**
      * Remove the virtual desktop identified by id, if it exists
      * difference with setCount is that is possible to remove an arbitrary desktop,
      * not only the last one.
      * @param id the string id of the desktop to remove
      */
     void removeVirtualDesktop(const QByteArray &id);
 
     /**
      * Updates the net root info for new number of desktops
      */
     void updateRootInfo();
 
     /**
      * @returns The maximum number of desktops that KWin supports.
      */
     static uint maximum();
 
 public Q_SLOTS:
     /**
      * Set the number of available desktops to @a count. This function overrides any previous
      * grid layout.
      * There needs to be at least one virtual desktop and the new value is capped at the maximum
      * number of desktops. A caller of this function cannot expect that the change has been applied.
      * It is the callers responsibility to either check the numberOfDesktops or connect to the
      * countChanged signal.
      *
      * In case the @ref current desktop is on a desktop higher than the new count, the current desktop
      * is changed to be the new desktop with highest id. In that situation the signal desktopRemoved
      * is emitted.
      * @param count The new number of desktops to use
      * @see count
      * @see maximum
      * @see countChanged
      * @see desktopCreated
      * @see desktopRemoved
      */
     void setCount(uint count);
     /**
      * Set the current desktop to @a current.
      * @returns True on success, false otherwise.
      * @see current
      * @see currentChanged
      * @see moveTo
      */
     bool setCurrent(uint current);
     /**
      * Set the current desktop to @a current.
      * @returns True on success, false otherwise.
      * @see current
      * @see currentChanged
      * @see moveTo
      */
     bool setCurrent(VirtualDesktop *current);
     /**
      * Updates the layout to a new number of rows. The number of columns will be calculated accordingly
      */
     void setRows(uint rows);
     /**
      * Called from within setCount() to ensure the desktop layout is still valid.
      */
     void updateLayout();
     /**
      * @param enabled wrapping around borders for navigation in desktop layout
      * @see isNavigationWrappingAround
      * @see navigationWrappingAroundChanged
      */
     void setNavigationWrappingAround(bool enabled);
     /**
      * Loads number of desktops and names from configuration file
      */
     void load();
     /**
      * Saves number of desktops and names to configuration file
      */
     void save();
 
 Q_SIGNALS:
     /**
      * Signal emitted whenever the number of virtual desktops changes.
      * @param previousCount The number of desktops prior to the change
      * @param newCount The new current number of desktops
      */
     void countChanged(uint previousCount, uint newCount);
 
     /**
      * Signal when the number of rows in the layout changes
      * @param rows number of rows
      */
     void rowsChanged(uint rows);
 
     /**
      * A new desktop has been created
      * @param desktop the new just crated desktop
      */
     void desktopCreated(KWin::VirtualDesktop *desktop);
 
     /**
      * A desktop has been removed and is about to be deleted
      * @param desktop the desktop that has been removed.
      *          It's guaranteed to stil la valid pointer when the signal arrives,
      *          but it's about to be deleted.
      */
     void desktopRemoved(KWin::VirtualDesktop *desktop);
 
     /**
      * Signal emitted whenever the current desktop changes.
      * @param previousDesktop The virtual desktop changed from
      * @param newDesktop The virtual desktop changed to
      */
     void currentChanged(uint previousDesktop, uint newDesktop);
     /**
      * Signal emitted whenever the desktop layout changes.
      * @param columns The new number of columns in the layout
      * @param rows The new number of rows in the layout
      */
     void layoutChanged(int columns, int rows);
     /**
      * Signal emitted whenever the navigationWrappingAround property changes.
      */
     void navigationWrappingAroundChanged();
 
 private Q_SLOTS:
     /**
      * Common slot for all "Switch to Desktop n" shortcuts.
      * This method uses the sender() method to access some data.
      * DO NOT CALL DIRECTLY! ONLY TO BE USED FROM AN ACTION!
      */
     void slotSwitchTo();
     /**
      * Slot for switch to next desktop action.
      */
     void slotNext();
     /**
      * Slot for switch to previous desktop action.
      */
     void slotPrevious();
     /**
      * Slot for switch to right desktop action.
      */
     void slotRight();
     /**
      * Slot for switch to left desktop action.
      */
     void slotLeft();
     /**
      * Slot for switch to desktop above action.
      */
     void slotUp();
     /**
      * Slot for switch to desktop below action.
      */
     void slotDown();
 
 private:
     /**
      * Generate a desktop layout from EWMH _NET_DESKTOP_LAYOUT property parameters.
      */
     void setNETDesktopLayout(Qt::Orientation orientation, uint width, uint height, int startingCorner);
     /**
      * @returns A default name for the given @p desktop
      */
     QString defaultName(int desktop) const;
     /**
      * Creates all the global keyboard shortcuts for "Switch To Desktop n" actions.
      */
     void initSwitchToShortcuts();
     /**
      * Creates an action and connects it to the @p slot in this Manager. This method is
      * meant to be used for the case that an additional information needs to be stored in
      * the action and the label.
      * @param name The name of the action to be created
      * @param label The localized name for the action to be created
      * @param value An additional value added to the label and to the created action
      * @param key The global shortcut for the action
      * @param slot The slot to invoke when the action is triggered
      */
     QAction *addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)());
     /**
      * Creates an action and connects it to the @p slot in this Manager.
      * Overloaded method for the case that no additional value needs to be passed to the action and
      * no global shortcut is defined by default.
      * @param name The name of the action to be created
      * @param label The localized name for the action to be created
      * @param slot The slot to invoke when the action is triggered
      */
     QAction *addAction(const QString &name, const QString &label, void (VirtualDesktopManager::*slot)());
 
     QVector<VirtualDesktop*> m_desktops;
     QPointer<VirtualDesktop> m_current;
     quint32 m_rows = 2;
     bool m_navigationWrapsAround;
     VirtualDesktopGrid m_grid;
     // TODO: QPointer
     NETRootInfo *m_rootInfo;
-    KWayland::Server::PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
+    KWaylandServer::PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
     KSharedConfig::Ptr m_config;
 
     KWIN_SINGLETON_VARIABLE(VirtualDesktopManager, s_manager)
 };
 
 /**
  * Function object to select the desktop above in the layout.
  * Note: does not switch to the desktop!
  */
 class DesktopAbove
 {
 public:
     DesktopAbove() {}
     /**
      * @param desktop The desktop from which the desktop above should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already topmost desktop
      * @returns Id of the desktop above @p desktop
      */
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop above should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already topmost desktop
      * @returns the desktop above @p desktop
      */
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->above(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop below in the layout.
  * Note: does not switch to the desktop!
  */
 class DesktopBelow
 {
 public:
     DesktopBelow() {}
     /**
      * @param desktop The desktop from which the desktop below should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already lowest desktop
      * @returns Id of the desktop below @p desktop
      */
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop below should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already lowest desktop
      * @returns the desktop below @p desktop
      */
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->below(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop to the left in the layout.
  * Note: does not switch to the desktop!
  */
 class DesktopLeft
 {
 public:
     DesktopLeft() {}
     /**
      * @param desktop The desktop from which the desktop on the left should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already leftmost desktop
      * @returns Id of the desktop left of @p desktop
      */
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop on the left should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already leftmost desktop
      * @returns the desktop left of @p desktop
      */
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->toLeft(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop to the right in the layout.
  * Note: does not switch to the desktop!
  */
 class DesktopRight
 {
 public:
     DesktopRight() {}
     /**
      * @param desktop The desktop from which the desktop on the right should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already rightmost desktop
      * @returns Id of the desktop right of @p desktop
      */
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop on the right should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already rightmost desktop
      * @returns the desktop right of @p desktop
      */
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->toRight(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the next desktop in the layout.
  * Note: does not switch to the desktop!
  */
 class DesktopNext
 {
 public:
     DesktopNext() {}
     /**
      * @param desktop The desktop from which the next desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already last desktop
      * @returns Id of the next desktop
      */
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the next desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already last desktop
      * @returns the next desktop
      */
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->next(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the previous desktop in the layout.
  * Note: does not switch to the desktop!
  */
 class DesktopPrevious
 {
 public:
     DesktopPrevious() {}
     /**
      * @param desktop The desktop from which the previous desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already first desktop
      * @returns Id of the previous desktop
      */
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the previous desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already first desktop
      * @returns the previous desktop
      */
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->previous(desktop, wrap);
     }
 };
 
 /**
  * Helper function to get the ID of a virtual desktop in the direction from
  * the given @p desktop. If @c 0 the current desktop is used as a starting point.
  * @param desktop The desktop from which the desktop in given Direction should be selected.
  * @param wrap Whether desktop navigation wraps around at the borders of the layout
  * @returns The next desktop in specified direction
  */
 template <typename Direction>
 uint getDesktop(int desktop = 0, bool wrap = true);
 
 template <typename Direction>
 uint getDesktop(int d, bool wrap)
 {
     Direction direction;
     return direction(d, wrap);
 }
 
 inline
 int VirtualDesktopGrid::width() const
 {
     return m_size.width();
 }
 
 inline
 int VirtualDesktopGrid::height() const
 {
     return m_size.height();
 }
 
 inline
 const QSize &VirtualDesktopGrid::size() const
 {
     return m_size;
 }
 
 inline
 uint VirtualDesktopManager::maximum()
 {
     return 20;
 }
 
 inline
 uint VirtualDesktopManager::count() const
 {
     return m_desktops.count();
 }
 
 inline
 bool VirtualDesktopManager::isNavigationWrappingAround() const
 {
     return m_navigationWrapsAround;
 }
 
 inline
 void VirtualDesktopManager::setConfig(KSharedConfig::Ptr config)
 {
     m_config = std::move(config);
 }
 
 inline
 const VirtualDesktopGrid &VirtualDesktopManager::grid() const
 {
     return m_grid;
 }
 
 template <typename Direction>
 void VirtualDesktopManager::moveTo(bool wrap)
 {
     Direction functor;
     setCurrent(functor(nullptr, wrap));
 }
 
 } // namespace KWin
 #endif
diff --git a/virtualkeyboard.cpp b/virtualkeyboard.cpp
index b1abe415c..7e114d545 100644
--- a/virtualkeyboard.cpp
+++ b/virtualkeyboard.cpp
@@ -1,501 +1,501 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtualkeyboard.h"
 #include "virtualkeyboard_dbus.h"
 #include "input.h"
 #include "keyboard_input.h"
 #include "utils.h"
 #include "screens.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xkb.h"
 #include "screenlockerwatcher.h"
 
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/textinput_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/textinput_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <KStatusNotifierItem>
 #include <KLocalizedString>
 
 #include <QDBusConnection>
 #include <QDBusPendingCall>
 #include <QDBusMessage>
 #include <QGuiApplication>
 #include <QQmlComponent>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QQuickItem>
 #include <QQuickView>
 #include <QQuickWindow>
 #include <QTimer>
 // xkbcommon
 #include <xkbcommon/xkbcommon.h>
 
-using namespace KWayland::Server;
+using namespace KWaylandServer;
 
 namespace KWin
 {
 
 KWIN_SINGLETON_FACTORY(VirtualKeyboard)
 
 VirtualKeyboard::VirtualKeyboard(QObject *parent)
     : QObject(parent)
 {
     m_floodTimer = new QTimer(this);
     m_floodTimer->setSingleShot(true);
     m_floodTimer->setInterval(250);
     // this is actually too late. Other processes are started before init,
     // so might miss the availability of text input
     // but without Workspace we don't have the window listed at all
     connect(kwinApp(), &Application::workspaceCreated, this, &VirtualKeyboard::init);
 }
 
 VirtualKeyboard::~VirtualKeyboard() = default;
 
 void VirtualKeyboard::init()
 {
     // TODO: need a shared Qml engine
     qCDebug(KWIN_VIRTUALKEYBOARD) << "Initializing window";
     m_inputWindow.reset(new QQuickView(nullptr));
     m_inputWindow->setFlags(Qt::FramelessWindowHint);
     m_inputWindow->setGeometry(screens()->geometry(screens()->current()));
     m_inputWindow->setResizeMode(QQuickView::SizeRootObjectToView);
     m_inputWindow->setSource(QUrl::fromLocalFile(QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral(KWIN_NAME "/virtualkeyboard/main.qml"))));
     if (m_inputWindow->status() != QQuickView::Status::Ready) {
         qCWarning(KWIN_VIRTUALKEYBOARD) << "window not ready yet";
         m_inputWindow.reset();
         return;
     }
     m_inputWindow->setProperty("__kwin_input_method", true);
 
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::aboutToLock, this, &VirtualKeyboard::hide);
 
     if (waylandServer()) {
         m_enabled = !input()->hasAlphaNumericKeyboard();
         qCDebug(KWIN_VIRTUALKEYBOARD) << "enabled by default: " << m_enabled;
         connect(input(), &InputRedirection::hasAlphaNumericKeyboardChanged, this,
             [this] (bool set) {
                 qCDebug(KWIN_VIRTUALKEYBOARD) << "AlphaNumeric Keyboard changed:" << set << "toggling VirtualKeyboard.";
                 setEnabled(!set);
             }
         );
     }
 
     qCDebug(KWIN_VIRTUALKEYBOARD) << "Registering the SNI";
     m_sni = new KStatusNotifierItem(QStringLiteral("kwin-virtual-keyboard"), this);
     m_sni->setStandardActionsEnabled(false);
     m_sni->setCategory(KStatusNotifierItem::Hardware);
     m_sni->setStatus(KStatusNotifierItem::Passive);
     m_sni->setTitle(i18n("Virtual Keyboard"));
     updateSni();
     connect(m_sni, &KStatusNotifierItem::activateRequested, this,
         [this] {
             setEnabled(!m_enabled);
         }
     );
     connect(this, &VirtualKeyboard::enabledChanged, this, &VirtualKeyboard::updateSni);
 
     auto dbus = new VirtualKeyboardDBus(this);
     qCDebug(KWIN_VIRTUALKEYBOARD) << "Registering the DBus interface";
     dbus->setEnabled(m_enabled);
     connect(dbus, &VirtualKeyboardDBus::activateRequested, this, &VirtualKeyboard::setEnabled);
     connect(this, &VirtualKeyboard::enabledChanged, dbus, &VirtualKeyboardDBus::setEnabled);
 
     if (waylandServer()) {
         // we can announce support for the text input interface
         auto t = waylandServer()->display()->createTextInputManager(TextInputInterfaceVersion::UnstableV0, waylandServer()->display());
         t->create();
         auto t2 = waylandServer()->display()->createTextInputManager(TextInputInterfaceVersion::UnstableV2, waylandServer()->display());
         t2->create();
         connect(waylandServer()->seat(), &SeatInterface::focusedTextInputChanged, this,
             [this] {
                 disconnect(m_waylandShowConnection);
                 disconnect(m_waylandHideConnection);
                 disconnect(m_waylandHintsConnection);
                 disconnect(m_waylandSurroundingTextConnection);
                 disconnect(m_waylandResetConnection);
                 disconnect(m_waylandEnabledConnection);
                 qApp->inputMethod()->reset();
                 if (auto t = waylandServer()->seat()->focusedTextInput()) {
                     m_waylandShowConnection = connect(t, &TextInputInterface::requestShowInputPanel, this, &VirtualKeyboard::show);
                     m_waylandHideConnection = connect(t, &TextInputInterface::requestHideInputPanel, this, &VirtualKeyboard::hide);
                     m_waylandSurroundingTextConnection = connect(t, &TextInputInterface::surroundingTextChanged, this,
                         [] {
                             qApp->inputMethod()->update(Qt::ImSurroundingText | Qt::ImCursorPosition | Qt::ImAnchorPosition);
                         }
                     );
                     m_waylandHintsConnection = connect(t, &TextInputInterface::contentTypeChanged, this,
                         [] {
                             qApp->inputMethod()->update(Qt::ImHints);
                         }
                     );
                     m_waylandResetConnection = connect(t, &TextInputInterface::requestReset, qApp->inputMethod(), &QInputMethod::reset);
                     m_waylandEnabledConnection = connect(t, &TextInputInterface::enabledChanged, this,
                         [] {
                             qApp->inputMethod()->update(Qt::ImQueryAll);
                         }
                     );
 
                     auto newClient = waylandServer()->findClient(waylandServer()->seat()->focusedTextInputSurface());
                     // Reset the old client virtual keybaord geom if necessary
                     // Old and new clients could be the same if focus moves between subsurfaces
                     if (newClient != m_trackedClient) {
                         if (m_trackedClient) {
                             m_trackedClient->setVirtualKeyboardGeometry(QRect());
                         }
                         m_trackedClient = newClient;
                     }
 
                     m_trackedClient = waylandServer()->findClient(waylandServer()->seat()->focusedTextInputSurface());
 
                     updateInputPanelState();
                 } else {
                     m_waylandShowConnection = QMetaObject::Connection();
                     m_waylandHideConnection = QMetaObject::Connection();
                     m_waylandHintsConnection = QMetaObject::Connection();
                     m_waylandSurroundingTextConnection = QMetaObject::Connection();
                     m_waylandResetConnection = QMetaObject::Connection();
                     m_waylandEnabledConnection = QMetaObject::Connection();
                 }
                 qApp->inputMethod()->update(Qt::ImQueryAll);
             }
         );
     }
     m_inputWindow->installEventFilter(this);
     connect(Workspace::self(), &Workspace::destroyed, this,
         [this] {
             m_inputWindow.reset();
         }
     );
     m_inputWindow->setColor(Qt::transparent);
     m_inputWindow->setMask(m_inputWindow->rootObject()->childrenRect().toRect());
     connect(m_inputWindow->rootObject(), &QQuickItem::childrenRectChanged, m_inputWindow.data(),
         [this] {
             if (!m_inputWindow) {
                 return;
             }
             m_inputWindow->setMask(m_inputWindow->rootObject()->childrenRect().toRect());
         }
     );
 
     connect(qApp->inputMethod(), &QInputMethod::visibleChanged, this, &VirtualKeyboard::updateInputPanelState);
 
     connect(m_inputWindow->rootObject(), &QQuickItem::childrenRectChanged, this, &VirtualKeyboard::updateInputPanelState);
 }
 
 void VirtualKeyboard::setEnabled(bool enabled)
 {
     if (m_enabled == enabled) {
         return;
     }
     m_enabled = enabled;
     qApp->inputMethod()->update(Qt::ImQueryAll);
     emit enabledChanged(m_enabled);
 
     // send OSD message
     QDBusMessage msg = QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.plasmashell"),
         QStringLiteral("/org/kde/osdService"),
         QStringLiteral("org.kde.osdService"),
         QStringLiteral("virtualKeyboardEnabledChanged")
     );
     msg.setArguments({enabled});
     QDBusConnection::sessionBus().asyncCall(msg);
 }
 
 void VirtualKeyboard::updateSni()
 {
     if (!m_sni) {
         return;
     }
     if (m_enabled) {
         m_sni->setIconByName(QStringLiteral("input-keyboard-virtual-on"));
         m_sni->setTitle(i18n("Virtual Keyboard: enabled"));
     } else {
         m_sni->setIconByName(QStringLiteral("input-keyboard-virtual-off"));
         m_sni->setTitle(i18n("Virtual Keyboard: disabled"));
     }
     m_sni->setToolTipTitle(i18n("Whether to show the virtual keyboard on demand."));
 }
 
 void VirtualKeyboard::updateInputPanelState()
 {
     if (!waylandServer()) {
         return;
     }
 
     auto t = waylandServer()->seat()->focusedTextInput();
 
     if (!t || !m_inputWindow) {
         return;
     }
 
     const bool inputPanelHasBeenClosed = m_inputWindow->isVisible() && !qApp->inputMethod()->isVisible();
     if (inputPanelHasBeenClosed && m_floodTimer->isActive()) {
         return;
     }
     m_floodTimer->start();
 
     m_inputWindow->setVisible(qApp->inputMethod()->isVisible());
 
     if (qApp->inputMethod()->isVisible()) {
         m_inputWindow->setMask(m_inputWindow->rootObject()->childrenRect().toRect());
     }
 
     if (m_inputWindow->isVisible() && m_trackedClient && m_inputWindow->rootObject()) {
         const QRect inputPanelGeom = m_inputWindow->rootObject()->childrenRect().toRect().translated(m_inputWindow->geometry().topLeft());
 
         m_trackedClient->setVirtualKeyboardGeometry(inputPanelGeom);
 
         t->setInputPanelState(true, QRect(0, 0, 0, 0));
 
     } else {
         if (inputPanelHasBeenClosed && m_trackedClient) {
             m_trackedClient->setVirtualKeyboardGeometry(QRect());
         }
 
         t->setInputPanelState(false, QRect(0, 0, 0, 0));
     }
 }
 
 void VirtualKeyboard::show()
 {
     if (m_inputWindow.isNull() || !m_enabled) {
         return;
     }
     m_inputWindow->setGeometry(screens()->geometry(screens()->current()));
     qApp->inputMethod()->show();
 }
 
 void VirtualKeyboard::hide()
 {
     if (m_inputWindow.isNull()) {
         return;
     }
     m_inputWindow->hide();
     qApp->inputMethod()->hide();
 }
 
 bool VirtualKeyboard::event(QEvent *e)
 {
     if (e->type() == QEvent::InputMethod) {
         QInputMethodEvent *event = static_cast<QInputMethodEvent*>(e);
         if (m_enabled && waylandServer()) {
             bool isPreedit = false;
             for (auto attribute : event->attributes()) {
                 switch (attribute.type) {
                 case QInputMethodEvent::TextFormat:
                 case QInputMethodEvent::Cursor:
                 case QInputMethodEvent::Language:
                 case QInputMethodEvent::Ruby:
                     isPreedit = true;
                     break;
                 default:
                     break;
                 }
             }
             TextInputInterface *ti = waylandServer()->seat()->focusedTextInput();
             if (ti && ti->isEnabled()) {
                 if (!isPreedit && event->preeditString().isEmpty() && !event->commitString().isEmpty()) {
                     ti->commit(event->commitString().toUtf8());
                 } else {
                     ti->preEdit(event->preeditString().toUtf8(), event->commitString().toUtf8());
                 }
             }
         }
     }
     if (e->type() == QEvent::InputMethodQuery) {
         auto event = static_cast<QInputMethodQueryEvent*>(e);
         TextInputInterface *ti = nullptr;
         if (waylandServer() && m_enabled) {
             ti = waylandServer()->seat()->focusedTextInput();
         }
         if (event->queries().testFlag(Qt::ImEnabled)) {
             event->setValue(Qt::ImEnabled, QVariant(ti != nullptr && ti->isEnabled()));
         }
         if (event->queries().testFlag(Qt::ImCursorRectangle)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImFont)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImCursorPosition)) {
             // the virtual keyboard doesn't send us the cursor position in the preedit
             // this would break text input, thus we ignore it
             // see https://bugreports.qt.io/browse/QTBUG-53517
 #if 0
             event->setValue(Qt::ImCursorPosition, QString::fromUtf8(ti->surroundingText().left(ti->surroundingTextCursorPosition())).size());
 #else
             event->setValue(Qt::ImCursorPosition, 0);
 #endif
         }
         if (event->queries().testFlag(Qt::ImSurroundingText)) {
             // the virtual keyboard doesn't send us the cursor position in the preedit
             // this would break text input, thus we ignore it
             // see https://bugreports.qt.io/browse/QTBUG-53517
 #if 0
             event->setValue(Qt::ImSurroundingText, QString::fromUtf8(ti->surroundingText()));
 #else
             event->setValue(Qt::ImSurroundingText, QString());
 #endif
         }
         if (event->queries().testFlag(Qt::ImCurrentSelection)) {
             // TODO: should be text between cursor and anchor, but might be dangerous
         }
         if (event->queries().testFlag(Qt::ImMaximumTextLength)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImAnchorPosition)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImHints)) {
             if (ti && ti->isEnabled()) {
                 Qt::InputMethodHints hints;
                 const auto contentHints = ti->contentHints();
                 if (!contentHints.testFlag(TextInputInterface::ContentHint::AutoCompletion)) {
                     hints |= Qt::ImhNoPredictiveText;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::AutoCorrection)) {
                     // no mapping in Qt
                 }
                 if (!contentHints.testFlag(TextInputInterface::ContentHint::AutoCapitalization)) {
                     hints |= Qt::ImhNoAutoUppercase;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::LowerCase)) {
                     hints |= Qt::ImhPreferLowercase;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::UpperCase)) {
                     hints |= Qt::ImhPreferUppercase;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::TitleCase)) {
                     // no mapping in Qt
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::HiddenText)) {
                     hints |= Qt::ImhHiddenText;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::SensitiveData)) {
                     hints |= Qt::ImhSensitiveData;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::Latin)) {
                     hints |= Qt::ImhPreferLatin;
                 }
                 if (contentHints.testFlag(TextInputInterface::ContentHint::MultiLine)) {
                     hints |= Qt::ImhMultiLine;
                 }
                 switch (ti->contentPurpose()) {
                 case TextInputInterface::ContentPurpose::Digits:
                     hints |= Qt::ImhDigitsOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Number:
                     hints |= Qt::ImhFormattedNumbersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Phone:
                     hints |= Qt::ImhDialableCharactersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Url:
                     hints |= Qt::ImhUrlCharactersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Email:
                     hints |= Qt::ImhEmailCharactersOnly;
                     break;
                 case TextInputInterface::ContentPurpose::Date:
                     hints |= Qt::ImhDate;
                     break;
                 case TextInputInterface::ContentPurpose::Time:
                     hints |= Qt::ImhTime;
                     break;
                 case TextInputInterface::ContentPurpose::DateTime:
                     hints |= Qt::ImhDate;
                     hints |= Qt::ImhTime;
                     break;
                 case TextInputInterface::ContentPurpose::Name:
                     // no mapping in Qt
                 case TextInputInterface::ContentPurpose::Password:
                     // no mapping in Qt
                 case TextInputInterface::ContentPurpose::Terminal:
                     // no mapping in Qt
                 case TextInputInterface::ContentPurpose::Normal:
                     // that's the default
                 case TextInputInterface::ContentPurpose::Alpha:
                     // no mapping in Qt
                     break;
                 }
                 event->setValue(Qt::ImHints, QVariant(int(hints)));
             } else {
                 event->setValue(Qt::ImHints, Qt::ImhNone);
             }
         }
         if (event->queries().testFlag(Qt::ImPreferredLanguage)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImPlatformData)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImAbsolutePosition)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImTextBeforeCursor)) {
             // not used by virtual keyboard
         }
         if (event->queries().testFlag(Qt::ImTextAfterCursor)) {
             // not used by virtual keyboard
         }
         event->accept();
         return true;
     }
     return QObject::event(e);
 }
 
 bool VirtualKeyboard::eventFilter(QObject *o, QEvent *e)
 {
     if (o != m_inputWindow.data() || !m_inputWindow->isVisible()) {
         return false;
     }
     if (e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease) {
         QKeyEvent *event = static_cast<QKeyEvent*>(e);
         if (event->nativeScanCode() == 0) {
             // this is a key composed by the virtual keyboard - we need to send it to the client
             const auto sym = input()->keyboard()->xkb()->fromKeyEvent(event);
             if (sym != 0) {
                 if (waylandServer()) {
                     auto t = waylandServer()->seat()->focusedTextInput();
                     if (t && t->isEnabled()) {
                         if (e->type() == QEvent::KeyPress) {
                             t->keysymPressed(sym);
                         } else if (e->type() == QEvent::KeyRelease) {
                             t->keysymReleased(sym);
                         }
                     }
                 }
             }
             return true;
         }
     }
     return false;
 }
 
 QWindow *VirtualKeyboard::inputPanel() const
 {
     return m_inputWindow.data();
 }
 
 }
diff --git a/wayland_cursor_theme.cpp b/wayland_cursor_theme.cpp
index 4d539ccc3..721ed17d8 100644
--- a/wayland_cursor_theme.cpp
+++ b/wayland_cursor_theme.cpp
@@ -1,117 +1,117 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "wayland_cursor_theme.h"
 #include "cursor.h"
 #include "wayland_server.h"
 #include "screens.h"
 // Qt
 #include <QVector>
 // KWayland
 #include <KWayland/Client/shm_pool.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/output_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/output_interface.h>
 // Wayland
 #include <wayland-cursor.h>
 
 namespace KWin
 {
 
 WaylandCursorTheme::WaylandCursorTheme(KWayland::Client::ShmPool *shm, QObject *parent)
     : QObject(parent)
     , m_theme(nullptr)
     , m_shm(shm)
 {
     connect(screens(), &Screens::maxScaleChanged, this, &WaylandCursorTheme::loadTheme);
 }
 
 WaylandCursorTheme::~WaylandCursorTheme()
 {
     destroyTheme();
 }
 
 void WaylandCursorTheme::loadTheme()
 {
     if (!m_shm->isValid()) {
         return;
     }
     Cursor *c = Cursors::self()->mouse();
     int size = c->themeSize();
     if (size == 0) {
         //set a default size
         size = 24;
     }
 
     size *= screens()->maxScale();
 
     auto theme = wl_cursor_theme_load(c->themeName().toUtf8().constData(),
                                    size, m_shm->shm());
     if (theme) {
         if (!m_theme) {
             // so far the theme had not been created, this means we need to start tracking theme changes
             connect(c, &Cursor::themeChanged, this, &WaylandCursorTheme::loadTheme);
         } else {
             destroyTheme();
         }
         m_theme = theme;
         emit themeChanged();
     }
 }
 
 void WaylandCursorTheme::destroyTheme()
 {
     if (!m_theme) {
         return;
     }
     wl_cursor_theme_destroy(m_theme);
     m_theme = nullptr;
 }
 
 wl_cursor_image *WaylandCursorTheme::get(CursorShape shape)
 {
     return get(shape.name());
 }
 
 wl_cursor_image *WaylandCursorTheme::get(const QByteArray &name)
 {
     if (!m_theme) {
         loadTheme();
     }
     if (!m_theme) {
         // loading cursor failed
         return nullptr;
     }
     wl_cursor *c = wl_cursor_theme_get_cursor(m_theme, name.constData());
     if (!c || c->image_count <= 0) {
         const auto &names = Cursors::self()->mouse()->cursorAlternativeNames(name);
         for (auto it = names.begin(), end = names.end(); it != end; it++) {
             c = wl_cursor_theme_get_cursor(m_theme, (*it).constData());
             if (c && c->image_count > 0) {
                 break;
             }
         }
     }
     if (!c || c->image_count <= 0) {
         return nullptr;
     }
     // TODO: who deletes c?
     return c->images[0];
 }
 
 }
diff --git a/wayland_server.cpp b/wayland_server.cpp
index f617ecc7a..a875f2979 100644
--- a/wayland_server.cpp
+++ b/wayland_server.cpp
@@ -1,836 +1,836 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "wayland_server.h"
 #include "x11client.h"
 #include "platform.h"
 #include "composite.h"
 #include "idle_inhibition.h"
 #include "screens.h"
 #include "xdgshellclient.h"
 #include "workspace.h"
 
 // Client
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/event_queue.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/seat.h>
 #include <KWayland/Client/datadevicemanager.h>
 #include <KWayland/Client/shm_pool.h>
 #include <KWayland/Client/surface.h>
 // Server
-#include <KWayland/Server/appmenu_interface.h>
-#include <KWayland/Server/compositor_interface.h>
-#include <KWayland/Server/datadevicemanager_interface.h>
-#include <KWayland/Server/datasource_interface.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/dpms_interface.h>
-#include <KWayland/Server/idle_interface.h>
-#include <KWayland/Server/idleinhibit_interface.h>
-#include <KWayland/Server/linuxdmabuf_v1_interface.h>
-#include <KWayland/Server/output_interface.h>
-#include <KWayland/Server/plasmashell_interface.h>
-#include <KWayland/Server/plasmavirtualdesktop_interface.h>
-#include <KWayland/Server/plasmawindowmanagement_interface.h>
-#include <KWayland/Server/pointerconstraints_interface.h>
-#include <KWayland/Server/pointergestures_interface.h>
-#include <KWayland/Server/qtsurfaceextension_interface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/server_decoration_interface.h>
-#include <KWayland/Server/server_decoration_palette_interface.h>
-#include <KWayland/Server/shadow_interface.h>
-#include <KWayland/Server/subcompositor_interface.h>
-#include <KWayland/Server/blur_interface.h>
-#include <KWayland/Server/outputmanagement_interface.h>
-#include <KWayland/Server/outputconfiguration_interface.h>
-#include <KWayland/Server/xdgdecoration_interface.h>
-#include <KWayland/Server/xdgshell_interface.h>
-#include <KWayland/Server/xdgforeign_interface.h>
-#include <KWayland/Server/xdgoutput_interface.h>
-#include <KWayland/Server/keystate_interface.h>
-#include <KWayland/Server/filtered_display.h>
+#include <KWaylandServer/appmenu_interface.h>
+#include <KWaylandServer/compositor_interface.h>
+#include <KWaylandServer/datadevicemanager_interface.h>
+#include <KWaylandServer/datasource_interface.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/dpms_interface.h>
+#include <KWaylandServer/idle_interface.h>
+#include <KWaylandServer/idleinhibit_interface.h>
+#include <KWaylandServer/linuxdmabuf_v1_interface.h>
+#include <KWaylandServer/output_interface.h>
+#include <KWaylandServer/plasmashell_interface.h>
+#include <KWaylandServer/plasmavirtualdesktop_interface.h>
+#include <KWaylandServer/plasmawindowmanagement_interface.h>
+#include <KWaylandServer/pointerconstraints_interface.h>
+#include <KWaylandServer/pointergestures_interface.h>
+#include <KWaylandServer/qtsurfaceextension_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/server_decoration_interface.h>
+#include <KWaylandServer/server_decoration_palette_interface.h>
+#include <KWaylandServer/shadow_interface.h>
+#include <KWaylandServer/subcompositor_interface.h>
+#include <KWaylandServer/blur_interface.h>
+#include <KWaylandServer/outputmanagement_interface.h>
+#include <KWaylandServer/outputconfiguration_interface.h>
+#include <KWaylandServer/xdgdecoration_interface.h>
+#include <KWaylandServer/xdgshell_interface.h>
+#include <KWaylandServer/xdgforeign_interface.h>
+#include <KWaylandServer/xdgoutput_interface.h>
+#include <KWaylandServer/keystate_interface.h>
+#include <KWaylandServer/filtered_display.h>
 
 // KF
 #include <KServiceTypeTrader>
 
 // Qt
 #include <QCryptographicHash>
 #include <QDir>
 #include <QFileInfo>
 #include <QThread>
 #include <QWindow>
 
 // system
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <unistd.h>
 
 //screenlocker
 #include <KScreenLocker/KsldApp>
 
-using namespace KWayland::Server;
+using namespace KWaylandServer;
 
 namespace KWin
 {
 
 KWIN_SINGLETON_FACTORY(WaylandServer)
 
 WaylandServer::WaylandServer(QObject *parent)
     : QObject(parent)
 {
-    qRegisterMetaType<KWayland::Server::OutputInterface::DpmsMode>();
+    qRegisterMetaType<KWaylandServer::OutputInterface::DpmsMode>();
 }
 
 WaylandServer::~WaylandServer()
 {
     destroyInputMethodConnection();
 }
 
 void WaylandServer::destroyInternalConnection()
 {
     emit terminatingInternalClientConnection();
     if (m_internalConnection.client) {
         // delete all connections hold by plugins like e.g. widget style
         const auto connections = KWayland::Client::ConnectionThread::connections();
         for (auto c : connections) {
             if (c == m_internalConnection.client) {
                 continue;
             }
             emit c->connectionDied();
         }
 
         delete m_internalConnection.registry;
         delete m_internalConnection.compositor;
         delete m_internalConnection.seat;
         delete m_internalConnection.ddm;
         delete m_internalConnection.shm;
         dispatch();
         m_internalConnection.client->deleteLater();
         m_internalConnection.clientThread->quit();
         m_internalConnection.clientThread->wait();
         delete m_internalConnection.clientThread;
         m_internalConnection.client = nullptr;
         m_internalConnection.server->destroy();
         m_internalConnection.server = nullptr;
     }
 }
 
 void WaylandServer::terminateClientConnections()
 {
     destroyInternalConnection();
     destroyInputMethodConnection();
     if (m_display) {
         const auto connections = m_display->connections();
         for (auto it = connections.begin(); it != connections.end(); ++it) {
             (*it)->destroy();
         }
     }
 }
 
 template <class T>
 void WaylandServer::createSurface(T *surface)
 {
     if (!Workspace::self()) {
         // it's possible that a Surface gets created before Workspace is created
         return;
     }
     if (surface->client() == m_xwayland.client) {
         // skip Xwayland clients, those are created using standard X11 way
         return;
     }
     if (surface->client() == m_screenLockerClientConnection) {
         ScreenLocker::KSldApp::self()->lockScreenShown();
     }
     XdgShellClient *client = new XdgShellClient(surface);
     if (ServerSideDecorationInterface *deco = ServerSideDecorationInterface::get(surface->surface())) {
         client->installServerSideDecoration(deco);
     }
     auto it = std::find_if(m_plasmaShellSurfaces.begin(), m_plasmaShellSurfaces.end(),
         [client] (PlasmaShellSurfaceInterface *surface) {
             return client->surface() == surface->surface();
         }
     );
     if (it != m_plasmaShellSurfaces.end()) {
         client->installPlasmaShellSurface(*it);
         m_plasmaShellSurfaces.erase(it);
     }
     if (auto menu = m_appMenuManager->appMenuForSurface(surface->surface())) {
         client->installAppMenu(menu);
     }
     if (auto palette = m_paletteManager->paletteForSurface(surface->surface())) {
         client->installPalette(palette);
     }
     m_clients << client;
     if (client->readyForPainting()) {
         emit shellClientAdded(client);
     } else {
         connect(client, &XdgShellClient::windowShown, this, &WaylandServer::shellClientShown);
     }
 
     //not directly connected as the connection is tied to client instead of this
-    connect(m_XdgForeign, &KWayland::Server::XdgForeignInterface::transientChanged, client, [this](KWayland::Server::SurfaceInterface *child) {
+    connect(m_XdgForeign, &KWaylandServer::XdgForeignInterface::transientChanged, client, [this](KWaylandServer::SurfaceInterface *child) {
         emit foreignTransientChanged(child);
     });
 }
 
-class KWinDisplay : public KWayland::Server::FilteredDisplay
+class KWinDisplay : public KWaylandServer::FilteredDisplay
 {
 public:
     KWinDisplay(QObject *parent)
-        : KWayland::Server::FilteredDisplay(parent)
+        : KWaylandServer::FilteredDisplay(parent)
     {}
 
     static QByteArray sha256(const QString &fileName)
     {
         QFile f(fileName);
         if (f.open(QFile::ReadOnly)) {
             QCryptographicHash hash(QCryptographicHash::Sha256);
             if (hash.addData(&f)) {
                 return hash.result();
             }
         }
         return QByteArray();
     }
 
-    bool isTrustedOrigin(KWayland::Server::ClientConnection *client) const {
+    bool isTrustedOrigin(KWaylandServer::ClientConnection *client) const {
         const auto fullPathSha = sha256(client->executablePath());
         const auto localSha = sha256(QLatin1String("/proc/") + QString::number(client->processId()) + QLatin1String("/exe"));
         const bool trusted = !localSha.isEmpty() && fullPathSha == localSha;
 
         if (!trusted) {
             qCWarning(KWIN_CORE) << "Could not trust" << client->executablePath() << "sha" << localSha << fullPathSha;
         }
 
         return trusted;
     }
 
-    QStringList fetchRequestedInterfaces(KWayland::Server::ClientConnection *client) const {
+    QStringList fetchRequestedInterfaces(KWaylandServer::ClientConnection *client) const {
         const auto serviceQuery = QStringLiteral("exist Exec and exist [X-KDE-Wayland-Interfaces] and '%1' =~ Exec").arg(client->executablePath());
         const auto servicesFound = KServiceTypeTrader::self()->query(QStringLiteral("Application"), serviceQuery);
 
         if (servicesFound.isEmpty()) {
             qCDebug(KWIN_CORE) << "Could not find the desktop file for" << client->executablePath();
             return {};
         }
 
         const auto interfaces = servicesFound.first()->property("X-KDE-Wayland-Interfaces").toStringList();
         qCDebug(KWIN_CORE) << "Interfaces for" << client->executablePath() << interfaces;
         return interfaces;
     }
 
     QSet<QByteArray> interfacesBlackList = {"org_kde_kwin_remote_access_manager", "org_kde_plasma_window_management", "org_kde_kwin_fake_input", "org_kde_kwin_keystate"};
 
-    bool allowInterface(KWayland::Server::ClientConnection *client, const QByteArray &interfaceName) override {
+    bool allowInterface(KWaylandServer::ClientConnection *client, const QByteArray &interfaceName) override {
         if (client->processId() == getpid()) {
             return true;
         }
 
         if (!interfacesBlackList.contains(interfaceName)) {
             return true;
         }
 
         if (client->executablePath().isEmpty()) {
             qCWarning(KWIN_CORE) << "Could not identify process with pid" << client->processId();
             return false;
         }
 
         {
             auto requestedInterfaces = client->property("requestedInterfaces");
             if (requestedInterfaces.isNull()) {
                 requestedInterfaces = fetchRequestedInterfaces(client);
                 client->setProperty("requestedInterfaces", requestedInterfaces);
             }
             if (!requestedInterfaces.toStringList().contains(QString::fromUtf8(interfaceName))) {
                 qCWarning(KWIN_CORE) << "Did not grant the interface" << interfaceName << "to" << client->executablePath() << ". Please request it under X-KDE-Wayland-Interfaces";
                 return false;
             }
         }
 
         {
             auto trustedOrigin = client->property("isPrivileged");
             if (trustedOrigin.isNull()) {
                 trustedOrigin = isTrustedOrigin(client);
                 client->setProperty("isPrivileged", trustedOrigin);
             }
 
             if (!trustedOrigin.toBool()) {
                 return false;
             }
         }
         qCDebug(KWIN_CORE) << "authorized" << client->executablePath() << interfaceName;
         return true;
     }
 };
 
 bool WaylandServer::init(const QByteArray &socketName, InitializationFlags flags)
 {
     m_initFlags = flags;
     m_display = new KWinDisplay(this);
     if (!socketName.isNull() && !socketName.isEmpty()) {
         m_display->setSocketName(QString::fromUtf8(socketName));
     } else {
         m_display->setAutomaticSocketNaming(true);
     }
     m_display->start();
     if (!m_display->isRunning()) {
         return false;
     }
     m_compositor = m_display->createCompositor(m_display);
     m_compositor->create();
     connect(m_compositor, &CompositorInterface::surfaceCreated, this,
         [this] (SurfaceInterface *surface) {
             // check whether we have a Toplevel with the Surface's id
             Workspace *ws = Workspace::self();
             if (!ws) {
                 // it's possible that a Surface gets created before Workspace is created
                 return;
             }
             if (surface->client() != xWaylandConnection()) {
                 // setting surface is only relevat for Xwayland clients
                 return;
             }
             auto check = [surface] (const Toplevel *t) {
                 return t->surfaceId() == surface->id();
             };
             if (Toplevel *t = ws->findToplevel(check)) {
                 t->setSurface(surface);
             }
         }
     );
 
     m_tabletManager = m_display->createTabletManagerInterface(m_display);
 
     m_xdgShell = m_display->createXdgShell(XdgShellInterfaceVersion::Stable, m_display);
     m_xdgShell->create();
     connect(m_xdgShell, &XdgShellInterface::surfaceCreated, this, &WaylandServer::createSurface<XdgShellSurfaceInterface>);
     connect(m_xdgShell, &XdgShellInterface::xdgPopupCreated, this, &WaylandServer::createSurface<XdgShellPopupInterface>);
 
     m_xdgDecorationManager = m_display->createXdgDecorationManager(m_xdgShell, m_display);
     m_xdgDecorationManager->create();
     connect(m_xdgDecorationManager, &XdgDecorationManagerInterface::xdgDecorationInterfaceCreated, this,  [this] (XdgDecorationInterface *deco) {
         if (XdgShellClient *client = findXdgShellClient(deco->surface()->surface())) {
             client->installXdgDecoration(deco);
         }
     });
 
     m_display->createShm();
     m_seat = m_display->createSeat(m_display);
     m_seat->create();
     m_display->createPointerGestures(PointerGesturesInterfaceVersion::UnstableV1, m_display)->create();
     m_display->createPointerConstraints(PointerConstraintsInterfaceVersion::UnstableV1, m_display)->create();
     m_dataDeviceManager = m_display->createDataDeviceManager(m_display);
     m_dataDeviceManager->create();
     m_idle = m_display->createIdle(m_display);
     m_idle->create();
     auto idleInhibition = new IdleInhibition(m_idle);
     connect(this, &WaylandServer::shellClientAdded, idleInhibition, &IdleInhibition::registerClient);
     m_display->createIdleInhibitManager(IdleInhibitManagerInterfaceVersion::UnstableV1, m_display)->create();
     m_plasmaShell = m_display->createPlasmaShell(m_display);
     m_plasmaShell->create();
     connect(m_plasmaShell, &PlasmaShellInterface::surfaceCreated,
         [this] (PlasmaShellSurfaceInterface *surface) {
             if (XdgShellClient *client = findXdgShellClient(surface->surface())) {
                 client->installPlasmaShellSurface(surface);
             } else {
                 m_plasmaShellSurfaces << surface;
                 connect(surface, &QObject::destroyed, this,
                     [this, surface] {
                         m_plasmaShellSurfaces.removeOne(surface);
                     }
                 );
             }
         }
     );
     m_appMenuManager = m_display->createAppMenuManagerInterface(m_display);
     m_appMenuManager->create();
     connect(m_appMenuManager, &AppMenuManagerInterface::appMenuCreated,
         [this] (AppMenuInterface *appMenu) {
             if (XdgShellClient *client = findXdgShellClient(appMenu->surface())) {
                 client->installAppMenu(appMenu);
             }
         }
     );
     m_paletteManager = m_display->createServerSideDecorationPaletteManager(m_display);
     m_paletteManager->create();
     connect(m_paletteManager, &ServerSideDecorationPaletteManagerInterface::paletteCreated,
         [this] (ServerSideDecorationPaletteInterface *palette) {
             if (XdgShellClient *client = findXdgShellClient(palette->surface())) {
                 client->installPalette(palette);
             }
         }
     );
 
     m_windowManagement = m_display->createPlasmaWindowManagement(m_display);
     m_windowManagement->create();
     m_windowManagement->setShowingDesktopState(PlasmaWindowManagementInterface::ShowingDesktopState::Disabled);
     connect(m_windowManagement, &PlasmaWindowManagementInterface::requestChangeShowingDesktop, this,
         [] (PlasmaWindowManagementInterface::ShowingDesktopState state) {
             if (!workspace()) {
                 return;
             }
             bool set = false;
             switch (state) {
             case PlasmaWindowManagementInterface::ShowingDesktopState::Disabled:
                 set = false;
                 break;
             case PlasmaWindowManagementInterface::ShowingDesktopState::Enabled:
                 set = true;
                 break;
             default:
                 Q_UNREACHABLE();
                 break;
             }
             if (set == workspace()->showingDesktop()) {
                 return;
             }
             workspace()->setShowingDesktop(set);
         }
     );
 
     m_virtualDesktopManagement = m_display->createPlasmaVirtualDesktopManagement(m_display);
     m_virtualDesktopManagement->create();
     m_windowManagement->setPlasmaVirtualDesktopManagementInterface(m_virtualDesktopManagement);
 
     auto shadowManager = m_display->createShadowManager(m_display);
     shadowManager->create();
 
     m_display->createDpmsManager(m_display)->create();
 
     m_decorationManager = m_display->createServerSideDecorationManager(m_display);
     connect(m_decorationManager, &ServerSideDecorationManagerInterface::decorationCreated, this,
         [this] (ServerSideDecorationInterface *deco) {
             if (XdgShellClient *c = findXdgShellClient(deco->surface())) {
                 c->installServerSideDecoration(deco);
             }
             connect(deco, &ServerSideDecorationInterface::modeRequested, this,
                 [deco] (ServerSideDecorationManagerInterface::Mode mode) {
                     // always acknowledge the requested mode
                     deco->setMode(mode);
                 }
             );
         }
     );
     m_decorationManager->create();
 
     m_outputManagement = m_display->createOutputManagement(m_display);
     connect(m_outputManagement, &OutputManagementInterface::configurationChangeRequested,
-            this, [](KWayland::Server::OutputConfigurationInterface *config) {
+            this, [](KWaylandServer::OutputConfigurationInterface *config) {
                 kwinApp()->platform()->requestOutputsChange(config);
     });
     m_outputManagement->create();
 
     m_xdgOutputManager = m_display->createXdgOutputManager(m_display);
     m_xdgOutputManager->create();
 
     m_display->createSubCompositor(m_display)->create();
 
     m_XdgForeign = m_display->createXdgForeignInterface(m_display);
     m_XdgForeign->create();
 
     m_keyState = m_display->createKeyStateInterface(m_display);
     m_keyState->create();
 
     return true;
 }
 
-KWayland::Server::LinuxDmabufUnstableV1Interface *WaylandServer::linuxDmabuf()
+KWaylandServer::LinuxDmabufUnstableV1Interface *WaylandServer::linuxDmabuf()
 {
     if (!m_linuxDmabuf) {
         m_linuxDmabuf = m_display->createLinuxDmabufInterface(m_display);
         m_linuxDmabuf->create();
     }
     return m_linuxDmabuf;
 }
 
 SurfaceInterface *WaylandServer::findForeignTransientForSurface(SurfaceInterface *surface)
 {
     return m_XdgForeign->transientFor(surface);
 }
 
 void WaylandServer::shellClientShown(Toplevel *t)
 {
     XdgShellClient *c = dynamic_cast<XdgShellClient *>(t);
     if (!c) {
         qCWarning(KWIN_CORE) << "Failed to cast a Toplevel which is supposed to be a XdgShellClient to XdgShellClient";
         return;
     }
     disconnect(c, &XdgShellClient::windowShown, this, &WaylandServer::shellClientShown);
     emit shellClientAdded(c);
 }
 
 void WaylandServer::initWorkspace()
 {
     VirtualDesktopManager::self()->setVirtualDesktopManagement(m_virtualDesktopManagement);
 
     if (m_windowManagement) {
         connect(workspace(), &Workspace::showingDesktopChanged, this,
             [this] (bool set) {
-                using namespace KWayland::Server;
+                using namespace KWaylandServer;
                 m_windowManagement->setShowingDesktopState(set ?
                     PlasmaWindowManagementInterface::ShowingDesktopState::Enabled :
                     PlasmaWindowManagementInterface::ShowingDesktopState::Disabled
                 );
             }
         );
 
         connect(workspace(), &Workspace::workspaceInitialized, this, [this] {
             auto f = [this] () {
                 QVector<quint32> ids;
                 for (Toplevel *toplevel : workspace()->stackingOrder()) {
                     auto *client = qobject_cast<AbstractClient *>(toplevel);
                     if (client && client->windowManagementInterface()) {
                         ids << client->windowManagementInterface()->internalId();
                     }
                 }
                 m_windowManagement->setStackingOrder(ids);
             };
             f();
             connect(workspace(), &Workspace::stackingOrderChanged, this, f);
         });
     }
 
     if (hasScreenLockerIntegration()) {
         if (m_internalConnection.interfacesAnnounced) {
             initScreenLocker();
         } else {
             connect(m_internalConnection.registry, &KWayland::Client::Registry::interfacesAnnounced, this, &WaylandServer::initScreenLocker);
         }
     } else {
         emit initialized();
     }
 }
 
 void WaylandServer::initScreenLocker()
 {
     auto *screenLockerApp = ScreenLocker::KSldApp::self();
 
     ScreenLocker::KSldApp::self()->setGreeterEnvironment(kwinApp()->processStartupEnvironment());
     ScreenLocker::KSldApp::self()->initialize();
 
     connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::aboutToLock, this,
         [this, screenLockerApp] () {
             if (m_screenLockerClientConnection) {
                 // Already sent data to KScreenLocker.
                 return;
             }
             int clientFd = createScreenLockerConnection();
             if (clientFd < 0) {
                 return;
             }
             ScreenLocker::KSldApp::self()->setWaylandFd(clientFd);
 
             for (auto *seat : m_display->seats()) {
-                connect(seat, &KWayland::Server::SeatInterface::timestampChanged,
+                connect(seat, &KWaylandServer::SeatInterface::timestampChanged,
                         screenLockerApp, &ScreenLocker::KSldApp::userActivity);
             }
         }
     );
 
     connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::unlocked, this,
         [this, screenLockerApp] () {
             if (m_screenLockerClientConnection) {
                 m_screenLockerClientConnection->destroy();
                 delete m_screenLockerClientConnection;
                 m_screenLockerClientConnection = nullptr;
             }
 
             for (auto *seat : m_display->seats()) {
-                disconnect(seat, &KWayland::Server::SeatInterface::timestampChanged,
+                disconnect(seat, &KWaylandServer::SeatInterface::timestampChanged,
                            screenLockerApp, &ScreenLocker::KSldApp::userActivity);
             }
             ScreenLocker::KSldApp::self()->setWaylandFd(-1);
         }
     );
 
     if (m_initFlags.testFlag(InitializationFlag::LockScreen)) {
         ScreenLocker::KSldApp::self()->lock(ScreenLocker::EstablishLock::Immediate);
     }
     emit initialized();
 }
 
 WaylandServer::SocketPairConnection WaylandServer::createConnection()
 {
     SocketPairConnection ret;
     int sx[2];
     if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, sx) < 0) {
         qCWarning(KWIN_CORE) << "Could not create socket";
         return ret;
     }
     ret.connection = m_display->createClient(sx[0]);
     ret.fd = sx[1];
     return ret;
 }
 
 int WaylandServer::createScreenLockerConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return -1;
     }
     m_screenLockerClientConnection = socket.connection;
-    connect(m_screenLockerClientConnection, &KWayland::Server::ClientConnection::disconnected,
+    connect(m_screenLockerClientConnection, &KWaylandServer::ClientConnection::disconnected,
             this, [this] { m_screenLockerClientConnection = nullptr; });
     return socket.fd;
 }
 
 int WaylandServer::createXWaylandConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return -1;
     }
     m_xwayland.client = socket.connection;
-    m_xwayland.destroyConnection = connect(m_xwayland.client, &KWayland::Server::ClientConnection::disconnected, this,
+    m_xwayland.destroyConnection = connect(m_xwayland.client, &KWaylandServer::ClientConnection::disconnected, this,
         [] {
             qFatal("Xwayland Connection died");
         }
     );
     return socket.fd;
 }
 
 void WaylandServer::destroyXWaylandConnection()
 {
     if (!m_xwayland.client) {
         return;
     }
     disconnect(m_xwayland.destroyConnection);
     m_xwayland.client->destroy();
     m_xwayland.client = nullptr;
 }
 
 int WaylandServer::createInputMethodConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return -1;
     }
     m_inputMethodServerConnection = socket.connection;
     return socket.fd;
 }
 
 void WaylandServer::destroyInputMethodConnection()
 {
     if (!m_inputMethodServerConnection) {
         return;
     }
     m_inputMethodServerConnection->destroy();
     m_inputMethodServerConnection = nullptr;
 }
 
 void WaylandServer::createInternalConnection()
 {
     const auto socket = createConnection();
     if (!socket.connection) {
         return;
     }
     m_internalConnection.server = socket.connection;
     using namespace KWayland::Client;
     m_internalConnection.client = new ConnectionThread();
     m_internalConnection.client->setSocketFd(socket.fd);
     m_internalConnection.clientThread = new QThread;
     m_internalConnection.client->moveToThread(m_internalConnection.clientThread);
     m_internalConnection.clientThread->start();
 
     connect(m_internalConnection.client, &ConnectionThread::connected, this,
         [this] {
             Registry *registry = new Registry(this);
             EventQueue *eventQueue = new EventQueue(registry);
             eventQueue->setup(m_internalConnection.client);
             registry->setEventQueue(eventQueue);
             registry->create(m_internalConnection.client);
             m_internalConnection.registry = registry;
             connect(registry, &Registry::shmAnnounced, this,
                 [this] (quint32 name, quint32 version) {
                     m_internalConnection.shm = m_internalConnection.registry->createShmPool(name, version, this);
                 }
             );
             connect(registry, &Registry::interfacesAnnounced, this,
                 [this, registry] {
                     m_internalConnection.interfacesAnnounced = true;
 
                     const auto compInterface = registry->interface(Registry::Interface::Compositor);
                     if (compInterface.name != 0) {
                         m_internalConnection.compositor = registry->createCompositor(compInterface.name, compInterface.version, this);
                     }
                     const auto seatInterface = registry->interface(Registry::Interface::Seat);
                     if (seatInterface.name != 0) {
                         m_internalConnection.seat = registry->createSeat(seatInterface.name, seatInterface.version, this);
                     }
                     const auto ddmInterface = registry->interface(Registry::Interface::DataDeviceManager);
                     if (ddmInterface.name != 0) {
                         m_internalConnection.ddm = registry->createDataDeviceManager(ddmInterface.name, ddmInterface.version, this);
                     }
                 }
             );
             registry->setup();
         }
     );
     m_internalConnection.client->initConnection();
 }
 
 void WaylandServer::removeClient(AbstractClient *c)
 {
     m_clients.removeAll(c);
     emit shellClientRemoved(c);
 }
 
 void WaylandServer::dispatch()
 {
     if (!m_display) {
         return;
     }
     if (m_internalConnection.server) {
         m_internalConnection.server->flush();
     }
     m_display->dispatchEvents(0);
 }
 
 static AbstractClient *findClientInList(const QList<AbstractClient *> &clients, quint32 id)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
         [id] (AbstractClient *c) {
             return c->windowId() == id;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
-static AbstractClient *findClientInList(const QList<AbstractClient *> &clients, KWayland::Server::SurfaceInterface *surface)
+static AbstractClient *findClientInList(const QList<AbstractClient *> &clients, KWaylandServer::SurfaceInterface *surface)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
         [surface] (AbstractClient *c) {
             return c->surface() == surface;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
 AbstractClient *WaylandServer::findClient(quint32 id) const
 {
     if (id == 0) {
         return nullptr;
     }
     if (AbstractClient *c = findClientInList(m_clients, id)) {
         return c;
     }
     return nullptr;
 }
 
 AbstractClient *WaylandServer::findClient(SurfaceInterface *surface) const
 {
     if (!surface) {
         return nullptr;
     }
     if (AbstractClient *c = findClientInList(m_clients, surface)) {
         return c;
     }
     return nullptr;
 }
 
 XdgShellClient *WaylandServer::findXdgShellClient(SurfaceInterface *surface) const
 {
     return qobject_cast<XdgShellClient *>(findClient(surface));
 }
 
 quint32 WaylandServer::createWindowId(SurfaceInterface *surface)
 {
     auto it = m_clientIds.constFind(surface->client());
     quint16 clientId = 0;
     if (it != m_clientIds.constEnd()) {
         clientId = it.value();
     } else {
         clientId = createClientId(surface->client());
     }
     Q_ASSERT(clientId != 0);
     quint32 id = clientId;
     // TODO: this does not prevent that two surfaces of same client get same id
     id = (id << 16) | (surface->id() & 0xFFFF);
     if (findClient(id)) {
         qCWarning(KWIN_CORE) << "Invalid client windowId generated:" << id;
         return 0;
     }
     return id;
 }
 
 quint16 WaylandServer::createClientId(ClientConnection *c)
 {
     const QSet<unsigned short> ids(m_clientIds.constBegin(), m_clientIds.constEnd());
     quint16 id = 1;
     if (!ids.isEmpty()) {
         for (quint16 i = ids.count() + 1; i >= 1 ; i--) {
             if (!ids.contains(i)) {
                 id = i;
                 break;
             }
         }
     }
     Q_ASSERT(!ids.contains(id));
     m_clientIds.insert(c, id);
     connect(c, &ClientConnection::disconnected, this,
         [this] (ClientConnection *c) {
             m_clientIds.remove(c);
         }
     );
     return id;
 }
 
 bool WaylandServer::isScreenLocked() const
 {
     if (!hasScreenLockerIntegration()) {
         return false;
     }
     return ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::Locked ||
            ScreenLocker::KSldApp::self()->lockState() == ScreenLocker::KSldApp::AcquiringLock;
 }
 
 bool WaylandServer::hasScreenLockerIntegration() const
 {
     return !m_initFlags.testFlag(InitializationFlag::NoLockScreenIntegration);
 }
 
 bool WaylandServer::hasGlobalShortcutSupport() const
 {
     return !m_initFlags.testFlag(InitializationFlag::NoGlobalShortcuts);
 }
 
 void WaylandServer::simulateUserActivity()
 {
     if (m_idle) {
         m_idle->simulateUserActivity();
     }
 }
 
 void WaylandServer::updateKeyState(KWin::Xkb::LEDs leds)
 {
     if (!m_keyState)
         return;
 
     m_keyState->setState(KeyStateInterface::Key::CapsLock, leds & KWin::Xkb::LED::CapsLock ? KeyStateInterface::State::Locked : KeyStateInterface::State::Unlocked);
     m_keyState->setState(KeyStateInterface::Key::NumLock, leds & KWin::Xkb::LED::NumLock ? KeyStateInterface::State::Locked : KeyStateInterface::State::Unlocked);
     m_keyState->setState(KeyStateInterface::Key::ScrollLock, leds & KWin::Xkb::LED::ScrollLock ? KeyStateInterface::State::Locked : KeyStateInterface::State::Unlocked);
 }
 
 }
diff --git a/wayland_server.h b/wayland_server.h
index b2f1c77c5..79fdd6e5c 100644
--- a/wayland_server.h
+++ b/wayland_server.h
@@ -1,305 +1,306 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_WAYLAND_SERVER_H
 #define KWIN_WAYLAND_SERVER_H
 
 #include <kwinglobals.h>
 #include "keyboard_input.h"
 
 #include <QObject>
 
 class QThread;
 class QProcess;
 class QWindow;
 
 namespace KWayland
 {
 namespace Client
 {
 class ConnectionThread;
 class Registry;
 class Compositor;
 class Seat;
 class DataDeviceManager;
 class ShmPool;
 class Surface;
 }
-namespace Server
+}
+namespace KWaylandServer
 {
 class AppMenuManagerInterface;
 class ClientConnection;
 class CompositorInterface;
 class Display;
 class DataDeviceInterface;
 class IdleInterface;
 class SeatInterface;
 class DataDeviceManagerInterface;
 class ServerSideDecorationManagerInterface;
 class ServerSideDecorationPaletteManagerInterface;
 class SurfaceInterface;
 class OutputInterface;
 class PlasmaShellInterface;
 class PlasmaShellSurfaceInterface;
 class PlasmaVirtualDesktopManagementInterface;
 class PlasmaWindowManagementInterface;
 class QtSurfaceExtensionInterface;
 class OutputManagementInterface;
 class OutputConfigurationInterface;
 class XdgDecorationManagerInterface;
 class XdgShellInterface;
 class XdgForeignInterface;
 class XdgOutputManagerInterface;
 class KeyStateInterface;
 class LinuxDmabufUnstableV1Interface;
 class LinuxDmabufUnstableV1Buffer;
 class TabletManagerInterface;
 }
-}
+
 
 namespace KWin
 {
 class XdgShellClient;
 
 class AbstractClient;
 class Toplevel;
 
 class KWIN_EXPORT WaylandServer : public QObject
 {
     Q_OBJECT
 public:
     enum class InitializationFlag {
         NoOptions = 0x0,
         LockScreen = 0x1,
         NoLockScreenIntegration = 0x2,
         NoGlobalShortcuts = 0x4
     };
 
     Q_DECLARE_FLAGS(InitializationFlags, InitializationFlag)
 
     ~WaylandServer() override;
     bool init(const QByteArray &socketName = QByteArray(), InitializationFlags flags = InitializationFlag::NoOptions);
     void terminateClientConnections();
 
-    KWayland::Server::Display *display() {
+    KWaylandServer::Display *display() {
         return m_display;
     }
-    KWayland::Server::CompositorInterface *compositor() {
+    KWaylandServer::CompositorInterface *compositor() {
         return m_compositor;
     }
-    KWayland::Server::SeatInterface *seat() {
+    KWaylandServer::SeatInterface *seat() {
         return m_seat;
     }
-    KWayland::Server::TabletManagerInterface *tabletManager()
+    KWaylandServer::TabletManagerInterface *tabletManager()
     {
         return m_tabletManager;
     }
-    KWayland::Server::DataDeviceManagerInterface *dataDeviceManager() {
+    KWaylandServer::DataDeviceManagerInterface *dataDeviceManager() {
         return m_dataDeviceManager;
     }
-    KWayland::Server::PlasmaVirtualDesktopManagementInterface *virtualDesktopManagement() {
+    KWaylandServer::PlasmaVirtualDesktopManagementInterface *virtualDesktopManagement() {
         return m_virtualDesktopManagement;
     }
-    KWayland::Server::PlasmaWindowManagementInterface *windowManagement() {
+    KWaylandServer::PlasmaWindowManagementInterface *windowManagement() {
         return m_windowManagement;
     }
-    KWayland::Server::ServerSideDecorationManagerInterface *decorationManager() const {
+    KWaylandServer::ServerSideDecorationManagerInterface *decorationManager() const {
         return m_decorationManager;
     }
-    KWayland::Server::XdgOutputManagerInterface *xdgOutputManager() const {
+    KWaylandServer::XdgOutputManagerInterface *xdgOutputManager() const {
         return m_xdgOutputManager;
     }
-    KWayland::Server::LinuxDmabufUnstableV1Interface *linuxDmabuf();
+    KWaylandServer::LinuxDmabufUnstableV1Interface *linuxDmabuf();
 
     QList<AbstractClient *> clients() const {
         return m_clients;
     }
     void removeClient(AbstractClient *c);
     AbstractClient *findClient(quint32 id) const;
-    AbstractClient *findClient(KWayland::Server::SurfaceInterface *surface) const;
-    XdgShellClient *findXdgShellClient(KWayland::Server::SurfaceInterface *surface) const;
+    AbstractClient *findClient(KWaylandServer::SurfaceInterface *surface) const;
+    XdgShellClient *findXdgShellClient(KWaylandServer::SurfaceInterface *surface) const;
 
     /**
      * @returns a transient parent of a surface imported with the foreign protocol, if any
      */
-    KWayland::Server::SurfaceInterface *findForeignTransientForSurface(KWayland::Server::SurfaceInterface *surface);
+    KWaylandServer::SurfaceInterface *findForeignTransientForSurface(KWaylandServer::SurfaceInterface *surface);
 
     /**
      * @returns file descriptor for Xwayland to connect to.
      */
     int createXWaylandConnection();
     void destroyXWaylandConnection();
 
     /**
      * @returns file descriptor to the input method server's socket.
      */
     int createInputMethodConnection();
     void destroyInputMethodConnection();
 
     /**
      * @returns true if screen is locked.
      */
     bool isScreenLocked() const;
     /**
      * @returns whether integration with KScreenLocker is available.
      */
     bool hasScreenLockerIntegration() const;
 
     /**
      * @returns whether any kind of global shortcuts are supported.
      */
     bool hasGlobalShortcutSupport() const;
 
     void createInternalConnection();
     void initWorkspace();
 
-    KWayland::Server::ClientConnection *xWaylandConnection() const {
+    KWaylandServer::ClientConnection *xWaylandConnection() const {
         return m_xwayland.client;
     }
-    KWayland::Server::ClientConnection *inputMethodConnection() const {
+    KWaylandServer::ClientConnection *inputMethodConnection() const {
         return m_inputMethodServerConnection;
     }
-    KWayland::Server::ClientConnection *internalConnection() const {
+    KWaylandServer::ClientConnection *internalConnection() const {
         return m_internalConnection.server;
     }
-    KWayland::Server::ClientConnection *screenLockerClientConnection() const {
+    KWaylandServer::ClientConnection *screenLockerClientConnection() const {
         return m_screenLockerClientConnection;
     }
     KWayland::Client::Compositor *internalCompositor() {
         return m_internalConnection.compositor;
     }
     KWayland::Client::Seat *internalSeat() {
         return m_internalConnection.seat;
     }
     KWayland::Client::DataDeviceManager *internalDataDeviceManager() {
         return m_internalConnection.ddm;
     }
     KWayland::Client::ShmPool *internalShmPool() {
         return m_internalConnection.shm;
     }
     KWayland::Client::ConnectionThread *internalClientConection() {
         return m_internalConnection.client;
     }
     KWayland::Client::Registry *internalClientRegistry() {
         return m_internalConnection.registry;
     }
     void dispatch();
-    quint32 createWindowId(KWayland::Server::SurfaceInterface *surface);
+    quint32 createWindowId(KWaylandServer::SurfaceInterface *surface);
 
     /**
      * Struct containing information for a created Wayland connection through a
      * socketpair.
      */
     struct SocketPairConnection {
         /**
          * ServerSide Connection
          */
-        KWayland::Server::ClientConnection *connection = nullptr;
+        KWaylandServer::ClientConnection *connection = nullptr;
         /**
          * client-side file descriptor for the socket
          */
         int fd = -1;
     };
     /**
      * Creates a Wayland connection using a socket pair.
      */
     SocketPairConnection createConnection();
 
     void simulateUserActivity();
     void updateKeyState(KWin::Xkb::LEDs leds);
 
-    QSet<KWayland::Server::LinuxDmabufUnstableV1Buffer*> linuxDmabufBuffers() const {
+    QSet<KWaylandServer::LinuxDmabufUnstableV1Buffer*> linuxDmabufBuffers() const {
         return m_linuxDmabufBuffers;
     }
-    void addLinuxDmabufBuffer(KWayland::Server::LinuxDmabufUnstableV1Buffer *buffer) {
+    void addLinuxDmabufBuffer(KWaylandServer::LinuxDmabufUnstableV1Buffer *buffer) {
         m_linuxDmabufBuffers << buffer;
     }
-    void removeLinuxDmabufBuffer(KWayland::Server::LinuxDmabufUnstableV1Buffer *buffer) {
+    void removeLinuxDmabufBuffer(KWaylandServer::LinuxDmabufUnstableV1Buffer *buffer) {
         m_linuxDmabufBuffers.remove(buffer);
     }
 
 Q_SIGNALS:
     void shellClientAdded(KWin::AbstractClient *);
     void shellClientRemoved(KWin::AbstractClient *);
     void terminatingInternalClientConnection();
     void initialized();
-    void foreignTransientChanged(KWayland::Server::SurfaceInterface *child);
+    void foreignTransientChanged(KWaylandServer::SurfaceInterface *child);
 
 private:
     int createScreenLockerConnection();
     void shellClientShown(Toplevel *t);
-    quint16 createClientId(KWayland::Server::ClientConnection *c);
+    quint16 createClientId(KWaylandServer::ClientConnection *c);
     void destroyInternalConnection();
     template <class T>
     void createSurface(T *surface);
     void initScreenLocker();
-    KWayland::Server::Display *m_display = nullptr;
-    KWayland::Server::CompositorInterface *m_compositor = nullptr;
-    KWayland::Server::SeatInterface *m_seat = nullptr;
-    KWayland::Server::TabletManagerInterface *m_tabletManager = nullptr;
-    KWayland::Server::DataDeviceManagerInterface *m_dataDeviceManager = nullptr;
-    KWayland::Server::XdgShellInterface *m_xdgShell = nullptr;
-    KWayland::Server::PlasmaShellInterface *m_plasmaShell = nullptr;
-    KWayland::Server::PlasmaWindowManagementInterface *m_windowManagement = nullptr;
-    KWayland::Server::PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
-    KWayland::Server::ServerSideDecorationManagerInterface *m_decorationManager = nullptr;
-    KWayland::Server::OutputManagementInterface *m_outputManagement = nullptr;
-    KWayland::Server::AppMenuManagerInterface *m_appMenuManager = nullptr;
-    KWayland::Server::ServerSideDecorationPaletteManagerInterface *m_paletteManager = nullptr;
-    KWayland::Server::IdleInterface *m_idle = nullptr;
-    KWayland::Server::XdgOutputManagerInterface *m_xdgOutputManager = nullptr;
-    KWayland::Server::XdgDecorationManagerInterface *m_xdgDecorationManager = nullptr;
-    KWayland::Server::LinuxDmabufUnstableV1Interface *m_linuxDmabuf = nullptr;
-    QSet<KWayland::Server::LinuxDmabufUnstableV1Buffer*> m_linuxDmabufBuffers;
+    KWaylandServer::Display *m_display = nullptr;
+    KWaylandServer::CompositorInterface *m_compositor = nullptr;
+    KWaylandServer::SeatInterface *m_seat = nullptr;
+    KWaylandServer::TabletManagerInterface *m_tabletManager = nullptr;
+    KWaylandServer::DataDeviceManagerInterface *m_dataDeviceManager = nullptr;
+    KWaylandServer::XdgShellInterface *m_xdgShell = nullptr;
+    KWaylandServer::PlasmaShellInterface *m_plasmaShell = nullptr;
+    KWaylandServer::PlasmaWindowManagementInterface *m_windowManagement = nullptr;
+    KWaylandServer::PlasmaVirtualDesktopManagementInterface *m_virtualDesktopManagement = nullptr;
+    KWaylandServer::ServerSideDecorationManagerInterface *m_decorationManager = nullptr;
+    KWaylandServer::OutputManagementInterface *m_outputManagement = nullptr;
+    KWaylandServer::AppMenuManagerInterface *m_appMenuManager = nullptr;
+    KWaylandServer::ServerSideDecorationPaletteManagerInterface *m_paletteManager = nullptr;
+    KWaylandServer::IdleInterface *m_idle = nullptr;
+    KWaylandServer::XdgOutputManagerInterface *m_xdgOutputManager = nullptr;
+    KWaylandServer::XdgDecorationManagerInterface *m_xdgDecorationManager = nullptr;
+    KWaylandServer::LinuxDmabufUnstableV1Interface *m_linuxDmabuf = nullptr;
+    QSet<KWaylandServer::LinuxDmabufUnstableV1Buffer*> m_linuxDmabufBuffers;
     struct {
-        KWayland::Server::ClientConnection *client = nullptr;
+        KWaylandServer::ClientConnection *client = nullptr;
         QMetaObject::Connection destroyConnection;
     } m_xwayland;
-    KWayland::Server::ClientConnection *m_inputMethodServerConnection = nullptr;
-    KWayland::Server::ClientConnection *m_screenLockerClientConnection = nullptr;
+    KWaylandServer::ClientConnection *m_inputMethodServerConnection = nullptr;
+    KWaylandServer::ClientConnection *m_screenLockerClientConnection = nullptr;
     struct {
-        KWayland::Server::ClientConnection *server = nullptr;
+        KWaylandServer::ClientConnection *server = nullptr;
         KWayland::Client::ConnectionThread *client = nullptr;
         QThread *clientThread = nullptr;
         KWayland::Client::Registry *registry = nullptr;
         KWayland::Client::Compositor *compositor = nullptr;
         KWayland::Client::Seat *seat = nullptr;
         KWayland::Client::DataDeviceManager *ddm = nullptr;
         KWayland::Client::ShmPool *shm = nullptr;
         bool interfacesAnnounced = false;
 
     } m_internalConnection;
-    KWayland::Server::XdgForeignInterface *m_XdgForeign = nullptr;
-    KWayland::Server::KeyStateInterface *m_keyState = nullptr;
+    KWaylandServer::XdgForeignInterface *m_XdgForeign = nullptr;
+    KWaylandServer::KeyStateInterface *m_keyState = nullptr;
     QList<AbstractClient *> m_clients;
-    QHash<KWayland::Server::ClientConnection*, quint16> m_clientIds;
+    QHash<KWaylandServer::ClientConnection*, quint16> m_clientIds;
     InitializationFlags m_initFlags;
-    QVector<KWayland::Server::PlasmaShellSurfaceInterface*> m_plasmaShellSurfaces;
+    QVector<KWaylandServer::PlasmaShellSurfaceInterface*> m_plasmaShellSurfaces;
     KWIN_SINGLETON(WaylandServer)
 };
 
 inline
 WaylandServer *waylandServer() {
     return WaylandServer::self();
 }
 
 } // namespace KWin
 
 #endif
 
diff --git a/xdgshellclient.cpp b/xdgshellclient.cpp
index dcca4d833..40f2e8b67 100644
--- a/xdgshellclient.cpp
+++ b/xdgshellclient.cpp
@@ -1,2024 +1,2024 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 David Edmundson <davidedmundson@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "xdgshellclient.h"
 #include "cursor.h"
 #include "decorations/decoratedclient.h"
 #include "decorations/decorationbridge.h"
 #include "deleted.h"
 #include "placement.h"
 #include "screenedge.h"
 #include "screens.h"
 #ifdef KWIN_BUILD_TABBOX
 #include "tabbox.h"
 #endif
 #include "virtualdesktops.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KDecoration2/DecoratedClient>
 #include <KDecoration2/Decoration>
-#include <KWayland/Server/appmenu_interface.h>
-#include <KWayland/Server/buffer_interface.h>
-#include <KWayland/Server/clientconnection.h>
-#include <KWayland/Server/display.h>
-#include <KWayland/Server/plasmashell_interface.h>
-#include <KWayland/Server/plasmawindowmanagement_interface.h>
-#include <KWayland/Server/qtsurfaceextension_interface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/server_decoration_interface.h>
-#include <KWayland/Server/server_decoration_palette_interface.h>
-#include <KWayland/Server/shadow_interface.h>
-#include <KWayland/Server/surface_interface.h>
-#include <KWayland/Server/xdgdecoration_interface.h>
+#include <KWaylandServer/appmenu_interface.h>
+#include <KWaylandServer/buffer_interface.h>
+#include <KWaylandServer/clientconnection.h>
+#include <KWaylandServer/display.h>
+#include <KWaylandServer/plasmashell_interface.h>
+#include <KWaylandServer/plasmawindowmanagement_interface.h>
+#include <KWaylandServer/qtsurfaceextension_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/server_decoration_interface.h>
+#include <KWaylandServer/server_decoration_palette_interface.h>
+#include <KWaylandServer/shadow_interface.h>
+#include <KWaylandServer/surface_interface.h>
+#include <KWaylandServer/xdgdecoration_interface.h>
 
 #include <QFileInfo>
 
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <csignal>
 
 Q_DECLARE_METATYPE(NET::WindowType)
 
-using namespace KWayland::Server;
+using namespace KWaylandServer;
 
 namespace KWin
 {
 
 XdgShellClient::XdgShellClient(XdgShellSurfaceInterface *surface)
     : AbstractClient()
     , m_xdgShellToplevel(surface)
     , m_xdgShellPopup(nullptr)
 {
     setSurface(surface->surface());
     init();
 }
 
 XdgShellClient::XdgShellClient(XdgShellPopupInterface *surface)
     : AbstractClient()
     , m_xdgShellToplevel(nullptr)
     , m_xdgShellPopup(surface)
 {
     setSurface(surface->surface());
     init();
 }
 
 XdgShellClient::~XdgShellClient() = default;
 
 void XdgShellClient::init()
 {
     m_requestGeometryBlockCounter++;
 
     connect(this, &XdgShellClient::desktopFileNameChanged, this, &XdgShellClient::updateIcon);
     createWindowId();
     setupCompositing();
     updateIcon();
 
     // TODO: Initialize with null rect.
     m_frameGeometry = QRect(0, 0, -1, -1);
     m_windowGeometry = QRect(0, 0, -1, -1);
 
     if (waylandServer()->inputMethodConnection() == surface()->client()) {
         m_windowType = NET::OnScreenDisplay;
     }
 
     connect(surface(), &SurfaceInterface::unmapped, this, &XdgShellClient::unmap);
     connect(surface(), &SurfaceInterface::unbound, this, &XdgShellClient::destroyClient);
     connect(surface(), &SurfaceInterface::destroyed, this, &XdgShellClient::destroyClient);
 
     if (m_xdgShellToplevel) {
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::destroyed, this, &XdgShellClient::destroyClient);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::configureAcknowledged, this, &XdgShellClient::handleConfigureAcknowledged);
 
         m_caption = m_xdgShellToplevel->title().simplified();
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::titleChanged, this, &XdgShellClient::handleWindowTitleChanged);
         QTimer::singleShot(0, this, &XdgShellClient::updateCaption);
 
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::moveRequested, this, &XdgShellClient::handleMoveRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::resizeRequested, this, &XdgShellClient::handleResizeRequested);
 
         // Determine the resource name, this is inspired from ICCCM 4.1.2.5
         // the binary name of the invoked client.
         QFileInfo info{m_xdgShellToplevel->client()->executablePath()};
         QByteArray resourceName;
         if (info.exists()) {
             resourceName = info.fileName().toUtf8();
         }
         setResourceClass(resourceName, m_xdgShellToplevel->windowClass());
         setDesktopFileName(m_xdgShellToplevel->windowClass());
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::windowClassChanged, this, &XdgShellClient::handleWindowClassChanged);
 
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::minimizeRequested, this, &XdgShellClient::handleMinimizeRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::maximizedChanged, this, &XdgShellClient::handleMaximizeRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::fullscreenChanged, this, &XdgShellClient::handleFullScreenRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::windowMenuRequested, this, &XdgShellClient::handleWindowMenuRequested);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::transientForChanged, this, &XdgShellClient::handleTransientForChanged);
         connect(m_xdgShellToplevel, &XdgShellSurfaceInterface::windowGeometryChanged, this, &XdgShellClient::handleWindowGeometryChanged);
 
         auto global = static_cast<XdgShellInterface *>(m_xdgShellToplevel->global());
         connect(global, &XdgShellInterface::pingDelayed, this, &XdgShellClient::handlePingDelayed);
         connect(global, &XdgShellInterface::pingTimeout, this, &XdgShellClient::handlePingTimeout);
         connect(global, &XdgShellInterface::pongReceived, this, &XdgShellClient::handlePongReceived);
 
         auto configure = [this] {
             if (m_closing) {
                 return;
             }
             if (m_requestGeometryBlockCounter != 0 || areGeometryUpdatesBlocked()) {
                 return;
             }
             m_xdgShellToplevel->configure(xdgSurfaceStates(), m_requestedClientSize);
         };
         connect(this, &AbstractClient::activeChanged, this, configure);
         connect(this, &AbstractClient::clientStartUserMovedResized, this, configure);
         connect(this, &AbstractClient::clientFinishUserMovedResized, this, configure);
 
         connect(this, &XdgShellClient::frameGeometryChanged, this, &XdgShellClient::updateClientOutputs);
         connect(screens(), &Screens::changed, this, &XdgShellClient::updateClientOutputs);
     } else if (m_xdgShellPopup) {
         connect(m_xdgShellPopup, &XdgShellPopupInterface::configureAcknowledged, this, &XdgShellClient::handleConfigureAcknowledged);
         connect(m_xdgShellPopup, &XdgShellPopupInterface::grabRequested, this, &XdgShellClient::handleGrabRequested);
         connect(m_xdgShellPopup, &XdgShellPopupInterface::destroyed, this, &XdgShellClient::destroyClient);
         connect(m_xdgShellPopup, &XdgShellPopupInterface::windowGeometryChanged, this, &XdgShellClient::handleWindowGeometryChanged);
     }
 
     // set initial desktop
     setDesktop(VirtualDesktopManager::self()->current());
 
     // setup shadow integration
     updateShadow();
     connect(surface(), &SurfaceInterface::shadowChanged, this, &Toplevel::updateShadow);
 
-    connect(waylandServer(), &WaylandServer::foreignTransientChanged, this, [this](KWayland::Server::SurfaceInterface *child) {
+    connect(waylandServer(), &WaylandServer::foreignTransientChanged, this, [this](KWaylandServer::SurfaceInterface *child) {
         if (child == surface()) {
             handleTransientForChanged();
         }
     });
     handleTransientForChanged();
 
     AbstractClient::updateColorScheme(QString());
 
     connect(surface(), &SurfaceInterface::committed, this, &XdgShellClient::finishInit);
 }
 
 void XdgShellClient::finishInit()
 {
     disconnect(surface(), &SurfaceInterface::committed, this, &XdgShellClient::finishInit);
 
     connect(surface(), &SurfaceInterface::committed, this, &XdgShellClient::handleCommitted);
 
     bool needsPlacement = !isInitialPositionSet();
 
     if (supportsWindowRules()) {
         setupWindowRules(false);
 
         const QRect originalGeometry = frameGeometry();
         const QRect ruledGeometry = rules()->checkGeometry(originalGeometry, true);
         if (originalGeometry != ruledGeometry) {
             setFrameGeometry(ruledGeometry);
         }
 
         maximize(rules()->checkMaximize(maximizeMode(), true));
 
         setDesktop(rules()->checkDesktop(desktop(), true));
         setDesktopFileName(rules()->checkDesktopFile(desktopFileName(), true).toUtf8());
         if (rules()->checkMinimize(isMinimized(), true)) {
             minimize(true); // No animation.
         }
         setSkipTaskbar(rules()->checkSkipTaskbar(skipTaskbar(), true));
         setSkipPager(rules()->checkSkipPager(skipPager(), true));
         setSkipSwitcher(rules()->checkSkipSwitcher(skipSwitcher(), true));
         setKeepAbove(rules()->checkKeepAbove(keepAbove(), true));
         setKeepBelow(rules()->checkKeepBelow(keepBelow(), true));
         setShortcut(rules()->checkShortcut(shortcut().toString(), true));
         updateColorScheme();
 
         // Don't place the client if its position is set by a rule.
         if (rules()->checkPosition(invalidPoint, true) != invalidPoint) {
             needsPlacement = false;
         }
 
         // Don't place the client if the maximize state is set by a rule.
         if (requestedMaximizeMode() != MaximizeRestore) {
             needsPlacement = false;
         }
 
         discardTemporaryRules();
         RuleBook::self()->discardUsed(this, false); // Remove Apply Now rules.
         updateWindowRules(Rules::All);
     }
 
     if (isFullScreen()) {
         needsPlacement = false;
     }
 
     if (needsPlacement) {
         const QRect area = workspace()->clientArea(PlacementArea, Screens::self()->current(), desktop());
         placeIn(area);
     }
 
     m_requestGeometryBlockCounter--;
     if (m_requestGeometryBlockCounter == 0) {
         requestGeometry(m_blockedRequestGeometry);
     }
 
     m_isInitialized = true;
 }
 
 void XdgShellClient::destroyClient()
 {
     m_closing = true;
 #ifdef KWIN_BUILD_TABBOX
     TabBox::TabBox *tabBox = TabBox::TabBox::self();
     if (tabBox->isDisplayed() && tabBox->currentClient() == this) {
         tabBox->nextPrev(true);
     }
 #endif
     if (isMoveResize()) {
         leaveMoveResize();
     }
 
     // Replace ShellClient with an instance of Deleted in the stacking order.
     Deleted *deleted = Deleted::create(this);
     emit windowClosed(this, deleted);
 
     // Remove Force Temporarily rules.
     RuleBook::self()->discardUsed(this, true);
 
     destroyWindowManagementInterface();
     destroyDecoration();
 
     StackingUpdatesBlocker blocker(workspace());
     if (transientFor()) {
         transientFor()->removeTransient(this);
     }
     for (auto it = transients().constBegin(); it != transients().constEnd();) {
         if ((*it)->transientFor() == this) {
             removeTransient(*it);
             it = transients().constBegin(); // restart, just in case something more has changed with the list
         } else {
             ++it;
         }
     }
 
     waylandServer()->removeClient(this);
 
     deleted->unrefWindow();
 
     m_xdgShellToplevel = nullptr;
     m_xdgShellPopup = nullptr;
     deleteClient(this);
 }
 
 void XdgShellClient::deleteClient(XdgShellClient *c)
 {
     delete c;
 }
 
 QRect XdgShellClient::inputGeometry() const
 {
     if (isDecorated()) {
         return AbstractClient::inputGeometry();
     }
     // TODO: What about sub-surfaces sticking outside the main surface?
     return m_bufferGeometry;
 }
 
 QRect XdgShellClient::bufferGeometry() const
 {
     return m_bufferGeometry;
 }
 
 QStringList XdgShellClient::activities() const
 {
     // TODO: implement
     return QStringList();
 }
 
 QPoint XdgShellClient::clientContentPos() const
 {
     return -1 * clientPos();
 }
 
 QSize XdgShellClient::clientSize() const
 {
     const QRect boundingRect = surface()->boundingRect();
     return m_windowGeometry.size().boundedTo(boundingRect.size());
 }
 
 QSize XdgShellClient::minSize() const
 {
     if (m_xdgShellToplevel) {
         return rules()->checkMinSize(m_xdgShellToplevel->minimumSize());
     }
     return QSize(0, 0);
 }
 
 QSize XdgShellClient::maxSize() const
 {
     if (m_xdgShellToplevel) {
         return rules()->checkMaxSize(m_xdgShellToplevel->maximumSize());
     }
     return QSize(INT_MAX, INT_MAX);
 }
 
 void XdgShellClient::debug(QDebug &stream) const
 {
     stream.nospace();
     stream << "\'XdgShellClient:" << surface() << ";WMCLASS:" << resourceClass() << ":"
            << resourceName() << ";Caption:" << caption() << "\'";
 }
 
 bool XdgShellClient::belongsToDesktop() const
 {
     const auto clients = waylandServer()->clients();
 
     return std::any_of(clients.constBegin(), clients.constEnd(),
         [this](const AbstractClient *client) {
             if (belongsToSameApplication(client, SameApplicationChecks())) {
                 return client->isDesktop();
             }
             return false;
         }
     );
 }
 
 Layer XdgShellClient::layerForDock() const
 {
     if (m_plasmaShellSurface) {
         switch (m_plasmaShellSurface->panelBehavior()) {
         case PlasmaShellSurfaceInterface::PanelBehavior::WindowsCanCover:
             return NormalLayer;
         case PlasmaShellSurfaceInterface::PanelBehavior::AutoHide:
             return AboveLayer;
         case PlasmaShellSurfaceInterface::PanelBehavior::WindowsGoBelow:
         case PlasmaShellSurfaceInterface::PanelBehavior::AlwaysVisible:
             return DockLayer;
         default:
             Q_UNREACHABLE();
             break;
         }
     }
     return AbstractClient::layerForDock();
 }
 
 QRect XdgShellClient::transparentRect() const
 {
     // TODO: implement
     return QRect();
 }
 
 NET::WindowType XdgShellClient::windowType(bool direct, int supported_types) const
 {
     // TODO: implement
     Q_UNUSED(direct)
     Q_UNUSED(supported_types)
     return m_windowType;
 }
 
 double XdgShellClient::opacity() const
 {
     return m_opacity;
 }
 
 void XdgShellClient::setOpacity(double opacity)
 {
     const qreal newOpacity = qBound(0.0, opacity, 1.0);
     if (newOpacity == m_opacity) {
         return;
     }
     const qreal oldOpacity = m_opacity;
     m_opacity = newOpacity;
     addRepaintFull();
     emit opacityChanged(this, oldOpacity);
 }
 
 void XdgShellClient::addDamage(const QRegion &damage)
 {
     const int offsetX = m_bufferGeometry.x() - frameGeometry().x();
     const int offsetY = m_bufferGeometry.y() - frameGeometry().y();
     repaints_region += damage.translated(offsetX, offsetY);
 
     Toplevel::addDamage(damage);
 }
 
 void XdgShellClient::markAsMapped()
 {
     if (!m_unmapped) {
         return;
     }
 
     m_unmapped = false;
     if (!ready_for_painting) {
         setReadyForPainting();
     } else {
         addRepaintFull();
         emit windowShown(this);
     }
     if (shouldExposeToWindowManagement()) {
         setupWindowManagementInterface();
     }
     updateShowOnScreenEdge();
 }
 
 void XdgShellClient::updateDecoration(bool check_workspace_pos, bool force)
 {
     if (!force &&
             ((!isDecorated() && noBorder()) || (isDecorated() && !noBorder())))
         return;
     QRect oldgeom = frameGeometry();
     QRect oldClientGeom = oldgeom.adjusted(borderLeft(), borderTop(), -borderRight(), -borderBottom());
     blockGeometryUpdates(true);
     if (force)
         destroyDecoration();
     if (!noBorder()) {
         createDecoration(oldgeom);
     } else
         destroyDecoration();
     if (m_serverDecoration && isDecorated()) {
-        m_serverDecoration->setMode(KWayland::Server::ServerSideDecorationManagerInterface::Mode::Server);
+        m_serverDecoration->setMode(KWaylandServer::ServerSideDecorationManagerInterface::Mode::Server);
     }
     if (m_xdgDecoration) {
         auto mode = isDecorated() || m_userNoBorder ? XdgDecorationInterface::Mode::ServerSide: XdgDecorationInterface::Mode::ClientSide;
         m_xdgDecoration->configure(mode);
         if (m_requestGeometryBlockCounter == 0) {
             m_xdgShellToplevel->configure(xdgSurfaceStates(), m_requestedClientSize);
         }
     }
     updateShadow();
     if (check_workspace_pos)
         checkWorkspacePosition(oldgeom, -2, oldClientGeom);
     blockGeometryUpdates(false);
 }
 
 void XdgShellClient::setFrameGeometry(const QRect &rect, ForceGeometry_t force)
 {
     const QRect newGeometry = rules()->checkGeometry(rect);
 
     if (areGeometryUpdatesBlocked()) {
         // when the GeometryUpdateBlocker exits the current geom is passed to setGeometry
         // thus we need to set it here.
         m_frameGeometry = newGeometry;
         if (pendingGeometryUpdate() == PendingGeometryForced) {
             // maximum, nothing needed
         } else if (force == ForceGeometrySet) {
             setPendingGeometryUpdate(PendingGeometryForced);
         } else {
             setPendingGeometryUpdate(PendingGeometryNormal);
         }
         return;
     }
 
     if (pendingGeometryUpdate() != PendingGeometryNone) {
         // reset geometry to the one before blocking, so that we can compare properly
         m_frameGeometry = frameGeometryBeforeUpdateBlocking();
     }
 
     const QSize requestedClientSize = newGeometry.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
 
     if (requestedClientSize == m_windowGeometry.size() &&
         (m_requestedClientSize.isEmpty() || requestedClientSize == m_requestedClientSize)) {
         // size didn't change, and we don't need to explicitly request a new size
         doSetGeometry(newGeometry);
         updateMaximizeMode(m_requestedMaximizeMode);
     } else {
         // size did change, Client needs to provide a new buffer
         requestGeometry(newGeometry);
     }
 }
 
 QRect XdgShellClient::determineBufferGeometry() const
 {
     // Offset of the main surface relative to the frame rect.
     const int offsetX = borderLeft() - m_windowGeometry.left();
     const int offsetY = borderTop() - m_windowGeometry.top();
 
     QRect bufferGeometry;
     bufferGeometry.setX(x() + offsetX);
     bufferGeometry.setY(y() + offsetY);
     bufferGeometry.setSize(surface()->size());
 
     return bufferGeometry;
 }
 
 void XdgShellClient::doSetGeometry(const QRect &rect)
 {
     bool frameGeometryIsChanged = false;
     bool bufferGeometryIsChanged = false;
 
     if (m_frameGeometry != rect) {
         m_frameGeometry = rect;
         frameGeometryIsChanged = true;
     }
 
     const QRect bufferGeometry = determineBufferGeometry();
     if (m_bufferGeometry != bufferGeometry) {
         m_bufferGeometry = bufferGeometry;
         bufferGeometryIsChanged = true;
     }
 
     if (!frameGeometryIsChanged && !bufferGeometryIsChanged) {
         return;
     }
 
     if (m_unmapped && geometryRestore().isEmpty() && !m_frameGeometry.isEmpty()) {
         // use first valid geometry as restore geometry
         setGeometryRestore(m_frameGeometry);
     }
 
     if (frameGeometryIsChanged) {
         if (hasStrut()) {
             workspace()->updateClientArea();
         }
         updateWindowRules(Rules::Position | Rules::Size);
         emit frameGeometryChanged(this, frameGeometryBeforeUpdateBlocking());
     }
 
     emit geometryShapeChanged(this, frameGeometryBeforeUpdateBlocking());
 
     addRepaintDuringGeometryUpdates();
     updateGeometryBeforeUpdateBlocking();
 
     if (isResize()) {
         performMoveResize();
     }
 }
 
 void XdgShellClient::doMove(int x, int y)
 {
     Q_UNUSED(x)
     Q_UNUSED(y)
     m_bufferGeometry = determineBufferGeometry();
 }
 
 QByteArray XdgShellClient::windowRole() const
 {
     return QByteArray();
 }
 
 bool XdgShellClient::belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const
 {
     if (checks.testFlag(SameApplicationCheck::AllowCrossProcesses)) {
         if (other->desktopFileName() == desktopFileName()) {
             return true;
         }
     }
     if (auto s = other->surface()) {
         return s->client() == surface()->client();
     }
     return false;
 }
 
 void XdgShellClient::blockActivityUpdates(bool b)
 {
     Q_UNUSED(b)
 }
 
 QString XdgShellClient::captionNormal() const
 {
     return m_caption;
 }
 
 QString XdgShellClient::captionSuffix() const
 {
     return m_captionSuffix;
 }
 
 void XdgShellClient::updateCaption()
 {
     const QString oldSuffix = m_captionSuffix;
     const auto shortcut = shortcutCaptionSuffix();
     m_captionSuffix = shortcut;
     if ((!isSpecialWindow() || isToolbar()) && findClientWithSameCaption()) {
         int i = 2;
         do {
             m_captionSuffix = shortcut + QLatin1String(" <") + QString::number(i) + QLatin1Char('>');
             i++;
         } while (findClientWithSameCaption());
     }
     if (m_captionSuffix != oldSuffix) {
         emit captionChanged();
     }
 }
 
 void XdgShellClient::closeWindow()
 {
     if (m_xdgShellToplevel && isCloseable()) {
         m_xdgShellToplevel->close();
         ping(PingReason::CloseWindow);
     }
 }
 
 AbstractClient *XdgShellClient::findModal(bool allow_itself)
 {
     Q_UNUSED(allow_itself)
     return nullptr;
 }
 
 bool XdgShellClient::isCloseable() const
 {
     if (m_windowType == NET::Desktop || m_windowType == NET::Dock) {
         return false;
     }
     if (m_xdgShellToplevel) {
         return true;
     }
     return false;
 }
 
 bool XdgShellClient::isFullScreen() const
 {
     return m_fullScreen;
 }
 
 bool XdgShellClient::isMaximizable() const
 {
     if (!isResizable()) {
         return false;
     }
     if (rules()->checkMaximize(MaximizeRestore) != MaximizeRestore || rules()->checkMaximize(MaximizeFull) != MaximizeFull) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isMinimizable() const
 {
     if (!rules()->checkMinimize(true)) {
         return false;
     }
     return (!m_plasmaShellSurface || m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal);
 }
 
 bool XdgShellClient::isMovable() const
 {
     if (isFullScreen()) {
         return false;
     }
     if (rules()->checkPosition(invalidPoint) != invalidPoint) {
         return false;
     }
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isMovableAcrossScreens() const
 {
     if (rules()->checkPosition(invalidPoint) != invalidPoint) {
         return false;
     }
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isResizable() const
 {
     if (isFullScreen()) {
         return false;
     }
     if (rules()->checkSize(QSize()).isValid()) {
         return false;
     }
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Normal;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
 bool XdgShellClient::isShown(bool shaded_is_shown) const
 {
     Q_UNUSED(shaded_is_shown)
     return !m_closing && !m_unmapped && !isMinimized() && !m_hidden;
 }
 
 bool XdgShellClient::isHiddenInternal() const
 {
     return m_unmapped || m_hidden;
 }
 
 void XdgShellClient::hideClient(bool hide)
 {
     if (m_hidden == hide) {
         return;
     }
     m_hidden = hide;
     if (hide) {
         addWorkspaceRepaint(visibleRect());
         workspace()->clientHidden(this);
         emit windowHidden(this);
     } else {
         emit windowShown(this);
     }
 }
 
 static bool changeMaximizeRecursion = false;
 void XdgShellClient::changeMaximize(bool horizontal, bool vertical, bool adjust)
 {
     if (changeMaximizeRecursion) {
         return;
     }
 
     if (!isResizable()) {
         return;
     }
 
     const QRect clientArea = isElectricBorderMaximizing() ?
         workspace()->clientArea(MaximizeArea, Cursors::self()->mouse()->pos(), desktop()) :
         workspace()->clientArea(MaximizeArea, this);
 
     const MaximizeMode oldMode = m_requestedMaximizeMode;
     const QRect oldGeometry = frameGeometry();
 
     // 'adjust == true' means to update the size only, e.g. after changing workspace size
     if (!adjust) {
         if (vertical)
             m_requestedMaximizeMode = MaximizeMode(m_requestedMaximizeMode ^ MaximizeVertical);
         if (horizontal)
             m_requestedMaximizeMode = MaximizeMode(m_requestedMaximizeMode ^ MaximizeHorizontal);
     }
 
     m_requestedMaximizeMode = rules()->checkMaximize(m_requestedMaximizeMode);
     if (!adjust && m_requestedMaximizeMode == oldMode) {
         return;
     }
 
     StackingUpdatesBlocker blocker(workspace());
     RequestGeometryBlocker geometryBlocker(this);
 
     // call into decoration update borders
     if (isDecorated() && decoration()->client() && !(options->borderlessMaximizedWindows() && m_requestedMaximizeMode == KWin::MaximizeFull)) {
         changeMaximizeRecursion = true;
         const auto c = decoration()->client().toStrongRef();
         if ((m_requestedMaximizeMode & MaximizeVertical) != (oldMode & MaximizeVertical)) {
             emit c->maximizedVerticallyChanged(m_requestedMaximizeMode & MaximizeVertical);
         }
         if ((m_requestedMaximizeMode & MaximizeHorizontal) != (oldMode & MaximizeHorizontal)) {
             emit c->maximizedHorizontallyChanged(m_requestedMaximizeMode & MaximizeHorizontal);
         }
         if ((m_requestedMaximizeMode == MaximizeFull) != (oldMode == MaximizeFull)) {
             emit c->maximizedChanged(m_requestedMaximizeMode & MaximizeFull);
         }
         changeMaximizeRecursion = false;
     }
 
     if (options->borderlessMaximizedWindows()) {
         // triggers a maximize change.
         // The next setNoBorder interation will exit since there's no change but the first recursion pullutes the restore geometry
         changeMaximizeRecursion = true;
         setNoBorder(rules()->checkNoBorder(m_requestedMaximizeMode == MaximizeFull));
         changeMaximizeRecursion = false;
     }
 
     // Conditional quick tiling exit points
     const auto oldQuickTileMode = quickTileMode();
     if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) {
         if (oldMode == MaximizeFull &&
                 !clientArea.contains(geometryRestore().center())) {
             // Not restoring on the same screen
             // TODO: The following doesn't work for some reason
             //quick_tile_mode = QuickTileNone; // And exit quick tile mode manually
         } else if ((oldMode == MaximizeVertical && m_requestedMaximizeMode == MaximizeRestore) ||
                   (oldMode == MaximizeFull && m_requestedMaximizeMode == MaximizeHorizontal)) {
             // Modifying geometry of a tiled window
             updateQuickTileMode(QuickTileFlag::None); // Exit quick tile mode without restoring geometry
         }
     }
 
     if (m_requestedMaximizeMode == MaximizeFull) {
         setGeometryRestore(oldGeometry);
         // TODO: Client has more checks
         if (options->electricBorderMaximize()) {
             updateQuickTileMode(QuickTileFlag::Maximize);
         } else {
             updateQuickTileMode(QuickTileFlag::None);
         }
         if (quickTileMode() != oldQuickTileMode) {
             emit quickTileModeChanged();
         }
         setFrameGeometry(workspace()->clientArea(MaximizeArea, this));
         workspace()->raiseClient(this);
     } else {
         if (m_requestedMaximizeMode == MaximizeRestore) {
             updateQuickTileMode(QuickTileFlag::None);
         }
         if (quickTileMode() != oldQuickTileMode) {
             emit quickTileModeChanged();
         }
 
         if (geometryRestore().isValid()) {
             setFrameGeometry(geometryRestore());
         } else {
             setFrameGeometry(workspace()->clientArea(PlacementArea, this));
         }
     }
 }
 
 MaximizeMode XdgShellClient::maximizeMode() const
 {
     return m_maximizeMode;
 }
 
 MaximizeMode XdgShellClient::requestedMaximizeMode() const
 {
     return m_requestedMaximizeMode;
 }
 
 bool XdgShellClient::noBorder() const
 {
     if (m_serverDecoration) {
         if (m_serverDecoration->mode() == ServerSideDecorationManagerInterface::Mode::Server) {
             return m_userNoBorder || isFullScreen();
         }
     }
     if (m_xdgDecoration && m_xdgDecoration->requestedMode() != XdgDecorationInterface::Mode::ClientSide) {
         return m_userNoBorder || isFullScreen();
     }
     return true;
 }
 
 bool XdgShellClient::isFullScreenable() const
 {
     if (!rules()->checkFullScreen(true)) {
         return false;
     }
     return !isSpecialWindow();
 }
 
 void XdgShellClient::setFullScreen(bool set, bool user)
 {
     set = rules()->checkFullScreen(set);
 
     const bool wasFullscreen = isFullScreen();
     if (wasFullscreen == set) {
         return;
     }
     if (isSpecialWindow()) {
         return;
     }
     if (user && !userCanSetFullScreen()) {
         return;
     }
 
     if (wasFullscreen) {
         workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
     } else {
         m_geomFsRestore = frameGeometry();
     }
     m_fullScreen = set;
 
     if (set) {
         workspace()->raiseClient(this);
     }
     RequestGeometryBlocker requestBlocker(this);
     StackingUpdatesBlocker blocker1(workspace());
     GeometryUpdatesBlocker blocker2(this);
 
     workspace()->updateClientLayer(this);   // active fullscreens get different layer
     updateDecoration(false, false);
 
     if (set) {
         setFrameGeometry(workspace()->clientArea(FullScreenArea, this));
     } else {
         if (m_geomFsRestore.isValid()) {
             int currentScreen = screen();
             setFrameGeometry(QRect(m_geomFsRestore.topLeft(), constrainFrameSize(m_geomFsRestore.size())));
             if( currentScreen != screen())
                 workspace()->sendClientToScreen( this, currentScreen );
         } else {
             // this can happen when the window was first shown already fullscreen,
             // so let the client set the size by itself
             setFrameGeometry(QRect(workspace()->clientArea(PlacementArea, this).topLeft(), QSize(0, 0)));
         }
     }
 
     updateWindowRules(Rules::Fullscreen|Rules::Position|Rules::Size);
     emit fullScreenChanged();
 }
 
 void XdgShellClient::setNoBorder(bool set)
 {
     if (!userCanSetNoBorder()) {
         return;
     }
     set = rules()->checkNoBorder(set);
     if (m_userNoBorder == set) {
         return;
     }
     m_userNoBorder = set;
     updateDecoration(true, false);
     updateWindowRules(Rules::NoBorder);
 }
 
 void XdgShellClient::setOnAllActivities(bool set)
 {
     Q_UNUSED(set)
 }
 
 void XdgShellClient::takeFocus()
 {
     if (rules()->checkAcceptFocus(wantsInput())) {
         if (m_xdgShellToplevel) {
             ping(PingReason::FocusWindow);
         }
         setActive(true);
     }
 
     if (!keepAbove() && !isOnScreenDisplay() && !belongsToDesktop()) {
         workspace()->setShowingDesktop(false);
     }
 }
 
 void XdgShellClient::doSetActive()
 {
     if (!isActive()) {
         return;
     }
     StackingUpdatesBlocker blocker(workspace());
     workspace()->focusToNull();
 }
 
 bool XdgShellClient::userCanSetFullScreen() const
 {
     if (m_xdgShellToplevel) {
         return true;
     }
     return false;
 }
 
 bool XdgShellClient::userCanSetNoBorder() const
 {
     if (m_serverDecoration && m_serverDecoration->mode() == ServerSideDecorationManagerInterface::Mode::Server) {
         return !isFullScreen() && !isShade();
     }
     if (m_xdgDecoration && m_xdgDecoration->requestedMode() != XdgDecorationInterface::Mode::ClientSide) {
         return !isFullScreen() && !isShade();
     }
     return false;
 }
 
 bool XdgShellClient::wantsInput() const
 {
     return rules()->checkAcceptFocus(acceptsFocus());
 }
 
 bool XdgShellClient::acceptsFocus() const
 {
     if (waylandServer()->inputMethodConnection() == surface()->client()) {
         return false;
     }
     if (m_plasmaShellSurface) {
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::OnScreenDisplay ||
             m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::ToolTip) {
             return false;
         }
 
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Notification ||
             m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::CriticalNotification) {
             return m_plasmaShellSurface->panelTakesFocus();
         }
     }
     if (m_closing) {
         // a closing window does not accept focus
         return false;
     }
     if (m_unmapped) {
         // an unmapped window does not accept focus
         return false;
     }
     if (m_xdgShellToplevel) {
         // TODO: proper
         return true;
     }
     return false;
 }
 
 void XdgShellClient::createWindowId()
 {
     m_windowId = waylandServer()->createWindowId(surface());
 }
 
 pid_t XdgShellClient::pid() const
 {
     return surface()->client()->processId();
 }
 
 bool XdgShellClient::isLockScreen() const
 {
     return surface()->client() == waylandServer()->screenLockerClientConnection();
 }
 
 bool XdgShellClient::isInputMethod() const
 {
     return surface()->client() == waylandServer()->inputMethodConnection();
 }
 
 void XdgShellClient::requestGeometry(const QRect &rect)
 {
     if (m_requestGeometryBlockCounter != 0) {
         m_blockedRequestGeometry = rect;
         return;
     }
 
     QSize size;
     if (rect.isValid()) {
         size = rect.size() - QSize(borderLeft() + borderRight(), borderTop() + borderBottom());
     } else {
         size = QSize(0, 0);
     }
     m_requestedClientSize = size;
 
     quint64 serialId = 0;
 
     if (m_xdgShellToplevel) {
         serialId = m_xdgShellToplevel->configure(xdgSurfaceStates(), size);
     }
     if (m_xdgShellPopup) {
         auto parent = transientFor();
         if (parent) {
             const QPoint globalClientContentPos = parent->frameGeometry().topLeft() + parent->clientPos();
             const QPoint relativeOffset = rect.topLeft() - globalClientContentPos;
             serialId = m_xdgShellPopup->configure(QRect(relativeOffset, size));
         }
     }
 
     if (rect.isValid()) { //if there's no requested size, then there's implicity no positional information worth using
         PendingConfigureRequest configureRequest;
         configureRequest.serialId = serialId;
         configureRequest.positionAfterResize = rect.topLeft();
         configureRequest.maximizeMode = m_requestedMaximizeMode;
         m_pendingConfigureRequests.append(configureRequest);
     }
 
     m_blockedRequestGeometry = QRect();
 }
 
 void XdgShellClient::updatePendingGeometry()
 {
     QPoint position = pos();
     MaximizeMode maximizeMode = m_maximizeMode;
     for (auto it = m_pendingConfigureRequests.begin(); it != m_pendingConfigureRequests.end(); it++) {
         if (it->serialId > m_lastAckedConfigureRequest) {
             //this serial is not acked yet, therefore we know all future serials are not
             break;
         }
         if (it->serialId == m_lastAckedConfigureRequest) {
             if (position != it->positionAfterResize) {
                 addLayerRepaint(frameGeometry());
             }
             position = it->positionAfterResize;
             maximizeMode = it->maximizeMode;
 
             m_pendingConfigureRequests.erase(m_pendingConfigureRequests.begin(), ++it);
             break;
         }
         //else serialId < m_lastAckedConfigureRequest and the state is now irrelevant and can be ignored
     }
     QRect geometry = QRect(position, adjustedSize());
     if (isMove()) {
         geometry = adjustMoveGeometry(geometry);
     }
     if (isResize()) {
         geometry = adjustResizeGeometry(geometry);
     }
     doSetGeometry(geometry);
     updateMaximizeMode(maximizeMode);
 }
 
 void XdgShellClient::handleConfigureAcknowledged(quint32 serial)
 {
     m_lastAckedConfigureRequest = serial;
 }
 
 void XdgShellClient::handleTransientForChanged()
 {
     SurfaceInterface *transientSurface = nullptr;
     if (m_xdgShellToplevel) {
         if (auto transient = m_xdgShellToplevel->transientFor().data()) {
             transientSurface = transient->surface();
         }
     }
     if (m_xdgShellPopup) {
         transientSurface = m_xdgShellPopup->transientFor().data();
     }
     if (!transientSurface) {
         transientSurface = waylandServer()->findForeignTransientForSurface(surface());
     }
     AbstractClient *transientClient = waylandServer()->findClient(transientSurface);
     if (transientClient != transientFor()) {
         // Remove from main client.
         if (transientFor()) {
             transientFor()->removeTransient(this);
         }
         setTransientFor(transientClient);
         if (transientClient) {
             transientClient->addTransient(this);
         }
     }
     m_transient = (transientSurface != nullptr);
 }
 
 void XdgShellClient::handleWindowClassChanged(const QByteArray &windowClass)
 {
     setResourceClass(resourceName(), windowClass);
     if (m_isInitialized && supportsWindowRules()) {
         setupWindowRules(true);
         applyWindowRules();
     }
     setDesktopFileName(windowClass);
 }
 
 void XdgShellClient::handleWindowGeometryChanged(const QRect &windowGeometry)
 {
     m_windowGeometry = windowGeometry;
     m_hasWindowGeometry = true;
 }
 
 void XdgShellClient::handleWindowTitleChanged(const QString &title)
 {
     const QString oldSuffix = m_captionSuffix;
     m_caption = title.simplified();
     updateCaption();
     if (m_captionSuffix == oldSuffix) {
         // Don't emit caption change twice it already got emitted by the changing suffix.
         emit captionChanged();
     }
 }
 
 void XdgShellClient::handleMoveRequested(SeatInterface *seat, quint32 serial)
 {
     // FIXME: Check the seat and serial.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     performMouseCommand(Options::MouseMove, Cursors::self()->mouse()->pos());
 }
 
 void XdgShellClient::handleResizeRequested(SeatInterface *seat, quint32 serial, Qt::Edges edges)
 {
     // FIXME: Check the seat and serial.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     if (!isResizable() || isShade()) {
         return;
     }
     if (isMoveResize()) {
         finishMoveResize(false);
     }
     setMoveResizePointerButtonDown(true);
     setMoveOffset(Cursors::self()->mouse()->pos() - pos());  // map from global
     setInvertedMoveOffset(rect().bottomRight() - moveOffset());
     setUnrestrictedMoveResize(false);
     auto toPosition = [edges] {
         Position position = PositionCenter;
         if (edges.testFlag(Qt::TopEdge)) {
             position = PositionTop;
         } else if (edges.testFlag(Qt::BottomEdge)) {
             position = PositionBottom;
         }
         if (edges.testFlag(Qt::LeftEdge)) {
             position = Position(position | PositionLeft);
         } else if (edges.testFlag(Qt::RightEdge)) {
             position = Position(position | PositionRight);
         }
         return position;
     };
     setMoveResizePointerMode(toPosition());
     if (!startMoveResize()) {
         setMoveResizePointerButtonDown(false);
     }
     updateCursor();
 }
 
 void XdgShellClient::handleMinimizeRequested()
 {
     performMouseCommand(Options::MouseMinimize, Cursors::self()->mouse()->pos());
 }
 
 void XdgShellClient::handleMaximizeRequested(bool maximized)
 {
     // If the maximized state of the client hasn't been changed due to a window
     // rule or because the requested state is the same as the current, then the
     // compositor still has to send a configure event.
     RequestGeometryBlocker blocker(this);
 
     maximize(maximized ? MaximizeFull : MaximizeRestore);
 }
 
 void XdgShellClient::handleFullScreenRequested(bool fullScreen, OutputInterface *output)
 {
     // FIXME: Consider output as well.
     Q_UNUSED(output);
     setFullScreen(fullScreen, false);
 }
 
 void XdgShellClient::handleWindowMenuRequested(SeatInterface *seat, quint32 serial, const QPoint &surfacePos)
 {
     // FIXME: Check the seat and serial.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     performMouseCommand(Options::MouseOperationsMenu, pos() + surfacePos);
 }
 
 void XdgShellClient::handleGrabRequested(SeatInterface *seat, quint32 serial)
 {
     // FIXME: Check the seat and serial as well whether the parent had focus.
     Q_UNUSED(seat)
     Q_UNUSED(serial)
     m_hasPopupGrab = true;
 }
 
 void XdgShellClient::handlePingDelayed(quint32 serial)
 {
     auto it = m_pingSerials.find(serial);
     if (it != m_pingSerials.end()) {
         qCDebug(KWIN_CORE) << "First ping timeout:" << caption();
         setUnresponsive(true);
     }
 }
 
 void XdgShellClient::handlePingTimeout(quint32 serial)
 {
     auto it = m_pingSerials.find(serial);
     if (it != m_pingSerials.end()) {
         if (it.value() == PingReason::CloseWindow) {
             qCDebug(KWIN_CORE) << "Final ping timeout on a close attempt, asking to kill:" << caption();
 
             //for internal windows, killing the window will delete this
             QPointer<QObject> guard(this);
             killWindow();
             if (!guard) {
                 return;
             }
         }
         m_pingSerials.erase(it);
     }
 }
 
 void XdgShellClient::handlePongReceived(quint32 serial)
 {
     auto it = m_pingSerials.find(serial);
     if (it != m_pingSerials.end()) {
         setUnresponsive(false);
         m_pingSerials.erase(it);
     }
 }
 
 void XdgShellClient::handleCommitted()
 {
     if (!surface()->buffer()) {
         return;
     }
 
     if (!m_hasWindowGeometry) {
         m_windowGeometry = surface()->boundingRect();
     }
 
     updatePendingGeometry();
 
     setDepth((surface()->buffer()->hasAlphaChannel() && !isDesktop()) ? 32 : 24);
     markAsMapped();
 }
 
 void XdgShellClient::resizeWithChecks(const QSize &size, ForceGeometry_t force)
 {
     // don't allow growing larger than workarea
     const QRect area = workspace()->clientArea(WorkArea, this);
     setFrameGeometry(QRect{pos(), size.boundedTo(area.size())}, force);
 }
 
 void XdgShellClient::unmap()
 {
     m_unmapped = true;
     if (isMoveResize()) {
         leaveMoveResize();
     }
     m_requestedClientSize = QSize(0, 0);
     destroyWindowManagementInterface();
     if (Workspace::self()) {
         addWorkspaceRepaint(visibleRect());
         workspace()->clientHidden(this);
     }
     emit windowHidden(this);
 }
 
 void XdgShellClient::installPlasmaShellSurface(PlasmaShellSurfaceInterface *surface)
 {
     m_plasmaShellSurface = surface;
     auto updatePosition = [this, surface] {
         // That's a mis-use of doSetGeometry method. One should instead use move method.
         QRect rect = QRect(surface->position(), size());
         doSetGeometry(rect);
     };
     auto updateRole = [this, surface] {
         NET::WindowType type = NET::Unknown;
         switch (surface->role()) {
         case PlasmaShellSurfaceInterface::Role::Desktop:
             type = NET::Desktop;
             break;
         case PlasmaShellSurfaceInterface::Role::Panel:
             type = NET::Dock;
             break;
         case PlasmaShellSurfaceInterface::Role::OnScreenDisplay:
             type = NET::OnScreenDisplay;
             break;
         case PlasmaShellSurfaceInterface::Role::Notification:
             type = NET::Notification;
             break;
         case PlasmaShellSurfaceInterface::Role::ToolTip:
             type = NET::Tooltip;
             break;
         case PlasmaShellSurfaceInterface::Role::CriticalNotification:
             type = NET::CriticalNotification;
             break;
         case PlasmaShellSurfaceInterface::Role::Normal:
         default:
             type = NET::Normal;
             break;
         }
         if (type != m_windowType) {
             m_windowType = type;
             if (m_windowType == NET::Desktop || type == NET::Dock || type == NET::OnScreenDisplay || type == NET::Notification || type == NET::Tooltip || type == NET::CriticalNotification) {
                 setOnAllDesktops(true);
             }
             workspace()->updateClientArea();
         }
     };
     connect(surface, &PlasmaShellSurfaceInterface::panelTakesFocusChanged , this, [this, surface]() {
         if (surface->panelTakesFocus()) {
             workspace()->activateClient(this);
         }
     });
     connect(surface, &PlasmaShellSurfaceInterface::positionChanged, this, updatePosition);
     connect(surface, &PlasmaShellSurfaceInterface::roleChanged, this, updateRole);
     connect(surface, &PlasmaShellSurfaceInterface::panelBehaviorChanged, this,
         [this] {
             updateShowOnScreenEdge();
             workspace()->updateClientArea();
         }
     );
     connect(surface, &PlasmaShellSurfaceInterface::panelAutoHideHideRequested, this,
         [this] {
             hideClient(true);
             m_plasmaShellSurface->hideAutoHidingPanel();
             updateShowOnScreenEdge();
         }
     );
     connect(surface, &PlasmaShellSurfaceInterface::panelAutoHideShowRequested, this,
         [this] {
             hideClient(false);
             ScreenEdges::self()->reserve(this, ElectricNone);
             m_plasmaShellSurface->showAutoHidingPanel();
         }
     );
     if (surface->isPositionSet())
         updatePosition();
     updateRole();
     updateShowOnScreenEdge();
     connect(this, &XdgShellClient::frameGeometryChanged, this, &XdgShellClient::updateShowOnScreenEdge);
 
     setSkipTaskbar(surface->skipTaskbar());
     connect(surface, &PlasmaShellSurfaceInterface::skipTaskbarChanged, this, [this] {
         setSkipTaskbar(m_plasmaShellSurface->skipTaskbar());
     });
 
     setSkipSwitcher(surface->skipSwitcher());
     connect(surface, &PlasmaShellSurfaceInterface::skipSwitcherChanged, this, [this] {
         setSkipSwitcher(m_plasmaShellSurface->skipSwitcher());
     });
 }
 
 void XdgShellClient::updateShowOnScreenEdge()
 {
     if (!ScreenEdges::self()) {
         return;
     }
     if (m_unmapped || !m_plasmaShellSurface || m_plasmaShellSurface->role() != PlasmaShellSurfaceInterface::Role::Panel) {
         ScreenEdges::self()->reserve(this, ElectricNone);
         return;
     }
     if ((m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AutoHide && m_hidden) ||
         m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::WindowsCanCover) {
         // screen edge API requires an edge, thus we need to figure out which edge the window borders
         const QRect clientGeometry = frameGeometry();
         Qt::Edges edges;
         for (int i = 0; i < screens()->count(); i++) {
             const QRect screenGeometry = screens()->geometry(i);
             if (screenGeometry.left() == clientGeometry.left()) {
                 edges |= Qt::LeftEdge;
             }
             if (screenGeometry.right() == clientGeometry.right()) {
                 edges |= Qt::RightEdge;
             }
             if (screenGeometry.top() == clientGeometry.top()) {
                 edges |= Qt::TopEdge;
             }
             if (screenGeometry.bottom() == clientGeometry.bottom()) {
                 edges |= Qt::BottomEdge;
             }
         }
         // a panel might border multiple screen edges. E.g. a horizontal panel at the bottom will
         // also border the left and right edge
         // let's remove such cases
         if (edges.testFlag(Qt::LeftEdge) && edges.testFlag(Qt::RightEdge)) {
             edges = edges & (~(Qt::LeftEdge | Qt::RightEdge));
         }
         if (edges.testFlag(Qt::TopEdge) && edges.testFlag(Qt::BottomEdge)) {
             edges = edges & (~(Qt::TopEdge | Qt::BottomEdge));
         }
         // it's still possible that a panel borders two edges, e.g. bottom and left
         // in that case the one which is sharing more with the edge wins
         auto check = [clientGeometry](Qt::Edges edges, Qt::Edge horiz, Qt::Edge vert) {
             if (edges.testFlag(horiz) && edges.testFlag(vert)) {
                 if (clientGeometry.width() >= clientGeometry.height()) {
                     return edges & ~horiz;
                 } else {
                     return edges & ~vert;
                 }
             }
             return edges;
         };
         edges = check(edges, Qt::LeftEdge, Qt::TopEdge);
         edges = check(edges, Qt::LeftEdge, Qt::BottomEdge);
         edges = check(edges, Qt::RightEdge, Qt::TopEdge);
         edges = check(edges, Qt::RightEdge, Qt::BottomEdge);
 
         ElectricBorder border = ElectricNone;
         if (edges.testFlag(Qt::LeftEdge)) {
             border = ElectricLeft;
         }
         if (edges.testFlag(Qt::RightEdge)) {
             border = ElectricRight;
         }
         if (edges.testFlag(Qt::TopEdge)) {
             border = ElectricTop;
         }
         if (edges.testFlag(Qt::BottomEdge)) {
             border = ElectricBottom;
         }
         ScreenEdges::self()->reserve(this, border);
     } else {
         ScreenEdges::self()->reserve(this, ElectricNone);
     }
 }
 
 bool XdgShellClient::isInitialPositionSet() const
 {
     if (m_plasmaShellSurface) {
         return m_plasmaShellSurface->isPositionSet();
     }
     return false;
 }
 
 void XdgShellClient::installAppMenu(AppMenuInterface *menu)
 {
     m_appMenuInterface = menu;
 
     auto updateMenu = [this](AppMenuInterface::InterfaceAddress address) {
         updateApplicationMenuServiceName(address.serviceName);
         updateApplicationMenuObjectPath(address.objectPath);
     };
     connect(m_appMenuInterface, &AppMenuInterface::addressChanged, this, [=](AppMenuInterface::InterfaceAddress address) {
         updateMenu(address);
     });
     updateMenu(menu->address());
 }
 
 void XdgShellClient::installPalette(ServerSideDecorationPaletteInterface *palette)
 {
     m_paletteInterface = palette;
 
     auto updatePalette = [this](const QString &palette) {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(palette));
     };
     connect(m_paletteInterface, &ServerSideDecorationPaletteInterface::paletteChanged, this, [=](const QString &palette) {
         updatePalette(palette);
     });
     connect(m_paletteInterface, &QObject::destroyed, this, [=]() {
         updatePalette(QString());
     });
     updatePalette(palette->palette());
 }
 
 void XdgShellClient::updateColorScheme()
 {
     if (m_paletteInterface) {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(m_paletteInterface->palette()));
     } else {
         AbstractClient::updateColorScheme(rules()->checkDecoColor(QString()));
     }
 }
 
 void XdgShellClient::updateMaximizeMode(MaximizeMode maximizeMode)
 {
     if (maximizeMode == m_maximizeMode) {
         return;
     }
 
     m_maximizeMode = maximizeMode;
     updateWindowRules(Rules::MaximizeHoriz | Rules::MaximizeVert | Rules::Position | Rules::Size);
 
     emit clientMaximizedStateChanged(this, m_maximizeMode);
     emit clientMaximizedStateChanged(this, m_maximizeMode & MaximizeHorizontal, m_maximizeMode & MaximizeVertical);
 }
 
 bool XdgShellClient::hasStrut() const
 {
     if (!isShown(true)) {
         return false;
     }
     if (!m_plasmaShellSurface) {
         return false;
     }
     if (m_plasmaShellSurface->role() != PlasmaShellSurfaceInterface::Role::Panel) {
         return false;
     }
     return m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AlwaysVisible;
 }
 
 quint32 XdgShellClient::windowId() const
 {
     return m_windowId;
 }
 
 void XdgShellClient::updateIcon()
 {
     const QString waylandIconName = QStringLiteral("wayland");
     const QString dfIconName = iconFromDesktopFile();
     const QString iconName = dfIconName.isEmpty() ? waylandIconName : dfIconName;
     if (iconName == icon().name()) {
         return;
     }
     setIcon(QIcon::fromTheme(iconName));
 }
 
 bool XdgShellClient::isTransient() const
 {
     return m_transient;
 }
 
 bool XdgShellClient::hasTransientPlacementHint() const
 {
     return isTransient() && transientFor() && m_xdgShellPopup;
 }
 
 QRect XdgShellClient::transientPlacement(const QRect &bounds) const
 {
     Q_ASSERT(m_xdgShellPopup);
 
     QRect anchorRect;
     Qt::Edges anchorEdge;
     Qt::Edges gravity;
     QPoint offset;
     PositionerConstraints constraintAdjustments;
     QSize size = frameGeometry().size();
 
     const QPoint parentClientPos = transientFor()->pos() + transientFor()->clientPos();
 
     // returns if a target is within the supplied bounds, optional edges argument states which side to check
     auto inBounds = [bounds](const QRect &target, Qt::Edges edges = Qt::LeftEdge | Qt::RightEdge | Qt::TopEdge | Qt::BottomEdge) -> bool {
         if (edges & Qt::LeftEdge && target.left() < bounds.left()) {
             return false;
         }
         if (edges & Qt::TopEdge && target.top() < bounds.top()) {
             return false;
         }
         if (edges & Qt::RightEdge && target.right() > bounds.right()) {
             //normal QRect::right issue cancels out
             return false;
         }
         if (edges & Qt::BottomEdge && target.bottom() > bounds.bottom()) {
             return false;
         }
         return true;
     };
 
     anchorRect = m_xdgShellPopup->anchorRect();
     anchorEdge = m_xdgShellPopup->anchorEdge();
     gravity = m_xdgShellPopup->gravity();
     offset = m_xdgShellPopup->anchorOffset();
     constraintAdjustments = m_xdgShellPopup->constraintAdjustments();
     if (!size.isValid()) {
         size = m_xdgShellPopup->initialSize();
     }
 
     QRect popupRect(popupOffset(anchorRect, anchorEdge, gravity, size) + offset + parentClientPos, size);
 
     //if that fits, we don't need to do anything
     if (inBounds(popupRect)) {
         return popupRect;
     }
     //otherwise apply constraint adjustment per axis in order XDG Shell Popup states
 
     if (constraintAdjustments & PositionerConstraint::FlipX) {
         if (!inBounds(popupRect, Qt::LeftEdge | Qt::RightEdge)) {
             //flip both edges (if either bit is set, XOR both)
             auto flippedAnchorEdge = anchorEdge;
             if (flippedAnchorEdge & (Qt::LeftEdge | Qt::RightEdge)) {
                 flippedAnchorEdge ^= (Qt::LeftEdge | Qt::RightEdge);
             }
             auto flippedGravity = gravity;
             if (flippedGravity & (Qt::LeftEdge | Qt::RightEdge)) {
                 flippedGravity ^= (Qt::LeftEdge | Qt::RightEdge);
             }
             auto flippedPopupRect = QRect(popupOffset(anchorRect, flippedAnchorEdge, flippedGravity, size) + offset + parentClientPos, size);
 
             //if it still doesn't fit we should continue with the unflipped version
             if (inBounds(flippedPopupRect, Qt::LeftEdge | Qt::RightEdge)) {
                 popupRect.moveLeft(flippedPopupRect.left());
             }
         }
     }
     if (constraintAdjustments & PositionerConstraint::SlideX) {
         if (!inBounds(popupRect, Qt::LeftEdge)) {
             popupRect.moveLeft(bounds.left());
         }
         if (!inBounds(popupRect, Qt::RightEdge)) {
             popupRect.moveRight(bounds.right());
         }
     }
     if (constraintAdjustments & PositionerConstraint::ResizeX) {
         QRect unconstrainedRect = popupRect;
 
         if (!inBounds(unconstrainedRect, Qt::LeftEdge)) {
             unconstrainedRect.setLeft(bounds.left());
         }
         if (!inBounds(unconstrainedRect, Qt::RightEdge)) {
             unconstrainedRect.setRight(bounds.right());
         }
 
         if (unconstrainedRect.isValid()) {
             popupRect = unconstrainedRect;
         }
     }
 
     if (constraintAdjustments & PositionerConstraint::FlipY) {
         if (!inBounds(popupRect, Qt::TopEdge | Qt::BottomEdge)) {
             //flip both edges (if either bit is set, XOR both)
             auto flippedAnchorEdge = anchorEdge;
             if (flippedAnchorEdge & (Qt::TopEdge | Qt::BottomEdge)) {
                 flippedAnchorEdge ^= (Qt::TopEdge | Qt::BottomEdge);
             }
             auto flippedGravity = gravity;
             if (flippedGravity & (Qt::TopEdge | Qt::BottomEdge)) {
                 flippedGravity ^= (Qt::TopEdge | Qt::BottomEdge);
             }
             auto flippedPopupRect = QRect(popupOffset(anchorRect, flippedAnchorEdge, flippedGravity, size) + offset + parentClientPos, size);
 
             //if it still doesn't fit we should continue with the unflipped version
             if (inBounds(flippedPopupRect, Qt::TopEdge | Qt::BottomEdge)) {
                 popupRect.moveTop(flippedPopupRect.top());
             }
         }
     }
     if (constraintAdjustments & PositionerConstraint::SlideY) {
         if (!inBounds(popupRect, Qt::TopEdge)) {
             popupRect.moveTop(bounds.top());
         }
         if (!inBounds(popupRect, Qt::BottomEdge)) {
             popupRect.moveBottom(bounds.bottom());
         }
     }
     if (constraintAdjustments & PositionerConstraint::ResizeY) {
         QRect unconstrainedRect = popupRect;
 
         if (!inBounds(unconstrainedRect, Qt::TopEdge)) {
             unconstrainedRect.setTop(bounds.top());
         }
         if (!inBounds(unconstrainedRect, Qt::BottomEdge)) {
             unconstrainedRect.setBottom(bounds.bottom());
         }
 
         if (unconstrainedRect.isValid()) {
             popupRect = unconstrainedRect;
         }
     }
 
     return popupRect;
 }
 
 QPoint XdgShellClient::popupOffset(const QRect &anchorRect, const Qt::Edges anchorEdge, const Qt::Edges gravity, const QSize popupSize) const
 {
     QPoint anchorPoint;
     switch (anchorEdge & (Qt::LeftEdge | Qt::RightEdge)) {
     case Qt::LeftEdge:
         anchorPoint.setX(anchorRect.x());
         break;
     case Qt::RightEdge:
         anchorPoint.setX(anchorRect.x() + anchorRect.width());
         break;
     default:
         anchorPoint.setX(qRound(anchorRect.x() + anchorRect.width() / 2.0));
     }
     switch (anchorEdge & (Qt::TopEdge | Qt::BottomEdge)) {
     case Qt::TopEdge:
         anchorPoint.setY(anchorRect.y());
         break;
     case Qt::BottomEdge:
         anchorPoint.setY(anchorRect.y() + anchorRect.height());
         break;
     default:
         anchorPoint.setY(qRound(anchorRect.y() + anchorRect.height() / 2.0));
     }
 
     // calculate where the top left point of the popup will end up with the applied gravity
     // gravity indicates direction. i.e if gravitating towards the top the popup's bottom edge
     // will next to the anchor point
     QPoint popupPosAdjust;
     switch (gravity & (Qt::LeftEdge | Qt::RightEdge)) {
     case Qt::LeftEdge:
         popupPosAdjust.setX(-popupSize.width());
         break;
     case Qt::RightEdge:
         popupPosAdjust.setX(0);
         break;
     default:
         popupPosAdjust.setX(qRound(-popupSize.width() / 2.0));
     }
     switch (gravity & (Qt::TopEdge | Qt::BottomEdge)) {
     case Qt::TopEdge:
         popupPosAdjust.setY(-popupSize.height());
         break;
     case Qt::BottomEdge:
         popupPosAdjust.setY(0);
         break;
     default:
         popupPosAdjust.setY(qRound(-popupSize.height() / 2.0));
     }
 
     return anchorPoint + popupPosAdjust;
 }
 
 void XdgShellClient::doResizeSync()
 {
     requestGeometry(moveResizeGeometry());
 }
 
 QMatrix4x4 XdgShellClient::inputTransformation() const
 {
     QMatrix4x4 matrix;
     matrix.translate(-m_bufferGeometry.x(), -m_bufferGeometry.y());
     return matrix;
 }
 
-void XdgShellClient::installServerSideDecoration(KWayland::Server::ServerSideDecorationInterface *deco)
+void XdgShellClient::installServerSideDecoration(KWaylandServer::ServerSideDecorationInterface *deco)
 {
     if (m_serverDecoration == deco) {
         return;
     }
     m_serverDecoration = deco;
     connect(m_serverDecoration, &ServerSideDecorationInterface::destroyed, this,
         [this] {
             m_serverDecoration = nullptr;
             if (m_closing || !Workspace::self()) {
                 return;
             }
             if (!m_unmapped) {
                 // maybe delay to next event cycle in case the XdgShellClient is getting destroyed, too
                 updateDecoration(true);
             }
         }
     );
     if (!m_unmapped) {
         updateDecoration(true);
     }
     connect(m_serverDecoration, &ServerSideDecorationInterface::modeRequested, this,
         [this] (ServerSideDecorationManagerInterface::Mode mode) {
             const bool changed = mode != m_serverDecoration->mode();
             if (changed && !m_unmapped) {
                 updateDecoration(false);
             }
         }
     );
 }
 
 void XdgShellClient::installXdgDecoration(XdgDecorationInterface *deco)
 {
     Q_ASSERT(m_xdgShellToplevel);
 
     m_xdgDecoration = deco;
 
     connect(m_xdgDecoration, &QObject::destroyed, this,
         [this] {
             m_xdgDecoration = nullptr;
             if (m_closing || !Workspace::self()) {
                 return;
             }
             updateDecoration(true);
         }
     );
 
     connect(m_xdgDecoration, &XdgDecorationInterface::modeRequested, this,
         [this] () {
         //force is true as we must send a new configure response
         updateDecoration(false, true);
     });
 }
 
 bool XdgShellClient::shouldExposeToWindowManagement()
 {
     if (isLockScreen()) {
         return false;
     }
     if (m_xdgShellPopup) {
         return false;
     }
     return true;
 }
 
-KWayland::Server::XdgShellSurfaceInterface::States XdgShellClient::xdgSurfaceStates() const
+KWaylandServer::XdgShellSurfaceInterface::States XdgShellClient::xdgSurfaceStates() const
 {
     XdgShellSurfaceInterface::States states;
     if (isActive()) {
         states |= XdgShellSurfaceInterface::State::Activated;
     }
     if (isFullScreen()) {
         states |= XdgShellSurfaceInterface::State::Fullscreen;
     }
     if (m_requestedMaximizeMode == MaximizeMode::MaximizeFull) {
         states |= XdgShellSurfaceInterface::State::Maximized;
     }
     if (isResize()) {
         states |= XdgShellSurfaceInterface::State::Resizing;
     }
     return states;
 }
 
 void XdgShellClient::doMinimize()
 {
     if (isMinimized()) {
         workspace()->clientHidden(this);
     } else {
         emit windowShown(this);
     }
     workspace()->updateMinimizedOfTransients(this);
 }
 
 void XdgShellClient::showOnScreenEdge()
 {
     if (!m_plasmaShellSurface || m_unmapped) {
         return;
     }
     hideClient(false);
     workspace()->raiseClient(this);
     if (m_plasmaShellSurface->panelBehavior() == PlasmaShellSurfaceInterface::PanelBehavior::AutoHide) {
         m_plasmaShellSurface->showAutoHidingPanel();
     }
 }
 
 bool XdgShellClient::dockWantsInput() const
 {
     if (m_plasmaShellSurface) {
         if (m_plasmaShellSurface->role() == PlasmaShellSurfaceInterface::Role::Panel) {
             return m_plasmaShellSurface->panelTakesFocus();
         }
     }
     return false;
 }
 
 void XdgShellClient::killWindow()
 {
     if (!surface()) {
         return;
     }
     auto c = surface()->client();
     if (c->processId() == getpid() || c->processId() == 0) {
         c->destroy();
         return;
     }
     ::kill(c->processId(), SIGTERM);
     // give it time to terminate and only if terminate fails, try destroy Wayland connection
     QTimer::singleShot(5000, c, &ClientConnection::destroy);
 }
 
 bool XdgShellClient::isLocalhost() const
 {
     return true;
 }
 
 bool XdgShellClient::hasPopupGrab() const
 {
     return m_hasPopupGrab;
 }
 
 void XdgShellClient::popupDone()
 {
     if (m_xdgShellPopup) {
         m_xdgShellPopup->popupDone();
     }
 }
 
 void XdgShellClient::updateClientOutputs()
 {
     QVector<OutputInterface *> clientOutputs;
     const auto outputs = waylandServer()->display()->outputs();
     for (OutputInterface *output : outputs) {
         const QRect outputGeometry(output->globalPosition(), output->pixelSize() / output->scale());
         if (frameGeometry().intersects(outputGeometry)) {
             clientOutputs << output;
         }
     }
     surface()->setOutputs(clientOutputs);
 }
 
 bool XdgShellClient::isPopupWindow() const
 {
     if (Toplevel::isPopupWindow()) {
         return true;
     }
     if (m_xdgShellPopup != nullptr) {
         return true;
     }
     return false;
 }
 
 bool XdgShellClient::supportsWindowRules() const
 {
     if (m_plasmaShellSurface) {
         return false;
     }
     return m_xdgShellToplevel;
 }
 
 QRect XdgShellClient::adjustMoveGeometry(const QRect &rect) const
 {
     QRect geometry = rect;
     geometry.moveTopLeft(moveResizeGeometry().topLeft());
     return geometry;
 }
 
 QRect XdgShellClient::adjustResizeGeometry(const QRect &rect) const
 {
     QRect geometry = rect;
 
     // We need to adjust frame geometry because configure events carry the maximum window geometry
     // size. A client that has aspect ratio can attach a buffer with smaller size than the one in
     // a configure event.
     switch (moveResizePointerMode()) {
     case PositionTopLeft:
         geometry.moveRight(moveResizeGeometry().right());
         geometry.moveBottom(moveResizeGeometry().bottom());
         break;
     case PositionTop:
     case PositionTopRight:
         geometry.moveLeft(moveResizeGeometry().left());
         geometry.moveBottom(moveResizeGeometry().bottom());
         break;
     case PositionRight:
     case PositionBottomRight:
     case PositionBottom:
         geometry.moveLeft(moveResizeGeometry().left());
         geometry.moveTop(moveResizeGeometry().top());
         break;
     case PositionBottomLeft:
     case PositionLeft:
         geometry.moveRight(moveResizeGeometry().right());
         geometry.moveTop(moveResizeGeometry().top());
         break;
     case PositionCenter:
         Q_UNREACHABLE();
     }
 
     return geometry;
 }
 
 void XdgShellClient::ping(PingReason reason)
 {
     Q_ASSERT(m_xdgShellToplevel);
 
     XdgShellInterface *shell = static_cast<XdgShellInterface *>(m_xdgShellToplevel->global());
     const quint32 serial = shell->ping(m_xdgShellToplevel);
     m_pingSerials.insert(serial, reason);
 }
 
 }
diff --git a/xdgshellclient.h b/xdgshellclient.h
index c82c9c52e..66a3b3fbe 100644
--- a/xdgshellclient.h
+++ b/xdgshellclient.h
@@ -1,267 +1,264 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2015 Martin Gräßlin <mgraesslin@kde.org>
 Copyright (C) 2018 David Edmundson <davidedmundson@kde.org>
 Copyright (C) 2019 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #pragma once
 
 #include "abstract_client.h"
 
-#include <KWayland/Server/xdgshell_interface.h>
+#include <KWaylandServer/xdgshell_interface.h>
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class ServerSideDecorationInterface;
 class ServerSideDecorationPaletteInterface;
 class AppMenuInterface;
 class PlasmaShellSurfaceInterface;
 class XdgDecorationInterface;
 }
-}
 
 namespace KWin
 {
 
 /**
  * @brief The reason for which the server pinged a client surface
  */
 enum class PingReason {
     CloseWindow = 0,
     FocusWindow
 };
 
 class KWIN_EXPORT XdgShellClient : public AbstractClient
 {
     Q_OBJECT
 
 public:
-    XdgShellClient(KWayland::Server::XdgShellSurfaceInterface *surface);
-    XdgShellClient(KWayland::Server::XdgShellPopupInterface *surface);
+    XdgShellClient(KWaylandServer::XdgShellSurfaceInterface *surface);
+    XdgShellClient(KWaylandServer::XdgShellPopupInterface *surface);
     ~XdgShellClient() override;
 
     QRect inputGeometry() const override;
     QRect bufferGeometry() const override;
     QStringList activities() const override;
     QPoint clientContentPos() const override;
     QSize clientSize() const override;
     QSize minSize() const override;
     QSize maxSize() const override;
     QRect transparentRect() const override;
     NET::WindowType windowType(bool direct = false, int supported_types = 0) const override;
     void debug(QDebug &stream) const override;
     double opacity() const override;
     void setOpacity(double opacity) override;
     QByteArray windowRole() const override;
     void blockActivityUpdates(bool b = true) override;
     QString captionNormal() const override;
     QString captionSuffix() const override;
     void closeWindow() override;
     AbstractClient *findModal(bool allow_itself = false) override;
     bool isCloseable() const override;
     bool isFullScreenable() const override;
     bool isFullScreen() const override;
     bool isMaximizable() const override;
     bool isMinimizable() const override;
     bool isMovable() const override;
     bool isMovableAcrossScreens() const override;
     bool isResizable() const override;
     bool isShown(bool shaded_is_shown) const override;
     bool isHiddenInternal() const override;
     void hideClient(bool hide) override;
     MaximizeMode maximizeMode() const override;
     MaximizeMode requestedMaximizeMode() const override;
     bool noBorder() const override;
     void setFullScreen(bool set, bool user = true) override;
     void setNoBorder(bool set) override;
     void updateDecoration(bool check_workspace_pos, bool force = false) override;
     void setOnAllActivities(bool set) override;
     void takeFocus() override;
     bool userCanSetFullScreen() const override;
     bool userCanSetNoBorder() const override;
     bool wantsInput() const override;
     bool dockWantsInput() const override;
     void resizeWithChecks(const QSize &size, ForceGeometry_t force = NormalGeometrySet) override;
     void setFrameGeometry(const QRect &rect, ForceGeometry_t force = NormalGeometrySet) override;
     bool hasStrut() const override;
     quint32 windowId() const override;
     pid_t pid() const override;
     bool isLockScreen() const override;
     bool isInputMethod() const override;
     bool isInitialPositionSet() const override;
     bool isTransient() const override;
     bool hasTransientPlacementHint() const override;
     QRect transientPlacement(const QRect &bounds) const override;
     QMatrix4x4 inputTransformation() const override;
     void showOnScreenEdge() override;
     bool hasPopupGrab() const override;
     void popupDone() override;
     void updateColorScheme() override;
     bool isPopupWindow() const override;
     void killWindow() override;
     bool isLocalhost() const override;
     bool supportsWindowRules() const override;
     void destroyClient() override;
 
-    void installPlasmaShellSurface(KWayland::Server::PlasmaShellSurfaceInterface *surface);
-    void installServerSideDecoration(KWayland::Server::ServerSideDecorationInterface *decoration);
-    void installAppMenu(KWayland::Server::AppMenuInterface *appmenu);
-    void installPalette(KWayland::Server::ServerSideDecorationPaletteInterface *palette);
-    void installXdgDecoration(KWayland::Server::XdgDecorationInterface *decoration);
+    void installPlasmaShellSurface(KWaylandServer::PlasmaShellSurfaceInterface *surface);
+    void installServerSideDecoration(KWaylandServer::ServerSideDecorationInterface *decoration);
+    void installAppMenu(KWaylandServer::AppMenuInterface *appmenu);
+    void installPalette(KWaylandServer::ServerSideDecorationPaletteInterface *palette);
+    void installXdgDecoration(KWaylandServer::XdgDecorationInterface *decoration);
 
 protected:
     void addDamage(const QRegion &damage) override;
     bool belongsToSameApplication(const AbstractClient *other, SameApplicationChecks checks) const override;
     void doSetActive() override;
     bool belongsToDesktop() const override;
     Layer layerForDock() const override;
     void changeMaximize(bool horizontal, bool vertical, bool adjust) override;
     void doResizeSync() override;
     bool acceptsFocus() const override;
     void doMinimize() override;
     void updateCaption() override;
     void doMove(int x, int y) override;
 
 private Q_SLOTS:
     void handleConfigureAcknowledged(quint32 serial);
     void handleTransientForChanged();
     void handleWindowClassChanged(const QByteArray &windowClass);
     void handleWindowGeometryChanged(const QRect &windowGeometry);
     void handleWindowTitleChanged(const QString &title);
-    void handleMoveRequested(KWayland::Server::SeatInterface *seat, quint32 serial);
-    void handleResizeRequested(KWayland::Server::SeatInterface *seat, quint32 serial, Qt::Edges edges);
+    void handleMoveRequested(KWaylandServer::SeatInterface *seat, quint32 serial);
+    void handleResizeRequested(KWaylandServer::SeatInterface *seat, quint32 serial, Qt::Edges edges);
     void handleMinimizeRequested();
     void handleMaximizeRequested(bool maximized);
-    void handleFullScreenRequested(bool fullScreen, KWayland::Server::OutputInterface *output);
-    void handleWindowMenuRequested(KWayland::Server::SeatInterface *seat, quint32 serial, const QPoint &surfacePos);
-    void handleGrabRequested(KWayland::Server::SeatInterface *seat, quint32 serial);
+    void handleFullScreenRequested(bool fullScreen, KWaylandServer::OutputInterface *output);
+    void handleWindowMenuRequested(KWaylandServer::SeatInterface *seat, quint32 serial, const QPoint &surfacePos);
+    void handleGrabRequested(KWaylandServer::SeatInterface *seat, quint32 serial);
     void handlePingDelayed(quint32 serial);
     void handlePingTimeout(quint32 serial);
     void handlePongReceived(quint32 serial);
     void handleCommitted();
 
 private:
     /**
      *  Called when the shell is created.
      */
     void init();
     /**
      * Called for the XDG case when the shell surface is committed to the surface.
      * At this point all initial properties should have been set by the client.
      */
     void finishInit();
     void createWindowId();
     void updateIcon();
     bool shouldExposeToWindowManagement();
     void updateClientOutputs();
-    KWayland::Server::XdgShellSurfaceInterface::States xdgSurfaceStates() const;
+    KWaylandServer::XdgShellSurfaceInterface::States xdgSurfaceStates() const;
     void updateShowOnScreenEdge();
     void updateMaximizeMode(MaximizeMode maximizeMode);
     // called on surface commit and processes all m_pendingConfigureRequests up to m_lastAckedConfigureReqest
     void updatePendingGeometry();
     QPoint popupOffset(const QRect &anchorRect, const Qt::Edges anchorEdge, const Qt::Edges gravity, const QSize popupSize) const;
     void requestGeometry(const QRect &rect);
     void doSetGeometry(const QRect &rect);
     void unmap();
     void markAsMapped();
     QRect determineBufferGeometry() const;
     void ping(PingReason reason);
     static void deleteClient(XdgShellClient *c);
 
     QRect adjustMoveGeometry(const QRect &rect) const;
     QRect adjustResizeGeometry(const QRect &rect) const;
 
-    KWayland::Server::XdgShellSurfaceInterface *m_xdgShellToplevel;
-    KWayland::Server::XdgShellPopupInterface *m_xdgShellPopup;
+    KWaylandServer::XdgShellSurfaceInterface *m_xdgShellToplevel;
+    KWaylandServer::XdgShellPopupInterface *m_xdgShellPopup;
 
     QRect m_bufferGeometry;
     QRect m_windowGeometry;
     bool m_hasWindowGeometry = false;
 
     // last size we requested or empty if we haven't sent an explicit request to the client
     // if empty the client should choose their own default size
     QSize m_requestedClientSize = QSize(0, 0);
 
     struct PendingConfigureRequest {
         //note for wl_shell we have no serial, so serialId and m_lastAckedConfigureRequest will always be 0
         //meaning we treat a surface commit as having processed all requests
         quint32 serialId = 0;
         // position to apply after a resize operation has been completed
         QPoint positionAfterResize;
         MaximizeMode maximizeMode;
     };
     QVector<PendingConfigureRequest> m_pendingConfigureRequests;
     quint32 m_lastAckedConfigureRequest = 0;
 
     //mode in use by the current buffer
     MaximizeMode m_maximizeMode = MaximizeRestore;
     //mode we currently want to be, could be pending on client updating, could be not sent yet
     MaximizeMode m_requestedMaximizeMode = MaximizeRestore;
 
     QRect m_geomFsRestore; //size and position of the window before it was set to fullscreen
     bool m_closing = false;
     quint32 m_windowId = 0;
     bool m_unmapped = true;
     NET::WindowType m_windowType = NET::Normal;
-    QPointer<KWayland::Server::PlasmaShellSurfaceInterface> m_plasmaShellSurface;
-    QPointer<KWayland::Server::AppMenuInterface> m_appMenuInterface;
-    QPointer<KWayland::Server::ServerSideDecorationPaletteInterface> m_paletteInterface;
-    KWayland::Server::ServerSideDecorationInterface *m_serverDecoration = nullptr;
-    KWayland::Server::XdgDecorationInterface *m_xdgDecoration = nullptr;
+    QPointer<KWaylandServer::PlasmaShellSurfaceInterface> m_plasmaShellSurface;
+    QPointer<KWaylandServer::AppMenuInterface> m_appMenuInterface;
+    QPointer<KWaylandServer::ServerSideDecorationPaletteInterface> m_paletteInterface;
+    KWaylandServer::ServerSideDecorationInterface *m_serverDecoration = nullptr;
+    KWaylandServer::XdgDecorationInterface *m_xdgDecoration = nullptr;
     bool m_userNoBorder = false;
     bool m_fullScreen = false;
     bool m_transient = false;
     bool m_hidden = false;
     bool m_hasPopupGrab = false;
     qreal m_opacity = 1.0;
 
     class RequestGeometryBlocker { //TODO rename ConfigureBlocker when this class is Xdg only
     public:
         RequestGeometryBlocker(XdgShellClient *client)
             : m_client(client)
         {
             m_client->m_requestGeometryBlockCounter++;
         }
         ~RequestGeometryBlocker()
         {
             m_client->m_requestGeometryBlockCounter--;
             if (m_client->m_requestGeometryBlockCounter == 0) {
                 m_client->requestGeometry(m_client->m_blockedRequestGeometry);
             }
         }
     private:
         XdgShellClient *m_client;
     };
     friend class RequestGeometryBlocker;
     int m_requestGeometryBlockCounter = 0;
     QRect m_blockedRequestGeometry;
     QString m_caption;
     QString m_captionSuffix;
     QHash<quint32, PingReason> m_pingSerials;
 
     bool m_isInitialized = false;
 
     friend class Workspace;
 };
 
 }
 
 Q_DECLARE_METATYPE(KWin::XdgShellClient *)
diff --git a/xkb.cpp b/xkb.cpp
index e21618dab..b305b7f81 100644
--- a/xkb.cpp
+++ b/xkb.cpp
@@ -1,581 +1,581 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016, 2017 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "xkb.h"
 #include "xkb_qt_mapping.h"
 #include "utils.h"
 // frameworks
 #include <KConfigGroup>
 // KWayland
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/seat_interface.h>
 // Qt
 #include <QTemporaryFile>
 #include <QKeyEvent>
 // xkbcommon
 #include <xkbcommon/xkbcommon.h>
 #include <xkbcommon/xkbcommon-compose.h>
 #include <xkbcommon/xkbcommon-keysyms.h>
 // system
 #include <sys/mman.h>
 #include <unistd.h>
 #include <bitset>
 
 Q_LOGGING_CATEGORY(KWIN_XKB, "kwin_xkbcommon", QtCriticalMsg)
 
 namespace KWin
 {
 
 static void xkbLogHandler(xkb_context *context, xkb_log_level priority, const char *format, va_list args)
 {
     Q_UNUSED(context)
     char buf[1024];
     if (std::vsnprintf(buf, 1023, format, args) <= 0) {
         return;
     }
     switch (priority) {
     case XKB_LOG_LEVEL_DEBUG:
         qCDebug(KWIN_XKB) << "XKB:" << buf;
         break;
     case XKB_LOG_LEVEL_INFO:
         qCInfo(KWIN_XKB) << "XKB:" << buf;
         break;
     case XKB_LOG_LEVEL_WARNING:
         qCWarning(KWIN_XKB) << "XKB:" << buf;
         break;
     case XKB_LOG_LEVEL_ERROR:
     case XKB_LOG_LEVEL_CRITICAL:
     default:
         qCCritical(KWIN_XKB) << "XKB:" << buf;
         break;
     }
 }
 
 Xkb::Xkb(QObject *parent)
     : QObject(parent)
     , m_context(xkb_context_new(XKB_CONTEXT_NO_FLAGS))
     , m_keymap(nullptr)
     , m_state(nullptr)
     , m_shiftModifier(0)
     , m_capsModifier(0)
     , m_controlModifier(0)
     , m_altModifier(0)
     , m_metaModifier(0)
     , m_numModifier(0)
     , m_numLock(0)
     , m_capsLock(0)
     , m_scrollLock(0)
     , m_modifiers(Qt::NoModifier)
     , m_consumedModifiers(Qt::NoModifier)
     , m_keysym(XKB_KEY_NoSymbol)
     , m_leds()
 {
     qRegisterMetaType<KWin::Xkb::LEDs>();
     if (!m_context) {
         qCDebug(KWIN_XKB) << "Could not create xkb context";
     } else {
         xkb_context_set_log_level(m_context, XKB_LOG_LEVEL_DEBUG);
         xkb_context_set_log_fn(m_context, &xkbLogHandler);
 
         // get locale as described in xkbcommon doc
         // cannot use QLocale as it drops the modifier part
         QByteArray locale = qgetenv("LC_ALL");
         if (locale.isEmpty()) {
             locale = qgetenv("LC_CTYPE");
         }
         if (locale.isEmpty()) {
             locale = qgetenv("LANG");
         }
         if (locale.isEmpty()) {
             locale = QByteArrayLiteral("C");
         }
 
         m_compose.table = xkb_compose_table_new_from_locale(m_context, locale.constData(), XKB_COMPOSE_COMPILE_NO_FLAGS);
         if (m_compose.table) {
             m_compose.state = xkb_compose_state_new(m_compose.table, XKB_COMPOSE_STATE_NO_FLAGS);
         }
     }
 }
 
 Xkb::~Xkb()
 {
     xkb_compose_state_unref(m_compose.state);
     xkb_compose_table_unref(m_compose.table);
     xkb_state_unref(m_state);
     xkb_keymap_unref(m_keymap);
     xkb_context_unref(m_context);
 }
 
 void Xkb::reconfigure()
 {
     if (!m_context) {
         return;
     }
 
     xkb_keymap *keymap = nullptr;
     if (!qEnvironmentVariableIsSet("KWIN_XKB_DEFAULT_KEYMAP")) {
         keymap = loadKeymapFromConfig();
     }
     if (!keymap) {
         qCDebug(KWIN_XKB) << "Could not create xkb keymap from configuration";
         keymap = loadDefaultKeymap();
     }
     if (keymap) {
         updateKeymap(keymap);
     } else {
         qCDebug(KWIN_XKB) << "Could not create default xkb keymap";
     }
 }
 
 static bool stringIsEmptyOrNull(const char *str)
 {
     return str == nullptr || str[0] == '\0';
 }
 
 /**
  * libxkbcommon uses secure_getenv to read the XKB_DEFAULT_* variables.
  * As kwin_wayland may have the CAP_SET_NICE capability, it returns nullptr
  * so we need to do it ourselves (see xkb_context_sanitize_rule_names).
 **/
 static void applyEnvironmentRules(xkb_rule_names &ruleNames)
 {
     if (stringIsEmptyOrNull(ruleNames.rules)) {
         ruleNames.rules = getenv("XKB_DEFAULT_RULES");
     }
 
     if (stringIsEmptyOrNull(ruleNames.model)) {
         ruleNames.model = getenv("XKB_DEFAULT_MODEL");
     }
 
     if (stringIsEmptyOrNull(ruleNames.layout)) {
         ruleNames.layout = getenv("XKB_DEFAULT_LAYOUT");
         ruleNames.variant = getenv("XKB_DEFAULT_VARIANT");
     }
 
     if (ruleNames.options == nullptr) {
         ruleNames.options = getenv("XKB_DEFAULT_OPTIONS");
     }
 }
 
 xkb_keymap *Xkb::loadKeymapFromConfig()
 {
     // load config
     if (!m_config) {
         return nullptr;
     }
     const KConfigGroup config = m_config->group("Layout");
     const QByteArray model = config.readEntry("Model", "pc104").toLocal8Bit();
     const QByteArray layout = config.readEntry("LayoutList", "").toLocal8Bit();
     const QByteArray options = config.readEntry("Options", "").toLocal8Bit();
 
     xkb_rule_names ruleNames = {
         .rules = nullptr,
         .model = model.constData(),
         .layout = layout.constData(),
         .variant = nullptr,
         .options = options.constData()
     };
     applyEnvironmentRules(ruleNames);
     return xkb_keymap_new_from_names(m_context, &ruleNames, XKB_KEYMAP_COMPILE_NO_FLAGS);
 }
 
 xkb_keymap *Xkb::loadDefaultKeymap()
 {
     xkb_rule_names ruleNames = {};
     applyEnvironmentRules(ruleNames);
     return xkb_keymap_new_from_names(m_context, &ruleNames, XKB_KEYMAP_COMPILE_NO_FLAGS);
 }
 
 void Xkb::installKeymap(int fd, uint32_t size)
 {
     if (!m_context) {
         return;
     }
     char *map = reinterpret_cast<char*>(mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0));
     if (map == MAP_FAILED) {
         return;
     }
     xkb_keymap *keymap = xkb_keymap_new_from_string(m_context, map, XKB_KEYMAP_FORMAT_TEXT_V1, XKB_MAP_COMPILE_PLACEHOLDER);
     munmap(map, size);
     if (!keymap) {
         qCDebug(KWIN_XKB) << "Could not map keymap from file";
         return;
     }
     m_ownership = Ownership::Client;
     updateKeymap(keymap);
 }
 
 void Xkb::updateKeymap(xkb_keymap *keymap)
 {
     Q_ASSERT(keymap);
     xkb_state *state = xkb_state_new(keymap);
     if (!state) {
         qCDebug(KWIN_XKB) << "Could not create XKB state";
         xkb_keymap_unref(keymap);
         return;
     }
     // now release the old ones
     xkb_state_unref(m_state);
     xkb_keymap_unref(m_keymap);
 
     m_keymap = keymap;
     m_state = state;
 
     m_shiftModifier   = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_SHIFT);
     m_capsModifier    = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CAPS);
     m_controlModifier = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CTRL);
     m_altModifier     = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_ALT);
     m_metaModifier    = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_LOGO);
     m_numModifier     = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_NUM);
 
     m_numLock         = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_NUM);
     m_capsLock        = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_CAPS);
     m_scrollLock      = xkb_keymap_led_get_index(m_keymap, XKB_LED_NAME_SCROLL);
 
     m_currentLayout = xkb_state_serialize_layout(m_state, XKB_STATE_LAYOUT_EFFECTIVE);
 
     m_modifierState.depressed = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_DEPRESSED));
     m_modifierState.latched = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LATCHED));
     m_modifierState.locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED));
 
     static bool s_startup = true;
     if (s_startup || qEnvironmentVariableIsSet("KWIN_FORCE_NUM_LOCK_EVALUATION")) {
         s_startup = false;
         if (m_ownership == Ownership::Server && m_numModifier != XKB_MOD_INVALID && m_numLockConfig) {
             const KConfigGroup config = m_numLockConfig->group("Keyboard");
             // STATE_ON = 0,  STATE_OFF = 1, STATE_UNCHANGED = 2, see plasma-desktop/kcms/keyboard/kcmmisc.h
             const auto setting = config.readEntry("NumLock", 2);
             const bool numLockIsOn = xkb_state_mod_index_is_active(m_state, m_numModifier, XKB_STATE_MODS_LOCKED);
             if ((setting == 0 && !numLockIsOn) || (setting == 1 && numLockIsOn)) {
                 std::bitset<sizeof(xkb_mod_mask_t)*8> mask{m_modifierState.locked};
                 if (mask.size() > m_numModifier) {
                     mask[m_numModifier] = (setting == 0);
                     m_modifierState.locked = mask.to_ulong();
                     xkb_state_update_mask(m_state, m_modifierState.depressed, m_modifierState.latched, m_modifierState.locked, 0, 0, m_currentLayout);
                     m_modifierState.locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED));
                 }
             }
         }
     }
 
     createKeymapFile();
     forwardModifiers();
     updateModifiers();
 }
 
 void Xkb::createKeymapFile()
 {
     if (!m_seat) {
         return;
     }
     // TODO: uninstall keymap on server?
     if (!m_keymap) {
         return;
     }
 
     ScopedCPointer<char> keymapString(xkb_keymap_get_as_string(m_keymap, XKB_KEYMAP_FORMAT_TEXT_V1));
     if (keymapString.isNull()) {
         return;
     }
     const uint size = qstrlen(keymapString.data()) + 1;
 
     QTemporaryFile *tmp = new QTemporaryFile(this);
     if (!tmp->open()) {
         delete tmp;
         return;
     }
     unlink(tmp->fileName().toUtf8().constData());
     if (!tmp->resize(size)) {
         delete tmp;
         return;
     }
     uchar *address = tmp->map(0, size);
     if (!address) {
         return;
     }
     if (qstrncpy(reinterpret_cast<char*>(address), keymapString.data(), size) == nullptr) {
         delete tmp;
         return;
     }
     m_seat->setKeymap(tmp->handle(), size);
 }
 
 void Xkb::updateModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group)
 {
     if (!m_keymap || !m_state) {
         return;
     }
     xkb_state_update_mask(m_state, modsDepressed, modsLatched, modsLocked, 0, 0, group);
     updateModifiers();
     forwardModifiers();
 }
 
 void Xkb::updateKey(uint32_t key, InputRedirection::KeyboardKeyState state)
 {
     if (!m_keymap || !m_state) {
         return;
     }
     xkb_state_update_key(m_state, key + 8, static_cast<xkb_key_direction>(state));
     if (state == InputRedirection::KeyboardKeyPressed) {
         const auto sym = toKeysym(key);
         if (m_compose.state && xkb_compose_state_feed(m_compose.state, sym) == XKB_COMPOSE_FEED_ACCEPTED) {
             switch (xkb_compose_state_get_status(m_compose.state)) {
             case XKB_COMPOSE_NOTHING:
                 m_keysym = sym;
                 break;
             case XKB_COMPOSE_COMPOSED:
                 m_keysym = xkb_compose_state_get_one_sym(m_compose.state);
                 break;
             default:
                 m_keysym = XKB_KEY_NoSymbol;
                 break;
             }
         } else {
             m_keysym = sym;
         }
     }
     updateModifiers();
     updateConsumedModifiers(key);
 }
 
 void Xkb::updateModifiers()
 {
     Qt::KeyboardModifiers mods = Qt::NoModifier;
     if (xkb_state_mod_index_is_active(m_state, m_shiftModifier, XKB_STATE_MODS_EFFECTIVE) == 1 ||
         xkb_state_mod_index_is_active(m_state, m_capsModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::ShiftModifier;
     }
     if (xkb_state_mod_index_is_active(m_state, m_altModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::AltModifier;
     }
     if (xkb_state_mod_index_is_active(m_state, m_controlModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::ControlModifier;
     }
     if (xkb_state_mod_index_is_active(m_state, m_metaModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::MetaModifier;
     }
     if (isKeypadKey(m_keysym)) {
         mods |= Qt::KeypadModifier;
     }
     m_modifiers = mods;
 
     // update LEDs
     LEDs leds;
     if (xkb_state_led_index_is_active(m_state, m_numLock) == 1) {
         leds = leds | LED::NumLock;
     }
     if (xkb_state_led_index_is_active(m_state, m_capsLock) == 1) {
         leds = leds | LED::CapsLock;
     }
     if (xkb_state_led_index_is_active(m_state, m_scrollLock) == 1) {
         leds = leds | LED::ScrollLock;
     }
     if (m_leds != leds) {
         m_leds = leds;
         emit ledsChanged(m_leds);
     }
 
     m_currentLayout = xkb_state_serialize_layout(m_state, XKB_STATE_LAYOUT_EFFECTIVE);
     m_modifierState.depressed = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_DEPRESSED));
     m_modifierState.latched = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LATCHED));
     m_modifierState.locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED));
 }
 
 void Xkb::forwardModifiers()
 {
     if (!m_seat) {
         return;
     }
     m_seat->updateKeyboardModifiers(m_modifierState.depressed,
                                                      m_modifierState.latched,
                                                      m_modifierState.locked,
                                                      m_currentLayout);
 }
 
 QString Xkb::layoutName() const
 {
     return layoutName(m_currentLayout);
 }
 
 QString Xkb::layoutName(xkb_layout_index_t layout) const
 {
     if (!m_keymap) {
         return QString{};
     }
     return QString::fromLocal8Bit(xkb_keymap_layout_get_name(m_keymap, layout));
 }
 
 QMap<xkb_layout_index_t, QString> Xkb::layoutNames() const
 {
     QMap<xkb_layout_index_t, QString> layouts;
     const auto size = m_keymap ? xkb_keymap_num_layouts(m_keymap) : 0u;
     for (xkb_layout_index_t i = 0; i < size; i++) {
         layouts.insert(i, layoutName(i));
     }
     return layouts;
 }
 
 void Xkb::updateConsumedModifiers(uint32_t key)
 {
     Qt::KeyboardModifiers mods = Qt::NoModifier;
     if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_shiftModifier, XKB_CONSUMED_MODE_GTK) == 1) {
         mods |= Qt::ShiftModifier;
     }
     if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_altModifier, XKB_CONSUMED_MODE_GTK) == 1) {
         mods |= Qt::AltModifier;
     }
     if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_controlModifier, XKB_CONSUMED_MODE_GTK) == 1) {
         mods |= Qt::ControlModifier;
     }
     if (xkb_state_mod_index_is_consumed2(m_state, key + 8, m_metaModifier, XKB_CONSUMED_MODE_GTK) == 1) {
         mods |= Qt::MetaModifier;
     }
     m_consumedModifiers = mods;
 }
 
 Qt::KeyboardModifiers Xkb::modifiersRelevantForGlobalShortcuts() const
 {
     if (!m_state) {
         return Qt::NoModifier;
     }
     Qt::KeyboardModifiers mods = Qt::NoModifier;
     if (xkb_state_mod_index_is_active(m_state, m_shiftModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::ShiftModifier;
     }
     if (xkb_state_mod_index_is_active(m_state, m_altModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::AltModifier;
     }
     if (xkb_state_mod_index_is_active(m_state, m_controlModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::ControlModifier;
     }
     if (xkb_state_mod_index_is_active(m_state, m_metaModifier, XKB_STATE_MODS_EFFECTIVE) == 1) {
         mods |= Qt::MetaModifier;
     }
 
     Qt::KeyboardModifiers consumedMods = m_consumedModifiers;
     if ((mods & Qt::ShiftModifier) && (consumedMods == Qt::ShiftModifier)) {
         // test whether current keysym is a letter
         // in that case the shift should be removed from the consumed modifiers again
         // otherwise it would not be possible to trigger e.g. Shift+W as a shortcut
         // see BUG: 370341
         if (QChar(toQtKey(m_keysym)).isLetter()) {
             consumedMods = Qt::KeyboardModifiers();
         }
     }
 
     return mods & ~consumedMods;
 }
 
 xkb_keysym_t Xkb::toKeysym(uint32_t key)
 {
     if (!m_state) {
         return XKB_KEY_NoSymbol;
     }
     return xkb_state_key_get_one_sym(m_state, key + 8);
 }
 
 QString Xkb::toString(xkb_keysym_t keysym)
 {
     if (!m_state || keysym == XKB_KEY_NoSymbol) {
         return QString();
     }
     QByteArray byteArray(7, 0);
     int ok = xkb_keysym_to_utf8(keysym, byteArray.data(), byteArray.size());
     if (ok == -1 || ok == 0) {
         return QString();
     }
     return QString::fromUtf8(byteArray.constData());
 }
 
 Qt::Key Xkb::toQtKey(xkb_keysym_t keysym) const
 {
     return xkbToQtKey(keysym);
 }
 
 xkb_keysym_t Xkb::fromQtKey(Qt::Key key, Qt::KeyboardModifiers mods) const
 {
     return qtKeyToXkb(key, mods);
 }
 
 xkb_keysym_t Xkb::fromKeyEvent(QKeyEvent *event) const
 {
     xkb_keysym_t sym = xkb_keysym_from_name(event->text().toUtf8().constData(), XKB_KEYSYM_NO_FLAGS);
     if (sym == XKB_KEY_NoSymbol) {
         // mapping from text failed, try mapping through KKeyServer
         sym = fromQtKey(Qt::Key(event->key() & ~Qt::KeyboardModifierMask), event->modifiers());
     }
     return sym;
 }
 
 bool Xkb::shouldKeyRepeat(quint32 key) const
 {
     if (!m_keymap) {
         return false;
     }
     return xkb_keymap_key_repeats(m_keymap, key + 8) != 0;
 }
 
 void Xkb::switchToNextLayout()
 {
     if (!m_keymap || !m_state) {
         return;
     }
     const xkb_layout_index_t numLayouts = xkb_keymap_num_layouts(m_keymap);
     const xkb_layout_index_t nextLayout = (xkb_state_serialize_layout(m_state, XKB_STATE_LAYOUT_EFFECTIVE) + 1) % numLayouts;
     switchToLayout(nextLayout);
 }
 
 void Xkb::switchToPreviousLayout()
 {
     if (!m_keymap || !m_state) {
         return;
     }
     const xkb_layout_index_t previousLayout = m_currentLayout == 0 ? numberOfLayouts() - 1 : m_currentLayout -1;
     switchToLayout(previousLayout);
 }
 
 void Xkb::switchToLayout(xkb_layout_index_t layout)
 {
     if (!m_keymap || !m_state) {
         return;
     }
     if (layout >= numberOfLayouts()) {
         return;
     }
     const xkb_mod_mask_t depressed = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_DEPRESSED));
     const xkb_mod_mask_t latched = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LATCHED));
     const xkb_mod_mask_t locked = xkb_state_serialize_mods(m_state, xkb_state_component(XKB_STATE_MODS_LOCKED));
     xkb_state_update_mask(m_state, depressed, latched, locked, 0, 0, layout);
     updateModifiers();
     forwardModifiers();
 }
 
 quint32 Xkb::numberOfLayouts() const
 {
     if (!m_keymap) {
         return 0;
     }
     return xkb_keymap_num_layouts(m_keymap);
 }
 
-void Xkb::setSeat(KWayland::Server::SeatInterface *seat)
+void Xkb::setSeat(KWaylandServer::SeatInterface *seat)
 {
-    m_seat = QPointer<KWayland::Server::SeatInterface>(seat);
+    m_seat = QPointer<KWaylandServer::SeatInterface>(seat);
 }
 
 }
diff --git a/xkb.h b/xkb.h
index d37c6054f..8df68f0f3 100644
--- a/xkb.h
+++ b/xkb.h
@@ -1,179 +1,176 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2013, 2016, 2017 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XKB_H
 #define KWIN_XKB_H
 #include "input.h"
 
 #include <kwin_export.h>
 
 #include <KSharedConfig>
 
 #include <QLoggingCategory>
 Q_DECLARE_LOGGING_CATEGORY(KWIN_XKB)
 
 struct xkb_context;
 struct xkb_keymap;
 struct xkb_state;
 struct xkb_compose_table;
 struct xkb_compose_state;
 typedef uint32_t xkb_mod_index_t;
 typedef uint32_t xkb_led_index_t;
 typedef uint32_t xkb_keysym_t;
 typedef uint32_t xkb_layout_index_t;
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
     class SeatInterface;
 }
-}
 
 namespace KWin
 {
 
 class KWIN_EXPORT Xkb : public QObject
 {
     Q_OBJECT
 public:
     Xkb(QObject *parent = nullptr);
     ~Xkb() override;
     void setConfig(KSharedConfigPtr config) {
         m_config = std::move(config);
     }
     void setNumLockConfig(KSharedConfigPtr config) {
         m_numLockConfig = std::move(config);
     }
     void reconfigure();
 
     void installKeymap(int fd, uint32_t size);
     void updateModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     void updateKey(uint32_t key, InputRedirection::KeyboardKeyState state);
     xkb_keysym_t toKeysym(uint32_t key);
     xkb_keysym_t currentKeysym() const {
         return m_keysym;
     }
     QString toString(xkb_keysym_t keysym);
     Qt::Key toQtKey(xkb_keysym_t keysym) const;
     xkb_keysym_t fromQtKey(Qt::Key key, Qt::KeyboardModifiers mods) const;
     xkb_keysym_t fromKeyEvent(QKeyEvent *event) const;
     Qt::KeyboardModifiers modifiers() const;
     Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() const;
     bool shouldKeyRepeat(quint32 key) const;
 
     void switchToNextLayout();
     void switchToPreviousLayout();
     void switchToLayout(xkb_layout_index_t layout);
 
     enum class LED {
         NumLock = 1 << 0,
         CapsLock = 1 << 1,
         ScrollLock = 1 << 2
     };
     Q_DECLARE_FLAGS(LEDs, LED)
     LEDs leds() const {
         return m_leds;
     }
 
     xkb_keymap *keymap() const {
         return m_keymap;
     }
 
     xkb_state *state() const {
         return m_state;
     }
 
     quint32 currentLayout() const {
         return m_currentLayout;
     }
     QString layoutName() const;
     QMap<xkb_layout_index_t, QString> layoutNames() const;
     quint32 numberOfLayouts() const;
 
     /**
      * Forwards the current modifier state to the Wayland seat
      */
     void forwardModifiers();
 
-    void setSeat(KWayland::Server::SeatInterface *seat);
+    void setSeat(KWaylandServer::SeatInterface *seat);
 
 Q_SIGNALS:
     void ledsChanged(const LEDs &leds);
 
 private:
     xkb_keymap *loadKeymapFromConfig();
     xkb_keymap *loadDefaultKeymap();
     void updateKeymap(xkb_keymap *keymap);
     void createKeymapFile();
     void updateModifiers();
     void updateConsumedModifiers(uint32_t key);
     QString layoutName(xkb_layout_index_t layout) const;
     xkb_context *m_context;
     xkb_keymap *m_keymap;
     xkb_state *m_state;
     xkb_mod_index_t m_shiftModifier;
     xkb_mod_index_t m_capsModifier;
     xkb_mod_index_t m_controlModifier;
     xkb_mod_index_t m_altModifier;
     xkb_mod_index_t m_metaModifier;
     xkb_mod_index_t m_numModifier;
     xkb_led_index_t m_numLock;
     xkb_led_index_t m_capsLock;
     xkb_led_index_t m_scrollLock;
     Qt::KeyboardModifiers m_modifiers;
     Qt::KeyboardModifiers m_consumedModifiers;
     xkb_keysym_t m_keysym;
     quint32 m_currentLayout = 0;
 
     struct {
         xkb_compose_table *table = nullptr;
         xkb_compose_state *state = nullptr;
     } m_compose;
     LEDs m_leds;
     KSharedConfigPtr m_config;
     KSharedConfigPtr m_numLockConfig;
 
     struct {
         xkb_mod_index_t depressed = 0;
         xkb_mod_index_t latched = 0;
         xkb_mod_index_t locked = 0;
     } m_modifierState;
 
     enum class Ownership {
         Server,
         Client
     };
     Ownership m_ownership = Ownership::Server;
 
-    QPointer<KWayland::Server::SeatInterface> m_seat;
+    QPointer<KWaylandServer::SeatInterface> m_seat;
 };
 
 inline
 Qt::KeyboardModifiers Xkb::modifiers() const
 {
     return m_modifiers;
 }
 
 }
 
 Q_DECLARE_METATYPE(KWin::Xkb::LED)
 Q_DECLARE_METATYPE(KWin::Xkb::LEDs)
 
 #endif
diff --git a/xwl/clipboard.cpp b/xwl/clipboard.cpp
index 3ba6ae36f..d64dd1b95 100644
--- a/xwl/clipboard.cpp
+++ b/xwl/clipboard.cpp
@@ -1,192 +1,192 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "clipboard.h"
 
 #include "databridge.h"
 #include "selection_source.h"
 #include "transfer.h"
 #include "xwayland.h"
 
 #include "x11client.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/datadevice.h>
 #include <KWayland/Client/datasource.h>
 
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/datasource_interface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/datasource_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <xcb/xcb_event.h>
 #include <xcb/xfixes.h>
 
 #include <xwayland_logging.h>
 
 namespace KWin
 {
 namespace Xwl
 {
 
 Clipboard::Clipboard(xcb_atom_t atom, QObject *parent)
     : Selection(atom, parent)
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
     const uint32_t clipboardValues[] = { XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
                                    XCB_EVENT_MASK_PROPERTY_CHANGE };
     xcb_create_window(xcbConn,
                       XCB_COPY_FROM_PARENT,
                       window(),
                       kwinApp()->x11RootWindow(),
                       0, 0,
                       10, 10,
                       0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT,
                       Xwayland::self()->xcbScreen()->root_visual,
                       XCB_CW_EVENT_MASK,
                       clipboardValues);
     registerXfixes();
     xcb_flush(xcbConn);
 
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::selectionChanged,
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::selectionChanged,
             this, &Clipboard::wlSelectionChanged);
 }
 
-void Clipboard::wlSelectionChanged(KWayland::Server::DataDeviceInterface *ddi)
+void Clipboard::wlSelectionChanged(KWaylandServer::DataDeviceInterface *ddi)
 {
     if (ddi && ddi != DataBridge::self()->dataDeviceIface()) {
         // Wayland native client provides new selection
         if (!m_checkConnection) {
             m_checkConnection = connect(workspace(), &Workspace::clientActivated,
                                         this, [this](AbstractClient *ac) {
                                             Q_UNUSED(ac);
                                             checkWlSource();
                                         });
         }
         // remove previous source so checkWlSource() can create a new one
         setWlSource(nullptr);
     }
     checkWlSource();
 }
 
 void Clipboard::checkWlSource()
 {
     auto ddi = waylandServer()->seat()->selection();
     auto removeSource = [this] {
         if (wlSource()) {
             setWlSource(nullptr);
             ownSelection(false);
         }
     };
 
     // Wayland source gets created when:
     // - the Wl selection exists,
     // - its source is not Xwayland,
     // - a client is active,
     // - this client is an Xwayland one.
     //
     // Otherwise the Wayland source gets destroyed to shield
     // against snooping X clients.
 
     if (!ddi || DataBridge::self()->dataDeviceIface() == ddi) {
         // Xwayland source or no source
         disconnect(m_checkConnection);
         m_checkConnection = QMetaObject::Connection();
         removeSource();
         return;
     }
     if (!workspace()->activeClient() || !workspace()->activeClient()->inherits("KWin::X11Client")) {
         // no active client or active client is Wayland native
         removeSource();
         return;
     }
     // Xwayland client is active and we need a Wayland source
     if (wlSource()) {
         // source already exists, nothing more to do
         return;
     }
     auto *wls = new WlSource(this, ddi);
     setWlSource(wls);
     auto *dsi = ddi->selection();
     if (dsi) {
         wls->setDataSourceIface(dsi);
     }
-    connect(ddi, &KWayland::Server::DataDeviceInterface::selectionChanged,
+    connect(ddi, &KWaylandServer::DataDeviceInterface::selectionChanged,
             wls, &WlSource::setDataSourceIface);
     ownSelection(true);
 }
 
 void Clipboard::doHandleXfixesNotify(xcb_xfixes_selection_notify_event_t *event)
 {
     createX11Source(nullptr);
 
     const AbstractClient *client = workspace()->activeClient();
     if (!qobject_cast<const X11Client *>(client)) {
         // clipboard is only allowed to be acquired when Xwayland has focus
         // TODO: can we make this stronger (window id comparison)?
         return;
     }
 
     createX11Source(event);
 
     if (X11Source *source = x11Source()) {
         source->getTargets();
     }
 }
 
 void Clipboard::x11OffersChanged(const QStringList &added, const QStringList &removed)
 {
     X11Source *source = x11Source();
     if (!source) {
         return;
     }
 
     const Mimes offers = source->offers();
 
     if (!offers.isEmpty()) {
         if (!source->dataSource() || !removed.isEmpty()) {
             // create new Wl DataSource if there is none or when types
             // were removed (Wl Data Sources can only add types)
             KWayland::Client::DataDeviceManager *dataDeviceManager =
                 waylandServer()->internalDataDeviceManager();
             KWayland::Client::DataSource *dataSource =
                 dataDeviceManager->createDataSource(source);
 
             // also offers directly the currently available types
             source->setDataSource(dataSource);
             DataBridge::self()->dataDevice()->setSelection(0, dataSource);
             waylandServer()->seat()->setSelection(DataBridge::self()->dataDeviceIface());
         } else if (auto *dataSource = source->dataSource()) {
             for (const QString &mime : added) {
                 dataSource->offer(mime);
             }
         }
     } else {
         waylandServer()->seat()->setSelection(nullptr);
     }
 
     waylandServer()->internalClientConection()->flush();
     waylandServer()->dispatch();
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/clipboard.h b/xwl/clipboard.h
index 1c9eac4d9..45aa6ef9c 100644
--- a/xwl/clipboard.h
+++ b/xwl/clipboard.h
@@ -1,70 +1,67 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_CLIPBOARD
 #define KWIN_XWL_CLIPBOARD
 
 #include "selection.h"
 
-namespace KWayland
-{
-namespace Server
+namespace KWaylandServer
 {
 class DataDeviceInterface;
 }
-}
 
 namespace KWin
 {
 namespace Xwl
 {
 
 /**
  * Represents the X clipboard, which is on Wayland side just called
  * @e selection.
  */
 class Clipboard : public Selection
 {
     Q_OBJECT
 
 public:
     Clipboard(xcb_atom_t atom, QObject *parent);
 
 private:
     void doHandleXfixesNotify(xcb_xfixes_selection_notify_event_t *event) override;
     void x11OffersChanged(const QStringList &added, const QStringList &removed) override;
     /**
      * React to Wl selection change.
      */
-    void wlSelectionChanged(KWayland::Server::DataDeviceInterface *ddi);
+    void wlSelectionChanged(KWaylandServer::DataDeviceInterface *ddi);
     /**
      * Check the current state of the selection and if a source needs
      * to be created or destroyed.
      */
     void checkWlSource();
 
     QMetaObject::Connection m_checkConnection;
 
     Q_DISABLE_COPY(Clipboard)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif
diff --git a/xwl/databridge.cpp b/xwl/databridge.cpp
index bf2b3f6a7..32e0d70fd 100644
--- a/xwl/databridge.cpp
+++ b/xwl/databridge.cpp
@@ -1,135 +1,135 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2018 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "databridge.h"
 #include "clipboard.h"
 #include "dnd.h"
 #include "selection.h"
 #include "xwayland.h"
 
 #include "abstract_client.h"
 #include "atoms.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/datadevicemanager.h>
 #include <KWayland/Client/seat.h>
 
-#include <KWayland/Server/datadevicemanager_interface.h>
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/datadevicemanager_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 using namespace KWayland::Client;
-using namespace KWayland::Server;
+using namespace KWaylandServer;
 
 namespace KWin
 {
 namespace Xwl
 {
 
 static DataBridge *s_self = nullptr;
 
 DataBridge *DataBridge::self()
 {
     return s_self;
 }
 
 DataBridge::DataBridge(QObject *parent)
     : QObject(parent)
 {
     s_self = this;
 
     DataDeviceManager *dataDeviceManager = waylandServer()->internalDataDeviceManager();
     Seat *seat = waylandServer()->internalSeat();
     m_dataDevice = dataDeviceManager->getDataDevice(seat, this);
     waylandServer()->dispatch();
 
     const DataDeviceManagerInterface *dataDeviceManagerInterface =
         waylandServer()->dataDeviceManager();
 
     auto *dc = new QMetaObject::Connection();
     *dc = connect(dataDeviceManagerInterface, &DataDeviceManagerInterface::dataDeviceCreated, this,
         [this, dc](DataDeviceInterface *dataDeviceInterface) {
             if (m_dataDeviceInterface) {
                 return;
             }
             if (dataDeviceInterface->client() != waylandServer()->internalConnection()) {
                 return;
             }
             QObject::disconnect(*dc);
             delete dc;
             m_dataDeviceInterface = dataDeviceInterface;
             init();
         }
     );
 }
 
 DataBridge::~DataBridge()
 {
     s_self = nullptr;
 }
 
 void DataBridge::init()
 {
     m_clipboard = new Clipboard(atoms->clipboard, this);
     m_dnd = new Dnd(atoms->xdnd_selection, this);
     waylandServer()->dispatch();
 }
 
 bool DataBridge::filterEvent(xcb_generic_event_t *event)
 {
     if (m_clipboard->filterEvent(event)) {
         return true;
     }
     if (m_dnd->filterEvent(event)) {
         return true;
     }
     if (event->response_type - Xwayland::self()->xfixes()->first_event == XCB_XFIXES_SELECTION_NOTIFY) {
         return handleXfixesNotify((xcb_xfixes_selection_notify_event_t *)event);
     }
     return false;
 }
 
 bool DataBridge::handleXfixesNotify(xcb_xfixes_selection_notify_event_t *event)
 {
     Selection *selection = nullptr;
 
     if (event->selection == atoms->clipboard) {
         selection = m_clipboard;
     } else if (event->selection == atoms->xdnd_selection) {
         selection = m_dnd;
     }
 
     if (!selection) {
         return false;
     }
 
     return selection->handleXfixesNotify(event);
 }
 
 DragEventReply DataBridge::dragMoveFilter(Toplevel *target, const QPoint &pos)
 {
     if (!m_dnd) {
         return DragEventReply::Wayland;
     }
     return m_dnd->dragMoveFilter(target, pos);
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/databridge.h b/xwl/databridge.h
index d4b86c331..23b34dba1 100644
--- a/xwl/databridge.h
+++ b/xwl/databridge.h
@@ -1,104 +1,104 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2018 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_DATABRIDGE
 #define KWIN_XWL_DATABRIDGE
 
 #include <QObject>
 #include <QPoint>
 
 #include <xcb/xcb.h>
 
 struct xcb_xfixes_selection_notify_event_t;
 
 namespace KWayland
 {
 namespace Client
 {
 class DataDevice;
 }
-namespace Server
+}
+namespace KWaylandServer
 {
 class DataDeviceInterface;
 class SurfaceInterface;
 }
-}
 
 namespace KWin
 {
 class Toplevel;
 
 namespace Xwl
 {
 class Xwayland;
 class Clipboard;
 class Dnd;
 enum class DragEventReply;
 
 /**
  * Interface class for all data sharing in the context of X selections
  * and Wayland's internal mechanism.
  *
  * Exists only once per Xwayland session.
  */
 class DataBridge : public QObject
 {
     Q_OBJECT
 
 public:
     static DataBridge *self();
 
     explicit DataBridge(QObject *parent = nullptr);
     ~DataBridge() override;
 
     bool filterEvent(xcb_generic_event_t *event);
     DragEventReply dragMoveFilter(Toplevel *target, const QPoint &pos);
 
     KWayland::Client::DataDevice *dataDevice() const
     {
         return m_dataDevice;
     }
-    KWayland::Server::DataDeviceInterface *dataDeviceIface() const
+    KWaylandServer::DataDeviceInterface *dataDeviceIface() const
     {
         return m_dataDeviceInterface;
     }
     Dnd *dnd() const
     {
         return m_dnd;
     }
 
 private:
     void init();
 
     bool handleXfixesNotify(xcb_xfixes_selection_notify_event_t *event);
 
     Clipboard *m_clipboard = nullptr;
     Dnd *m_dnd = nullptr;
 
     /* Internal data device interface */
     KWayland::Client::DataDevice *m_dataDevice = nullptr;
-    KWayland::Server::DataDeviceInterface *m_dataDeviceInterface = nullptr;
+    KWaylandServer::DataDeviceInterface *m_dataDeviceInterface = nullptr;
 
     Q_DISABLE_COPY(DataBridge)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif
diff --git a/xwl/dnd.cpp b/xwl/dnd.cpp
index 469641115..c97f7ebe6 100644
--- a/xwl/dnd.cpp
+++ b/xwl/dnd.cpp
@@ -1,229 +1,229 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "dnd.h"
 
 #include "databridge.h"
 #include "drag_wl.h"
 #include "drag_x.h"
 #include "selection_source.h"
 
 #include "abstract_client.h"
 #include "atoms.h"
 #include "wayland_server.h"
 #include "workspace.h"
 #include "xwayland.h"
 
 #include <KWayland/Client/compositor.h>
 #include <KWayland/Client/surface.h>
 
-#include <KWayland/Server/compositor_interface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/compositor_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <QMouseEvent>
 
 #include <xcb/xcb.h>
 
 namespace KWin
 {
 namespace Xwl
 {
 
 // version of DnD support in X
 const static uint32_t s_version = 5;
 uint32_t Dnd::version()
 {
     return s_version;
 }
 
 Dnd::Dnd(xcb_atom_t atom, QObject *parent)
     : Selection(atom, parent)
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
     const uint32_t dndValues[] = { XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
                                    XCB_EVENT_MASK_PROPERTY_CHANGE };
     xcb_create_window(xcbConn,
                       XCB_COPY_FROM_PARENT,
                       window(),
                       kwinApp()->x11RootWindow(),
                       0, 0,
                       8192, 8192,           // TODO: get current screen size and connect to changes
                       0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT,
                       Xwayland::self()->xcbScreen()->root_visual,
                       XCB_CW_EVENT_MASK,
                       dndValues);
     registerXfixes();
 
     xcb_change_property(xcbConn,
                         XCB_PROP_MODE_REPLACE,
                         window(),
                         atoms->xdnd_aware,
                         XCB_ATOM_ATOM,
                         32, 1, &s_version);
     xcb_flush(xcbConn);
 
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragStarted, this, &Dnd::startDrag);
-    connect(waylandServer()->seat(), &KWayland::Server::SeatInterface::dragEnded, this, &Dnd::endDrag);
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::dragStarted, this, &Dnd::startDrag);
+    connect(waylandServer()->seat(), &KWaylandServer::SeatInterface::dragEnded, this, &Dnd::endDrag);
 
     const auto *comp = waylandServer()->compositor();
     m_surface = waylandServer()->internalCompositor()->createSurface(this);
     m_surface->setInputRegion(nullptr);
     m_surface->commit(KWayland::Client::Surface::CommitFlag::None);
     auto *dc = new QMetaObject::Connection();
-    *dc = connect(comp, &KWayland::Server::CompositorInterface::surfaceCreated, this,
-                 [this, dc](KWayland::Server::SurfaceInterface *si) {
+    *dc = connect(comp, &KWaylandServer::CompositorInterface::surfaceCreated, this,
+                 [this, dc](KWaylandServer::SurfaceInterface *si) {
                     // TODO: how to make sure that it is the iface of m_surface?
                     if (m_surfaceIface || si->client() != waylandServer()->internalConnection()) {
                         return;
                     }
                     QObject::disconnect(*dc);
                     delete dc;
                     m_surfaceIface = si;
                     connect(workspace(), &Workspace::clientActivated, this,
                         [this](AbstractClient *ac) {
                             if (!ac || !ac->inherits("KWin::X11Client")) {
                                 return;
                             }
                             auto *surface = ac->surface();
                             if (surface) {
                                 surface->setDataProxy(m_surfaceIface);
                             } else {
                                 auto *dc = new QMetaObject::Connection();
                                 *dc = connect(ac, &AbstractClient::surfaceChanged, this, [this, ac, dc] {
                                         if (auto *surface = ac->surface()) {
                                             surface->setDataProxy(m_surfaceIface);
                                             QObject::disconnect(*dc);
                                             delete dc;
                                         }
                                       }
                                 );
                             }
                     });
                 }
     );
     waylandServer()->dispatch();
 }
 
 void Dnd::doHandleXfixesNotify(xcb_xfixes_selection_notify_event_t *event)
 {
     if (qobject_cast<XToWlDrag *>(m_currentDrag)) {
         // X drag is in progress, rogue X client took over the selection.
         return;
     }
     if (m_currentDrag) {
         // Wl drag is in progress - don't overwrite by rogue X client,
         // get it back instead!
         ownSelection(true);
         return;
     }
     createX11Source(nullptr);
     const auto *seat = waylandServer()->seat();
     auto *originSurface = seat->focusedPointerSurface();
     if (!originSurface) {
         return;
     }
     if (originSurface->client() != waylandServer()->xWaylandConnection()) {
         // focused surface client is not Xwayland - do not allow drag to start
         // TODO: can we make this stronger (window id comparison)?
         return;
     }
     if (!seat->isPointerButtonPressed(Qt::LeftButton)) {
         // we only allow drags to be started on (left) pointer button being
         // pressed for now
         return;
     }
     createX11Source(event);
     X11Source *source = x11Source();
     if (!source) {
         return;
     }
     DataBridge::self()->dataDeviceIface()->updateProxy(originSurface);
     m_currentDrag = new XToWlDrag(source);
 }
 
 void Dnd::x11OffersChanged(const QStringList &added, const QStringList &removed)
 {
     Q_UNUSED(added);
     Q_UNUSED(removed);
     // TODO: handled internally
 }
 
 bool Dnd::handleClientMessage(xcb_client_message_event_t *event)
 {
     for (Drag *drag : m_oldDrags) {
         if (drag->handleClientMessage(event)) {
             return true;
         }
     }
     if (m_currentDrag && m_currentDrag->handleClientMessage(event)) {
         return true;
     }
     return false;
 }
 
 DragEventReply Dnd::dragMoveFilter(Toplevel *target, const QPoint &pos)
 {
     // This filter only is used when a drag is in process.
     Q_ASSERT(m_currentDrag);
     return m_currentDrag->moveFilter(target, pos);
 }
 
 void Dnd::startDrag()
 {
     auto *ddi = waylandServer()->seat()->dragSource();
     if (ddi == DataBridge::self()->dataDeviceIface()) {
         // X to Wl drag, started by us, is in progress.
         Q_ASSERT(m_currentDrag);
         return;
     }
 
     // There can only ever be one Wl native drag at the same time.
     Q_ASSERT(!m_currentDrag);
 
     // New Wl to X drag, init drag and Wl source.
     m_currentDrag = new WlToXDrag();
     auto source = new WlSource(this, ddi);
     source->setDataSourceIface(ddi->dragSource());
     setWlSource(source);
     ownSelection(true);
 }
 
 void Dnd::endDrag()
 {
     Q_ASSERT(m_currentDrag);
 
     if (m_currentDrag->end()) {
         delete m_currentDrag;
     } else {
         connect(m_currentDrag, &Drag::finish, this, &Dnd::clearOldDrag);
         m_oldDrags << m_currentDrag;
     }
     m_currentDrag = nullptr;
 }
 
 void Dnd::clearOldDrag(Drag *drag)
 {
     m_oldDrags.removeOne(drag);
     delete drag;
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/dnd.h b/xwl/dnd.h
index 01fcc801b..73ec07177 100644
--- a/xwl/dnd.h
+++ b/xwl/dnd.h
@@ -1,93 +1,93 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_DND
 #define KWIN_XWL_DND
 
 #include "selection.h"
 
 #include <QPoint>
 
 namespace KWayland
 {
 namespace Client
 {
 class Surface;
 }
-namespace Server
+}
+namespace KWaylandServer
 {
 class SurfaceInterface;
 }
-}
 
 namespace KWin
 {
 class Toplevel;
 
 namespace Xwl
 {
 class Drag;
 enum class DragEventReply;
 
 /**
  * Represents the drag and drop mechanism, on X side this is the XDND protocol.
  * For more information on XDND see: https://johnlindal.wixsite.com/xdnd
  */
 class Dnd : public Selection
 {
     Q_OBJECT
 
 public:
     explicit Dnd(xcb_atom_t atom, QObject *parent);
 
     static uint32_t version();
 
     void doHandleXfixesNotify(xcb_xfixes_selection_notify_event_t *event) override;
     void x11OffersChanged(const QStringList &added, const QStringList &removed) override;
     bool handleClientMessage(xcb_client_message_event_t *event) override;
 
     DragEventReply dragMoveFilter(Toplevel *target, const QPoint &pos);
 
-    KWayland::Server::SurfaceInterface *surfaceIface() const {
+    KWaylandServer::SurfaceInterface *surfaceIface() const {
         return m_surfaceIface;
     }
     KWayland::Client::Surface *surface() const {
         return m_surface;
     }
 
 private:
     // start and end Wl native client drags (Wl -> Xwl)
     void startDrag();
     void endDrag();
     void clearOldDrag(Drag *drag);
 
     // active drag or null when no drag active
     Drag *m_currentDrag = nullptr;
     QVector<Drag *> m_oldDrags;
 
     KWayland::Client::Surface *m_surface;
-    KWayland::Server::SurfaceInterface *m_surfaceIface = nullptr;
+    KWaylandServer::SurfaceInterface *m_surfaceIface = nullptr;
 
     Q_DISABLE_COPY(Dnd)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif
diff --git a/xwl/drag_wl.cpp b/xwl/drag_wl.cpp
index 1052ebc83..c26ee2197 100644
--- a/xwl/drag_wl.cpp
+++ b/xwl/drag_wl.cpp
@@ -1,446 +1,446 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "drag_wl.h"
 
 #include "databridge.h"
 #include "dnd.h"
 #include "xwayland.h"
 
 #include "atoms.h"
 #include "x11client.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/datadevice.h>
 #include <KWayland/Client/datasource.h>
 
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/datasource_interface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/datasource_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <QMouseEvent>
 #include <QTimer>
 
 namespace KWin
 {
 namespace Xwl
 {
 
 WlToXDrag::WlToXDrag()
 {
     m_dsi = waylandServer()->seat()->dragSource()->dragSource();
 }
 
 DragEventReply WlToXDrag::moveFilter(Toplevel *target, const QPoint &pos)
 {
     AbstractClient *ac = qobject_cast<AbstractClient *>(target);
     auto *seat = waylandServer()->seat();
     if (m_visit && m_visit->target() == ac) {
         // no target change
         return DragEventReply::Take;
     }
     // leave current target
     if (m_visit) {
         seat->setDragTarget(nullptr);
         m_visit->leave();
         delete m_visit;
         m_visit = nullptr;
     }
     if (!qobject_cast<X11Client *>(ac)) {
         // no target or wayland native target,
         // handled by input code directly
         return DragEventReply::Wayland;
     }
     // new target
     workspace()->activateClient(ac, false);
     seat->setDragTarget(DataBridge::self()->dnd()->surfaceIface(), pos, ac->inputTransformation());
     m_visit = new Xvisit(this, ac);
     return DragEventReply::Take;
 }
 
 bool WlToXDrag::handleClientMessage(xcb_client_message_event_t *event)
 {
     if (m_visit && m_visit->handleClientMessage(event)) {
         return true;
     }
     return false;
 }
 
 bool WlToXDrag::end()
 {
     if (!m_visit || m_visit->finished()) {
         delete m_visit;
         m_visit = nullptr;
         return true;
     }
     connect(m_visit, &Xvisit::finish, this, [this](Xvisit *visit) {
         Q_ASSERT(m_visit == visit);
         delete visit;
         m_visit = nullptr;
         // we direclty allow to delete previous visits
         Q_EMIT finish(this);
     });
     return false;
 }
 
 Xvisit::Xvisit(WlToXDrag *drag, AbstractClient *target)
     : QObject(drag),
       m_drag(drag),
       m_target(target)
 {
     // first check supported DND version
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     xcb_get_property_cookie_t cookie = xcb_get_property(xcbConn,
                                                         0,
                                                         m_target->window(),
                                                         atoms->xdnd_aware,
                                                         XCB_GET_PROPERTY_TYPE_ANY,
                                                         0, 1);
     auto *reply = xcb_get_property_reply(xcbConn, cookie, nullptr);
     if (!reply) {
         doFinish();
         return;
     }
     if (reply->type != XCB_ATOM_ATOM) {
         doFinish();
         free(reply);
         return;
     }
     xcb_atom_t *value = static_cast<xcb_atom_t *>(xcb_get_property_value(reply));
     m_version = qMin(*value, Dnd::version());
     if (m_version < 1) {
         // minimal version we accept is 1
         doFinish();
         free(reply);
         return;
     }
     free(reply);
 
     const auto *dd = DataBridge::self()->dataDevice();
     // proxy drop
     m_enterConnection = connect(dd, &KWayland::Client::DataDevice::dragEntered,
                          this, &Xvisit::receiveOffer);
     m_dropConnection = connect(dd, &KWayland::Client::DataDevice::dropped,
                         this, &Xvisit::drop);
 }
 
 bool Xvisit::handleClientMessage(xcb_client_message_event_t *event)
 {
     if (event->type == atoms->xdnd_status) {
         return handleStatus(event);
     } else if (event->type == atoms->xdnd_finished) {
         return handleFinished(event);
     }
     return false;
 }
 
 bool Xvisit::handleStatus(xcb_client_message_event_t *event)
 {
     xcb_client_message_data_t *data = &event->data;
     if (data->data32[0] != m_target->window()) {
         // wrong target window
         return false;
     }
 
     m_accepts = data->data32[1] & 1;
     xcb_atom_t actionAtom = data->data32[4];
 
     // TODO: we could optimize via rectangle in data32[2] and data32[3]
 
     // position round trip finished
     m_pos.pending = false;
 
     if (!m_state.dropped) {
         // as long as the drop is not yet done determine requested action
         m_preferredAction = Drag::atomToClientAction(actionAtom);
         determineProposedAction();
         requestDragAndDropAction();
     }
 
     if (m_pos.cached) {
         // send cached position
         m_pos.cached = false;
         sendPosition(m_pos.cache);
     } else if (m_state.dropped) {
         // drop was done in between, now close it out
         drop();
     }
     return true;
 }
 
 bool Xvisit::handleFinished(xcb_client_message_event_t *event)
 {
     xcb_client_message_data_t *data = &event->data;
 
     if (data->data32[0] != m_target->window()) {
         // different target window
         return false;
     }
 
     if (!m_state.dropped) {
         // drop was never done
         doFinish();
         return true;
     }
 
     const bool success = m_version > 4 ? data->data32[1] & 1 : true;
     const xcb_atom_t usedActionAtom = m_version > 4 ? data->data32[2] :
                                                       static_cast<uint32_t>(XCB_ATOM_NONE);
     Q_UNUSED(success);
     Q_UNUSED(usedActionAtom);
 
     // data offer might have been deleted already by the DataDevice
     if (!m_dataOffer.isNull()) {
         m_dataOffer->dragAndDropFinished();
         delete m_dataOffer;
         m_dataOffer = nullptr;
     }
     doFinish();
     return true;
 }
 
 void Xvisit::sendPosition(const QPointF &globalPos)
 {
     const int16_t x = globalPos.x();
     const int16_t y = globalPos.y();
 
     if (m_pos.pending) {
         m_pos.cache = QPoint(x, y);
         m_pos.cached = true;
         return;
     }
     m_pos.pending = true;
 
     xcb_client_message_data_t data = {0};
     data.data32[0] = DataBridge::self()->dnd()->window();
     data.data32[2] = (x << 16) | y;
     data.data32[3] = XCB_CURRENT_TIME;
     data.data32[4] = Drag::clientActionToAtom(m_proposedAction);
 
     Drag::sendClientMessage(m_target->window(), atoms->xdnd_position, &data);
 }
 
 void Xvisit::leave()
 {
     Q_ASSERT(!m_state.dropped);
     if (m_state.finished) {
         // was already finished
         return;
     }
     // we only need to leave, when we entered before
     if (m_state.entered) {
         sendLeave();
     }
     doFinish();
 }
 
 void Xvisit::receiveOffer()
 {
     if (m_state.finished) {
         // already ended
         return;
     }
 
     Q_ASSERT(m_dataOffer.isNull());
     m_dataOffer = DataBridge::self()->dataDevice()->dragOffer();
     Q_ASSERT(!m_dataOffer.isNull());
 
     retrieveSupportedActions();
     m_actionConnection = connect(m_dataOffer, &KWayland::Client::DataOffer::sourceDragAndDropActionsChanged,
                           this, &Xvisit::retrieveSupportedActions);
     enter();
 }
 
 void Xvisit::enter()
 {
     m_state.entered = true;
     // send enter event and current position to X client
     sendEnter();
     sendPosition(waylandServer()->seat()->pointerPos());
 
     // proxy future pointer position changes
     m_motionConnection = connect(waylandServer()->seat(),
-                          &KWayland::Server::SeatInterface::pointerPosChanged,
+                          &KWaylandServer::SeatInterface::pointerPosChanged,
                           this, &Xvisit::sendPosition);
 }
 
 void Xvisit::sendEnter()
 {
     xcb_client_message_data_t data = {0};
     data.data32[0] = DataBridge::self()->dnd()->window();
     data.data32[1] = m_version << 24;
 
     // TODO: replace this with the mime type getter from m_dataOffer,
     // then we can get rid of m_drag.
     const auto mimeTypesNames = m_drag->dataSourceIface()->mimeTypes();
     const int mimesCount = mimeTypesNames.size();
     size_t cnt = 0;
     size_t totalCnt = 0;
     for (const auto mimeName : mimeTypesNames) {
         // 3 mimes and less can be sent directly in the XdndEnter message
         if (totalCnt == 3) {
             break;
         }
         const auto atom = Selection::mimeTypeToAtom(mimeName);
 
         if (atom != XCB_ATOM_NONE) {
             data.data32[cnt + 2] = atom;
             cnt++;
         }
         totalCnt++;
     }
     for (int i = cnt; i < 4; i++) {
         data.data32[i + 2] = XCB_ATOM_NONE;
     }
 
     if (mimesCount > 3) {
         // need to first transfer all available mime types
         data.data32[1] |= 1;
 
         QVector<xcb_atom_t> targets;
         targets.resize(mimesCount);
 
         size_t cnt = 0;
         for (const auto mimeName : mimeTypesNames) {
             const auto atom = Selection::mimeTypeToAtom(mimeName);
             if (atom != XCB_ATOM_NONE) {
                 targets[cnt] = atom;
                 cnt++;
             }
         }
 
         xcb_change_property(kwinApp()->x11Connection(),
                             XCB_PROP_MODE_REPLACE,
                             DataBridge::self()->dnd()->window(),
                             atoms->xdnd_type_list,
                             XCB_ATOM_ATOM,
                             32, cnt, targets.data());
     }
     Drag::sendClientMessage(m_target->window(), atoms->xdnd_enter, &data);
 }
 
 void Xvisit::sendDrop(uint32_t time)
 {
     xcb_client_message_data_t data = {0};
     data.data32[0] = DataBridge::self()->dnd()->window();
     data.data32[2] = time;
 
     Drag::sendClientMessage(m_target->window(), atoms->xdnd_drop, &data);
 
     if (m_version < 2) {
         doFinish();
     }
 }
 
 void Xvisit::sendLeave()
 {
     xcb_client_message_data_t data = {0};
     data.data32[0] = DataBridge::self()->dnd()->window();
     Drag::sendClientMessage(m_target->window(), atoms->xdnd_leave, &data);
 }
 
 void Xvisit::retrieveSupportedActions()
 {
     m_supportedActions = m_dataOffer->sourceDragAndDropActions();
     determineProposedAction();
     requestDragAndDropAction();
 }
 
 void Xvisit::determineProposedAction()
 {
     DnDAction oldProposedAction = m_proposedAction;
     if (m_supportedActions.testFlag(m_preferredAction)) {
         m_proposedAction = m_preferredAction;
     } else if (m_supportedActions.testFlag(DnDAction::Copy)) {
         m_proposedAction = DnDAction::Copy;
     } else {
         m_proposedAction = DnDAction::None;
     }
     // send updated action to X target
     if (oldProposedAction != m_proposedAction) {
         sendPosition(waylandServer()->seat()->pointerPos());
     }
 }
 
 void Xvisit::requestDragAndDropAction()
 {
     if (m_dataOffer.isNull()) {
         return;
     }
     const auto pref = m_preferredAction != DnDAction::None ? m_preferredAction:
                                                            DnDAction::Copy;
     // we assume the X client supports Move, but this might be wrong - then
     // the drag just cancels, if the user tries to force it.
 
     m_dataOffer->setDragAndDropActions(DnDAction::Copy | DnDAction::Move, pref);
     waylandServer()->dispatch();
 }
 
 void Xvisit::drop()
 {
     Q_ASSERT(!m_state.finished);
     m_state.dropped = true;
     // stop further updates
     // TODO: revisit when we allow ask action
     stopConnections();
     if (!m_state.entered) {
         // wait for enter (init + offers)
         return;
     }
     if (m_pos.pending) {
         // wait for pending position roundtrip
         return;
     }
     if (!m_accepts) {
         // target does not accept current action/offer
         sendLeave();
         doFinish();
         return;
     }
     // dnd session ended successfully
     sendDrop(XCB_CURRENT_TIME);
 }
 
 void Xvisit::doFinish()
 {
     m_state.finished = true;
     m_pos.cached = false;
     stopConnections();
     Q_EMIT finish(this);
 }
 
 void Xvisit::stopConnections()
 {
     // final outcome has been determined from Wayland side
     // no more updates needed
     disconnect(m_enterConnection);
     m_enterConnection = QMetaObject::Connection();
     disconnect(m_dropConnection);
     m_dropConnection = QMetaObject::Connection();
 
     disconnect(m_motionConnection);
     m_motionConnection = QMetaObject::Connection();
     disconnect(m_actionConnection);
     m_actionConnection = QMetaObject::Connection();
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/drag_wl.h b/xwl/drag_wl.h
index 98587e20c..a26f72ba1 100644
--- a/xwl/drag_wl.h
+++ b/xwl/drag_wl.h
@@ -1,166 +1,166 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_DRAG_WL
 #define KWIN_XWL_DRAG_WL
 
 #include "drag.h"
 
 #include <KWayland/Client/dataoffer.h>
 
 #include <QPoint>
 #include <QPointer>
 #include <QVector>
 
 namespace KWayland
 {
 namespace Client
 {
 class Surface;
 }
-namespace Server
+}
+namespace KWaylandServer
 {
 class DataDeviceInterface;
 class DataSourceInterface;
 class SurfaceInterface;
 }
-}
 
 namespace KWin
 {
 class Toplevel;
 class AbstractClient;
 
 namespace Xwl
 {
 class X11Source;
 enum class DragEventReply;
 class Xvisit;
 
 using DnDActions = KWayland::Client::DataDeviceManager::DnDActions;
 
 class WlToXDrag : public Drag
 {
     Q_OBJECT
 
 public:
     explicit WlToXDrag();
 
     DragEventReply moveFilter(Toplevel *target, const QPoint &pos) override;
     bool handleClientMessage(xcb_client_message_event_t *event) override;
 
     bool end() override;
 
-    KWayland::Server::DataSourceInterface *dataSourceIface() const {
+    KWaylandServer::DataSourceInterface *dataSourceIface() const {
         return m_dsi;
     }
 
 private:
-    KWayland::Server::DataSourceInterface *m_dsi;
+    KWaylandServer::DataSourceInterface *m_dsi;
     Xvisit *m_visit = nullptr;
 
     Q_DISABLE_COPY(WlToXDrag)
 };
 
 // visit to an X window
 class Xvisit : public QObject
 {
     Q_OBJECT
 
 public:
     // TODO: handle ask action
 
     Xvisit(WlToXDrag *drag, AbstractClient *target);
 
     bool handleClientMessage(xcb_client_message_event_t *event);
     bool handleStatus(xcb_client_message_event_t *event);
     bool handleFinished(xcb_client_message_event_t *event);
 
     void sendPosition(const QPointF &globalPos);
     void leave();
 
     bool finished() const {
         return m_state.finished;
     }
     AbstractClient *target() const {
         return m_target;
     }
 
 Q_SIGNALS:
     void finish(Xvisit *self);
 
 private:
     void sendEnter();
     void sendDrop(uint32_t time);
     void sendLeave();
 
     void receiveOffer();
     void enter();
 
     void retrieveSupportedActions();
     void determineProposedAction();
     void requestDragAndDropAction();
     void setProposedAction();
 
     void drop();
 
     void doFinish();
     void stopConnections();
 
     WlToXDrag *m_drag;
     AbstractClient *m_target;
     uint32_t m_version = 0;
 
     QMetaObject::Connection m_enterConnection;
     QMetaObject::Connection m_motionConnection;
     QMetaObject::Connection m_actionConnection;
     QMetaObject::Connection m_dropConnection;
 
     struct {
         bool pending = false;
         bool cached = false;
         QPoint cache;
     } m_pos;
 
     // Must be QPointer, because KWayland::Client::DataDevice
     // might delete it.
     QPointer<KWayland::Client::DataOffer> m_dataOffer;
 
     // supported by the Wl source
     DnDActions m_supportedActions = DnDAction::None;
     // preferred by the X client
     DnDAction m_preferredAction = DnDAction::None;
     // decided upon by the compositor
     DnDAction m_proposedAction = DnDAction::None;
 
     struct {
         bool entered = false;
         bool dropped = false;
         bool finished = false;
     } m_state;
 
     bool m_accepts = false;
 
     Q_DISABLE_COPY(Xvisit)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif
diff --git a/xwl/drag_x.cpp b/xwl/drag_x.cpp
index 10105d412..722c06394 100644
--- a/xwl/drag_x.cpp
+++ b/xwl/drag_x.cpp
@@ -1,549 +1,549 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "drag_x.h"
 
 #include "databridge.h"
 #include "dnd.h"
 #include "selection_source.h"
 #include "xwayland.h"
 
 #include "abstract_client.h"
 #include "atoms.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/datadevice.h>
 #include <KWayland/Client/datasource.h>
 
-#include <KWayland/Server/datasource_interface.h>
-#include <KWayland/Server/seat_interface.h>
-#include <KWayland/Server/surface_interface.h>
+#include <KWaylandServer/datasource_interface.h>
+#include <KWaylandServer/seat_interface.h>
+#include <KWaylandServer/surface_interface.h>
 
 #include <QMouseEvent>
 #include <QTimer>
 
 namespace KWin
 {
 namespace Xwl
 {
 
 static QStringList atomToMimeTypes(xcb_atom_t atom)
 {
     QStringList mimeTypes;
 
     if (atom == atoms->utf8_string) {
         mimeTypes << QString::fromLatin1("text/plain;charset=utf-8");
     } else if (atom == atoms->text) {
         mimeTypes << QString::fromLatin1("text/plain");
     } else if (atom == atoms->uri_list || atom == atoms->netscape_url || atom == atoms->moz_url) {
     // We identify netscape and moz format as less detailed formats text/uri-list,
     // text/x-uri and accept the information loss.
         mimeTypes << QString::fromLatin1("text/uri-list") << QString::fromLatin1("text/x-uri");
     } else {
         mimeTypes << Selection::atomName(atom);
     }
     return mimeTypes;
 }
 
 XToWlDrag::XToWlDrag(X11Source *source)
     : m_source(source)
 {
     connect(DataBridge::self()->dnd(), &Dnd::transferFinished, this, [this](xcb_timestamp_t eventTime) {
         // we use this mechanism, because the finished call is not
         // reliable done by Wayland clients
         auto it = std::find_if(m_dataRequests.begin(), m_dataRequests.end(), [eventTime](const QPair<xcb_timestamp_t, bool> &req) {
             return req.first == eventTime && req.second == false;
         });
         if (it == m_dataRequests.end()) {
             // transfer finished for a different drag
             return;
         }
         (*it).second = true;
         checkForFinished();
     });
     connect(source, &X11Source::transferReady, this, [this](xcb_atom_t target, qint32 fd) {
         Q_UNUSED(target);
         Q_UNUSED(fd);
         m_dataRequests << QPair<xcb_timestamp_t, bool>(m_source->timestamp(), false);
     });
     auto *ddm = waylandServer()->internalDataDeviceManager();
     m_dataSource = ddm->createDataSource(this);
     connect(m_dataSource, &KWayland::Client::DataSource::dragAndDropPerformed, this, [this] {
         m_performed = true;
         if (m_visit) {
             connect(m_visit, &WlVisit::finish, this, [this](WlVisit *visit) {
                 Q_UNUSED(visit);
                 checkForFinished();
             });
 
             QTimer::singleShot(2000, this, [this]{
                 if (!m_visit->entered() || !m_visit->dropHandled()) {
                     // X client timed out
                     Q_EMIT finish(this);
                 } else if (m_dataRequests.size() == 0) {
                     // Wl client timed out
                     m_visit->sendFinished();
                     Q_EMIT finish(this);
                 }
             });
         }
         checkForFinished();
     });
     connect(m_dataSource, &KWayland::Client::DataSource::dragAndDropFinished, this, [this] {
         // this call is not reliably initiated by Wayland clients
         checkForFinished();
     });
 
     // source does _not_ take ownership of m_dataSource
     source->setDataSource(m_dataSource);
 
     auto *dc = new QMetaObject::Connection();
-    *dc = connect(waylandServer()->dataDeviceManager(), &KWayland::Server::DataDeviceManagerInterface::dataSourceCreated, this,
-                 [this, dc](KWayland::Server::DataSourceInterface *dsi) {
+    *dc = connect(waylandServer()->dataDeviceManager(), &KWaylandServer::DataDeviceManagerInterface::dataSourceCreated, this,
+                 [this, dc](KWaylandServer::DataSourceInterface *dsi) {
                     Q_ASSERT(dsi);
                     if (dsi->client() != waylandServer()->internalConnection()) {
                         return;
                     }
                     QObject::disconnect(*dc);
                     delete dc;
-                    connect(dsi, &KWayland::Server::DataSourceInterface::mimeTypeOffered, this, &XToWlDrag::offerCallback);
+                    connect(dsi, &KWaylandServer::DataSourceInterface::mimeTypeOffered, this, &XToWlDrag::offerCallback);
                 }
     );
     // Start drag with serial of last left pointer button press.
     // This means X to Wl drags can only be executed with the left pointer button being pressed.
     // For touch and (maybe) other pointer button drags we have to revisit this.
     //
     // Until then we accept the restriction for Xwayland clients.
     DataBridge::self()->dataDevice()->startDrag(waylandServer()->seat()->pointerButtonSerial(Qt::LeftButton),
                                                 m_dataSource,
                                                 DataBridge::self()->dnd()->surface());
     waylandServer()->dispatch();
 }
 
 XToWlDrag::~XToWlDrag()
 {
     delete m_dataSource;
     m_dataSource = nullptr;
 }
 
 DragEventReply XToWlDrag::moveFilter(Toplevel *target, const QPoint &pos)
 {
     Q_UNUSED(pos);
 
     auto *seat = waylandServer()->seat();
 
     if (m_visit && m_visit->target() == target) {
         // still same Wl target, wait for X events
         return DragEventReply::Ignore;
     }
     if (m_visit) {
         if (m_visit->leave()) {
             delete m_visit;
         } else {
             connect(m_visit, &WlVisit::finish, this, [this](WlVisit *visit) {
                 m_oldVisits.removeOne(visit);
                 delete visit;
             });
             m_oldVisits << m_visit;
         }
     }
     const bool hasCurrent = m_visit;
     m_visit = nullptr;
 
     if (!target || !target->surface() ||
             target->surface()->client() == waylandServer()->xWaylandConnection()) {
         // currently there is no target or target is an Xwayland window
         // handled here and by X directly
         if (AbstractClient *ac = qobject_cast<AbstractClient*>(target)) {
             if (workspace()->activeClient() != ac) {
                 workspace()->activateClient(ac);
             }
         }
         if (hasCurrent) {
             // last received enter event is now void,
             // wait for the next one
             seat->setDragTarget(nullptr);
         }
         return DragEventReply::Ignore;
     }
     // new Wl native target
     auto *ac = static_cast<AbstractClient*>(target);
     m_visit = new WlVisit(ac, this);
     connect(m_visit, &WlVisit::offersReceived, this, &XToWlDrag::setOffers);
     return DragEventReply::Ignore;
 }
 
 bool XToWlDrag::handleClientMessage(xcb_client_message_event_t *event)
 {
     for (auto *visit : m_oldVisits) {
         if (visit->handleClientMessage(event)) {
             return true;
         }
     }
     if (m_visit && m_visit->handleClientMessage(event)) {
         return true;
     }
     return false;
 }
 
 void XToWlDrag::setDragAndDropAction(DnDAction action)
 {
     m_dataSource->setDragAndDropActions(action);
 }
 
 DnDAction XToWlDrag::selectedDragAndDropAction()
 {
     // Take the last received action only from before the drag was performed,
     // because the action gets reset as soon as the drag is performed
     // (this seems to be a bug in KWayland -> TODO).
     if (!m_performed) {
         m_lastSelectedDragAndDropAction = m_dataSource->selectedDragAndDropAction();
     }
     return m_lastSelectedDragAndDropAction;
 }
 
 void XToWlDrag::setOffers(const Mimes &offers)
 {
     m_source->setOffers(offers);
     if (offers.isEmpty()) {
         // There are no offers, so just directly set the drag target,
         // no transfer possible anyways.
         setDragTarget();
         return;
     }
     if (m_offers == offers) {
         // offers had been set already by a previous visit
         // Wl side is already configured
         setDragTarget();
         return;
     }
 
     // TODO: make sure that offers are not changed in between visits
 
     m_offersPending = m_offers = offers;
     for (const auto mimePair : offers) {
         m_dataSource->offer(mimePair.first);
     }
 }
 
 using Mime = QPair<QString, xcb_atom_t>;
 
 void XToWlDrag::offerCallback(const QString &mime)
 {
     m_offersPending.erase(std::remove_if(m_offersPending.begin(), m_offersPending.end(),
                    [mime](const Mime &m) { return m.first == mime; }));
     if (m_offersPending.isEmpty() && m_visit && m_visit->entered()) {
         setDragTarget();
     }
 }
 
 void XToWlDrag::setDragTarget()
 {
     auto *ac = m_visit->target();
     workspace()->activateClient(ac);
     waylandServer()->seat()->setDragTarget(ac->surface(), ac->inputTransformation());
 }
 
 bool XToWlDrag::checkForFinished()
 {
     if (!m_visit) {
         // not dropped above Wl native target
         Q_EMIT finish(this);
         return true;
     }
     if (!m_visit->finished()) {
         return false;
     }
     if (m_dataRequests.size() == 0) {
         // need to wait for first data request
         return false;
     }
     const bool transfersFinished = std::all_of(m_dataRequests.begin(), m_dataRequests.end(),
                                                [](QPair<xcb_timestamp_t, bool> req) { return req.second; });
     if (transfersFinished) {
         m_visit->sendFinished();
         Q_EMIT finish(this);
     }
     return transfersFinished;
 }
 
 WlVisit::WlVisit(AbstractClient *target, XToWlDrag *drag)
     : QObject(drag),
       m_target(target),
       m_drag(drag)
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
     m_window = xcb_generate_id(xcbConn);
     DataBridge::self()->dnd()->overwriteRequestorWindow(m_window);
 
     const uint32_t dndValues[] = { XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
                                    XCB_EVENT_MASK_PROPERTY_CHANGE };
     xcb_create_window(xcbConn,
                       XCB_COPY_FROM_PARENT,
                       m_window,
                       kwinApp()->x11RootWindow(),
                       0, 0,
                       8192, 8192,           // TODO: get current screen size and connect to changes
                       0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT,
                       Xwayland::self()->xcbScreen()->root_visual,
                       XCB_CW_EVENT_MASK,
                       dndValues);
 
     uint32_t version = Dnd::version();
     xcb_change_property(xcbConn,
                         XCB_PROP_MODE_REPLACE,
                         m_window,
                         atoms->xdnd_aware,
                         XCB_ATOM_ATOM,
                         32, 1, &version);
 
     xcb_map_window(xcbConn, m_window);
     workspace()->addManualOverlay(m_window);
     workspace()->updateStackingOrder(true);
 
     xcb_flush(xcbConn);
     m_mapped = true;
 }
 
 WlVisit::~WlVisit()
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     xcb_destroy_window(xcbConn, m_window);
     xcb_flush(xcbConn);
 }
 
 bool WlVisit::leave()
 {
     DataBridge::self()->dnd()->overwriteRequestorWindow(XCB_WINDOW_NONE);
     unmapProxyWindow();
     return m_finished;
 }
 
 bool WlVisit::handleClientMessage(xcb_client_message_event_t *event)
 {
     if (event->window != m_window) {
         // different window
         return false;
     }
 
     if (event->type == atoms->xdnd_enter) {
         return handleEnter(event);
     } else if (event->type == atoms->xdnd_position) {
         return handlePosition(event);
     } else if (event->type == atoms->xdnd_drop) {
         return handleDrop(event);
     } else if (event->type == atoms->xdnd_leave) {
         return handleLeave(event);
     }
     return false;
 }
 
 static bool hasMimeName(const Mimes &mimes, const QString &name)
 {
     return std::any_of(mimes.begin(), mimes.end(),
                        [name](const Mime &m) { return m.first == name; });
 }
 
 bool WlVisit::handleEnter(xcb_client_message_event_t *event)
 {
     if (m_entered) {
         // a drag already entered
         return true;
     }
     m_entered = true;
 
     xcb_client_message_data_t *data = &event->data;
     m_srcWindow = data->data32[0];
     m_version = data->data32[1] >> 24;
 
     // get types
     Mimes offers;
     if (!(data->data32[1] & 1)) {
         // message has only max 3 types (which are directly in data)
         for (size_t i = 0; i < 3; i++) {
             xcb_atom_t mimeAtom = data->data32[2 + i];
             const auto mimeStrings = atomToMimeTypes(mimeAtom);
             for (const auto mime : mimeStrings ) {
                 if (!hasMimeName(offers, mime)) {
                     offers << Mime(mime, mimeAtom);
                 }
             }
         }
     } else {
         // more than 3 types -> in window property
         getMimesFromWinProperty(offers);
     }
 
     Q_EMIT offersReceived(offers);
     return true;
 }
 
 void WlVisit::getMimesFromWinProperty(Mimes &offers)
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     auto cookie = xcb_get_property(xcbConn,
                                    0,
                                    m_srcWindow,
                                    atoms->xdnd_type_list,
                                    XCB_GET_PROPERTY_TYPE_ANY,
                                    0, 0x1fffffff);
 
     auto *reply = xcb_get_property_reply(xcbConn, cookie, nullptr);
     if (reply == nullptr) {
         return;
     }
     if (reply->type != XCB_ATOM_ATOM || reply->value_len == 0) {
         // invalid reply value
         free(reply);
         return;
     }
 
     xcb_atom_t *mimeAtoms = static_cast<xcb_atom_t *>(xcb_get_property_value(reply));
     for (size_t i = 0; i < reply->value_len; ++i) {
         const auto mimeStrings = atomToMimeTypes(mimeAtoms[i]);
         for (const auto mime : mimeStrings) {
             if (!hasMimeName(offers, mime)) {
                 offers << Mime(mime, mimeAtoms[i]);
             }
         }
     }
     free(reply);
 }
 
 bool WlVisit::handlePosition(xcb_client_message_event_t *event)
 {
     xcb_client_message_data_t *data = &event->data;
     m_srcWindow = data->data32[0];
 
     if (!m_target) {
         // not over Wl window at the moment
         m_action = DnDAction::None;
         m_actionAtom = XCB_ATOM_NONE;
         sendStatus();
         return true;
     }
     const uint32_t pos = data->data32[2];
     Q_UNUSED(pos);
 
     const xcb_timestamp_t timestamp = data->data32[3];
     m_drag->x11Source()->setTimestamp(timestamp);
 
     xcb_atom_t actionAtom = m_version > 1 ? data->data32[4] :
                                             atoms->xdnd_action_copy;
     auto action = Drag::atomToClientAction(actionAtom);
 
     if (action == DnDAction::None) {
         // copy action is always possible in XDND
         action = DnDAction::Copy;
         actionAtom = atoms->xdnd_action_copy;
     }
 
     if (m_action != action) {
         m_action = action;
         m_actionAtom = actionAtom;
         m_drag->setDragAndDropAction(m_action);
     }
 
     sendStatus();
     return true;
 }
 
 bool WlVisit::handleDrop(xcb_client_message_event_t *event)
 {
     m_dropHandled = true;
 
     xcb_client_message_data_t *data = &event->data;
     m_srcWindow = data->data32[0];
     const xcb_timestamp_t timestamp = data->data32[2];
     m_drag->x11Source()->setTimestamp(timestamp);
 
     // we do nothing more here, the drop is being processed
     // through the X11Source object
     doFinish();
     return true;
 }
 
 void WlVisit::doFinish()
 {
     m_finished = true;
     unmapProxyWindow();
     Q_EMIT finish(this);
 }
 
 bool WlVisit::handleLeave(xcb_client_message_event_t *event)
 {
     m_entered = false;
     xcb_client_message_data_t *data = &event->data;
     m_srcWindow = data->data32[0];
     doFinish();
     return true;
 }
 
 void WlVisit::sendStatus()
 {
     // receive position events
     uint32_t flags = 1 << 1;
     if (targetAcceptsAction()) {
         // accept the drop
         flags |= (1 << 0);
     }
     xcb_client_message_data_t data = {0};
     data.data32[0] = m_window;
     data.data32[1] = flags;
     data.data32[4] = flags & (1 << 0) ? m_actionAtom : static_cast<uint32_t>(XCB_ATOM_NONE);
     Drag::sendClientMessage(m_srcWindow, atoms->xdnd_status, &data);
 }
 
 void WlVisit::sendFinished()
 {
     const bool accepted = m_entered && m_action != DnDAction::None;
     xcb_client_message_data_t data = {0};
     data.data32[0] = m_window;
     data.data32[1] = accepted;
     data.data32[2] = accepted ? m_actionAtom : static_cast<uint32_t>(XCB_ATOM_NONE);
     Drag::sendClientMessage(m_srcWindow, atoms->xdnd_finished, &data);
 }
 
 bool WlVisit::targetAcceptsAction() const
 {
     if (m_action == DnDAction::None) {
         return false;
     }
     const auto selAction = m_drag->selectedDragAndDropAction();
     return selAction == m_action || selAction == DnDAction::Copy;
 }
 
 void WlVisit::unmapProxyWindow()
 {
     if (!m_mapped) {
         return;
     }
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     xcb_unmap_window(xcbConn, m_window);
     workspace()->removeManualOverlay(m_window);
     workspace()->updateStackingOrder(true);
     xcb_flush(xcbConn);
     m_mapped = false;
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/drag_x.h b/xwl/drag_x.h
index 1bbf40b0b..4188f8013 100644
--- a/xwl/drag_x.h
+++ b/xwl/drag_x.h
@@ -1,169 +1,169 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_DRAG_X
 #define KWIN_XWL_DRAG_X
 
 #include "drag.h"
 
 #include <KWayland/Client/datadevicemanager.h>
 #include <KWayland/Client/dataoffer.h>
 
-#include <KWayland/Server/datadevicemanager_interface.h>
+#include <KWaylandServer/datadevicemanager_interface.h>
 
 #include <QPoint>
 #include <QPointer>
 #include <QVector>
 
 namespace KWayland
 {
 namespace Client
 {
 class DataSource;
 }
 }
 
 namespace KWin
 {
 class Toplevel;
 class AbstractClient;
 
 namespace Xwl
 {
 class X11Source;
 enum class DragEventReply;
 class WlVisit;
 
 using Mimes = QVector<QPair<QString, xcb_atom_t> >;
 
 class XToWlDrag : public Drag
 {
     Q_OBJECT
 
 public:
     explicit XToWlDrag(X11Source *source);
     ~XToWlDrag() override;
 
     DragEventReply moveFilter(Toplevel *target, const QPoint &pos) override;
     bool handleClientMessage(xcb_client_message_event_t *event) override;
 
     void setDragAndDropAction(DnDAction action);
     DnDAction selectedDragAndDropAction();
 
     bool end() override {
         return false;
     }
     X11Source *x11Source() const {
         return m_source;
     }
 
 private:
     void setOffers(const Mimes &offers);
     void offerCallback(const QString &mime);
     void setDragTarget();
 
     bool checkForFinished();
 
     KWayland::Client::DataSource *m_dataSource;
 
     Mimes m_offers;
     Mimes m_offersPending;
 
     X11Source *m_source;
     QVector<QPair<xcb_timestamp_t, bool> > m_dataRequests;
 
     WlVisit *m_visit = nullptr;
     QVector<WlVisit *> m_oldVisits;
 
     bool m_performed = false;
     DnDAction m_lastSelectedDragAndDropAction = DnDAction::None;
 
     Q_DISABLE_COPY(XToWlDrag)
 };
 
 class WlVisit : public QObject
 {
     Q_OBJECT
 
 public:
     WlVisit(AbstractClient *target, XToWlDrag *drag);
     ~WlVisit() override;
 
     bool handleClientMessage(xcb_client_message_event_t *event);
     bool leave();
 
     AbstractClient *target() const {
         return m_target;
     }
     xcb_window_t window() const {
         return m_window;
     }
     bool entered() const {
         return m_entered;
     }
     bool dropHandled() const {
         return m_dropHandled;
     }
     bool finished() const {
         return m_finished;
     }
     void sendFinished();
 
 Q_SIGNALS:
     void offersReceived(const Mimes &offers);
     void finish(WlVisit *self);
 
 private:
     bool handleEnter(xcb_client_message_event_t *event);
     bool handlePosition(xcb_client_message_event_t *event);
     bool handleDrop(xcb_client_message_event_t *event);
     bool handleLeave(xcb_client_message_event_t *event);
 
     void sendStatus();
 
     void getMimesFromWinProperty(Mimes &offers);
 
     bool targetAcceptsAction() const;
 
     void doFinish();
     void unmapProxyWindow();
 
     AbstractClient *m_target;
     xcb_window_t m_window;
 
     xcb_window_t m_srcWindow = XCB_WINDOW_NONE;
     XToWlDrag *m_drag;
 
     uint32_t m_version = 0;
 
     xcb_atom_t m_actionAtom;
     DnDAction m_action = DnDAction::None;
 
     bool m_mapped = false;
     bool m_entered = false;
     bool m_dropHandled = false;
     bool m_finished = false;
 
     Q_DISABLE_COPY(WlVisit)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif
diff --git a/xwl/selection_source.cpp b/xwl/selection_source.cpp
index 1b08448f2..96cfa0491 100644
--- a/xwl/selection_source.cpp
+++ b/xwl/selection_source.cpp
@@ -1,323 +1,323 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "selection_source.h"
 #include "selection.h"
 #include "transfer.h"
 
 #include "atoms.h"
 #include "wayland_server.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/datadevicemanager.h>
 #include <KWayland/Client/datadevice.h>
 #include <KWayland/Client/datasource.h>
 
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/datasource_interface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/datasource_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <unistd.h>
 
 #include <xwayland_logging.h>
 
 namespace KWin
 {
 namespace Xwl
 {
 
 SelectionSource::SelectionSource(Selection *selection)
     : QObject(selection)
     , m_selection(selection)
     , m_window(selection->window())
 {
 }
 
-WlSource::WlSource(Selection *selection, KWayland::Server::DataDeviceInterface *ddi)
+WlSource::WlSource(Selection *selection, KWaylandServer::DataDeviceInterface *ddi)
     : SelectionSource(selection)
     , m_ddi(ddi)
 {
     Q_ASSERT(ddi);
 }
 
-void WlSource::setDataSourceIface(KWayland::Server::DataSourceInterface *dsi)
+void WlSource::setDataSourceIface(KWaylandServer::DataSourceInterface *dsi)
 {
     if (m_dsi == dsi) {
         return;
     }
     for (const auto &mime : dsi->mimeTypes()) {
         m_offers << mime;
     }
     m_offerConnection = connect(dsi,
-                         &KWayland::Server::DataSourceInterface::mimeTypeOffered,
+                         &KWaylandServer::DataSourceInterface::mimeTypeOffered,
                          this, &WlSource::receiveOffer);
     m_dsi = dsi;
 }
 
 void WlSource::receiveOffer(const QString &mime)
 {
     m_offers << mime;
 }
 
 void WlSource::sendSelectionNotify(xcb_selection_request_event_t *event, bool success)
 {
     Selection::sendSelectionNotify(event, success);
 }
 
 bool WlSource::handleSelectionRequest(xcb_selection_request_event_t *event)
 {
     if (event->target == atoms->targets) {
         sendTargets(event);
     } else if (event->target == atoms->timestamp) {
         sendTimestamp(event);
     } else if (event->target == atoms->delete_atom) {
         sendSelectionNotify(event, true);
     } else {
         // try to send mime data
         if (!checkStartTransfer(event)) {
             sendSelectionNotify(event, false);
         }
     }
     return true;
 }
 
 void WlSource::sendTargets(xcb_selection_request_event_t *event)
 {
     QVector<xcb_atom_t> targets;
     targets.resize(m_offers.size() + 2);
     targets[0] = atoms->timestamp;
     targets[1] = atoms->targets;
 
     size_t cnt = 2;
     for (const auto mime : m_offers) {
         targets[cnt] = Selection::mimeTypeToAtom(mime);
         cnt++;
     }
 
     xcb_change_property(kwinApp()->x11Connection(),
                         XCB_PROP_MODE_REPLACE,
                         event->requestor,
                         event->property,
                         XCB_ATOM_ATOM,
                         32, cnt, targets.data());
     sendSelectionNotify(event, true);
 }
 
 void WlSource::sendTimestamp(xcb_selection_request_event_t *event)
 {
     const xcb_timestamp_t time = timestamp();
     xcb_change_property(kwinApp()->x11Connection(),
                         XCB_PROP_MODE_REPLACE,
                         event->requestor,
                         event->property,
                         XCB_ATOM_INTEGER,
                         32, 1, &time);
 
     sendSelectionNotify(event, true);
 }
 
 bool WlSource::checkStartTransfer(xcb_selection_request_event_t *event)
 {
     // check interfaces available
     if (!m_ddi || !m_dsi) {
         return false;
     }
 
     const auto targets = Selection::atomToMimeTypes(event->target);
     if (targets.isEmpty()) {
         qCDebug(KWIN_XWL) << "Unknown selection atom. Ignoring request.";
         return false;
     }
     const auto firstTarget = targets[0];
 
     auto cmp = [firstTarget](const QString &b) {
         if (firstTarget == "text/uri-list") {
             // Wayland sources might announce the old mime or the new standard
             return firstTarget == b || b == "text/x-uri";
         }
         return firstTarget == b;
     };
     // check supported mimes
     const auto offers = m_dsi->mimeTypes();
     const auto mimeIt = std::find_if(offers.begin(), offers.end(), cmp);
     if (mimeIt == offers.end()) {
         // Requested Mime not supported. Not sending selection.
         return false;
     }
 
     int p[2];
     if (pipe(p) == -1) {
         qCWarning(KWIN_XWL) << "Pipe failed. Not sending selection.";
         return false;
     }
 
     m_dsi->requestData(*mimeIt, p[1]);
     waylandServer()->dispatch();
 
     Q_EMIT transferReady(new xcb_selection_request_event_t(*event), p[0]);
     return true;
 }
 
 X11Source::X11Source(Selection *selection, xcb_xfixes_selection_notify_event_t *event)
     : SelectionSource(selection)
     , m_owner(event->owner)
 {
     setTimestamp(event->timestamp);
 }
 
 void X11Source::getTargets()
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     /* will lead to a selection request event for the new owner */
     xcb_convert_selection(xcbConn,
                           window(),
                           selection()->atom(),
                           atoms->targets,
                           atoms->wl_selection,
                           timestamp());
     xcb_flush(xcbConn);
 }
 
 using Mime = QPair<QString, xcb_atom_t>;
 
 void X11Source::handleTargets()
 {
     // receive targets
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     xcb_get_property_cookie_t cookie = xcb_get_property(xcbConn,
                                                         1,
                                                         window(),
                                                         atoms->wl_selection,
                                                         XCB_GET_PROPERTY_TYPE_ANY,
                                                         0,
                                                         4096
                                                         );
     auto *reply = xcb_get_property_reply(xcbConn, cookie, nullptr);
     if (!reply) {
         return;
     }
     if (reply->type != XCB_ATOM_ATOM) {
         free(reply);
         return;
     }
 
     QStringList added;
     QStringList removed;
 
     Mimes all;
     xcb_atom_t *value = static_cast<xcb_atom_t *>(xcb_get_property_value(reply));
     for (uint32_t i = 0; i < reply->value_len; i++) {
         if (value[i] == XCB_ATOM_NONE) {
             continue;
         }
 
         const auto mimeStrings = Selection::atomToMimeTypes(value[i]);
         if (mimeStrings.isEmpty()) {
             // TODO: this should never happen? assert?
             continue;
         }
 
 
         const auto mimeIt = std::find_if(m_offers.begin(), m_offers.end(),
             [value, i](const Mime &mime) {
                 return mime.second == value[i];
             }
         );
 
         auto mimePair = Mime(mimeStrings[0], value[i]);
         if (mimeIt == m_offers.end()) {
             added << mimePair.first;
         } else {
             m_offers.removeAll(mimePair);
         }
         all << mimePair;
     }
     // all left in m_offers are not in the updated targets
     for (const auto mimePair : m_offers) {
         removed << mimePair.first;
     }
     m_offers = all;
 
     if (!added.isEmpty() || !removed.isEmpty()) {
         Q_EMIT offersChanged(added, removed);
     }
 
     free(reply);
 }
 
 void X11Source::setDataSource(KWayland::Client::DataSource *dataSource)
 {
     Q_ASSERT(dataSource);
     if (m_dataSource) {
         delete m_dataSource;
     }
 
     m_dataSource = dataSource;
 
     for (const Mime &offer : m_offers) {
         dataSource->offer(offer.first);
     }
 
     connect(dataSource, &KWayland::Client::DataSource::sendDataRequested,
         this, &X11Source::startTransfer);
 }
 
 void X11Source::setOffers(const Mimes &offers)
 {
     // TODO: share code with handleTargets and emit signals accordingly?
     m_offers = offers;
 }
 
 bool X11Source::handleSelectionNotify(xcb_selection_notify_event_t *event)
 {
     if (event->requestor != window()) {
         return false;
     }
     if (event->selection != selection()->atom()) {
         return false;
     }
     if (event->property == XCB_ATOM_NONE) {
         qCWarning(KWIN_XWL) << "Incoming X selection conversion failed";
         return true;
     }
     if (event->target == atoms->targets) {
         handleTargets();
         return true;
     }
     return false;
 }
 
 void X11Source::startTransfer(const QString &mimeName, qint32 fd)
 {
     const auto mimeIt = std::find_if(m_offers.begin(), m_offers.end(),
         [mimeName](const Mime &mime) {
             return mime.first == mimeName;
         }
     );
     if (mimeIt == m_offers.end()) {
         qCDebug(KWIN_XWL) << "Sending X11 clipboard to Wayland failed: unsupported MIME.";
         close(fd);
         return;
     }
 
     Q_EMIT transferReady((*mimeIt).second, fd);
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/selection_source.h b/xwl/selection_source.h
index 90d834e05..46af9ea92 100644
--- a/xwl/selection_source.h
+++ b/xwl/selection_source.h
@@ -1,175 +1,175 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2019 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_SELECTION_SOURCE
 #define KWIN_XWL_SELECTION_SOURCE
 
 #include <QObject>
 #include <QVector>
 
 #include <xcb/xcb.h>
 
 class QSocketNotifier;
 
 struct xcb_selection_request_event_t;
 struct xcb_xfixes_selection_notify_event_t;
 
 namespace KWayland
 {
 namespace Client
 {
 class DataSource;
 }
-namespace Server
+}
+namespace KWaylandServer
 {
 class DataDeviceInterface;
 class DataSourceInterface;
 }
-}
 
 namespace KWin
 {
 namespace Xwl
 {
 class Selection;
 
 /**
  * Base class representing a data source.
  */
 class SelectionSource : public QObject
 {
     Q_OBJECT
 
 public:
     SelectionSource(Selection *selection);
 
     xcb_timestamp_t timestamp() const {
         return m_timestamp;
     }
     void setTimestamp(xcb_timestamp_t time) {
         m_timestamp = time;
     }
 
 protected:
     Selection *selection() const {
         return m_selection;
     }
     void setWindow(xcb_window_t window) {
         m_window = window;
     }
     xcb_window_t window() const {
         return m_window;
     }
 
 private:
     xcb_timestamp_t m_timestamp = XCB_CURRENT_TIME;
     Selection *m_selection;
     xcb_window_t m_window;
 
     Q_DISABLE_COPY(SelectionSource)
 };
 
 /**
  * Representing a Wayland native data source.
  */
 class WlSource : public SelectionSource
 {
     Q_OBJECT
 
 public:
-    WlSource(Selection *selection, KWayland::Server::DataDeviceInterface *ddi);
-    void setDataSourceIface(KWayland::Server::DataSourceInterface *dsi);
+    WlSource(Selection *selection, KWaylandServer::DataDeviceInterface *ddi);
+    void setDataSourceIface(KWaylandServer::DataSourceInterface *dsi);
 
     bool handleSelectionRequest(xcb_selection_request_event_t *event);
     void sendTargets(xcb_selection_request_event_t *event);
     void sendTimestamp(xcb_selection_request_event_t *event);
 
     void receiveOffer(const QString &mime);
     void sendSelectionNotify(xcb_selection_request_event_t *event, bool success);
 
 Q_SIGNALS:
     void transferReady(xcb_selection_request_event_t *event, qint32 fd);
 
 private:
     bool checkStartTransfer(xcb_selection_request_event_t *event);
 
-    KWayland::Server::DataDeviceInterface *m_ddi = nullptr;
-    KWayland::Server::DataSourceInterface *m_dsi = nullptr;
+    KWaylandServer::DataDeviceInterface *m_ddi = nullptr;
+    KWaylandServer::DataSourceInterface *m_dsi = nullptr;
 
     QVector<QString> m_offers;
     QMetaObject::Connection m_offerConnection;
 
     Q_DISABLE_COPY(WlSource)
 };
 
 using Mimes = QVector<QPair<QString, xcb_atom_t> >;
 
 /**
  * Representing an X data source.
  */
 class X11Source : public SelectionSource
 {
     Q_OBJECT
 
 public:
     X11Source(Selection *selection, xcb_xfixes_selection_notify_event_t *event);
 
     /**
      * @param ds must exist.
      *
      * X11Source does not take ownership of it in general, but if the function
      * is called again, it will delete the previous data source.
      */
     void setDataSource(KWayland::Client::DataSource *dataSource);
     KWayland::Client::DataSource *dataSource() const {
         return m_dataSource;
     }
     void getTargets();
 
     Mimes offers() const {
         return m_offers;
     }
     void setOffers(const Mimes &offers);
 
     bool handleSelectionNotify(xcb_selection_notify_event_t *event);
 
     void setRequestor(xcb_window_t window) {
         setWindow(window);
     }
 
 Q_SIGNALS:
     void offersChanged(const QStringList &added, const QStringList &removed);
     void transferReady(xcb_atom_t target, qint32 fd);
 
 private:
     void handleTargets();
     void startTransfer(const QString &mimeName, qint32 fd);
 
     xcb_window_t m_owner;
     KWayland::Client::DataSource *m_dataSource = nullptr;
 
     Mimes m_offers;
 
     Q_DISABLE_COPY(X11Source)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif
diff --git a/xwl/transfer.cpp b/xwl/transfer.cpp
index f88934698..b82b2fde5 100644
--- a/xwl/transfer.cpp
+++ b/xwl/transfer.cpp
@@ -1,594 +1,594 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2018 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "transfer.h"
 
 #include "databridge.h"
 #include "xwayland.h"
 
 #include "abstract_client.h"
 #include "atoms.h"
 #include "wayland_server.h"
 #include "workspace.h"
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/datadevicemanager.h>
 #include <KWayland/Client/datadevice.h>
 #include <KWayland/Client/datasource.h>
 
-#include <KWayland/Server/datadevice_interface.h>
-#include <KWayland/Server/datasource_interface.h>
-#include <KWayland/Server/seat_interface.h>
+#include <KWaylandServer/datadevice_interface.h>
+#include <KWaylandServer/datasource_interface.h>
+#include <KWaylandServer/seat_interface.h>
 
 #include <xcb/xcb_event.h>
 #include <xcb/xfixes.h>
 
 #include <algorithm>
 #include <unistd.h>
 
 #include <xwayland_logging.h>
 
 namespace KWin
 {
 namespace Xwl
 {
 
 // in Bytes: equals 64KB
 static const uint32_t s_incrChunkSize = 63 * 1024;
 
 Transfer::Transfer(xcb_atom_t selection, qint32 fd, xcb_timestamp_t timestamp, QObject *parent)
     : QObject(parent)
     , m_atom(selection)
     , m_fd(fd)
     , m_timestamp(timestamp)
 {
 }
 
 void Transfer::createSocketNotifier(QSocketNotifier::Type type)
 {
     delete m_notifier;
     m_notifier = new QSocketNotifier(m_fd, type, this);
 }
 
 void Transfer::clearSocketNotifier()
 {
     delete m_notifier;
     m_notifier = nullptr;
 }
 
 void Transfer::timeout()
 {
     if (m_timeout) {
         endTransfer();
     }
     m_timeout = true;
 }
 
 void Transfer::endTransfer()
 {
     clearSocketNotifier();
     closeFd();
     Q_EMIT finished();
 }
 
 void Transfer::closeFd()
 {
     if (m_fd < 0) {
         return;
     }
     close(m_fd);
     m_fd = -1;
 }
 
 TransferWltoX::TransferWltoX(xcb_atom_t selection, xcb_selection_request_event_t *request,
                              qint32 fd, QObject *parent)
     : Transfer(selection, fd, 0, parent)
     , m_request(request)
 {
 }
 
 TransferWltoX::~TransferWltoX()
 {
     delete m_request;
     m_request = nullptr;
 }
 
 void TransferWltoX::startTransferFromSource()
 {
     createSocketNotifier(QSocketNotifier::Read);
     connect(socketNotifier(), &QSocketNotifier::activated, this,
             [this](int socket) {
                 Q_UNUSED(socket);
                 readWlSource();
             }
     );
 }
 
 int TransferWltoX::flushSourceData()
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
     xcb_change_property(xcbConn,
                         XCB_PROP_MODE_REPLACE,
                         m_request->requestor,
                         m_request->property,
                         m_request->target,
                         8,
                         m_chunks.first().first.size(),
                         m_chunks.first().first.data());
     xcb_flush(xcbConn);
 
     m_propertyIsSet = true;
     resetTimeout();
 
     const auto rm = m_chunks.takeFirst();
     return rm.first.size();
 }
 
 void TransferWltoX::startIncr()
 {
     Q_ASSERT(m_chunks.size() == 1);
 
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
     uint32_t mask[] = { XCB_EVENT_MASK_PROPERTY_CHANGE };
     xcb_change_window_attributes (xcbConn,
                                   m_request->requestor,
                                   XCB_CW_EVENT_MASK, mask);
 
     // spec says to make the available space larger
     const uint32_t chunkSpace = 1024 + s_incrChunkSize;
     xcb_change_property(xcbConn,
                         XCB_PROP_MODE_REPLACE,
                         m_request->requestor,
                         m_request->property,
                         atoms->incr,
                         32, 1, &chunkSpace);
     xcb_flush(xcbConn);
 
     setIncr(true);
     // first data will be flushed after the property has been deleted
     // again by the requestor
     m_flushPropertyOnDelete = true;
     m_propertyIsSet = true;
     Q_EMIT selectionNotify(m_request, true);
 }
 
 void TransferWltoX::readWlSource()
 {
     if (m_chunks.size() == 0 ||
             m_chunks.last().second == s_incrChunkSize) {
         // append new chunk
         auto next = QPair<QByteArray, int>();
         next.first.resize(s_incrChunkSize);
         next.second = 0;
         m_chunks.append(next);
     }
 
     const auto oldLen = m_chunks.last().second;
     const auto avail = s_incrChunkSize - m_chunks.last().second;
     Q_ASSERT(avail > 0);
 
     ssize_t readLen = read(fd(), m_chunks.last().first.data() + oldLen, avail);
     if (readLen == -1) {
         qCWarning(KWIN_XWL) << "Error reading in Wl data.";
 
         // TODO: cleanup X side?
         endTransfer();
         return;
     }
     m_chunks.last().second = oldLen + readLen;
 
     if (readLen == 0) {
         // at the fd end - complete transfer now
         m_chunks.last().first.resize(m_chunks.last().second);
 
         if (incr()) {
             // incremental transfer is to be completed now
             m_flushPropertyOnDelete = true;
             if (!m_propertyIsSet) {
                 // flush if target's property is not set at the moment
                 flushSourceData();
             }
             clearSocketNotifier();
         } else {
             // non incremental transfer is to be completed now,
             // data can be transferred to X client via a single property set
             flushSourceData();
             Q_EMIT selectionNotify(m_request, true);
             endTransfer();
         }
     } else if (m_chunks.last().second == s_incrChunkSize) {
         // first chunk full, but not yet at fd end -> go incremental
         if (incr()) {
             m_flushPropertyOnDelete = true;
             if (!m_propertyIsSet) {
                 // flush if target's property is not set at the moment
                 flushSourceData();
             }
         } else {
             // starting incremental transfer
             startIncr();
         }
     }
     resetTimeout();
 }
 
 bool TransferWltoX::handlePropertyNotify(xcb_property_notify_event_t *event)
 {
     if (event->window == m_request->requestor) {
         if (event->state == XCB_PROPERTY_DELETE &&
                 event->atom == m_request->property) {
             handlePropertyDelete();
         }
         return true;
     }
     return false;
 }
 
 void TransferWltoX::handlePropertyDelete()
 {
     if (!incr()) {
         // non-incremental transfer: nothing to do
         return;
     }
     m_propertyIsSet = false;
 
     if (m_flushPropertyOnDelete) {
         if (!socketNotifier() && m_chunks.isEmpty()) {
             // transfer complete
             xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
             uint32_t mask[] = {0};
             xcb_change_window_attributes (xcbConn,
                                           m_request->requestor,
                                           XCB_CW_EVENT_MASK, mask);
 
             xcb_change_property(xcbConn,
                                 XCB_PROP_MODE_REPLACE,
                                 m_request->requestor,
                                 m_request->property,
                                 m_request->target,
                                 8, 0, nullptr);
             xcb_flush(xcbConn);
             m_flushPropertyOnDelete = false;
             endTransfer();
         } else {
             flushSourceData();
         }
     }
 }
 
 TransferXtoWl::TransferXtoWl(xcb_atom_t selection, xcb_atom_t target, qint32 fd,
                              xcb_timestamp_t timestamp, xcb_window_t parentWindow,
                              QObject *parent)
     : Transfer(selection, fd, timestamp, parent)
 {
     // create transfer window
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     m_window = xcb_generate_id(xcbConn);
     const uint32_t values[] = { XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY |
                                    XCB_EVENT_MASK_PROPERTY_CHANGE };
     xcb_create_window(xcbConn,
                       XCB_COPY_FROM_PARENT,
                       m_window,
                       parentWindow,
                       0, 0,
                       10, 10,
                       0,
                       XCB_WINDOW_CLASS_INPUT_OUTPUT,
                       Xwayland::self()->xcbScreen()->root_visual,
                       XCB_CW_EVENT_MASK,
                       values);
     // convert selection
     xcb_convert_selection(xcbConn,
                           m_window,
                           selection,
                           target,
                           atoms->wl_selection,
                           timestamp);
     xcb_flush(xcbConn);
 }
 
 TransferXtoWl::~TransferXtoWl()
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     xcb_destroy_window(xcbConn, m_window);
     xcb_flush(xcbConn);
 
     delete m_receiver;
     m_receiver = nullptr;
 }
 
 bool TransferXtoWl::handlePropertyNotify(xcb_property_notify_event_t *event)
 {
     if (event->window == m_window) {
         if (event->state == XCB_PROPERTY_NEW_VALUE &&
                 event->atom == atoms->wl_selection) {
             getIncrChunk();
         }
         return true;
     }
     return false;
 }
 
 bool TransferXtoWl::handleSelectionNotify(xcb_selection_notify_event_t *event)
 {
     if (event->requestor != m_window) {
         return false;
     }
     if (event->selection != atom()) {
         return false;
     }
     if (event->property == XCB_ATOM_NONE) {
         qCWarning(KWIN_XWL) << "Incoming X selection conversion failed";
         return true;
     }
     if (event->target == atoms->targets) {
         qCWarning(KWIN_XWL) << "Received targets too late";
         // TODO: or allow it?
         return true;
     }
     if (m_receiver) {
         // second selection notify element - misbehaving source
 
         // TODO: cancel this transfer?
         return true;
     }
 
     if (event->target == atoms->netscape_url) {
         m_receiver = new NetscapeUrlReceiver;
     } else if (event->target == atoms->moz_url) {
         m_receiver = new MozUrlReceiver;
     } else {
         m_receiver = new DataReceiver;
     }
     startTransfer();
     return true;
 }
 
 void TransferXtoWl::startTransfer()
 {
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
     auto cookie = xcb_get_property(xcbConn,
                                    1,
                                    m_window,
                                    atoms->wl_selection,
                                    XCB_GET_PROPERTY_TYPE_ANY,
                                    0,
                                    0x1fffffff
                                    );
 
     auto *reply = xcb_get_property_reply(xcbConn, cookie, nullptr);
     if (reply == nullptr) {
         qCWarning(KWIN_XWL) << "Can't get selection property.";
         endTransfer();
         return;
     }
 
     if (reply->type == atoms->incr) {
         setIncr(true);
         free(reply);
     } else {
         setIncr(false);
         // reply's ownership is transferred
         m_receiver->transferFromProperty(reply);
         dataSourceWrite();
     }
 }
 
 void TransferXtoWl::getIncrChunk()
 {
     if (!incr()) {
         // source tries to sent incrementally, but did not announce it before
         return;
     }
     if (!m_receiver) {
         // receive mechanism has not yet been setup
         return;
     }
     xcb_connection_t *xcbConn = kwinApp()->x11Connection();
 
     auto cookie = xcb_get_property(xcbConn,
                                    0,
                                    m_window,
                                    atoms->wl_selection,
                                    XCB_GET_PROPERTY_TYPE_ANY,
                                    0,
                                    0x1fffffff);
 
     auto *reply = xcb_get_property_reply(xcbConn, cookie, nullptr);
     if (!reply) {
         qCWarning(KWIN_XWL) << "Can't get selection property.";
         endTransfer();
         return;
     }
 
     if (xcb_get_property_value_length(reply) > 0) {
         // reply's ownership is transferred
         m_receiver->transferFromProperty(reply);
         dataSourceWrite();
     } else {
         // Transfer complete
         free(reply);
         endTransfer();
     }
 }
 
 DataReceiver::~DataReceiver()
 {
     if (m_propertyReply) {
         free(m_propertyReply);
         m_propertyReply = nullptr;
     }
 }
 
 void DataReceiver::transferFromProperty(xcb_get_property_reply_t *reply)
 {
     m_propertyStart = 0;
     m_propertyReply = reply;
 
     setData(static_cast<char *>(xcb_get_property_value(reply)),
             xcb_get_property_value_length(reply));
 }
 
 void DataReceiver::setData(const char *value, int length)
 {
     // simply set data without copy
     m_data = QByteArray::fromRawData(value, length);
 }
 
 QByteArray DataReceiver::data() const
 {
     return QByteArray::fromRawData(m_data.data() + m_propertyStart,
                                    m_data.size() - m_propertyStart);
 }
 
 void DataReceiver::partRead(int length)
 {
     m_propertyStart += length;
     if (m_propertyStart == m_data.size()) {
         Q_ASSERT(m_propertyReply);
         free(m_propertyReply);
         m_propertyReply = nullptr;
     }
 }
 
 void NetscapeUrlReceiver::setData(const char *value, int length)
 {
     auto origData = QByteArray::fromRawData(value, length);
 
     if (origData.indexOf('\n') == -1) {
         // there are no line breaks, not in Netscape url format or empty,
         // but try anyway
         setDataInternal(origData);
         return;
     }
     // remove every second line
     QByteArray data;
     int start = 0;
     bool remLine = false;
     while (start < length) {
         auto part = QByteArray::fromRawData(value + start, length - start);
         const int linebreak = part.indexOf('\n');
         if (linebreak == -1) {
             // no more linebreaks, end of work
             if (!remLine) {
                 // append the rest
                 data.append(part);
             }
             break;
         }
         if (remLine) {
             // no data to add, but add a linebreak for the next line
             data.append('\n');
         } else {
             // add data till before linebreak
             data.append(part.data(), linebreak);
         }
         remLine = !remLine;
         start = linebreak + 1;
     }
     setDataInternal(data);
 }
 
 void MozUrlReceiver::setData(const char *value, int length)
 {
     // represent as QByteArray (guaranteed '\0'-terminated)
     const auto origData = QByteArray::fromRawData(value, length);
 
     // text/x-moz-url data is sent in utf-16 - copies the content
     // and converts it into 8 byte representation
     const auto byteData = QString::fromUtf16(reinterpret_cast<const char16_t *>(origData.data())).toLatin1();
 
     if (byteData.indexOf('\n') == -1) {
         // there are no line breaks, not in text/x-moz-url format or empty,
         // but try anyway
         setDataInternal(byteData);
         return;
     }
     // remove every second line
     QByteArray data;
     int start = 0;
     bool remLine = false;
     while (start < length) {
         auto part = QByteArray::fromRawData(byteData.data() + start, byteData.size() - start);
         const int linebreak = part.indexOf('\n');
         if (linebreak == -1) {
             // no more linebreaks, end of work
             if (!remLine) {
                 // append the rest
                 data.append(part);
             }
             break;
         }
         if (remLine) {
             // no data to add, but add a linebreak for the next line
             data.append('\n');
         } else {
             // add data till before linebreak
             data.append(part.data(), linebreak);
         }
         remLine = !remLine;
         start = linebreak + 1;
     }
     setDataInternal(data);
 }
 
 void TransferXtoWl::dataSourceWrite()
 {
     QByteArray property = m_receiver->data();
 
     ssize_t len = write(fd(), property.constData(), property.size());
     if (len == -1) {
         qCWarning(KWIN_XWL) << "X11 to Wayland write error on fd:" << fd();
         endTransfer();
         return;
     }
 
     m_receiver->partRead(len);
     if (len == property.size()) {
         // property completely transferred
         if (incr()) {
             clearSocketNotifier();
             xcb_connection_t *xcbConn = kwinApp()->x11Connection();
             xcb_delete_property(xcbConn,
                                 m_window,
                                 atoms->wl_selection);
             xcb_flush(xcbConn);
         } else {
             // transfer complete
             endTransfer();
         }
     } else {
         if (!socketNotifier()) {
             createSocketNotifier(QSocketNotifier::Write);
             connect(socketNotifier(), &QSocketNotifier::activated, this,
                 [this](int socket) {
                     Q_UNUSED(socket);
                     dataSourceWrite();
                 }
             );
         }
     }
     resetTimeout();
 }
 
 } // namespace Xwl
 } // namespace KWin
diff --git a/xwl/transfer.h b/xwl/transfer.h
index e6aa18f0d..5b193875c 100644
--- a/xwl/transfer.h
+++ b/xwl/transfer.h
@@ -1,230 +1,230 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright 2018 Roman Gilg <subdiff@gmail.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_XWL_TRANSFER
 #define KWIN_XWL_TRANSFER
 
 #include <QObject>
 #include <QSocketNotifier>
 #include <QVector>
 
 #include <xcb/xcb.h>
 
 namespace KWayland
 {
 namespace Client
 {
 class DataDevice;
 class DataSource;
 }
-namespace Server
+}
+namespace KWaylandServer
 {
 class DataDeviceInterface;
 }
-}
 
 namespace KWin
 {
 namespace Xwl
 {
 
 /**
  * Represents for an arbitrary selection a data transfer between
  * sender and receiver.
  *
  * Lives for the duration of the transfer and must be cleaned up
  * externally afterwards. For that the owner should connect to the
  * @c finished() signal.
  */
 class Transfer : public QObject
 {
     Q_OBJECT
 
 public:
     Transfer(xcb_atom_t selection,
              qint32 fd,
              xcb_timestamp_t timestamp,
              QObject *parent = nullptr);
 
     virtual bool handlePropertyNotify(xcb_property_notify_event_t *event) = 0;
     void timeout();
     xcb_timestamp_t timestamp() const {
         return m_timestamp;
     }
 
 Q_SIGNALS:
     void finished();
 
 protected:
     void endTransfer();
 
     xcb_atom_t atom() const {
         return m_atom;
     }
     qint32 fd() const {
         return m_fd;
     }
 
     void setIncr(bool set) {
         m_incr = set;
     }
     bool incr() const {
         return m_incr;
     }
     void resetTimeout() {
         m_timeout = false;
     }
     void createSocketNotifier(QSocketNotifier::Type type);
     void clearSocketNotifier();
     QSocketNotifier *socketNotifier() const {
         return m_notifier;
     }
 private:
     void closeFd();
 
     xcb_atom_t m_atom;
     qint32 m_fd;
     xcb_timestamp_t m_timestamp = XCB_CURRENT_TIME;
 
     QSocketNotifier *m_notifier = nullptr;
     bool m_incr = false;
     bool m_timeout = false;
 
     Q_DISABLE_COPY(Transfer)
 };
 
 /**
  * Represents a transfer from a Wayland native source to an X window.
  */
 class TransferWltoX : public Transfer
 {
     Q_OBJECT
 
 public:
     TransferWltoX(xcb_atom_t selection,
                   xcb_selection_request_event_t *request,
                   qint32 fd,
                   QObject *parent = nullptr);
     ~TransferWltoX() override;
 
     void startTransferFromSource();
     bool handlePropertyNotify(xcb_property_notify_event_t *event) override;
 
 Q_SIGNALS:
     void selectionNotify(xcb_selection_request_event_t *event, bool success);
 
 private:
     void startIncr();
     void readWlSource();
     int flushSourceData();
     void handlePropertyDelete();
 
     xcb_selection_request_event_t *m_request = nullptr;
 
     /* contains all received data portioned in chunks
      * TODO: explain second QPair component
      */
     QVector<QPair<QByteArray, int> > m_chunks;
 
     bool m_propertyIsSet = false;
     bool m_flushPropertyOnDelete = false;
 
     Q_DISABLE_COPY(TransferWltoX)
 };
 
 /**
  * Helper class for X to Wl transfers.
  */
 class DataReceiver
 {
 public:
     virtual ~DataReceiver();
 
     void transferFromProperty(xcb_get_property_reply_t *reply);
 
 
     virtual void setData(const char *value, int length);
     QByteArray data() const;
 
     void partRead(int length);
 
 protected:
     void setDataInternal(QByteArray data) {
         m_data = data;
     }
 
 private:
     xcb_get_property_reply_t *m_propertyReply = nullptr;
     int m_propertyStart = 0;
     QByteArray m_data;
 };
 
 /**
  * Compatibility receiver for clients only
  * supporting the NETSCAPE_URL scheme (Firefox)
  */
 class NetscapeUrlReceiver : public DataReceiver
 {
 public:
     void setData(const char *value, int length) override;
 };
 
 /**
  * Compatibility receiver for clients only
  * supporting the text/x-moz-url scheme (Chromium on own drags)
  */
 class MozUrlReceiver : public DataReceiver
 {
 public:
     void setData(const char *value, int length) override;
 };
 
 /**
  * Represents a transfer from an X window to a Wayland native client.
  */
 class TransferXtoWl : public Transfer
 {
     Q_OBJECT
 
 public:
     TransferXtoWl(xcb_atom_t selection,
                   xcb_atom_t target,
                   qint32 fd,
                   xcb_timestamp_t timestamp, xcb_window_t parentWindow,
                   QObject *parent = nullptr);
     ~TransferXtoWl() override;
 
     bool handleSelectionNotify(xcb_selection_notify_event_t *event);
     bool handlePropertyNotify(xcb_property_notify_event_t *event) override;
 
 private:
     void dataSourceWrite();
     void startTransfer();
     void getIncrChunk();
 
     xcb_window_t m_window;
     DataReceiver *m_receiver = nullptr;
 
     Q_DISABLE_COPY(TransferXtoWl)
 };
 
 } // namespace Xwl
 } // namespace KWin
 
 #endif