diff --git a/CMakeLists.txt b/CMakeLists.txt
index 42b3118c9..5ab8137ac 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,761 +1,764 @@
 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.12.0")
 set(KF5_MIN_VERSION "5.66.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.13.0 CONFIG REQUIRED)
 
 find_package(KScreenLocker CONFIG REQUIRED)
 set_package_properties(KScreenLocker PROPERTIES
     TYPE REQUIRED
     PURPOSE "For screenlocker integration in kwin_wayland"
 )
 
 find_package(Breeze 5.9.0 CONFIG)
 set_package_properties(Breeze PROPERTIES
     TYPE OPTIONAL
     PURPOSE "For setting the default window decoration plugin"
 )
 if (${Breeze_FOUND})
     if (${BREEZE_WITH_KDECORATION})
         set(HAVE_BREEZE_DECO true)
     else()
         set(HAVE_BREEZE_DECO FALSE)
     endif()
 else()
     set(HAVE_BREEZE_DECO FALSE)
 endif()
 add_feature_info("Breeze-Decoration" HAVE_BREEZE_DECO "Default decoration plugin Breeze")
 
 find_package(EGL)
 set_package_properties(EGL PROPERTIES
     TYPE RUNTIME
     PURPOSE "Required to build KWin with EGL support"
 )
 
 find_package(epoxy)
 set_package_properties(epoxy PROPERTIES
     DESCRIPTION "libepoxy"
     URL "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})
 
 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)
 
 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
     orientation_sensor.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
     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
     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
     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)
 
 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.OrientationSensor.xml orientation_sensor.h KWin::OrientationSensor)
 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
     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/autotests/libinput/mock_libinput.cpp b/autotests/libinput/mock_libinput.cpp
index e3f3ace30..5742f8f5e 100644
--- a/autotests/libinput/mock_libinput.cpp
+++ b/autotests/libinput/mock_libinput.cpp
@@ -1,918 +1,936 @@
 /********************************************************************
 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 <libinput.h>
 #include "mock_libinput.h"
 #include <config-kwin.h>
 
 #include <linux/input.h>
 
 int libinput_device_keyboard_has_key(struct libinput_device *device, uint32_t code)
 {
     return device->keys.contains(code);
 }
 
 int libinput_device_has_capability(struct libinput_device *device, enum libinput_device_capability capability)
 {
     switch (capability) {
     case LIBINPUT_DEVICE_CAP_KEYBOARD:
         return device->keyboard;
     case LIBINPUT_DEVICE_CAP_POINTER:
         return device->pointer;
     case LIBINPUT_DEVICE_CAP_TOUCH:
         return device->touch;
     case LIBINPUT_DEVICE_CAP_GESTURE:
         return device->gestureSupported;
     case LIBINPUT_DEVICE_CAP_TABLET_TOOL:
         return device->tabletTool;
     case LIBINPUT_DEVICE_CAP_SWITCH:
         return device->switchDevice;
     default:
         return 0;
     }
 }
 
 const char *libinput_device_get_name(struct libinput_device *device)
 {
     return device->name.constData();
 }
 
 const char *libinput_device_get_sysname(struct libinput_device *device)
 {
     return device->sysName.constData();
 }
 
 const char *libinput_device_get_output_name(struct libinput_device *device)
 {
     return device->outputName.constData();
 }
 
 unsigned int libinput_device_get_id_product(struct libinput_device *device)
 {
     return device->product;
 }
 
 unsigned int libinput_device_get_id_vendor(struct libinput_device *device)
 {
     return device->vendor;
 }
 
 int libinput_device_config_tap_get_finger_count(struct libinput_device *device)
 {
     return device->tapFingerCount;
 }
 
 enum libinput_config_tap_state libinput_device_config_tap_get_enabled(struct libinput_device *device)
 {
     if (device->tapToClick) {
         return LIBINPUT_CONFIG_TAP_ENABLED;
     } else {
         return LIBINPUT_CONFIG_TAP_DISABLED;
     }
 }
 
 enum libinput_config_status libinput_device_config_tap_set_enabled(struct libinput_device *device, enum libinput_config_tap_state enable)
 {
     if (device->setTapToClickReturnValue == 0) {
         device->tapToClick = (enable == LIBINPUT_CONFIG_TAP_ENABLED);
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_tap_state libinput_device_config_tap_get_default_enabled(struct libinput_device *device)
 {
     if (device->tapEnabledByDefault) {
         return LIBINPUT_CONFIG_TAP_ENABLED;
     } else {
         return LIBINPUT_CONFIG_TAP_DISABLED;
     }
 }
 
 enum libinput_config_drag_state libinput_device_config_tap_get_default_drag_enabled(struct libinput_device *device)
 {
     if (device->tapAndDragEnabledByDefault) {
         return LIBINPUT_CONFIG_DRAG_ENABLED;
     } else {
         return LIBINPUT_CONFIG_DRAG_DISABLED;
     }
 }
 
 enum libinput_config_drag_state libinput_device_config_tap_get_drag_enabled(struct libinput_device *device)
 {
     if (device->tapAndDrag) {
         return LIBINPUT_CONFIG_DRAG_ENABLED;
     } else {
         return LIBINPUT_CONFIG_DRAG_DISABLED;
     }
 }
 
 enum libinput_config_status libinput_device_config_tap_set_drag_enabled(struct libinput_device *device, enum libinput_config_drag_state enable)
 {
     if (device->setTapAndDragReturnValue == 0) {
         device->tapAndDrag = (enable == LIBINPUT_CONFIG_DRAG_ENABLED);
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_drag_lock_state libinput_device_config_tap_get_default_drag_lock_enabled(struct libinput_device *device)
 {
     if (device->tapDragLockEnabledByDefault) {
         return LIBINPUT_CONFIG_DRAG_LOCK_ENABLED;
     } else {
         return LIBINPUT_CONFIG_DRAG_LOCK_DISABLED;
     }
 }
 
 enum libinput_config_drag_lock_state libinput_device_config_tap_get_drag_lock_enabled(struct libinput_device *device)
 {
     if (device->tapDragLock) {
         return LIBINPUT_CONFIG_DRAG_LOCK_ENABLED;
     } else {
         return LIBINPUT_CONFIG_DRAG_LOCK_DISABLED;
     }
 }
 
 enum libinput_config_status libinput_device_config_tap_set_drag_lock_enabled(struct libinput_device *device, enum libinput_config_drag_lock_state enable)
 {
     if (device->setTapDragLockReturnValue == 0) {
         device->tapDragLock = (enable == LIBINPUT_CONFIG_DRAG_LOCK_ENABLED);
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 int libinput_device_config_dwt_is_available(struct libinput_device *device)
 {
     return device->supportsDisableWhileTyping;
 }
 
 enum libinput_config_status libinput_device_config_dwt_set_enabled(struct libinput_device *device, enum libinput_config_dwt_state state)
 {
     if (device->setDisableWhileTypingReturnValue == 0) {
         if (!device->supportsDisableWhileTyping) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->disableWhileTyping = state;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_dwt_state libinput_device_config_dwt_get_enabled(struct libinput_device *device)
 {
     return device->disableWhileTyping;
 }
 
 enum libinput_config_dwt_state libinput_device_config_dwt_get_default_enabled(struct libinput_device *device)
 {
     return device->disableWhileTypingEnabledByDefault;
 }
 
 int libinput_device_config_accel_is_available(struct libinput_device *device)
 {
     return device->supportsPointerAcceleration;
 }
 
 int libinput_device_config_calibration_has_matrix(struct libinput_device *device)
 {
     return device->supportsCalibrationMatrix;
 }
 
 enum libinput_config_status libinput_device_config_calibration_set_matrix(struct libinput_device *device, const float matrix[6])
 {
     for (std::size_t i = 0; i < 6; i++) {
         device->calibrationMatrix[i] = matrix[i];
     }
     return LIBINPUT_CONFIG_STATUS_SUCCESS;
 }
 
 int libinput_device_config_calibration_get_default_matrix(struct libinput_device *device, float matrix[6])
 {
     for (std::size_t i = 0; i < 6; i++) {
         matrix[i] = device->defaultCalibrationMatrix[i];
     }
     return device->defaultCalibrationMatrixIsIdentity ? 0 : 1;
 }
 
 int libinput_device_config_left_handed_is_available(struct libinput_device *device)
 {
     return device->supportsLeftHanded;
 }
 
 uint32_t libinput_device_config_send_events_get_modes(struct libinput_device *device)
 {
     uint32_t modes = LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
     if (device->supportsDisableEvents) {
         modes |= LIBINPUT_CONFIG_SEND_EVENTS_DISABLED;
     }
     if (device->supportsDisableEventsOnExternalMouse) {
         modes |= LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE;
     }
     return modes;
 }
 
 int libinput_device_config_left_handed_get(struct libinput_device *device)
 {
     return device->leftHanded;
 }
 
 double libinput_device_config_accel_get_default_speed(struct libinput_device *device)
 {
     return device->defaultPointerAcceleration;
 }
 
 int libinput_device_config_left_handed_get_default(struct libinput_device *device)
 {
     return device->leftHandedEnabledByDefault;
 }
 
 double libinput_device_config_accel_get_speed(struct libinput_device *device)
 {
     return device->pointerAcceleration;
 }
 
 uint32_t libinput_device_config_accel_get_profiles(struct libinput_device *device)
 {
     return device->supportedPointerAccelerationProfiles;
 }
 
 enum libinput_config_accel_profile libinput_device_config_accel_get_default_profile(struct libinput_device *device)
 {
     return device->defaultPointerAccelerationProfile;
 }
 
 enum libinput_config_status libinput_device_config_accel_set_profile(struct libinput_device *device, enum libinput_config_accel_profile profile)
 {
     if (device->setPointerAccelerationProfileReturnValue == 0) {
         if (!(device->supportedPointerAccelerationProfiles & profile) && profile!= LIBINPUT_CONFIG_ACCEL_PROFILE_NONE) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->pointerAccelerationProfile = profile;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_accel_profile libinput_device_config_accel_get_profile(struct libinput_device *device)
 {
     return device->pointerAccelerationProfile;
 }
 
 uint32_t libinput_device_config_click_get_methods(struct libinput_device *device)
 {
     return device->supportedClickMethods;
 }
 
 enum libinput_config_click_method libinput_device_config_click_get_default_method(struct libinput_device *device)
 {
     return device->defaultClickMethod;
 }
 
 enum libinput_config_click_method libinput_device_config_click_get_method(struct libinput_device *device)
 {
     return device->clickMethod;
 }
 
 enum libinput_config_status libinput_device_config_click_set_method(struct libinput_device *device, enum libinput_config_click_method method)
 {
     if (device->setClickMethodReturnValue == 0) {
         if (!(device->supportedClickMethods & method) && method != LIBINPUT_CONFIG_CLICK_METHOD_NONE) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->clickMethod = method;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 uint32_t libinput_device_config_send_events_get_mode(struct libinput_device *device)
 {
     if (device->enabled) {
         return LIBINPUT_CONFIG_SEND_EVENTS_ENABLED;
     } else {
         // TODO: disabled on eternal mouse
         return LIBINPUT_CONFIG_SEND_EVENTS_DISABLED;
     }
 }
 
 struct libinput_device *libinput_device_ref(struct libinput_device *device)
 {
     return device;
 }
 
 struct libinput_device *libinput_device_unref(struct libinput_device *device)
 {
     return device;
 }
 
 int libinput_device_get_size(struct libinput_device *device, double *width, double *height)
 {
     if (device->deviceSizeReturnValue) {
         return device->deviceSizeReturnValue;
     }
     if (width) {
         *width = device->deviceSize.width();
     }
     if (height) {
         *height = device->deviceSize.height();
     }
     return device->deviceSizeReturnValue;
 }
 
 int libinput_device_pointer_has_button(struct libinput_device *device, uint32_t code)
 {
     switch (code) {
     case BTN_LEFT:
         return device->supportedButtons.testFlag(Qt::LeftButton);
     case BTN_MIDDLE:
         return device->supportedButtons.testFlag(Qt::MiddleButton);
     case BTN_RIGHT:
         return device->supportedButtons.testFlag(Qt::RightButton);
     case BTN_SIDE:
         return device->supportedButtons.testFlag(Qt::ExtraButton1);
     case BTN_EXTRA:
         return device->supportedButtons.testFlag(Qt::ExtraButton2);
     case BTN_BACK:
         return device->supportedButtons.testFlag(Qt::BackButton);
     case BTN_FORWARD:
         return device->supportedButtons.testFlag(Qt::ForwardButton);
     case BTN_TASK:
         return device->supportedButtons.testFlag(Qt::TaskButton);
     default:
         return 0;
     }
 }
 
 enum libinput_config_status libinput_device_config_left_handed_set(struct libinput_device *device, int left_handed)
 {
     if (device->setLeftHandedReturnValue == 0) {
         device->leftHanded = left_handed;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_status libinput_device_config_accel_set_speed(struct libinput_device *device, double speed)
 {
     if (device->setPointerAccelerationReturnValue == 0) {
         device->pointerAcceleration = speed;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_status libinput_device_config_send_events_set_mode(struct libinput_device *device, uint32_t mode)
 {
     if (device->setEnableModeReturnValue == 0) {
         device->enabled = (mode == LIBINPUT_CONFIG_SEND_EVENTS_ENABLED);
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 
 enum libinput_event_type libinput_event_get_type(struct libinput_event *event)
 {
     return event->type;
 }
 
 struct libinput_device *libinput_event_get_device(struct libinput_event *event)
 {
     return event->device;
 }
 
 void libinput_event_destroy(struct libinput_event *event)
 {
     delete event;
 }
 
 struct libinput_event_keyboard *libinput_event_get_keyboard_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_KEYBOARD_KEY) {
         return reinterpret_cast<libinput_event_keyboard *>(event);
     }
     return nullptr;
 }
 
 struct libinput_event_pointer *libinput_event_get_pointer_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_POINTER_MOTION ||
         event->type == LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE ||
         event->type == LIBINPUT_EVENT_POINTER_BUTTON ||
         event->type == LIBINPUT_EVENT_POINTER_AXIS) {
         return reinterpret_cast<libinput_event_pointer *>(event);
     }
     return nullptr;
 }
 
 struct libinput_event_touch *libinput_event_get_touch_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_TOUCH_DOWN ||
         event->type == LIBINPUT_EVENT_TOUCH_UP ||
         event->type == LIBINPUT_EVENT_TOUCH_MOTION ||
         event->type == LIBINPUT_EVENT_TOUCH_CANCEL ||
         event->type == LIBINPUT_EVENT_TOUCH_FRAME) {
         return reinterpret_cast<libinput_event_touch *>(event);
     }
     return nullptr;
 }
 
 struct libinput_event_gesture *libinput_event_get_gesture_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_GESTURE_PINCH_BEGIN ||
         event->type == LIBINPUT_EVENT_GESTURE_PINCH_UPDATE ||
         event->type == LIBINPUT_EVENT_GESTURE_PINCH_END ||
         event->type == LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN ||
         event->type == LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE ||
         event->type == LIBINPUT_EVENT_GESTURE_SWIPE_END) {
         return reinterpret_cast<libinput_event_gesture *>(event);
     }
     return nullptr;
 }
 
 int libinput_event_gesture_get_cancelled(struct libinput_event_gesture *event)
 {
     if (event->type == LIBINPUT_EVENT_GESTURE_PINCH_END || event->type == LIBINPUT_EVENT_GESTURE_SWIPE_END) {
         return event->cancelled;
     }
     return 0;
 }
 
 uint32_t libinput_event_gesture_get_time(struct libinput_event_gesture *event)
 {
     return event->time;
 }
 
 int libinput_event_gesture_get_finger_count(struct libinput_event_gesture *event)
 {
     return event->fingerCount;
 }
 
 double libinput_event_gesture_get_dx(struct libinput_event_gesture *event)
 {
     if (event->type == LIBINPUT_EVENT_GESTURE_PINCH_UPDATE || event->type == LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE) {
         return event->delta.width();
     }
     return 0.0;
 }
 
 double libinput_event_gesture_get_dy(struct libinput_event_gesture *event)
 {
     if (event->type == LIBINPUT_EVENT_GESTURE_PINCH_UPDATE || event->type == LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE) {
         return event->delta.height();
     }
     return 0.0;
 }
 
 double libinput_event_gesture_get_scale(struct libinput_event_gesture *event)
 {
     switch (event->type) {
     case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN:
         return 1.0;
     case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE:
     case LIBINPUT_EVENT_GESTURE_PINCH_END:
         return event->scale;
     default:
         return 0.0;
     }
 }
 
 double libinput_event_gesture_get_angle_delta(struct libinput_event_gesture *event)
 {
     if (event->type == LIBINPUT_EVENT_GESTURE_PINCH_UPDATE) {
         return event->angleDelta;
     }
     return 0.0;
 }
 
 uint32_t libinput_event_keyboard_get_key(struct libinput_event_keyboard *event)
 {
     return event->key;
 }
 
 enum libinput_key_state libinput_event_keyboard_get_key_state(struct libinput_event_keyboard *event)
 {
     return event->state;
 }
 
 uint32_t libinput_event_keyboard_get_time(struct libinput_event_keyboard *event)
 {
     return event->time;
 }
 
 double libinput_event_pointer_get_absolute_x(struct libinput_event_pointer *event)
 {
     return event->absolutePos.x();
 }
 
 double libinput_event_pointer_get_absolute_y(struct libinput_event_pointer *event)
 {
     return event->absolutePos.y();
 }
 
 double libinput_event_pointer_get_absolute_x_transformed(struct libinput_event_pointer *event, uint32_t width)
 {
     double deviceWidth = 0.0;
     double deviceHeight = 0.0;
     libinput_device_get_size(event->device, &deviceWidth, &deviceHeight);
     return event->absolutePos.x() / deviceWidth * width;
 }
 
 double libinput_event_pointer_get_absolute_y_transformed(struct libinput_event_pointer *event, uint32_t height)
 {
     double deviceWidth = 0.0;
     double deviceHeight = 0.0;
     libinput_device_get_size(event->device, &deviceWidth, &deviceHeight);
     return event->absolutePos.y() / deviceHeight * height;
 }
 
 double libinput_event_pointer_get_dx(struct libinput_event_pointer *event)
 {
     return event->delta.width();
 }
 
 double libinput_event_pointer_get_dy(struct libinput_event_pointer *event)
 {
     return event->delta.height();
 }
 
 double libinput_event_pointer_get_dx_unaccelerated(struct libinput_event_pointer *event)
 {
     return event->delta.width();
 }
 
 double libinput_event_pointer_get_dy_unaccelerated(struct libinput_event_pointer *event)
 {
     return event->delta.height();
 }
 
 uint32_t libinput_event_pointer_get_time(struct libinput_event_pointer *event)
 {
     return event->time;
 }
 
 uint64_t libinput_event_pointer_get_time_usec(struct libinput_event_pointer *event)
 {
     return quint64(event->time * 1000);
 }
 
 uint32_t libinput_event_pointer_get_button(struct libinput_event_pointer *event)
 {
     return event->button;
 }
 
 enum libinput_button_state libinput_event_pointer_get_button_state(struct libinput_event_pointer *event)
 {
     return event->buttonState;
 }
 
 int libinput_event_pointer_has_axis(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
 {
     if (axis == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL) {
         return event->verticalAxis;
     } else {
         return event->horizontalAxis;
     }
 }
 
 double libinput_event_pointer_get_axis_value(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
 {
     if (axis == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL) {
         return event->verticalAxisValue;
     } else {
         return event->horizontalAxisValue;
     }
 }
 
 double libinput_event_pointer_get_axis_value_discrete(struct libinput_event_pointer *event, enum libinput_pointer_axis axis)
 {
     if (axis == LIBINPUT_POINTER_AXIS_SCROLL_VERTICAL) {
         return event->verticalDiscreteAxisValue;
     } else {
         return event->horizontalDiscreteAxisValue;
     }
 }
 
 enum libinput_pointer_axis_source libinput_event_pointer_get_axis_source(struct libinput_event_pointer *event)
 {
     return event->axisSource;
 }
 
 uint32_t libinput_event_touch_get_time(struct libinput_event_touch *event)
 {
     return event->time;
 }
 
 double libinput_event_touch_get_x(struct libinput_event_touch *event)
 {
     return event->absolutePos.x();
 }
 
 double libinput_event_touch_get_y(struct libinput_event_touch *event)
 {
     return event->absolutePos.y();
 }
 
 double libinput_event_touch_get_x_transformed(struct libinput_event_touch *event, uint32_t width)
 {
     double deviceWidth = 0.0;
     double deviceHeight = 0.0;
     libinput_device_get_size(event->device, &deviceWidth, &deviceHeight);
     return event->absolutePos.x() / deviceWidth * width;
 }
 
 double libinput_event_touch_get_y_transformed(struct libinput_event_touch *event, uint32_t height)
 {
     double deviceWidth = 0.0;
     double deviceHeight = 0.0;
     libinput_device_get_size(event->device, &deviceWidth, &deviceHeight);
     return event->absolutePos.y() / deviceHeight * height;
 }
 
 int32_t libinput_event_touch_get_slot(struct libinput_event_touch *event)
 {
     return event->slot;
 }
 
 struct libinput *libinput_udev_create_context(const struct libinput_interface *interface, void *user_data, struct udev *udev)
 {
     if (!udev) {
         return nullptr;
     }
     Q_UNUSED(interface)
     Q_UNUSED(user_data)
     return new libinput;
 }
 
 void libinput_log_set_priority(struct libinput *libinput, enum libinput_log_priority priority)
 {
     Q_UNUSED(libinput)
     Q_UNUSED(priority)
 }
 
 void libinput_log_set_handler(struct libinput *libinput, libinput_log_handler log_handler)
 {
     Q_UNUSED(libinput)
     Q_UNUSED(log_handler)
 }
 
 struct libinput *libinput_unref(struct libinput *libinput)
 {
     libinput->refCount--;
     if (libinput->refCount == 0) {
         delete libinput;
         return nullptr;
     }
     return libinput;
 }
 
 int libinput_udev_assign_seat(struct libinput *libinput, const char *seat_id)
 {
     if (libinput->assignSeatRetVal == 0) {
         libinput->seat = QByteArray(seat_id);
     }
     return libinput->assignSeatRetVal;
 }
 
 int libinput_get_fd(struct libinput *libinput)
 {
     Q_UNUSED(libinput)
     return -1;
 }
 
 int libinput_dispatch(struct libinput *libinput)
 {
     Q_UNUSED(libinput)
     return 0;
 }
 
 struct libinput_event *libinput_get_event(struct libinput *libinput)
 {
     Q_UNUSED(libinput)
     return nullptr;
 }
 
 void libinput_suspend(struct libinput *libinput)
 {
     Q_UNUSED(libinput)
 }
 
 int libinput_resume(struct libinput *libinput)
 {
     Q_UNUSED(libinput)
     return 0;
 }
 
 int libinput_device_config_middle_emulation_is_available(struct libinput_device *device)
 {
     return device->supportsMiddleEmulation;
 }
 
 enum libinput_config_status libinput_device_config_middle_emulation_set_enabled(struct libinput_device *device, enum libinput_config_middle_emulation_state enable)
 {
     if (device->setMiddleEmulationReturnValue == 0) {
         if (!device->supportsMiddleEmulation) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->middleEmulation = (enable == LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED);
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_middle_emulation_state libinput_device_config_middle_emulation_get_enabled(struct libinput_device *device)
 {
     if (device->middleEmulation) {
         return LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED;
     } else {
         return LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED;
     }
 }
 
 enum libinput_config_middle_emulation_state libinput_device_config_middle_emulation_get_default_enabled(struct libinput_device *device)
 {
     if (device->middleEmulationEnabledByDefault) {
         return LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED;
     } else {
         return LIBINPUT_CONFIG_MIDDLE_EMULATION_DISABLED;
     }
 }
 
 int libinput_device_config_scroll_has_natural_scroll(struct libinput_device *device)
 {
     return device->supportsNaturalScroll;
 }
 
 enum libinput_config_status libinput_device_config_scroll_set_natural_scroll_enabled(struct libinput_device *device, int enable)
 {
     if (device->setNaturalScrollReturnValue == 0) {
         if (!device->supportsNaturalScroll) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->naturalScroll = enable;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 int libinput_device_config_scroll_get_natural_scroll_enabled(struct libinput_device *device)
 {
     return device->naturalScroll;
 }
 
 int libinput_device_config_scroll_get_default_natural_scroll_enabled(struct libinput_device *device)
 {
     return device->naturalScrollEnabledByDefault;
 }
 
 enum libinput_config_tap_button_map libinput_device_config_tap_get_default_button_map(struct libinput_device *device)
 {
     return device->defaultTapButtonMap;
 }
 
 enum libinput_config_status libinput_device_config_tap_set_button_map(struct libinput_device *device, enum libinput_config_tap_button_map map)
 {
     if (device->setTapButtonMapReturnValue == 0) {
         if (device->tapFingerCount == 0) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->tapButtonMap = map;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_tap_button_map libinput_device_config_tap_get_button_map(struct libinput_device *device)
 {
     return device->tapButtonMap;
 }
 
 uint32_t libinput_device_config_scroll_get_methods(struct libinput_device *device)
 {
     return device->supportedScrollMethods;
 }
 
 enum libinput_config_scroll_method libinput_device_config_scroll_get_default_method(struct libinput_device *device)
 {
     return device->defaultScrollMethod;
 }
 
 enum libinput_config_status libinput_device_config_scroll_set_method(struct libinput_device *device, enum libinput_config_scroll_method method)
 {
     if (device->setScrollMethodReturnValue == 0) {
         if (!(device->supportedScrollMethods & method) && method != LIBINPUT_CONFIG_SCROLL_NO_SCROLL) {
             return LIBINPUT_CONFIG_STATUS_INVALID;
         }
         device->scrollMethod = method;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 enum libinput_config_scroll_method libinput_device_config_scroll_get_method(struct libinput_device *device)
 {
     return device->scrollMethod;
 }
 
 enum libinput_config_status libinput_device_config_scroll_set_button(struct libinput_device *device, uint32_t button)
 {
     if (device->setScrollButtonReturnValue == 0) {
         if (!(device->supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN)) {
             return LIBINPUT_CONFIG_STATUS_UNSUPPORTED;
         }
         device->scrollButton = button;
         return LIBINPUT_CONFIG_STATUS_SUCCESS;
     }
     return LIBINPUT_CONFIG_STATUS_INVALID;
 }
 
 uint32_t libinput_device_config_scroll_get_button(struct libinput_device *device)
 {
     return device->scrollButton;
 }
 
 uint32_t libinput_device_config_scroll_get_default_button(struct libinput_device *device)
 {
     return device->defaultScrollButton;
 }
 
 int libinput_device_switch_has_switch(struct libinput_device *device, enum libinput_switch sw)
 {
     switch (sw) {
     case LIBINPUT_SWITCH_LID:
         return device->lidSwitch;
     case LIBINPUT_SWITCH_TABLET_MODE:
         return device->tabletModeSwitch;
     default:
         Q_UNREACHABLE();
     }
     return 0;
 }
 
 struct libinput_event_switch *libinput_event_get_switch_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_SWITCH_TOGGLE) {
         return reinterpret_cast<libinput_event_switch*>(event);
     } else {
         return nullptr;
     }
 }
 
 enum libinput_switch_state libinput_event_switch_get_switch_state(struct libinput_event_switch *event)
 {
     switch (event->state) {
     case libinput_event_switch::State::On:
         return LIBINPUT_SWITCH_STATE_ON;
     case libinput_event_switch::State::Off:
         return LIBINPUT_SWITCH_STATE_OFF;
     default:
         Q_UNREACHABLE();
     }
 }
 
 uint32_t libinput_event_switch_get_time(struct libinput_event_switch *event)
 {
     return event->time;;
 }
 
 uint64_t libinput_event_switch_get_time_usec(struct libinput_event_switch *event)
 {
     return event->timeMicroseconds;
 }
 
 struct libinput_event_tablet_pad *libinput_event_get_tablet_pad_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_TABLET_PAD_BUTTON) {
         return reinterpret_cast<libinput_event_tablet_pad *>(event);
     }
     return nullptr;
 }
 
 struct libinput_event_tablet_tool *
 libinput_event_get_tablet_tool_event(struct libinput_event *event)
 {
     if (event->type == LIBINPUT_EVENT_TABLET_TOOL_AXIS ||
         event->type == LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY ||
         event->type == LIBINPUT_EVENT_TABLET_TOOL_TIP) {
         return reinterpret_cast<libinput_event_tablet_tool *>(event);
     }
     return nullptr;
 }
+
+int
+libinput_device_tablet_pad_get_num_strips(struct libinput_device *device)
+{
+    return device->stripCount;
+}
+
+int
+libinput_device_tablet_pad_get_num_rings(struct libinput_device *device)
+{
+    return device->ringCount;
+}
+
+int
+libinput_device_tablet_pad_get_num_buttons(struct libinput_device *device)
+{
+    return device->buttonCount;
+}
diff --git a/autotests/libinput/mock_libinput.h b/autotests/libinput/mock_libinput.h
index 2ee789297..6f6d12646 100644
--- a/autotests/libinput/mock_libinput.h
+++ b/autotests/libinput/mock_libinput.h
@@ -1,166 +1,169 @@
 /********************************************************************
 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/>.
 *********************************************************************/
 #ifndef MOCK_LIBINPUT_H
 #define MOCK_LIBINPUT_H
 #include <libinput.h>
 
 #include <QByteArray>
 #include <QPointF>
 #include <QSizeF>
 #include <QVector>
 
 #include <array>
 
 struct libinput_device {
     bool keyboard = false;
     bool pointer = false;
     bool touch = false;
     bool tabletTool = false;
     bool gestureSupported = false;
     bool switchDevice = false;
     QByteArray name;
     QByteArray sysName = QByteArrayLiteral("event0");
     QByteArray outputName;
     quint32 product = 0;
     quint32 vendor = 0;
     int tapFingerCount = 0;
     QSizeF deviceSize;
     int deviceSizeReturnValue = 0;
     bool tapEnabledByDefault = false;
     bool tapToClick = false;
     bool tapAndDragEnabledByDefault = false;
     bool tapAndDrag = false;
     bool tapDragLockEnabledByDefault = false;
     bool tapDragLock = false;
     bool supportsDisableWhileTyping = false;
     bool supportsPointerAcceleration = false;
     bool supportsLeftHanded = false;
     bool supportsCalibrationMatrix = false;
     bool supportsDisableEvents = false;
     bool supportsDisableEventsOnExternalMouse = false;
     bool supportsMiddleEmulation = false;
     bool supportsNaturalScroll = false;
     quint32 supportedScrollMethods = 0;
     bool middleEmulationEnabledByDefault = false;
     bool middleEmulation = false;
     enum libinput_config_tap_button_map defaultTapButtonMap = LIBINPUT_CONFIG_TAP_MAP_LRM;
     enum libinput_config_tap_button_map tapButtonMap = LIBINPUT_CONFIG_TAP_MAP_LRM;
     int setTapButtonMapReturnValue = 0;
     enum libinput_config_dwt_state disableWhileTypingEnabledByDefault = LIBINPUT_CONFIG_DWT_DISABLED;
     enum libinput_config_dwt_state disableWhileTyping = LIBINPUT_CONFIG_DWT_DISABLED;
     int setDisableWhileTypingReturnValue = 0;
     qreal defaultPointerAcceleration = 0.0;
     qreal pointerAcceleration = 0.0;
     int setPointerAccelerationReturnValue = 0;
     bool leftHandedEnabledByDefault = false;
     bool leftHanded = false;
     int setLeftHandedReturnValue = 0;
     bool naturalScrollEnabledByDefault = false;
     bool naturalScroll = false;
     int setNaturalScrollReturnValue = 0;
     enum libinput_config_scroll_method defaultScrollMethod = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
     enum libinput_config_scroll_method scrollMethod = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
     int setScrollMethodReturnValue = 0;
     quint32 defaultScrollButton = 0;
     quint32 scrollButton = 0;
     int setScrollButtonReturnValue = 0;
     Qt::MouseButtons supportedButtons;
     QVector<quint32> keys;
     bool enabled = true;
     int setEnableModeReturnValue = 0;
     int setTapToClickReturnValue = 0;
     int setTapAndDragReturnValue = 0;
     int setTapDragLockReturnValue = 0;
     int setMiddleEmulationReturnValue = 0;
     quint32 supportedPointerAccelerationProfiles = 0;
     enum libinput_config_accel_profile defaultPointerAccelerationProfile = LIBINPUT_CONFIG_ACCEL_PROFILE_NONE;
     enum libinput_config_accel_profile pointerAccelerationProfile = LIBINPUT_CONFIG_ACCEL_PROFILE_NONE;
     bool setPointerAccelerationProfileReturnValue = 0;
     std::array<float, 6> defaultCalibrationMatrix{{1.0f, 0.0f, 0.0f,
                                                    0.0f, 1.0f, 0.0f}};
     std::array<float, 6> calibrationMatrix{{1.0f, 0.0f, 0.0f,
                                             0.0f, 1.0f, 0.0f}};
     bool defaultCalibrationMatrixIsIdentity = true;
 
     bool lidSwitch = false;
     bool tabletModeSwitch = false;
     quint32 supportedClickMethods = 0;
     enum libinput_config_click_method defaultClickMethod = LIBINPUT_CONFIG_CLICK_METHOD_NONE;
     enum libinput_config_click_method clickMethod = LIBINPUT_CONFIG_CLICK_METHOD_NONE;
     bool setClickMethodReturnValue = 0;
+    uint32_t buttonCount = 0;
+    uint32_t stripCount = 0;
+    uint32_t ringCount = 0;
 };
 
 struct libinput_event {
     libinput_device *device = nullptr;
     libinput_event_type type = LIBINPUT_EVENT_NONE;
     quint32 time = 0;
 };
 
 struct libinput_event_keyboard : libinput_event {
     libinput_event_keyboard() {
         type = LIBINPUT_EVENT_KEYBOARD_KEY;
     }
     libinput_key_state state = LIBINPUT_KEY_STATE_RELEASED;
     quint32 key = 0;
 };
 
 struct libinput_event_pointer : libinput_event {
     libinput_button_state buttonState = LIBINPUT_BUTTON_STATE_RELEASED;
     quint32 button = 0;
     bool verticalAxis = false;
     bool horizontalAxis = false;
     qreal horizontalAxisValue = 0.0;
     qreal verticalAxisValue = 0.0;
     qreal horizontalDiscreteAxisValue = 0.0;
     qreal verticalDiscreteAxisValue = 0.0;
     libinput_pointer_axis_source axisSource = {};
     QSizeF delta;
     QPointF absolutePos;
 };
 
 struct libinput_event_touch : libinput_event {
     qint32 slot = -1;
     QPointF absolutePos;
 };
 
 struct libinput_event_gesture : libinput_event {
     int fingerCount = 0;
     bool cancelled = false;
     QSizeF delta = QSizeF(0, 0);
     qreal scale = 0.0;
     qreal angleDelta = 0.0;
 };
 
 struct libinput_event_switch : libinput_event {
     enum class State {
         Off,
         On
     };
     State state = State::Off;
     quint64 timeMicroseconds = 0;
 };
 
 struct libinput {
     int refCount = 1;
     QByteArray seat;
     int assignSeatRetVal = 0;
 };
 
 #endif
diff --git a/debug_console.cpp b/debug_console.cpp
index c0f012ff3..7d21b019e 100644
--- a/debug_console.cpp
+++ b/debug_console.cpp
@@ -1,1596 +1,1597 @@
 /********************************************************************
  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 "xdgshellclient.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>
 // 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(QTabletEvent *event)
+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.type()) {
     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);
             } 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_shellClients.append(c);
         }
         // TODO: that only includes windows getting shown, not those which are only created
         connect(waylandServer(), &WaylandServer::shellClientAdded, this,
             [this] (XdgShellClient *c) {
                 add(s_waylandClientId -1, m_shellClients, c);
             }
         );
         connect(waylandServer(), &WaylandServer::shellClientRemoved, this,
             [this] (XdgShellClient *c) {
                 remove(s_waylandClientId -1, m_shellClients, 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_shellClients.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::shellClient);
     } 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_shellClients, 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::shellClient);
     } 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 (XdgShellClient *c = shellClient(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_shellClients);
         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);
 }
 
 XdgShellClient *DebugConsoleModel::shellClient(const QModelIndex &index) const
 {
     return clientForIndex(index, m_shellClients, 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;
 
     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] (XdgShellClient *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;
         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;
         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;
     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;
     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/debug_console.h b/debug_console.h
index 1ad925a24..1ad2dae5b 100644
--- a/debug_console.h
+++ b/debug_console.h
@@ -1,191 +1,191 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 #ifndef KWIN_DEBUG_CONSOLE_H
 #define KWIN_DEBUG_CONSOLE_H
 
 #include <kwin_export.h>
 #include <config-kwin.h>
 #include "input.h"
 #include "input_event_spy.h"
 
 #include <QAbstractItemModel>
 #include <QStyledItemDelegate>
 #include <QVector>
 
 class QTextEdit;
 
 namespace Ui
 {
 class DebugConsole;
 }
 
 namespace KWin
 {
 
 class X11Client;
 class InternalClient;
 class XdgShellClient;
 class Unmanaged;
 class DebugConsoleFilter;
 
 class KWIN_EXPORT DebugConsoleModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit DebugConsoleModel(QObject *parent = nullptr);
     ~DebugConsoleModel() override;
 
 
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent) const override;
     int rowCount(const QModelIndex &parent) const override;
     QModelIndex parent(const QModelIndex &child) const override;
 
 private:
     template <class T>
     QModelIndex indexForClient(int row, int column, const QVector<T*> &clients, int id) const;
     template <class T>
     QModelIndex indexForProperty(int row, int column, const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const;
     template <class T>
     int propertyCount(const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex&) const) const;
     QVariant propertyData(QObject *object, const QModelIndex &index, int role) const;
     template <class T>
     QVariant clientData(const QModelIndex &index, int role, const QVector<T*> clients) const;
     template <class T>
     void add(int parentRow, QVector<T*> &clients, T *client);
     template <class T>
     void remove(int parentRow, QVector<T*> &clients, T *client);
     XdgShellClient *shellClient(const QModelIndex &index) const;
     InternalClient *internalClient(const QModelIndex &index) const;
     X11Client *x11Client(const QModelIndex &index) const;
     Unmanaged *unmanaged(const QModelIndex &index) const;
     int topLevelRowCount() const;
 
     QVector<XdgShellClient *> m_shellClients;
     QVector<InternalClient*> m_internalClients;
     QVector<X11Client *> m_x11Clients;
     QVector<Unmanaged*> m_unmanageds;
 
 };
 
 class DebugConsoleDelegate : public QStyledItemDelegate
 {
     Q_OBJECT
 public:
     explicit DebugConsoleDelegate(QObject *parent = nullptr);
     ~DebugConsoleDelegate() override;
 
     QString displayText(const QVariant &value, const QLocale &locale) const override;
 };
 
 class KWIN_EXPORT DebugConsole : public QWidget
 {
     Q_OBJECT
 public:
     DebugConsole();
     ~DebugConsole() override;
 
 protected:
     void showEvent(QShowEvent *event) override;
 
 private:
     void initGLTab();
     void updateKeyboardTab();
 
     QScopedPointer<Ui::DebugConsole> m_ui;
     QScopedPointer<DebugConsoleFilter> m_inputFilter;
 };
 
 class SurfaceTreeModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit SurfaceTreeModel(QObject *parent = nullptr);
     ~SurfaceTreeModel() override;
 
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent) const override;
     int rowCount(const QModelIndex &parent) const override;
     QModelIndex parent(const QModelIndex &child) const override;
 };
 
 class DebugConsoleFilter : public InputEventSpy
 {
 public:
     explicit DebugConsoleFilter(QTextEdit *textEdit);
     ~DebugConsoleFilter() override;
 
     void pointerEvent(MouseEvent *event) override;
     void wheelEvent(WheelEvent *event) override;
     void keyEvent(KeyEvent *event) override;
     void touchDown(qint32 id, const QPointF &pos, quint32 time) override;
     void touchMotion(qint32 id, const QPointF &pos, quint32 time) override;
     void touchUp(qint32 id, quint32 time) override;
 
     void pinchGestureBegin(int fingerCount, quint32 time) override;
     void pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time) override;
     void pinchGestureEnd(quint32 time) override;
     void pinchGestureCancelled(quint32 time) override;
 
     void swipeGestureBegin(int fingerCount, quint32 time) override;
     void swipeGestureUpdate(const QSizeF &delta, quint32 time) override;
     void swipeGestureEnd(quint32 time) override;
     void swipeGestureCancelled(quint32 time) override;
 
     void switchEvent(SwitchEvent *event) override;
 
-    void tabletToolEvent(QTabletEvent *event) override;
+    void tabletToolEvent(TabletEvent *event) override;
     void tabletToolButtonEvent(const QSet<uint> &pressedButtons) override;
     void tabletPadButtonEvent(const QSet<uint> &pressedButtons) override;
     void tabletPadStripEvent(int number, int position, bool isFinger) override;
     void tabletPadRingEvent(int number, int position, bool isFinger) override;
 
 private:
     QTextEdit *m_textEdit;
 };
 
 namespace LibInput
 {
 class Device;
 }
 
 class InputDeviceModel : public QAbstractItemModel
 {
     Q_OBJECT
 public:
     explicit InputDeviceModel(QObject *parent = nullptr);
     ~InputDeviceModel() override;
 
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     QModelIndex index(int row, int column, const QModelIndex & parent) const override;
     int rowCount(const QModelIndex &parent) const override;
     QModelIndex parent(const QModelIndex &child) const override;
 
 private:
     void setupDeviceConnections(LibInput::Device *device);
     QVector<LibInput::Device*> m_devices;
 };
 
 }
 
 #endif
diff --git a/input.cpp b/input.cpp
index 27d1e926d..67d30638a 100644
--- a/input.cpp
+++ b/input.cpp
@@ -1,2539 +1,2684 @@
 /********************************************************************
  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 "unmanaged.h"
-#include "screenedge.h"
-#include "screens.h"
-#include "workspace.h"
+#include "internal_client.h"
 #include "libinput/connection.h"
 #include "libinput/device.h"
 #include "platform.h"
 #include "popup_input_filter.h"
-#include "xdgshellclient.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 "internal_client.h"
+#include <KDecoration2/Decoration>
+#include <KGlobalAccel>
 #include <KWayland/Server/display.h>
 #include <KWayland/Server/fakeinput_interface.h>
-#include <KWayland/Server/seat_interface.h>
 #include <KWayland/Server/relativepointer_interface.h>
+#include <KWayland/Server/seat_interface.h>
+#include <KWayland/Server/tablet_interface.h>
+#include <KWayland/Server/surface_interface.h>
 #include <decorations/decoratedclient.h>
-#include <KDecoration2/Decoration>
-#include <KGlobalAccel>
 
 //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(QTabletEvent *event)
+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)()) {
             if (Toplevel *t = waylandServer()->findClient(s)) {
                 return t->isLockScreen() || t->isInputMethod();
             }
             return false;
         }
         return true;
     }
     bool pointerSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedPointerSurface);
     }
     bool keyboardSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::SeatInterface::focusedKeyboardSurface);
     }
     bool touchSurfaceAllowed() const {
         return surfaceAllowed(&KWayland::Server::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:
     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->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;
     }
 };
 
 
 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;
         switch (_event->axisSource()) {
         case KWin::InputRedirection::PointerAxisSourceWheel:
             source = KWayland::Server::PointerAxisSource::Wheel;
             break;
         case KWin::InputRedirection::PointerAxisSourceFinger:
             source = KWayland::Server::PointerAxisSource::Finger;
             break;
         case KWin::InputRedirection::PointerAxisSourceContinuous:
             source = KWayland::Server::PointerAxisSource::Continuous;
             break;
         case KWin::InputRedirection::PointerAxisSourceWheelTilt:
             source = KWayland::Server::PointerAxisSource::WheelTilt;
             break;
         case KWin::InputRedirection::PointerAxisSourceUnknown:
         default:
             source = KWayland::Server::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()
+{
+    auto server = waylandServer();
+    if (!server) {
+        return nullptr;
+    }
+    return server->seat();
+}
+
 /**
  * Useful when there's no proper tablet support on the clients
  */
-class FakeTabletInputFilter : public InputEventFilter
+class TabletInputFilter : public QObject, public InputEventFilter
 {
 public:
-    FakeTabletInputFilter()
+    TabletInputFilter()
+    {
+    }
+
+    static KWayland::Server::TabletSeatInterface *findTabletSeat()
     {
+        auto server = waylandServer();
+        if (!server) {
+            return nullptr;
+        }
+        KWayland::Server::TabletManagerInterface* manager = server->tabletManager();
+        return manager->seat(findSeat());
+    }
+
+    void integrateDevice(LibInput::Device *device)
+    {
+        if (device->isTabletTool()) {
+            KWayland::Server::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();
+        tabletSeat->removeTablet(sysname);
+    }
+
+    bool tabletToolEvent(TabletEvent *event) override
+    {
+        if (!workspace()) {
+            return false;
+        }
+
+        KWayland::Server::TabletSeatInterface *tabletSeat = findTabletSeat();
+        auto tool = tabletSeat->toolByHardwareId(event->serialId());
+        if (!tool) {
+            using namespace KWayland::Server;
+
+            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);
+        }
+
+        KWayland::Server::TabletInterface *tablet = tabletSeat->tabletByName(event->tabletSysName());
+
+        Toplevel *toplevel = input()->findToplevel(event->globalPos());
+        if (!toplevel || !toplevel->surface()) {
+            return false;
+        }
+
+        KWayland::Server::SurfaceInterface* surface = toplevel->surface();
+        tool->setCurrentSurface(surface);
+
+        if (!tool->isClientSupported() || !tablet->isSurfaceSupported(surface)) {
+            return emulateTabletEvent(event);
+        }
+
+        switch (event->type()) {
+        case QEvent::TabletMove:
+            tool->sendMotion(event->globalPosF() - toplevel->pos());
+            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 tabletToolEvent(QTabletEvent *event) override
+    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;
     }
 };
 
 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;
         FakeInputInterface *fakeInput = waylandServer()->display()->createFakeInput(this);
         fakeInput->create();
         connect(fakeInput, &FakeInputInterface::deviceCreated, this,
             [this] (FakeInputDevice *device) {
                 connect(device, &FakeInputDevice::authenticationRequested, this,
                     [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);
-        installInputEventFilter(new FakeTabletInputFilter);
+
+        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);
     }
 }
 
-static KWayland::Server::SeatInterface *findSeat()
-{
-    auto server = waylandServer();
-    if (!server) {
-        return nullptr;
-    }
-    return server->seat();
-}
-
 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();
         }
 
         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/input.h b/input.h
index 3e983d476..68ce308f3 100644
--- a/input.h
+++ b/input.h
@@ -1,514 +1,537 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 #ifndef KWIN_INPUT_H
 #define KWIN_INPUT_H
 #include <kwinglobals.h>
 #include <QAction>
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <config-kwin.h>
 
 #include <KSharedConfig>
 #include <QSet>
 
 #include <functional>
 
 class KGlobalAccelInterface;
 class QKeySequence;
 class QMouseEvent;
 class QKeyEvent;
 class QWheelEvent;
 
 namespace KWin
 {
 class GlobalShortcutsManager;
 class Toplevel;
 class InputEventFilter;
 class InputEventSpy;
 class KeyboardInputRedirection;
 class PointerInputRedirection;
 class TabletInputRedirection;
 class TouchInputRedirection;
 class WindowSelectorFilter;
 class SwitchEvent;
+class TabletEvent;
+class TabletInputFilter;
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 }
 
 namespace LibInput
 {
     class Connection;
     class Device;
 }
 
 /**
  * @brief This class is responsible for redirecting incoming input to the surface which currently
  * has input or send enter/leave events.
  *
  * In addition input is intercepted before passed to the surfaces to have KWin internal areas
  * getting input first (e.g. screen edges) and filter the input event out if we currently have
  * a full input grab.
  */
 class KWIN_EXPORT InputRedirection : public QObject
 {
     Q_OBJECT
 public:
     enum PointerButtonState {
         PointerButtonReleased,
         PointerButtonPressed
     };
     enum PointerAxis {
         PointerAxisVertical,
         PointerAxisHorizontal
     };
     enum PointerAxisSource {
         PointerAxisSourceUnknown,
         PointerAxisSourceWheel,
         PointerAxisSourceFinger,
         PointerAxisSourceContinuous,
         PointerAxisSourceWheelTilt
     };
     enum KeyboardKeyState {
         KeyboardKeyReleased,
         KeyboardKeyPressed,
         KeyboardKeyAutoRepeat
     };
     enum TabletEventType {
         Axis,
         Proximity,
         Tip
     };
+    enum TabletToolType {
+        Pen,
+        Eraser,
+        Brush,
+        Pencil,
+        Airbrush,
+        Finger,
+        Mouse,
+        Lens,
+        Totem,
+    };
+    enum Capability {
+        Tilt,
+        Pressure,
+        Distance,
+        Rotation,
+        Slider,
+        Wheel,
+    };
+
     ~InputRedirection() override;
     void init();
 
     /**
      * @return const QPointF& The current global pointer position
      */
     QPointF globalPointer() const;
     Qt::MouseButtons qtButtonStates() const;
     Qt::KeyboardModifiers keyboardModifiers() const;
     Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() const;
 
     void registerShortcut(const QKeySequence &shortcut, QAction *action);
     /**
      * @overload
      *
      * Like registerShortcut, but also connects QAction::triggered to the @p slot on @p receiver.
      * It's recommended to use this method as it ensures that the X11 timestamp is updated prior
      * to the @p slot being invoked. If not using this overload it's required to ensure that
      * registerShortcut is called before connecting to QAction's triggered signal.
      */
     template <typename T, typename Slot>
     void registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, Slot slot);
     void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action);
     void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action);
     void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action);
     void registerGlobalAccel(KGlobalAccelInterface *interface);
 
     /**
      * @internal
      */
     void processPointerMotion(const QPointF &pos, uint32_t time);
     /**
      * @internal
      */
     void processPointerButton(uint32_t button, PointerButtonState state, uint32_t time);
     /**
      * @internal
      */
     void processPointerAxis(PointerAxis axis, qreal delta, qint32 discreteDelta, PointerAxisSource source, uint32_t time);
     /**
      * @internal
      */
     void processKeyboardKey(uint32_t key, KeyboardKeyState state, uint32_t time);
     /**
      * @internal
      */
     void processKeyboardModifiers(uint32_t modsDepressed, uint32_t modsLatched, uint32_t modsLocked, uint32_t group);
     /**
      * @internal
      */
     void processKeymapChange(int fd, uint32_t size);
     void processTouchDown(qint32 id, const QPointF &pos, quint32 time);
     void processTouchUp(qint32 id, quint32 time);
     void processTouchMotion(qint32 id, const QPointF &pos, quint32 time);
     void cancelTouch();
     void touchFrame();
 
     bool supportsPointerWarping() const;
     void warpPointer(const QPointF &pos);
 
     /**
      * Adds the @p filter to the list of event filters and makes it the first
      * event filter in processing.
      *
      * Note: the event filter will get events before the lock screen can get them, thus
      * this is a security relevant method.
      */
     void prependInputEventFilter(InputEventFilter *filter);
     void uninstallInputEventFilter(InputEventFilter *filter);
 
     /**
      * Installs the @p spy for spying on events.
      */
     void installInputEventSpy(InputEventSpy *spy);
 
     /**
      * Uninstalls the @p spy. This happens automatically when deleting an InputEventSpy.
      */
     void uninstallInputEventSpy(InputEventSpy *spy);
 
     Toplevel *findToplevel(const QPoint &pos);
     Toplevel *findManagedToplevel(const QPoint &pos);
     GlobalShortcutsManager *shortcuts() const {
         return m_shortcuts;
     }
 
     /**
      * Sends an event through all InputFilters.
      * The method @p function is invoked on each input filter. Processing is stopped if
      * a filter returns @c true for @p function.
      *
      * The UnaryPredicate is defined like the UnaryPredicate of std::any_of.
      * The signature of the function should be equivalent to the following:
      * @code
      * bool function(const InputEventFilter *spy);
      * @endcode
      *
      * The intended usage is to std::bind the method to invoke on the filter with all arguments
      * bind.
      */
     template <class UnaryPredicate>
     void processFilters(UnaryPredicate function) {
         std::any_of(m_filters.constBegin(), m_filters.constEnd(), function);
     }
 
     /**
      * Sends an event through all input event spies.
      * The @p function is invoked on each InputEventSpy.
      *
      * The UnaryFunction is defined like the UnaryFunction of std::for_each.
      * The signature of the function should be equivalent to the following:
      * @code
      * void function(const InputEventSpy *spy);
      * @endcode
      *
      * The intended usage is to std::bind the method to invoke on the spies with all arguments
      * bind.
      */
     template <class UnaryFunction>
     void processSpies(UnaryFunction function) {
         std::for_each(m_spies.constBegin(), m_spies.constEnd(), function);
     }
 
     KeyboardInputRedirection *keyboard() const {
         return m_keyboard;
     }
     PointerInputRedirection *pointer() const {
         return m_pointer;
     }
     TabletInputRedirection *tablet() const {
         return m_tablet;
     }
     TouchInputRedirection *touch() const {
         return m_touch;
     }
 
     bool hasAlphaNumericKeyboard();
     bool hasTabletModeSwitch();
 
     void startInteractiveWindowSelection(std::function<void(KWin::Toplevel*)> callback, const QByteArray &cursorName);
     void startInteractivePositionSelection(std::function<void(const QPoint &)> callback);
     bool isSelectingWindow() const;
 
 Q_SIGNALS:
     /**
      * @brief Emitted when the global pointer position changed
      *
      * @param pos The new global pointer position.
      */
     void globalPointerChanged(const QPointF &pos);
     /**
      * @brief Emitted when the state of a pointer button changed.
      *
      * @param button The button which changed
      * @param state The new button state
      */
     void pointerButtonStateChanged(uint32_t button, InputRedirection::PointerButtonState state);
     /**
      * @brief Emitted when a pointer axis changed
      *
      * @param axis The axis on which the even occurred
      * @param delta The delta of the event.
      */
     void pointerAxisChanged(InputRedirection::PointerAxis axis, qreal delta);
     /**
      * @brief Emitted when the modifiers changes.
      *
      * Only emitted for the mask which is provided by Qt::KeyboardModifiers, if other modifiers
      * change signal is not emitted
      *
      * @param newMods The new modifiers state
      * @param oldMods The previous modifiers state
      */
     void keyboardModifiersChanged(Qt::KeyboardModifiers newMods, Qt::KeyboardModifiers oldMods);
     /**
      * @brief Emitted when the state of a key changed.
      *
      * @param keyCode The keycode of the key which changed
      * @param state The new key state
      */
     void keyStateChanged(quint32 keyCode, InputRedirection::KeyboardKeyState state);
 
     void hasAlphaNumericKeyboardChanged(bool set);
     void hasTabletModeSwitchChanged(bool set);
 
 private:
     void setupLibInput();
     void setupTouchpadShortcuts();
     void setupLibInputWithScreens();
     void setupWorkspace();
     void reconfigure();
     void setupInputFilters();
     void installInputEventFilter(InputEventFilter *filter);
     KeyboardInputRedirection *m_keyboard;
     PointerInputRedirection *m_pointer;
     TabletInputRedirection *m_tablet;
     TouchInputRedirection *m_touch;
+    TabletInputFilter *m_tabletSupport = nullptr;
 
     GlobalShortcutsManager *m_shortcuts;
 
     LibInput::Connection *m_libInput = nullptr;
 
     WindowSelectorFilter *m_windowSelector = nullptr;
 
     QVector<InputEventFilter*> m_filters;
     QVector<InputEventSpy*> m_spies;
 
     KWIN_SINGLETON(InputRedirection)
     friend InputRedirection *input();
     friend class DecorationEventFilter;
     friend class InternalWindowEventFilter;
     friend class ForwardInputFilter;
 };
 
 /**
  * Base class for filtering input events inside InputRedirection.
  *
  * The idea behind the InputEventFilter is to have task oriented
  * filters. E.g. there is one filter taking care of a locked screen,
  * one to take care of interacting with window decorations, etc.
  *
  * A concrete subclass can reimplement the virtual methods and decide
  * whether an event should be filtered out or not by returning either
  * @c true or @c false. E.g. the lock screen filter can easily ensure
  * that all events are filtered out.
  *
  * As soon as a filter returns @c true the processing is stopped. If
  * a filter returns @c false the next one is invoked. This means a filter
  * installed early gets to see more events than a filter installed later on.
  *
  * Deleting an instance of InputEventFilter automatically uninstalls it from
  * InputRedirection.
  */
 class KWIN_EXPORT InputEventFilter
 {
 public:
     InputEventFilter();
     virtual ~InputEventFilter();
 
     /**
      * Event filter for pointer events which can be described by a QMouseEvent.
      *
      * Please note that the button translation in QMouseEvent cannot cover all
      * possible buttons. Because of that also the @p nativeButton code is passed
      * through the filter. For internal areas it's fine to use @p event, but for
      * passing to client windows the @p nativeButton should be used.
      *
      * @param event The event information about the move or button press/release
      * @param nativeButton The native key code of the button, for move events 0
      * @return @c true to stop further event processing, @c false to pass to next filter
      */
     virtual bool pointerEvent(QMouseEvent *event, quint32 nativeButton);
     /**
      * Event filter for pointer axis events.
      *
      * @param event The event information about the axis event
      * @return @c true to stop further event processing, @c false to pass to next filter
      */
     virtual bool wheelEvent(QWheelEvent *event);
     /**
      * Event filter for keyboard events.
      *
      * @param event The event information about the key event
      * @return @c tru to stop further event processing, @c false to pass to next filter.
      */
     virtual bool keyEvent(QKeyEvent *event);
     virtual bool touchDown(qint32 id, const QPointF &pos, quint32 time);
     virtual bool touchMotion(qint32 id, const QPointF &pos, quint32 time);
     virtual bool touchUp(qint32 id, quint32 time);
 
     virtual bool pinchGestureBegin(int fingerCount, quint32 time);
     virtual bool pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time);
     virtual bool pinchGestureEnd(quint32 time);
     virtual bool pinchGestureCancelled(quint32 time);
 
     virtual bool swipeGestureBegin(int fingerCount, quint32 time);
     virtual bool swipeGestureUpdate(const QSizeF &delta, quint32 time);
     virtual bool swipeGestureEnd(quint32 time);
     virtual bool swipeGestureCancelled(quint32 time);
 
     virtual bool switchEvent(SwitchEvent *event);
 
-    virtual bool tabletToolEvent(QTabletEvent *event);
+    virtual bool tabletToolEvent(TabletEvent *event);
     virtual bool tabletToolButtonEvent(const QSet<uint> &buttons);
     virtual bool tabletPadButtonEvent(const QSet<uint> &buttons);
     virtual bool tabletPadStripEvent(int number, int position, bool isFinger);
     virtual bool tabletPadRingEvent(int number, int position, bool isFinger);
 
 protected:
     void passToWaylandServer(QKeyEvent *event);
 };
 
 class KWIN_EXPORT InputDeviceHandler : public QObject
 {
     Q_OBJECT
 public:
     ~InputDeviceHandler() override;
     virtual void init();
 
     void update();
 
     /**
      * @brief First Toplevel currently at the position of the input device
      * according to the stacking order.
      * @return Toplevel* at device position.
      */
     QPointer<Toplevel> at() const {
         return m_at.at;
     }
     /**
      * @brief Toplevel currently having pointer input focus (this might
      * be different from the Toplevel at the position of the pointer).
      * @return Toplevel* with pointer focus.
      */
     QPointer<Toplevel> focus() const {
         return m_focus.focus;
     }
     /**
      * @brief The Decoration currently receiving events.
      * @return decoration with pointer focus.
      */
     QPointer<Decoration::DecoratedClientImpl> decoration() const {
         return m_focus.decoration;
     }
     /**
      * @brief The internal window currently receiving events.
      * @return QWindow with pointer focus.
      */
     QPointer<QWindow> internalWindow() const {
         return m_focus.internalWindow;
     }
 
     virtual QPointF position() const = 0;
 
     void setFocus(Toplevel *toplevel);
     void setDecoration(QPointer<Decoration::DecoratedClientImpl> decoration);
     void setInternalWindow(QWindow *window);
 
 Q_SIGNALS:
     void atChanged(Toplevel *old, Toplevel *now);
     void decorationChanged();
 
 protected:
     explicit InputDeviceHandler(InputRedirection *parent);
 
     virtual void cleanupInternalWindow(QWindow *old, QWindow *now) = 0;
     virtual void cleanupDecoration(Decoration::DecoratedClientImpl *old, Decoration::DecoratedClientImpl *now) = 0;
 
     virtual void focusUpdate(Toplevel *old, Toplevel *now) = 0;
 
     /**
      * Certain input devices can be in a state of having no valid
      * position. An example are touch screens when no finger/pen
      * is resting on the surface (no touch point).
      */
     virtual bool positionValid() const {
         return false;
     }
     virtual bool focusUpdatesBlocked() {
         return false;
     }
 
     inline bool inited() const {
         return m_inited;
     }
     inline void setInited(bool set) {
         m_inited = set;
     }
 
 private:
     bool setAt(Toplevel *toplevel);
     void updateFocus();
     bool updateDecoration();
     void updateInternalWindow(QWindow *window);
 
     QWindow* findInternalWindow(const QPoint &pos) const;
 
     struct {
         QPointer<Toplevel> at;
         QMetaObject::Connection surfaceCreatedConnection;
     } m_at;
 
     struct {
         QPointer<Toplevel> focus;
         QPointer<Decoration::DecoratedClientImpl> decoration;
         QPointer<QWindow> internalWindow;
     } m_focus;
 
     bool m_inited = false;
 };
 
 inline
 InputRedirection *input()
 {
     return InputRedirection::s_self;
 }
 
 template <typename T, typename Slot>
 inline
 void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, Slot slot) {
     registerShortcut(shortcut, action);
     connect(action, &QAction::triggered, receiver, slot);
 }
 
 } // namespace KWin
 
 Q_DECLARE_METATYPE(KWin::InputRedirection::KeyboardKeyState)
 Q_DECLARE_METATYPE(KWin::InputRedirection::PointerButtonState)
 Q_DECLARE_METATYPE(KWin::InputRedirection::PointerAxis)
 Q_DECLARE_METATYPE(KWin::InputRedirection::PointerAxisSource)
 
 #endif // KWIN_INPUT_H
diff --git a/input_event.cpp b/input_event.cpp
index a5efeef4d..83d3cdd9c 100644
--- a/input_event.cpp
+++ b/input_event.cpp
@@ -1,68 +1,81 @@
 /********************************************************************
  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 "input_event.h"
 
 namespace KWin
 {
 
 MouseEvent::MouseEvent(QEvent::Type type, const QPointF &pos, Qt::MouseButton button,
                        Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers,
                        quint32 timestamp, const QSizeF &delta, const QSizeF &deltaNonAccelerated,
                        quint64 timestampMicroseconds, LibInput::Device *device)
             : QMouseEvent(type, pos, pos, button, buttons, modifiers)
             , m_delta(delta)
             , m_deltaUnccelerated(deltaNonAccelerated)
             , m_timestampMicroseconds(timestampMicroseconds)
             , m_device(device)
 {
     setTimestamp(timestamp);
 }
 
 WheelEvent::WheelEvent(const QPointF &pos, qreal delta, qint32 discreteDelta, Qt::Orientation orientation,
                        Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, InputRedirection::PointerAxisSource source,
                        quint32 timestamp, LibInput::Device *device)
             : QWheelEvent(pos, pos, QPoint(), (orientation == Qt::Horizontal) ? QPoint(delta, 0) : QPoint(0, delta), delta, orientation, buttons, modifiers)
             , m_device(device)
             , m_orientation(orientation)
             , m_delta(delta)
             , m_discreteDelta(discreteDelta)
             , m_source(source)
 {
     setTimestamp(timestamp);
 }
 
 KeyEvent::KeyEvent(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers, quint32 code, quint32 keysym,
                    const QString &text, bool autorepeat, quint32 timestamp, LibInput::Device *device)
          : QKeyEvent(type, key, modifiers, code, keysym, 0, text, autorepeat)
          , m_device(device)
 {
     setTimestamp(timestamp);
 }
 
 SwitchEvent::SwitchEvent(State state, quint32 timestamp, quint64 timestampMicroseconds, LibInput::Device* device)
     : QInputEvent(QEvent::User)
     , m_state(state)
     , m_timestampMicroseconds(timestampMicroseconds)
     , m_device(device)
 {
     setTimestamp(timestamp);
 }
 
+TabletEvent::TabletEvent(Type t, const QPointF &pos, const QPointF &globalPos,
+                 int device, int pointerType, qreal pressure, int xTilt, int yTilt,
+                 qreal tangentialPressure, qreal rotation, int z,
+                 Qt::KeyboardModifiers keyState, qint64 uniqueID,
+                 Qt::MouseButton button, Qt::MouseButtons buttons, InputRedirection::TabletToolType toolType, const QVector<InputRedirection::Capability> &capabilities, quint64 serialId, const QString &tabletSysName)
+    : QTabletEvent(t, pos, globalPos, device, pointerType, pressure, xTilt, yTilt, tangentialPressure, rotation, z, keyState, uniqueID, button, buttons)
+    , m_toolType(toolType)
+    , m_capabilities(capabilities)
+    , m_serialId(serialId)
+    , m_tabletSysName(tabletSysName)
+{
+}
+
 }
diff --git a/input_event.h b/input_event.h
index 8d2bc2648..b44e9d0a5 100644
--- a/input_event.h
+++ b/input_event.h
@@ -1,181 +1,204 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 #ifndef KWIN_INPUT_EVENT_H
 #define KWIN_INPUT_EVENT_H
 
 #include "input.h"
 
 #include <QInputEvent>
 
 namespace KWin
 {
 
 namespace LibInput
 {
 class Device;
 }
 
 class MouseEvent : public QMouseEvent
 {
 public:
     explicit MouseEvent(QEvent::Type type, const QPointF &pos, Qt::MouseButton button, Qt::MouseButtons buttons,
                         Qt::KeyboardModifiers modifiers, quint32 timestamp,
                         const QSizeF &delta, const QSizeF &deltaNonAccelerated, quint64 timestampMicroseconds,
                         LibInput::Device *device);
 
     QSizeF delta() const {
         return m_delta;
     }
 
     QSizeF deltaUnaccelerated() const {
         return m_deltaUnccelerated;
     }
 
     quint64 timestampMicroseconds() const {
         return m_timestampMicroseconds;
     }
 
     LibInput::Device *device() const {
         return m_device;
     }
 
     Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() const {
         return m_modifiersRelevantForShortcuts;
     }
 
     void setModifiersRelevantForGlobalShortcuts(const Qt::KeyboardModifiers &mods) {
         m_modifiersRelevantForShortcuts = mods;
     }
 
     quint32 nativeButton() const {
         return m_nativeButton;
     }
 
     void setNativeButton(quint32 button) {
         m_nativeButton = button;
     }
 
 private:
     QSizeF m_delta;
     QSizeF m_deltaUnccelerated;
     quint64 m_timestampMicroseconds;
     LibInput::Device *m_device;
     Qt::KeyboardModifiers m_modifiersRelevantForShortcuts = Qt::KeyboardModifiers();
     quint32 m_nativeButton = 0;
 };
 
 // TODO: Don't derive from QWheelEvent, this event is quite domain specific.
 class WheelEvent : public QWheelEvent
 {
 public:
     explicit WheelEvent(const QPointF &pos, qreal delta, qint32 discreteDelta, Qt::Orientation orientation,
                         Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, InputRedirection::PointerAxisSource source,
                         quint32 timestamp, LibInput::Device *device);
 
     Qt::Orientation orientation() const {
         return m_orientation;
     }
 
     qreal delta() const {
         return m_delta;
     }
 
     qint32 discreteDelta() const {
         return m_discreteDelta;
     }
 
     InputRedirection::PointerAxisSource axisSource() const {
         return m_source;
     }
 
     LibInput::Device *device() const {
         return m_device;
     }
 
     Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() const {
         return m_modifiersRelevantForShortcuts;
     }
 
     void setModifiersRelevantForGlobalShortcuts(const Qt::KeyboardModifiers &mods) {
         m_modifiersRelevantForShortcuts = mods;
     }
 
 private:
     LibInput::Device *m_device;
     Qt::Orientation m_orientation;
     qreal m_delta;
     qint32 m_discreteDelta;
     InputRedirection::PointerAxisSource m_source;
     Qt::KeyboardModifiers m_modifiersRelevantForShortcuts = Qt::KeyboardModifiers();
 };
 
 class KeyEvent : public QKeyEvent
 {
 public:
     explicit KeyEvent(QEvent::Type type, Qt::Key key, Qt::KeyboardModifiers modifiers, quint32 code, quint32 keysym,
                       const QString &text, bool autorepeat, quint32 timestamp, LibInput::Device *device);
 
     LibInput::Device *device() const {
         return m_device;
     }
 
     Qt::KeyboardModifiers modifiersRelevantForGlobalShortcuts() const {
         return m_modifiersRelevantForShortcuts;
     }
 
     void setModifiersRelevantForGlobalShortcuts(const Qt::KeyboardModifiers &mods) {
         m_modifiersRelevantForShortcuts = mods;
     }
 
 private:
     LibInput::Device *m_device;
     Qt::KeyboardModifiers m_modifiersRelevantForShortcuts = Qt::KeyboardModifiers();
 };
 
 class SwitchEvent : public QInputEvent
 {
 public:
     enum class State {
         Off,
         On
     };
     explicit SwitchEvent(State state, quint32 timestamp, quint64 timestampMicroseconds, LibInput::Device *device);
 
     State state() const {
         return m_state;
     }
 
     quint64 timestampMicroseconds() const {
         return m_timestampMicroseconds;
     }
 
     LibInput::Device *device() const {
         return m_device;
     }
 
 private:
     State m_state;
     quint64 m_timestampMicroseconds;
     LibInput::Device *m_device;
 };
 
+class TabletEvent : public QTabletEvent
+{
+public:
+    TabletEvent(Type t, const QPointF &pos, const QPointF &globalPos,
+                int device, int pointerType, qreal pressure, int xTilt, int yTilt,
+                qreal tangentialPressure, qreal rotation, int z,
+                Qt::KeyboardModifiers keyState, qint64 uniqueID,
+                Qt::MouseButton button, Qt::MouseButtons buttons, InputRedirection::TabletToolType toolType,
+                const QVector<InputRedirection::Capability> &capabilities,
+                quint64 serialId, const QString &tabletSysname);
+
+    InputRedirection::TabletToolType toolType() const { return m_toolType; }
+    QVector<InputRedirection::Capability> capabilities() const { return m_capabilities; }
+    quint64 serialId() const { return m_serialId; }
+    QString tabletSysName() { return m_tabletSysName; }
+
+private:
+    const InputRedirection::TabletToolType m_toolType;
+    const QVector<InputRedirection::Capability> m_capabilities;
+    const quint64 m_serialId;
+    const QString m_tabletSysName;
+};
+
 }
 
 #endif
diff --git a/input_event_spy.cpp b/input_event_spy.cpp
index 85023d349..7613825e7 100644
--- a/input_event_spy.cpp
+++ b/input_event_spy.cpp
@@ -1,152 +1,152 @@
 /********************************************************************
  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 "input_event_spy.h"
 #include "input.h"
 
 #include <QPointF>
 #include <QSizeF>
 
 namespace KWin
 {
 
 InputEventSpy::InputEventSpy() = default;
 
 InputEventSpy::~InputEventSpy()
 {
     if (input()) {
         input()->uninstallInputEventSpy(this);
     }
 }
 
 void InputEventSpy::pointerEvent(MouseEvent *event)
 {
     Q_UNUSED(event)
 }
 
 void InputEventSpy::wheelEvent(WheelEvent *event)
 {
     Q_UNUSED(event)
 }
 
 void InputEventSpy::keyEvent(KeyEvent *event)
 {
     Q_UNUSED(event)
 }
 
 void InputEventSpy::touchDown(qint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::touchMotion(qint32 id, const QPointF &point, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(point)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::touchUp(qint32 id, quint32 time)
 {
     Q_UNUSED(id)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::pinchGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(scale)
     Q_UNUSED(angleDelta)
     Q_UNUSED(delta)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::pinchGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
 }
 
 void InputEventSpy::pinchGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
 }
 
 void InputEventSpy::swipeGestureBegin(int fingerCount, quint32 time)
 {
     Q_UNUSED(fingerCount)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::swipeGestureUpdate(const QSizeF &delta, quint32 time)
 {
     Q_UNUSED(delta)
     Q_UNUSED(time)
 }
 
 void InputEventSpy::swipeGestureEnd(quint32 time)
 {
     Q_UNUSED(time)
 }
 
 void InputEventSpy::swipeGestureCancelled(quint32 time)
 {
     Q_UNUSED(time)
 }
 
 void InputEventSpy::switchEvent(SwitchEvent *event)
 {
     Q_UNUSED(event)
 }
 
-void InputEventSpy::tabletToolEvent(QTabletEvent *event)
+void InputEventSpy::tabletToolEvent(TabletEvent* event)
 {
     Q_UNUSED(event)
 }
 
 void InputEventSpy::tabletToolButtonEvent(const QSet<uint> &pressedButtons)
 {
     Q_UNUSED(pressedButtons)
 }
 
 void InputEventSpy::tabletPadButtonEvent(const QSet<uint> &pressedButtons)
 {
     Q_UNUSED(pressedButtons)
 }
 
 void InputEventSpy::tabletPadStripEvent(int number, int position, bool isFinger)
 {
     Q_UNUSED(number)
     Q_UNUSED(position)
     Q_UNUSED(isFinger)
 }
 
 void InputEventSpy::tabletPadRingEvent(int number, int position, bool isFinger)
 {
     Q_UNUSED(number)
     Q_UNUSED(position)
     Q_UNUSED(isFinger)
 }
 }
diff --git a/input_event_spy.h b/input_event_spy.h
index fcd44aaa8..d709c731c 100644
--- a/input_event_spy.h
+++ b/input_event_spy.h
@@ -1,98 +1,99 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 #ifndef KWIN_INPUT_EVENT_SPY_H
 #define KWIN_INPUT_EVENT_SPY_H
 #include <kwin_export.h>
 
 #include <QtGlobal>
 
 class QPointF;
 class QSizeF;
 class QTabletEvent;
 
 namespace KWin
 {
 class KeyEvent;
 class MouseEvent;
 class WheelEvent;
 class SwitchEvent;
+class TabletEvent;
 
 
 /**
  * Base class for spying on input events inside InputRedirection.
  *
  * This class is quite similar to InputEventFilter, except that it does not
  * support event filtering. Each InputEventSpy gets to see all input events,
  * the processing happens prior to sending events through the InputEventFilters.
  *
  * Deleting an instance of InputEventSpy automatically uninstalls it from
  * InputRedirection.
  */
 class KWIN_EXPORT InputEventSpy
 {
 public:
     InputEventSpy();
     virtual ~InputEventSpy();
 
     /**
      * Event spy for pointer events which can be described by a MouseEvent.
      *
      * @param event The event information about the move or button press/release
      */
     virtual void pointerEvent(MouseEvent *event);
     /**
      * Event spy for pointer axis events.
      *
      * @param event The event information about the axis event
      */
     virtual void wheelEvent(WheelEvent *event);
     /**
      * Event spy for keyboard events.
      *
      * @param event The event information about the key event
      */
     virtual void keyEvent(KeyEvent *event);
     virtual void touchDown(qint32 id, const QPointF &pos, quint32 time);
     virtual void touchMotion(qint32 id, const QPointF &pos, quint32 time);
     virtual void touchUp(qint32 id, quint32 time);
 
     virtual void pinchGestureBegin(int fingerCount, quint32 time);
     virtual void pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time);
     virtual void pinchGestureEnd(quint32 time);
     virtual void pinchGestureCancelled(quint32 time);
 
     virtual void swipeGestureBegin(int fingerCount, quint32 time);
     virtual void swipeGestureUpdate(const QSizeF &delta, quint32 time);
     virtual void swipeGestureEnd(quint32 time);
     virtual void swipeGestureCancelled(quint32 time);
 
     virtual void switchEvent(SwitchEvent *event);
 
-    virtual void tabletToolEvent(QTabletEvent *event);
+    virtual void tabletToolEvent(TabletEvent *event);
     virtual void tabletToolButtonEvent(const QSet<uint> &pressedButtons);
     virtual void tabletPadButtonEvent(const QSet<uint> &pressedButtons);
     virtual void tabletPadStripEvent(int number, int position, bool isFinger);
     virtual void tabletPadRingEvent(int number, int position, bool isFinger);
 };
 
 
 } // namespace KWin
 
 #endif
diff --git a/libinput/connection.cpp b/libinput/connection.cpp
index ff1497b67..34b71ae86 100644
--- a/libinput/connection.cpp
+++ b/libinput/connection.cpp
@@ -1,720 +1,770 @@
 /********************************************************************
  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 "connection.h"
 #include "context.h"
 #include "device.h"
 #include "events.h"
 #ifndef KWIN_BUILD_TESTING
 #include "../screens.h"
 #endif
 #include "../logind.h"
 #include "../udev.h"
 #include "libinput_logging.h"
 
 #include <QDBusMessage>
 #include <QDBusConnection>
 #include <QDBusPendingCall>
 #include <QMutexLocker>
 #include <QSocketNotifier>
 #include <QThread>
 
 #include <libinput.h>
 #include <cmath>
 
 namespace KWin
 {
 namespace LibInput
 {
 
 class ConnectionAdaptor : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KWin.InputDeviceManager")
     Q_PROPERTY(QStringList devicesSysNames READ devicesSysNames CONSTANT)
 
 private:
     Connection *m_con;
 
 public:
     ConnectionAdaptor(Connection *con)
         : m_con(con)
     {
         connect(con, &Connection::deviceAddedSysName, this, &ConnectionAdaptor::deviceAdded, Qt::QueuedConnection);
         connect(con, &Connection::deviceRemovedSysName, this, &ConnectionAdaptor::deviceRemoved, Qt::QueuedConnection);
 
         QDBusConnection::sessionBus().registerObject(QStringLiteral("/org/kde/KWin/InputDevice"),
                                                      QStringLiteral("org.kde.KWin.InputDeviceManager"),
                                                      this,
                                                      QDBusConnection::ExportAllProperties | QDBusConnection::ExportAllSignals
         );
     }
 
     ~ConnectionAdaptor() override {
         QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/org/kde/KWin/InputDeviceManager"));
     }
 
     QStringList devicesSysNames() {
         // TODO: is this allowed? directly calling function of object in another thread!?
         //       otherwise use signal-slot mechanism
         return m_con->devicesSysNames();
     }
 
 Q_SIGNALS:
     void deviceAdded(QString sysName);
     void deviceRemoved(QString sysName);
 
 };
 
 Connection *Connection::s_self = nullptr;
 QPointer<QThread> Connection::s_thread;
 
 static ConnectionAdaptor *s_adaptor = nullptr;
 static Context *s_context = nullptr;
 
 static quint32 toLibinputLEDS(Xkb::LEDs leds)
 {
     quint32 libinputLeds = 0;
     if (leds.testFlag(Xkb::LED::NumLock)) {
         libinputLeds = libinputLeds | LIBINPUT_LED_NUM_LOCK;
     }
     if (leds.testFlag(Xkb::LED::CapsLock)) {
         libinputLeds = libinputLeds | LIBINPUT_LED_CAPS_LOCK;
     }
     if (leds.testFlag(Xkb::LED::ScrollLock)) {
         libinputLeds = libinputLeds | LIBINPUT_LED_SCROLL_LOCK;
     }
     return libinputLeds;
 }
 
 Connection::Connection(QObject *parent)
     : Connection(nullptr, parent)
 {
     // only here to fix build, using will crash, BUG 343529
 }
 
 void Connection::createThread()
 {
     if (s_thread) {
         return;
     }
     s_thread = new QThread();
     s_thread->setObjectName(QStringLiteral("libinput-connection"));
     s_thread->start();
 }
 
 Connection *Connection::create(QObject *parent)
 {
     Q_ASSERT(!s_self);
     static Udev s_udev;
     if (!s_udev.isValid()) {
         qCWarning(KWIN_LIBINPUT) << "Failed to initialize udev";
         return nullptr;
     }
     if (!s_context) {
         s_context = new Context(s_udev);
         if (!s_context->isValid()) {
             qCWarning(KWIN_LIBINPUT) << "Failed to create context from udev";
             delete s_context;
             s_context = nullptr;
             return nullptr;
         }
         if (!s_context->assignSeat(LogindIntegration::self()->seat().toUtf8().constData())) {
             qCWarning(KWIN_LIBINPUT) << "Failed to assign seat" << LogindIntegration::self()->seat();
             delete s_context;
             s_context = nullptr;
             return nullptr;
         }
     }
     Connection::createThread();
     s_self = new Connection(s_context);
     s_self->moveToThread(s_thread);
     QObject::connect(s_thread, &QThread::finished, s_self, &QObject::deleteLater);
     QObject::connect(s_thread, &QThread::finished, s_thread, &QObject::deleteLater);
     QObject::connect(parent, &QObject::destroyed, s_thread, &QThread::quit);
     if (!s_adaptor) {
         s_adaptor = new ConnectionAdaptor(s_self);
     }
 
     return s_self;
 }
 
 
 Connection::Connection(Context *input, QObject *parent)
     : QObject(parent)
     , m_input(input)
     , m_notifier(nullptr)
     , m_mutex(QMutex::Recursive)
     , m_leds()
 {
     Q_ASSERT(m_input);
     // need to connect to KGlobalSettings as the mouse KCM does not emit a dedicated signal
     QDBusConnection::sessionBus().connect(QString(), QStringLiteral("/KGlobalSettings"), QStringLiteral("org.kde.KGlobalSettings"),
                                           QStringLiteral("notifyChange"), this, SLOT(slotKGlobalSettingsNotifyChange(int,int)));
 }
 
 Connection::~Connection()
 {
     delete s_adaptor;
     s_adaptor = nullptr;
     s_self = nullptr;
     delete s_context;
     s_context = nullptr;
 }
 
 void Connection::setup()
 {
     QMetaObject::invokeMethod(this, "doSetup", Qt::QueuedConnection);
 }
 
 void Connection::doSetup()
 {
     connect(s_self, &Connection::deviceAdded, s_self, [](Device* device) {
                 emit s_self->deviceAddedSysName(device->sysName());
             });
     connect(s_self, &Connection::deviceRemoved, s_self, [](Device* device) {
                 emit s_self->deviceRemovedSysName(device->sysName());
             });
 
     Q_ASSERT(!m_notifier);
     m_notifier = new QSocketNotifier(m_input->fileDescriptor(), QSocketNotifier::Read, this);
     connect(m_notifier, &QSocketNotifier::activated, this, &Connection::handleEvent);
 
     LogindIntegration *logind = LogindIntegration::self();
     connect(logind, &LogindIntegration::sessionActiveChanged, this,
         [this](bool active) {
             if (active) {
                 if (!m_input->isSuspended()) {
                     return;
                 }
                 m_input->resume();
                 wasSuspended = true;
             } else {
                 deactivate();
             }
         }
     );
     handleEvent();
 }
 
 void Connection::deactivate()
 {
     if (m_input->isSuspended()) {
         return;
     }
     m_keyboardBeforeSuspend = hasKeyboard();
     m_alphaNumericKeyboardBeforeSuspend = hasAlphaNumericKeyboard();
     m_pointerBeforeSuspend = hasPointer();
     m_touchBeforeSuspend = hasTouch();
     m_tabletModeSwitchBeforeSuspend = hasTabletModeSwitch();
     m_input->suspend();
     handleEvent();
 }
 
 void Connection::handleEvent()
 {
     QMutexLocker locker(&m_mutex);
     const bool wasEmpty = m_eventQueue.isEmpty();
     do {
         m_input->dispatch();
         Event *event = m_input->event();
         if (!event) {
             break;
         }
         m_eventQueue << event;
     } while (true);
     if (wasEmpty && !m_eventQueue.isEmpty()) {
         emit eventsRead();
     }
 }
 
 void Connection::processEvents()
 {
     QMutexLocker locker(&m_mutex);
     while (!m_eventQueue.isEmpty()) {
         QScopedPointer<Event> event(m_eventQueue.takeFirst());
         switch (event->type()) {
             case LIBINPUT_EVENT_DEVICE_ADDED: {
                 auto device = new Device(event->nativeDevice());
                 device->moveToThread(s_thread);
                 m_devices << device;
                 if (device->isKeyboard()) {
                     m_keyboard++;
                     if (device->isAlphaNumericKeyboard()) {
                         m_alphaNumericKeyboard++;
                         if (m_alphaNumericKeyboard == 1) {
                             emit hasAlphaNumericKeyboardChanged(true);
                         }
                     }
                     if (m_keyboard == 1) {
                         emit hasKeyboardChanged(true);
                     }
                 }
                 if (device->isPointer()) {
                     m_pointer++;
                     if (m_pointer == 1) {
                         emit hasPointerChanged(true);
                     }
                 }
                 if (device->isTouch()) {
                     m_touch++;
                     if (m_touch == 1) {
                         emit hasTouchChanged(true);
                     }
                 }
                 if (device->isTabletModeSwitch()) {
                     m_tabletModeSwitch++;
                     if (m_tabletModeSwitch == 1) {
                         emit hasTabletModeSwitchChanged(true);
                     }
                 }
                 applyDeviceConfig(device);
                 applyScreenToDevice(device);
 
                 // enable possible leds
                 libinput_device_led_update(device->device(), static_cast<libinput_led>(toLibinputLEDS(m_leds)));
 
                 emit deviceAdded(device);
                 break;
             }
             case LIBINPUT_EVENT_DEVICE_REMOVED: {
                 auto it = std::find_if(m_devices.begin(), m_devices.end(), [&event] (Device *d) { return event->device() == d; } );
                 if (it == m_devices.end()) {
                     // we don't know this device
                     break;
                 }
                 auto device = *it;
                 m_devices.erase(it);
                 emit deviceRemoved(device);
 
                 if (device->isKeyboard()) {
                     m_keyboard--;
                     if (device->isAlphaNumericKeyboard()) {
                         m_alphaNumericKeyboard--;
                         if (m_alphaNumericKeyboard == 0) {
                             emit hasAlphaNumericKeyboardChanged(false);
                         }
                     }
                     if (m_keyboard == 0) {
                         emit hasKeyboardChanged(false);
                     }
                 }
                 if (device->isPointer()) {
                     m_pointer--;
                     if (m_pointer == 0) {
                         emit hasPointerChanged(false);
                     }
                 }
                 if (device->isTouch()) {
                     m_touch--;
                     if (m_touch == 0) {
                         emit hasTouchChanged(false);
                     }
                 }
                 if (device->isTabletModeSwitch()) {
                     m_tabletModeSwitch--;
                     if (m_tabletModeSwitch == 0) {
                         emit hasTabletModeSwitchChanged(false);
                     }
                 }
                 device->deleteLater();
                 break;
             }
             case LIBINPUT_EVENT_KEYBOARD_KEY: {
                 KeyEvent *ke = static_cast<KeyEvent*>(event.data());
                 emit keyChanged(ke->key(), ke->state(), ke->time(), ke->device());
                 break;
             }
             case LIBINPUT_EVENT_POINTER_AXIS: {
                 PointerEvent *pe = static_cast<PointerEvent*>(event.data());
                 const auto axes = pe->axis();
                 for (const InputRedirection::PointerAxis &axis : axes) {
                     emit pointerAxisChanged(axis, pe->axisValue(axis), pe->discreteAxisValue(axis),
                         pe->axisSource(), pe->time(), pe->device());
                 }
                 break;
             }
             case LIBINPUT_EVENT_POINTER_BUTTON: {
                 PointerEvent *pe = static_cast<PointerEvent*>(event.data());
                 emit pointerButtonChanged(pe->button(), pe->buttonState(), pe->time(), pe->device());
                 break;
             }
             case LIBINPUT_EVENT_POINTER_MOTION: {
                 PointerEvent *pe = static_cast<PointerEvent*>(event.data());
                 auto delta = pe->delta();
                 auto deltaNonAccel = pe->deltaUnaccelerated();
                 quint32 latestTime = pe->time();
                 quint64 latestTimeUsec = pe->timeMicroseconds();
                 auto it = m_eventQueue.begin();
                 while (it != m_eventQueue.end()) {
                     if ((*it)->type() == LIBINPUT_EVENT_POINTER_MOTION) {
                         QScopedPointer<PointerEvent> p(static_cast<PointerEvent*>(*it));
                         delta += p->delta();
                         deltaNonAccel += p->deltaUnaccelerated();
                         latestTime = p->time();
                         latestTimeUsec = p->timeMicroseconds();
                         it = m_eventQueue.erase(it);
                     } else {
                         break;
                     }
                 }
                 emit pointerMotion(delta, deltaNonAccel, latestTime, latestTimeUsec, pe->device());
                 break;
             }
             case LIBINPUT_EVENT_POINTER_MOTION_ABSOLUTE: {
                 PointerEvent *pe = static_cast<PointerEvent*>(event.data());
                 emit pointerMotionAbsolute(pe->absolutePos(), pe->absolutePos(m_size), pe->time(), pe->device());
                 break;
             }
             case LIBINPUT_EVENT_TOUCH_DOWN: {
 #ifndef KWIN_BUILD_TESTING
                 TouchEvent *te = static_cast<TouchEvent*>(event.data());
                 const auto &geo = screens()->geometry(te->device()->screenId());
                 emit touchDown(te->id(), geo.topLeft() + te->absolutePos(geo.size()), te->time(), te->device());
                 break;
 #endif
             }
             case LIBINPUT_EVENT_TOUCH_UP: {
                 TouchEvent *te = static_cast<TouchEvent*>(event.data());
                 emit touchUp(te->id(), te->time(), te->device());
                 break;
             }
             case LIBINPUT_EVENT_TOUCH_MOTION: {
 #ifndef KWIN_BUILD_TESTING
                 TouchEvent *te = static_cast<TouchEvent*>(event.data());
                 const auto &geo = screens()->geometry(te->device()->screenId());
                 emit touchMotion(te->id(), geo.topLeft() + te->absolutePos(geo.size()), te->time(), te->device());
                 break;
 #endif
             }
             case LIBINPUT_EVENT_TOUCH_CANCEL: {
                 emit touchCanceled(event->device());
                 break;
             }
             case LIBINPUT_EVENT_TOUCH_FRAME: {
                 emit touchFrame(event->device());
                 break;
             }
             case LIBINPUT_EVENT_GESTURE_PINCH_BEGIN: {
                 PinchGestureEvent *pe = static_cast<PinchGestureEvent*>(event.data());
                 emit pinchGestureBegin(pe->fingerCount(), pe->time(), pe->device());
                 break;
             }
             case LIBINPUT_EVENT_GESTURE_PINCH_UPDATE: {
                 PinchGestureEvent *pe = static_cast<PinchGestureEvent*>(event.data());
                 emit pinchGestureUpdate(pe->scale(), pe->angleDelta(), pe->delta(), pe->time(), pe->device());
                 break;
             }
             case LIBINPUT_EVENT_GESTURE_PINCH_END: {
                 PinchGestureEvent *pe = static_cast<PinchGestureEvent*>(event.data());
                 if (pe->isCancelled()) {
                     emit pinchGestureCancelled(pe->time(), pe->device());
                 } else {
                     emit pinchGestureEnd(pe->time(), pe->device());
                 }
                 break;
             }
             case LIBINPUT_EVENT_GESTURE_SWIPE_BEGIN: {
                 SwipeGestureEvent *se = static_cast<SwipeGestureEvent*>(event.data());
                 emit swipeGestureBegin(se->fingerCount(), se->time(), se->device());
                 break;
             }
             case LIBINPUT_EVENT_GESTURE_SWIPE_UPDATE: {
                 SwipeGestureEvent *se = static_cast<SwipeGestureEvent*>(event.data());
                 emit swipeGestureUpdate(se->delta(), se->time(), se->device());
                 break;
             }
             case LIBINPUT_EVENT_GESTURE_SWIPE_END: {
                 SwipeGestureEvent *se = static_cast<SwipeGestureEvent*>(event.data());
                 if (se->isCancelled()) {
                     emit swipeGestureCancelled(se->time(), se->device());
                 } else {
                     emit swipeGestureEnd(se->time(), se->device());
                 }
                 break;
             }
             case LIBINPUT_EVENT_SWITCH_TOGGLE: {
                 SwitchEvent *se = static_cast<SwitchEvent*>(event.data());
                 switch (se->state()) {
                 case SwitchEvent::State::Off:
                     emit switchToggledOff(se->time(), se->timeMicroseconds(), se->device());
                     break;
                 case SwitchEvent::State::On:
                     emit switchToggledOn(se->time(), se->timeMicroseconds(), se->device());
                     break;
                 default:
                     Q_UNREACHABLE();
                 }
                 break;
             }
             case LIBINPUT_EVENT_TABLET_TOOL_AXIS:
             case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
             case LIBINPUT_EVENT_TABLET_TOOL_TIP: {
                 auto *tte = static_cast<TabletToolEvent *>(event.data());
 
                 KWin::InputRedirection::TabletEventType tabletEventType;
                 switch (event->type()) {
                 case LIBINPUT_EVENT_TABLET_TOOL_AXIS:
                     tabletEventType = KWin::InputRedirection::Axis;
                     break;
                 case LIBINPUT_EVENT_TABLET_TOOL_PROXIMITY:
                     tabletEventType = KWin::InputRedirection::Proximity;
                     break;
                 case LIBINPUT_EVENT_TABLET_TOOL_TIP:
                 default:
                     tabletEventType = KWin::InputRedirection::Tip;
                     break;
                 }
                 auto serial = libinput_tablet_tool_get_serial(tte->tool());
                 auto toolId = libinput_tablet_tool_get_tool_id(tte->tool());
+                auto type = libinput_tablet_tool_get_type(tte->tool());
+                InputRedirection::TabletToolType toolType;
+                switch(type) {
+                case LIBINPUT_TABLET_TOOL_TYPE_PEN:
+                    toolType = InputRedirection::Pen;
+                    break;
+                case LIBINPUT_TABLET_TOOL_TYPE_ERASER:
+                    toolType = InputRedirection::Eraser;
+                    break;
+                case LIBINPUT_TABLET_TOOL_TYPE_BRUSH:
+                    toolType = InputRedirection::Brush;
+                    break;
+                case LIBINPUT_TABLET_TOOL_TYPE_PENCIL:
+                    toolType = InputRedirection::Pencil;
+                    break;
+                case LIBINPUT_TABLET_TOOL_TYPE_AIRBRUSH:
+                    toolType = InputRedirection::Airbrush;
+                    break;
+                case LIBINPUT_TABLET_TOOL_TYPE_MOUSE:
+                    toolType = InputRedirection::Mouse;
+                    break;
+                case LIBINPUT_TABLET_TOOL_TYPE_LENS:
+                    toolType = InputRedirection::Lens;
+                    break;
+#ifdef LIBINPUT_HAS_TOTEM
+                case LIBINPUT_TABLET_TOOL_TYPE_TOTEM:
+                    toolType = InputRedirection::Totem;
+                    break;
+#endif
+                }
+                QVector<InputRedirection::Capability> capabilities;
+                if (libinput_tablet_tool_has_pressure(tte->tool())) {
+                    capabilities << InputRedirection::Pressure;
+                }
+                if (libinput_tablet_tool_has_distance(tte->tool())) {
+                    capabilities << InputRedirection::Distance;
+                }
+                if (libinput_tablet_tool_has_rotation(tte->tool())) {
+                    capabilities << InputRedirection::Rotation;
+                }
+                if (libinput_tablet_tool_has_tilt(tte->tool())) {
+                    capabilities << InputRedirection::Tilt;
+                }
+                if (libinput_tablet_tool_has_slider(tte->tool())) {
+                    capabilities << InputRedirection::Slider;
+                }
+                if (libinput_tablet_tool_has_wheel(tte->tool())) {
+                    capabilities << InputRedirection::Wheel;
+                }
 
                 emit tabletToolEvent(tabletEventType,
                                      tte->transformedPosition(m_size), tte->pressure(),
                                      tte->xTilt(), tte->yTilt(), tte->rotation(),
                                      tte->isTipDown(), tte->isNearby(), serial,
-                                     toolId, event->device());
+                                     toolId, toolType, capabilities, tte->time(),
+                                     event->device());
                 break;
             }
             case LIBINPUT_EVENT_TABLET_TOOL_BUTTON: {
                 auto *tabletEvent = static_cast<TabletToolButtonEvent *>(event.data());
                 emit tabletToolButtonEvent(tabletEvent->buttonId(),
                                            tabletEvent->isButtonPressed());
                 break;
             }
             case LIBINPUT_EVENT_TABLET_PAD_BUTTON: {
                 auto *tabletEvent = static_cast<TabletPadButtonEvent *>(event.data());
                 emit tabletPadButtonEvent(tabletEvent->buttonId(),
                                           tabletEvent->isButtonPressed());
                 break;
             }
             case LIBINPUT_EVENT_TABLET_PAD_RING: {
                 auto *tabletEvent = static_cast<TabletPadRingEvent *>(event.data());
                 emit tabletPadRingEvent(tabletEvent->number(),
                                         tabletEvent->position(),
                                         tabletEvent->source() ==
                                             LIBINPUT_TABLET_PAD_RING_SOURCE_FINGER);
                 break;
             }
             case LIBINPUT_EVENT_TABLET_PAD_STRIP: {
                 auto *tabletEvent = static_cast<TabletPadStripEvent *>(event.data());
                 emit tabletPadStripEvent(tabletEvent->number(),
                                          tabletEvent->position(),
                                          tabletEvent->source() ==
                                              LIBINPUT_TABLET_PAD_STRIP_SOURCE_FINGER);
                 break;
             }
             default:
                 // nothing
                 break;
         }
     }
     if (wasSuspended) {
         if (m_keyboardBeforeSuspend && !m_keyboard) {
             emit hasKeyboardChanged(false);
         }
         if (m_alphaNumericKeyboardBeforeSuspend && !m_alphaNumericKeyboard) {
             emit hasAlphaNumericKeyboardChanged(false);
         }
         if (m_pointerBeforeSuspend && !m_pointer) {
             emit hasPointerChanged(false);
         }
         if (m_touchBeforeSuspend && !m_touch) {
             emit hasTouchChanged(false);
         }
         if (m_tabletModeSwitchBeforeSuspend && !m_tabletModeSwitch) {
             emit hasTabletModeSwitchChanged(false);
         }
         wasSuspended = false;
     }
 }
 
 void Connection::setScreenSize(const QSize &size)
 {
     m_size = size;
 }
 
 void Connection::updateScreens()
 {
     QMutexLocker locker(&m_mutex);
     for (auto device: qAsConst(m_devices)) {
         applyScreenToDevice(device);
     }
 }
 
 
 void Connection::applyScreenToDevice(Device *device)
 {
 #ifndef KWIN_BUILD_TESTING
     QMutexLocker locker(&m_mutex);
     if (!device->isTouch()) {
         return;
     }
     int id = -1;
     // let's try to find a screen for it
     if (screens()->count() == 1) {
         id = 0;
     }
     if (id == -1 && !device->outputName().isEmpty()) {
         // we have an output name, try to find a screen with matching name
         for (int i = 0; i < screens()->count(); i++) {
             if (screens()->name(i) == device->outputName()) {
                 id = i;
                 break;
             }
         }
     }
     if (id == -1) {
         // do we have an internal screen?
         int internalId = -1;
         for (int i = 0; i < screens()->count(); i++) {
             if (screens()->isInternal(i)) {
                 internalId = i;
                 break;
             }
         }
         auto testScreenMatches = [device] (int id) {
             const auto &size = device->size();
             const auto &screenSize = screens()->physicalSize(id);
             return std::round(size.width()) == std::round(screenSize.width())
                 && std::round(size.height()) == std::round(screenSize.height());
         };
         if (internalId != -1 && testScreenMatches(internalId)) {
             id = internalId;
         }
         // let's compare all screens for size
         for (int i = 0; i < screens()->count(); i++) {
             if (testScreenMatches(i)) {
                 id = i;
                 break;
             }
         }
         if (id == -1) {
             // still not found
             if (internalId != -1) {
                 // we have an internal id, so let's use that
                 id = internalId;
             } else {
                 // just take first screen, we have no clue
                 id = 0;
             }
         }
     }
     device->setScreenId(id);
     device->setOrientation(screens()->orientation(id));
 #else
     Q_UNUSED(device)
 #endif
 }
 
 bool Connection::isSuspended() const
 {
     if (!s_context) {
         return false;
     }
     return s_context->isSuspended();
 }
 
 void Connection::applyDeviceConfig(Device *device)
 {
     // pass configuration to Device
     device->setConfig(m_config->group("Libinput").group(QString::number(device->vendor())).group(QString::number(device->product())).group(device->name()));
     device->loadConfiguration();
 }
 
 void Connection::slotKGlobalSettingsNotifyChange(int type, int arg)
 {
     if (type == 3 /**SettingsChanged**/ && arg == 0 /** SETTINGS_MOUSE */) {
         m_config->reparseConfiguration();
         for (auto it = m_devices.constBegin(), end = m_devices.constEnd(); it != end; ++it) {
             if ((*it)->isPointer()) {
                 applyDeviceConfig(*it);
             }
         }
     }
 }
 
 void Connection::toggleTouchpads()
 {
     bool changed = false;
     m_touchpadsEnabled = !m_touchpadsEnabled;
     for (auto it = m_devices.constBegin(); it != m_devices.constEnd(); ++it) {
         auto device = *it;
         if (!device->isTouchpad()) {
             continue;
         }
         const bool old = device->isEnabled();
         device->setEnabled(m_touchpadsEnabled);
         if (old != device->isEnabled()) {
             changed = true;
         }
     }
     if (changed) {
         // send OSD message
         QDBusMessage msg = QDBusMessage::createMethodCall(
             QStringLiteral("org.kde.plasmashell"),
             QStringLiteral("/org/kde/osdService"),
             QStringLiteral("org.kde.osdService"),
             QStringLiteral("touchpadEnabledChanged")
         );
         msg.setArguments({m_touchpadsEnabled});
         QDBusConnection::sessionBus().asyncCall(msg);
     }
 }
 
 void Connection::enableTouchpads()
 {
     if (m_touchpadsEnabled) {
         return;
     }
     toggleTouchpads();
 }
 
 void Connection::disableTouchpads()
 {
     if (!m_touchpadsEnabled) {
         return;
     }
     toggleTouchpads();
 }
 
 void Connection::updateLEDs(Xkb::LEDs leds)
 {
     if (m_leds == leds) {
         return;
     }
     m_leds = leds;
     // update on devices
     const libinput_led l = static_cast<libinput_led>(toLibinputLEDS(leds));
     for (auto it = m_devices.constBegin(), end = m_devices.constEnd(); it != end; ++it) {
         libinput_device_led_update((*it)->device(), l);
     }
 }
 
 QStringList Connection::devicesSysNames() const {
     QStringList sl;
     foreach (Device *d, m_devices) {
         sl.append(d->sysName());
     }
     return sl;
 }
 
 }
 }
 
 #include "connection.moc"
diff --git a/libinput/connection.h b/libinput/connection.h
index f7133bc46..fba0b8923 100644
--- a/libinput/connection.h
+++ b/libinput/connection.h
@@ -1,182 +1,186 @@
 /********************************************************************
  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 KWIN_LIBINPUT_CONNECTION_H
 #define KWIN_LIBINPUT_CONNECTION_H
 
 #include "../input.h"
 #include "../keyboard_input.h"
 #include <kwinglobals.h>
 
 #include <QObject>
 #include <QPointer>
 #include <QSize>
 #include <QMutex>
 #include <QVector>
 #include <QStringList>
 
 class QSocketNotifier;
 class QThread;
 
 namespace KWin
 {
 namespace LibInput
 {
 
 class Event;
 class Device;
 class Context;
 
 class KWIN_EXPORT Connection : public QObject
 {
     Q_OBJECT
 
 public:
     ~Connection() override;
 
     void setInputConfig(const KSharedConfigPtr &config) {
         m_config = config;
     }
 
     void setup();
     /**
      * Sets the screen @p size. This is needed for mapping absolute pointer events to
      * the screen data.
      */
     void setScreenSize(const QSize &size);
 
     void updateScreens();
 
     bool hasKeyboard() const {
         return m_keyboard > 0;
     }
     bool hasAlphaNumericKeyboard() const {
         return m_alphaNumericKeyboard > 0;
     }
     bool hasTouch() const {
         return m_touch > 0;
     }
     bool hasPointer() const {
         return m_pointer > 0;
     }
     bool hasTabletModeSwitch() const {
         return m_tabletModeSwitch > 0;
     }
 
     bool isSuspended() const;
 
     void deactivate();
 
     void processEvents();
 
     void toggleTouchpads();
     void enableTouchpads();
     void disableTouchpads();
 
     QVector<Device*> devices() const {
         return m_devices;
     }
 
     QStringList devicesSysNames() const;
 
     void updateLEDs(KWin::Xkb::LEDs leds);
 
     static void createThread();
 
 Q_SIGNALS:
     void keyChanged(quint32 key, KWin::InputRedirection::KeyboardKeyState, quint32 time, KWin::LibInput::Device *device);
     void pointerButtonChanged(quint32 button, KWin::InputRedirection::PointerButtonState state, quint32 time, KWin::LibInput::Device *device);
     void pointerMotionAbsolute(QPointF orig, QPointF screen, quint32 time, KWin::LibInput::Device *device);
     void pointerMotion(const QSizeF &delta, const QSizeF &deltaNonAccelerated, quint32 time, quint64 timeMicroseconds, KWin::LibInput::Device *device);
     void pointerAxisChanged(KWin::InputRedirection::PointerAxis axis, qreal delta, qint32 discreteDelta,
         KWin::InputRedirection::PointerAxisSource source, quint32 time, KWin::LibInput::Device *device);
     void touchFrame(KWin::LibInput::Device *device);
     void touchCanceled(KWin::LibInput::Device *device);
     void touchDown(qint32 id, const QPointF &absolutePos, quint32 time, KWin::LibInput::Device *device);
     void touchUp(qint32 id, quint32 time, KWin::LibInput::Device *device);
     void touchMotion(qint32 id, const QPointF &absolutePos, quint32 time, KWin::LibInput::Device *device);
     void hasKeyboardChanged(bool);
     void hasAlphaNumericKeyboardChanged(bool);
     void hasPointerChanged(bool);
     void hasTouchChanged(bool);
     void hasTabletModeSwitchChanged(bool);
     void deviceAdded(KWin::LibInput::Device *);
     void deviceRemoved(KWin::LibInput::Device *);
     void deviceAddedSysName(QString);
     void deviceRemovedSysName(QString);
     void swipeGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device);
     void swipeGestureUpdate(const QSizeF &delta, quint32 time, KWin::LibInput::Device *device);
     void swipeGestureEnd(quint32 time, KWin::LibInput::Device *device);
     void swipeGestureCancelled(quint32 time, KWin::LibInput::Device *device);
     void pinchGestureBegin(int fingerCount, quint32 time, KWin::LibInput::Device *device);
     void pinchGestureUpdate(qreal scale, qreal angleDelta, const QSizeF &delta, quint32 time, KWin::LibInput::Device *device);
     void pinchGestureEnd(quint32 time, KWin::LibInput::Device *device);
     void pinchGestureCancelled(quint32 time, KWin::LibInput::Device *device);
     void switchToggledOn(quint32 time, quint64 timeMicroseconds, KWin::LibInput::Device *device);
     void switchToggledOff(quint32 time, quint64 timeMicroseconds, KWin::LibInput::Device *device);
 
     void tabletToolEvent(KWin::InputRedirection::TabletEventType type, const QPointF &pos,
                          qreal pressure, int xTilt, int yTilt, qreal rotation, bool tipDown,
-                         bool tipNear, quint64 serialId, quint64 toolId, LibInput::Device *device);
+                         bool tipNear, quint64 serialId, quint64 toolId,
+                         InputRedirection::TabletToolType toolType,
+                         const QVector<InputRedirection::Capability> &capabilities,
+                         quint32 time,
+                         LibInput::Device *device);
     void tabletToolButtonEvent(uint button, bool isPressed);
 
     void tabletPadButtonEvent(uint button, bool isPressed);
     void tabletPadStripEvent(int number, int position, bool isFinger);
     void tabletPadRingEvent(int number, int position, bool isFinger);
 
     void eventsRead();
 
 private Q_SLOTS:
     void doSetup();
     void slotKGlobalSettingsNotifyChange(int type, int arg);
 
 private:
     Connection(Context *input, QObject *parent = nullptr);
     void handleEvent();
     void applyDeviceConfig(Device *device);
     void applyScreenToDevice(Device *device);
     Context *m_input;
     QSocketNotifier *m_notifier;
     QSize m_size;
     int m_keyboard = 0;
     int m_alphaNumericKeyboard = 0;
     int m_pointer = 0;
     int m_touch = 0;
     int m_tabletModeSwitch = 0;
     bool m_keyboardBeforeSuspend = false;
     bool m_alphaNumericKeyboardBeforeSuspend = false;
     bool m_pointerBeforeSuspend = false;
     bool m_touchBeforeSuspend = false;
     bool m_tabletModeSwitchBeforeSuspend = false;
     QMutex m_mutex;
     QVector<Event*> m_eventQueue;
     bool wasSuspended = false;
     QVector<Device*> m_devices;
     KSharedConfigPtr m_config;
     bool m_touchpadsEnabled = true;
     Xkb::LEDs m_leds;
 
     KWIN_SINGLETON(Connection)
     static QPointer<QThread> s_thread;
 };
 
 }
 }
 
 #endif
diff --git a/libinput/device.cpp b/libinput/device.cpp
index 91f00134e..a5f970ace 100644
--- a/libinput/device.cpp
+++ b/libinput/device.cpp
@@ -1,526 +1,531 @@
 /********************************************************************
  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 "device.h"
 
 #include <QDBusConnection>
 
 #include <linux/input.h>
 
 #include <config-kwin.h>
 
 namespace KWin
 {
 namespace LibInput
 {
 
 static bool checkAlphaNumericKeyboard(libinput_device *device)
 {
     for (uint i = KEY_1; i <= KEY_0; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     for (uint i = KEY_Q; i <= KEY_P; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     for (uint i = KEY_A; i <= KEY_L; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     for (uint i = KEY_Z; i <= KEY_M; i++) {
         if (libinput_device_keyboard_has_key(device, i) == 0) {
             return false;
         }
     }
     return true;
 }
 
 QVector<Device*> Device::s_devices;
 
 Device *Device::getDevice(libinput_device *native)
 {
     auto it = std::find_if(s_devices.constBegin(), s_devices.constEnd(),
         [native] (const Device *d) {
             return d->device() == native;
         }
     );
     if (it != s_devices.constEnd()) {
         return *it;
     }
     return nullptr;
 }
 
 enum class ConfigKey {
     Enabled,
     LeftHanded,
     DisableWhileTyping,
     PointerAcceleration,
     PointerAccelerationProfile,
     TapToClick,
     LmrTapButtonMap,
     TapAndDrag,
     TapDragLock,
     MiddleButtonEmulation,
     NaturalScroll,
     ScrollMethod,
     ScrollButton,
     ClickMethod
 };
 
 struct ConfigData {
     explicit ConfigData(QByteArray _key, void (Device::*_setter)(bool), bool (Device::*_defaultValue)() const = nullptr)
         : key(_key)
     { booleanSetter.setter = _setter; booleanSetter.defaultValue = _defaultValue; }
 
     explicit ConfigData(QByteArray _key, void (Device::*_setter)(quint32), quint32 (Device::*_defaultValue)() const = nullptr)
         : key(_key)
     { quint32Setter.setter = _setter; quint32Setter.defaultValue = _defaultValue; }
 
     explicit ConfigData(QByteArray _key, void (Device::*_setter)(QString), QString (Device::*_defaultValue)() const = nullptr)
         : key(_key)
     { stringSetter.setter = _setter; stringSetter.defaultValue = _defaultValue; }
 
     QByteArray key;
 
     struct {
         void (Device::*setter)(bool) = nullptr;
         bool (Device::*defaultValue)() const;
     } booleanSetter;
 
     struct {
         void (Device::*setter)(quint32) = nullptr;
         quint32 (Device::*defaultValue)() const;
     } quint32Setter;
     struct {
         void (Device::*setter)(QString) = nullptr;
         QString (Device::*defaultValue)() const;
     } stringSetter;
 };
 
 static const QMap<ConfigKey, ConfigData> s_configData {
     {ConfigKey::Enabled, ConfigData(QByteArrayLiteral("Enabled"), &Device::setEnabled)},
     {ConfigKey::LeftHanded, ConfigData(QByteArrayLiteral("LeftHanded"), &Device::setLeftHanded, &Device::leftHandedEnabledByDefault)},
     {ConfigKey::DisableWhileTyping, ConfigData(QByteArrayLiteral("DisableWhileTyping"), &Device::setDisableWhileTyping, &Device::disableWhileTypingEnabledByDefault)},
     {ConfigKey::PointerAcceleration, ConfigData(QByteArrayLiteral("PointerAcceleration"), &Device::setPointerAccelerationFromString, &Device::defaultPointerAccelerationToString)},
     {ConfigKey::PointerAccelerationProfile, ConfigData(QByteArrayLiteral("PointerAccelerationProfile"), &Device::setPointerAccelerationProfileFromInt, &Device::defaultPointerAccelerationProfileToInt)},
     {ConfigKey::TapToClick, ConfigData(QByteArrayLiteral("TapToClick"), &Device::setTapToClick, &Device::tapToClickEnabledByDefault)},
     {ConfigKey::TapAndDrag, ConfigData(QByteArrayLiteral("TapAndDrag"), &Device::setTapAndDrag, &Device::tapAndDragEnabledByDefault)},
     {ConfigKey::TapDragLock, ConfigData(QByteArrayLiteral("TapDragLock"), &Device::setTapDragLock, &Device::tapDragLockEnabledByDefault)},
     {ConfigKey::MiddleButtonEmulation, ConfigData(QByteArrayLiteral("MiddleButtonEmulation"), &Device::setMiddleEmulation, &Device::middleEmulationEnabledByDefault)},
     {ConfigKey::LmrTapButtonMap, ConfigData(QByteArrayLiteral("LmrTapButtonMap"), &Device::setLmrTapButtonMap, &Device::lmrTapButtonMapEnabledByDefault)},
     {ConfigKey::NaturalScroll, ConfigData(QByteArrayLiteral("NaturalScroll"), &Device::setNaturalScroll, &Device::naturalScrollEnabledByDefault)},
     {ConfigKey::ScrollMethod, ConfigData(QByteArrayLiteral("ScrollMethod"), &Device::activateScrollMethodFromInt, &Device::defaultScrollMethodToInt)},
     {ConfigKey::ScrollButton, ConfigData(QByteArrayLiteral("ScrollButton"), &Device::setScrollButton, &Device::defaultScrollButton)},
     {ConfigKey::ClickMethod, ConfigData(QByteArrayLiteral("ClickMethod"), &Device::setClickMethodFromInt, &Device::defaultClickMethodToInt)}
 };
 
 namespace {
 QMatrix4x4 defaultCalibrationMatrix(libinput_device *device)
 {
     float matrix[6];
     const int ret = libinput_device_config_calibration_get_default_matrix(device, matrix);
     if (ret == 0) {
         return QMatrix4x4();
     }
     return QMatrix4x4{
         matrix[0], matrix[1], matrix[2], 0.0f,
         matrix[3], matrix[4], matrix[5], 0.0f,
         0.0f,  0.0f, 1.0f, 0.0f,
         0.0f,  0.0f, 0.0f, 1.0f
     };
 }
 }
 
 Device::Device(libinput_device *device, QObject *parent)
     : QObject(parent)
     , m_device(device)
     , m_keyboard(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_KEYBOARD))
     , m_pointer(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_POINTER))
     , m_touch(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_TOUCH))
     , m_tabletTool(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_TABLET_TOOL))
-#if 0
-    // next libinput version
     , m_tabletPad(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_TABLET_PAD))
-#else
-    , m_tabletPad(false)
-#endif
     , m_supportsGesture(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_GESTURE))
     , m_switch(libinput_device_has_capability(m_device, LIBINPUT_DEVICE_CAP_SWITCH))
     , m_lidSwitch(m_switch ? libinput_device_switch_has_switch(m_device, LIBINPUT_SWITCH_LID) : false)
     , m_tabletSwitch(m_switch ? libinput_device_switch_has_switch(m_device, LIBINPUT_SWITCH_TABLET_MODE) : false)
     , m_name(QString::fromLocal8Bit(libinput_device_get_name(m_device)))
     , m_sysName(QString::fromLocal8Bit(libinput_device_get_sysname(m_device)))
     , m_outputName(QString::fromLocal8Bit(libinput_device_get_output_name(m_device)))
     , m_product(libinput_device_get_id_product(m_device))
     , m_vendor(libinput_device_get_id_vendor(m_device))
     , m_tapFingerCount(libinput_device_config_tap_get_finger_count(m_device))
     , m_defaultTapButtonMap(libinput_device_config_tap_get_default_button_map(m_device))
     , m_tapButtonMap(libinput_device_config_tap_get_button_map(m_device))
     , m_tapToClickEnabledByDefault(libinput_device_config_tap_get_default_enabled(m_device) == LIBINPUT_CONFIG_TAP_ENABLED)
     , m_tapToClick(libinput_device_config_tap_get_enabled(m_device))
     , m_tapAndDragEnabledByDefault(libinput_device_config_tap_get_default_drag_enabled(m_device))
     , m_tapAndDrag(libinput_device_config_tap_get_drag_enabled(m_device))
     , m_tapDragLockEnabledByDefault(libinput_device_config_tap_get_default_drag_lock_enabled(m_device))
     , m_tapDragLock(libinput_device_config_tap_get_drag_lock_enabled(m_device))
     , m_supportsDisableWhileTyping(libinput_device_config_dwt_is_available(m_device))
     , m_supportsPointerAcceleration(libinput_device_config_accel_is_available(m_device))
     , m_supportsLeftHanded(libinput_device_config_left_handed_is_available(m_device))
     , m_supportsCalibrationMatrix(libinput_device_config_calibration_has_matrix(m_device))
     , m_supportsDisableEvents(libinput_device_config_send_events_get_modes(m_device) & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED)
     , m_supportsDisableEventsOnExternalMouse(libinput_device_config_send_events_get_modes(m_device) & LIBINPUT_CONFIG_SEND_EVENTS_DISABLED_ON_EXTERNAL_MOUSE)
     , m_supportsMiddleEmulation(libinput_device_config_middle_emulation_is_available(m_device))
     , m_supportsNaturalScroll(libinput_device_config_scroll_has_natural_scroll(m_device))
     , m_supportedScrollMethods(libinput_device_config_scroll_get_methods(m_device))
     , m_leftHandedEnabledByDefault(libinput_device_config_left_handed_get_default(m_device))
     , m_middleEmulationEnabledByDefault(libinput_device_config_middle_emulation_get_default_enabled(m_device) == LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED)
     , m_naturalScrollEnabledByDefault(libinput_device_config_scroll_get_default_natural_scroll_enabled(m_device))
     , m_defaultScrollMethod(libinput_device_config_scroll_get_default_method(m_device))
     , m_defaultScrollButton(libinput_device_config_scroll_get_default_button(m_device))
     , m_disableWhileTypingEnabledByDefault(libinput_device_config_dwt_get_default_enabled(m_device))
     , m_disableWhileTyping(m_supportsDisableWhileTyping ? libinput_device_config_dwt_get_enabled(m_device) == LIBINPUT_CONFIG_DWT_ENABLED : false)
     , m_middleEmulation(libinput_device_config_middle_emulation_get_enabled(m_device) == LIBINPUT_CONFIG_MIDDLE_EMULATION_ENABLED)
     , m_leftHanded(m_supportsLeftHanded ? libinput_device_config_left_handed_get(m_device) : false)
     , m_naturalScroll(m_supportsNaturalScroll ? libinput_device_config_scroll_get_natural_scroll_enabled(m_device) : false)
     , m_scrollMethod(libinput_device_config_scroll_get_method(m_device))
     , m_scrollButton(libinput_device_config_scroll_get_button(m_device))
     , m_defaultPointerAcceleration(libinput_device_config_accel_get_default_speed(m_device))
     , m_pointerAcceleration(libinput_device_config_accel_get_speed(m_device))
     , m_supportedPointerAccelerationProfiles(libinput_device_config_accel_get_profiles(m_device))
     , m_defaultPointerAccelerationProfile(libinput_device_config_accel_get_default_profile(m_device))
     , m_pointerAccelerationProfile(libinput_device_config_accel_get_profile(m_device))
     , m_enabled(m_supportsDisableEvents ? libinput_device_config_send_events_get_mode(m_device) == LIBINPUT_CONFIG_SEND_EVENTS_ENABLED : true)
     , m_config()
     , m_defaultCalibrationMatrix(m_supportsCalibrationMatrix ? defaultCalibrationMatrix(m_device) : QMatrix4x4{})
     , m_supportedClickMethods(libinput_device_config_click_get_methods(m_device))
     , m_defaultClickMethod(libinput_device_config_click_get_default_method(m_device))
     , m_clickMethod(libinput_device_config_click_get_method(m_device))
 {
     libinput_device_ref(m_device);
 
     qreal width = 0;
     qreal height = 0;
     if (libinput_device_get_size(m_device, &width, &height) == 0) {
         m_size = QSizeF(width, height);
     }
     if (m_pointer) {
         if (libinput_device_pointer_has_button(m_device, BTN_LEFT) == 1) {
             m_supportedButtons |= Qt::LeftButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_MIDDLE) == 1) {
             m_supportedButtons |= Qt::MiddleButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_RIGHT) == 1) {
             m_supportedButtons |= Qt::RightButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_SIDE) == 1) {
             m_supportedButtons |= Qt::ExtraButton1;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_EXTRA) == 1) {
             m_supportedButtons |= Qt::ExtraButton2;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_BACK) == 1) {
             m_supportedButtons |= Qt::BackButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_FORWARD) == 1) {
             m_supportedButtons |= Qt::ForwardButton;
         }
         if (libinput_device_pointer_has_button(m_device, BTN_TASK) == 1) {
             m_supportedButtons |= Qt::TaskButton;
         }
     }
     if (m_keyboard) {
         m_alphaNumericKeyboard = checkAlphaNumericKeyboard(m_device);
     }
 
     s_devices << this;
     QDBusConnection::sessionBus().registerObject(QStringLiteral("/org/kde/KWin/InputDevice/") + m_sysName,
                                                  QStringLiteral("org.kde.KWin.InputDevice"),
                                                  this,
                                                  QDBusConnection::ExportAllProperties
     );
 }
 
 Device::~Device()
 {
     s_devices.removeOne(this);
     QDBusConnection::sessionBus().unregisterObject(QStringLiteral("/org/kde/KWin/InputDevice/") + m_sysName);
     libinput_device_unref(m_device);
 }
 
 template <typename T>
 void Device::writeEntry(const ConfigKey &key, const T &value)
 {
     if (!m_config.isValid()) {
         return;
     }
     if (m_loading) {
         return;
     }
     auto it = s_configData.find(key);
     Q_ASSERT(it != s_configData.end());
     m_config.writeEntry(it.value().key.constData(), value);
     m_config.sync();
 }
 
 template <typename T, typename Setter>
 void Device::readEntry(const QByteArray &key, const Setter &s, const T &defaultValue)
 {
     if (!s.setter) {
         return;
     }
 
     (this->*(s.setter))(m_config.readEntry(key.constData(), s.defaultValue ? (this->*(s.defaultValue))() : defaultValue));
 }
 
 void Device::loadConfiguration()
 {
     if (!m_config.isValid()) {
         return;
     }
     m_loading = true;
     for (auto it = s_configData.begin(), end = s_configData.end(); it != end; ++it) {
         const auto key = it.value().key;
         if (!m_config.hasKey(key.constData())) {
             continue;
         }
         readEntry(key, it.value().booleanSetter, true);
         readEntry(key, it.value().quint32Setter, 0);
         readEntry(key, it.value().stringSetter, "");
     };
 
     m_loading = false;
 }
 
 void Device::setPointerAcceleration(qreal acceleration)
 {
     if (!m_supportsPointerAcceleration) {
         return;
     }
     acceleration = qBound(-1.0, acceleration, 1.0);
     if (libinput_device_config_accel_set_speed(m_device, acceleration) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_pointerAcceleration != acceleration) {
             m_pointerAcceleration = acceleration;
             emit pointerAccelerationChanged();
             writeEntry(ConfigKey::PointerAcceleration, QString::number(acceleration, 'f', 3));
         }
     }
 }
 
 void Device::setScrollButton(quint32 button)
 {
     if (!(m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN)) {
         return;
     }
     if (libinput_device_config_scroll_set_button(m_device, button) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_scrollButton != button) {
             m_scrollButton = button;
             writeEntry(ConfigKey::ScrollButton, m_scrollButton);
             emit scrollButtonChanged();
         }
     }
 }
 
 void Device::setPointerAccelerationProfile(bool set, enum  libinput_config_accel_profile profile)
 {
     if (!(m_supportedPointerAccelerationProfiles & profile)) {
         return;
     }
     if (!set) {
         profile = (profile == LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT) ? LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE : LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT;
         if (!(m_supportedPointerAccelerationProfiles & profile)) {
             return;
         }
     }
 
     if (libinput_device_config_accel_set_profile(m_device, profile) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_pointerAccelerationProfile != profile) {
             m_pointerAccelerationProfile = profile;
             emit pointerAccelerationProfileChanged();
             writeEntry(ConfigKey::PointerAccelerationProfile, (quint32) profile);
         }
     }
 }
 
 void Device::setClickMethod(bool set, enum libinput_config_click_method method)
 {
     if (!(m_supportedClickMethods & method)) {
         return;
     }
     if (!set) {
         method = (method == LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS) ? LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER : LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS;
         if (!(m_supportedClickMethods & method)) {
             return;
         }
     }
 
     if (libinput_device_config_click_set_method(m_device, method) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_clickMethod != method) {
             m_clickMethod = method;
             emit clickMethodChanged();
             writeEntry(ConfigKey::ClickMethod, (quint32) method);
         }
     }
 }
 
 void Device::setScrollMethod(bool set, enum libinput_config_scroll_method method)
 {
     if (!(m_supportedScrollMethods & method)) {
         return;
     }
 
     bool isCurrent = m_scrollMethod == method;
     if (!set) {
         if (isCurrent) {
             method = LIBINPUT_CONFIG_SCROLL_NO_SCROLL;
             isCurrent = false;
         } else {
             return;
         }
     }
 
     if (libinput_device_config_scroll_set_method(m_device, method) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (!isCurrent) {
             m_scrollMethod = method;
             emit scrollMethodChanged();
             writeEntry(ConfigKey::ScrollMethod, (quint32) method);
         }
     }
 }
 
 void Device::setLmrTapButtonMap(bool set)
 {
     enum libinput_config_tap_button_map map = set ? LIBINPUT_CONFIG_TAP_MAP_LMR : LIBINPUT_CONFIG_TAP_MAP_LRM;
 
     if (m_tapFingerCount < 2) {
         return;
     }
     if (!set) {
         map = LIBINPUT_CONFIG_TAP_MAP_LRM;
     }
 
     if (libinput_device_config_tap_set_button_map(m_device, map) == LIBINPUT_CONFIG_STATUS_SUCCESS) {
         if (m_tapButtonMap != map) {
             m_tapButtonMap = map;
             writeEntry(ConfigKey::LmrTapButtonMap, set);
             emit tapButtonMapChanged();
         }
     }
 }
 
+int Device::stripsCount() const
+{
+    return libinput_device_tablet_pad_get_num_strips(m_device);
+}
+
+int Device::ringsCount() const
+{
+    return libinput_device_tablet_pad_get_num_rings(m_device);
+}
+
 #define CONFIG(method, condition, function, variable, key) \
 void Device::method(bool set) \
 { \
     if (condition) { \
         return; \
     } \
     if (libinput_device_config_##function(m_device, set) == LIBINPUT_CONFIG_STATUS_SUCCESS) { \
         if (m_##variable != set) { \
             m_##variable = set; \
             writeEntry(ConfigKey::key, m_##variable); \
             emit variable##Changed(); \
         }\
     } \
 }
 
 CONFIG(setLeftHanded, !m_supportsLeftHanded, left_handed_set, leftHanded, LeftHanded)
 CONFIG(setNaturalScroll, !m_supportsNaturalScroll, scroll_set_natural_scroll_enabled, naturalScroll, NaturalScroll)
 
 #undef CONFIG
 
 #define CONFIG(method, condition, function, enum, variable, key) \
 void Device::method(bool set) \
 { \
     if (condition) { \
         return; \
     } \
     if (libinput_device_config_##function(m_device, set ? LIBINPUT_CONFIG_##enum##_ENABLED : LIBINPUT_CONFIG_##enum##_DISABLED) == LIBINPUT_CONFIG_STATUS_SUCCESS) { \
         if (m_##variable != set) { \
             m_##variable = set; \
             writeEntry(ConfigKey::key, m_##variable); \
             emit variable##Changed(); \
         }\
     } \
 }
 
 CONFIG(setEnabled, !m_supportsDisableEvents, send_events_set_mode, SEND_EVENTS, enabled, Enabled)
 CONFIG(setDisableWhileTyping, !m_supportsDisableWhileTyping, dwt_set_enabled, DWT, disableWhileTyping, DisableWhileTyping)
 CONFIG(setTapToClick, m_tapFingerCount == 0, tap_set_enabled, TAP, tapToClick, TapToClick)
 CONFIG(setTapAndDrag, false, tap_set_drag_enabled, DRAG, tapAndDrag, TapAndDrag)
 CONFIG(setTapDragLock, false, tap_set_drag_lock_enabled, DRAG_LOCK, tapDragLock, TapDragLock)
 CONFIG(setMiddleEmulation, m_supportsMiddleEmulation == false, middle_emulation_set_enabled, MIDDLE_EMULATION, middleEmulation, MiddleButtonEmulation)
 
 #undef CONFIG
 
 void Device::setOrientation(Qt::ScreenOrientation orientation)
 {
     if (!m_supportsCalibrationMatrix) {
         return;
     }
     // 90 deg cw:
     static const QMatrix4x4 portraitMatrix{
         0.0f, -1.0f, 1.0f, 0.0f,
         1.0f,  0.0f, 0.0f, 0.0f,
         0.0f,  0.0f, 1.0f, 0.0f,
         0.0f,  0.0f, 0.0f, 1.0f
     };
     // 180 deg cw:
     static const QMatrix4x4 invertedLandscapeMatrix{
         -1.0f,  0.0f, 1.0f, 0.0f,
          0.0f, -1.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 0.0f, 1.0f
     };
     // 270 deg cw
     static const QMatrix4x4 invertedPortraitMatrix{
          0.0f, 1.0f, 0.0f, 0.0f,
         -1.0f, 0.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 1.0f, 0.0f,
          0.0f,  0.0f, 0.0f, 1.0f
     };
     QMatrix4x4 matrix;
     switch (orientation) {
     case Qt::PortraitOrientation:
         matrix = portraitMatrix;
         break;
     case Qt::InvertedLandscapeOrientation:
         matrix = invertedLandscapeMatrix;
         break;
     case Qt::InvertedPortraitOrientation:
         matrix = invertedPortraitMatrix;
         break;
     case Qt::PrimaryOrientation:
     case Qt::LandscapeOrientation:
     default:
         break;
     }
     const auto combined = m_defaultCalibrationMatrix * matrix;
     const auto columnOrder = combined.constData();
     float m[6] = {
         columnOrder[0], columnOrder[4], columnOrder[8],
         columnOrder[1], columnOrder[5], columnOrder[9]
     };
     libinput_device_config_calibration_set_matrix(m_device, m);
 }
 
 }
 }
diff --git a/libinput/device.h b/libinput/device.h
index 5c6b735f3..c72f8c121 100644
--- a/libinput/device.h
+++ b/libinput/device.h
@@ -1,582 +1,585 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 #ifndef KWIN_LIBINPUT_DEVICE_H
 #define KWIN_LIBINPUT_DEVICE_H
 
 #include <libinput.h>
 
 #include <KConfigGroup>
 
 #include <QObject>
 #include <QMatrix4x4>
 #include <QSizeF>
 #include <QVector>
 #include "kwin_export.h"
 
 struct libinput_device;
 
 namespace KWin
 {
 namespace LibInput
 {
 enum class ConfigKey;
 
 class KWIN_EXPORT Device : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KWin.InputDevice")
     //
     // general
     Q_PROPERTY(bool keyboard READ isKeyboard CONSTANT)
     Q_PROPERTY(bool alphaNumericKeyboard READ isAlphaNumericKeyboard CONSTANT)
     Q_PROPERTY(bool pointer READ isPointer CONSTANT)
     Q_PROPERTY(bool touchpad READ isTouchpad CONSTANT)
     Q_PROPERTY(bool touch READ isTouch CONSTANT)
     Q_PROPERTY(bool tabletTool READ isTabletTool CONSTANT)
     Q_PROPERTY(bool tabletPad READ isTabletPad CONSTANT)
     Q_PROPERTY(bool gestureSupport READ supportsGesture CONSTANT)
     Q_PROPERTY(QString name READ name CONSTANT)
     Q_PROPERTY(QString sysName READ sysName CONSTANT)
     Q_PROPERTY(QString outputName READ outputName CONSTANT)
     Q_PROPERTY(QSizeF size READ size CONSTANT)
     Q_PROPERTY(quint32 product READ product CONSTANT)
     Q_PROPERTY(quint32 vendor READ vendor CONSTANT)
     Q_PROPERTY(bool supportsDisableEvents READ supportsDisableEvents CONSTANT)
     Q_PROPERTY(bool enabled READ isEnabled WRITE setEnabled NOTIFY enabledChanged)
     //
     // advanced
     Q_PROPERTY(int supportedButtons READ supportedButtons CONSTANT)
     Q_PROPERTY(bool supportsCalibrationMatrix READ supportsCalibrationMatrix CONSTANT)
 
     Q_PROPERTY(bool supportsLeftHanded READ supportsLeftHanded CONSTANT)
     Q_PROPERTY(bool leftHandedEnabledByDefault READ leftHandedEnabledByDefault CONSTANT)
     Q_PROPERTY(bool leftHanded READ isLeftHanded WRITE setLeftHanded NOTIFY leftHandedChanged)
 
     Q_PROPERTY(bool supportsDisableEventsOnExternalMouse READ supportsDisableEventsOnExternalMouse CONSTANT)
 
     Q_PROPERTY(bool supportsDisableWhileTyping READ supportsDisableWhileTyping CONSTANT)
     Q_PROPERTY(bool disableWhileTypingEnabledByDefault READ disableWhileTypingEnabledByDefault CONSTANT)
     Q_PROPERTY(bool disableWhileTyping READ isDisableWhileTyping WRITE setDisableWhileTyping NOTIFY disableWhileTypingChanged)
     //
     // acceleration speed and profile
     Q_PROPERTY(bool supportsPointerAcceleration READ supportsPointerAcceleration CONSTANT)
     Q_PROPERTY(qreal defaultPointerAcceleration READ defaultPointerAcceleration CONSTANT)
     Q_PROPERTY(qreal pointerAcceleration READ pointerAcceleration WRITE setPointerAcceleration NOTIFY pointerAccelerationChanged)
 
     Q_PROPERTY(bool supportsPointerAccelerationProfileFlat READ supportsPointerAccelerationProfileFlat CONSTANT)
     Q_PROPERTY(bool defaultPointerAccelerationProfileFlat READ defaultPointerAccelerationProfileFlat CONSTANT)
     Q_PROPERTY(bool pointerAccelerationProfileFlat READ pointerAccelerationProfileFlat WRITE setPointerAccelerationProfileFlat NOTIFY pointerAccelerationProfileChanged)
 
     Q_PROPERTY(bool supportsPointerAccelerationProfileAdaptive READ supportsPointerAccelerationProfileAdaptive CONSTANT)
     Q_PROPERTY(bool defaultPointerAccelerationProfileAdaptive READ defaultPointerAccelerationProfileAdaptive CONSTANT)
     Q_PROPERTY(bool pointerAccelerationProfileAdaptive READ pointerAccelerationProfileAdaptive WRITE setPointerAccelerationProfileAdaptive NOTIFY pointerAccelerationProfileChanged)
     //
     // tapping
     Q_PROPERTY(int tapFingerCount READ tapFingerCount CONSTANT)
     Q_PROPERTY(bool tapToClickEnabledByDefault READ tapToClickEnabledByDefault CONSTANT)
     Q_PROPERTY(bool tapToClick READ isTapToClick WRITE setTapToClick NOTIFY tapToClickChanged)
 
     Q_PROPERTY(bool supportsLmrTapButtonMap READ supportsLmrTapButtonMap CONSTANT)
     Q_PROPERTY(bool lmrTapButtonMapEnabledByDefault READ lmrTapButtonMapEnabledByDefault CONSTANT)
     Q_PROPERTY(bool lmrTapButtonMap READ lmrTapButtonMap WRITE setLmrTapButtonMap NOTIFY tapButtonMapChanged)
 
     Q_PROPERTY(bool tapAndDragEnabledByDefault READ tapAndDragEnabledByDefault CONSTANT)
     Q_PROPERTY(bool tapAndDrag READ isTapAndDrag WRITE setTapAndDrag NOTIFY tapAndDragChanged)
     Q_PROPERTY(bool tapDragLockEnabledByDefault READ tapDragLockEnabledByDefault CONSTANT)
     Q_PROPERTY(bool tapDragLock READ isTapDragLock WRITE setTapDragLock NOTIFY tapDragLockChanged)
 
     Q_PROPERTY(bool supportsMiddleEmulation READ supportsMiddleEmulation CONSTANT)
     Q_PROPERTY(bool middleEmulationEnabledByDefault READ middleEmulationEnabledByDefault CONSTANT)
     Q_PROPERTY(bool middleEmulation READ isMiddleEmulation WRITE setMiddleEmulation NOTIFY middleEmulationChanged)
     //
     // scrolling
     Q_PROPERTY(bool supportsNaturalScroll READ supportsNaturalScroll CONSTANT)
     Q_PROPERTY(bool naturalScrollEnabledByDefault READ naturalScrollEnabledByDefault CONSTANT)
     Q_PROPERTY(bool naturalScroll READ isNaturalScroll WRITE setNaturalScroll NOTIFY naturalScrollChanged)
 
     Q_PROPERTY(bool supportsScrollTwoFinger READ supportsScrollTwoFinger CONSTANT)
     Q_PROPERTY(bool scrollTwoFingerEnabledByDefault READ scrollTwoFingerEnabledByDefault CONSTANT)
     Q_PROPERTY(bool scrollTwoFinger READ isScrollTwoFinger WRITE setScrollTwoFinger NOTIFY scrollMethodChanged)
 
     Q_PROPERTY(bool supportsScrollEdge READ supportsScrollEdge CONSTANT)
     Q_PROPERTY(bool scrollEdgeEnabledByDefault READ scrollEdgeEnabledByDefault CONSTANT)
     Q_PROPERTY(bool scrollEdge READ isScrollEdge WRITE setScrollEdge NOTIFY scrollMethodChanged)
 
     Q_PROPERTY(bool supportsScrollOnButtonDown READ supportsScrollOnButtonDown CONSTANT)
     Q_PROPERTY(bool scrollOnButtonDownEnabledByDefault READ scrollOnButtonDownEnabledByDefault CONSTANT)
     Q_PROPERTY(quint32 defaultScrollButton READ defaultScrollButton CONSTANT)
     Q_PROPERTY(bool scrollOnButtonDown READ isScrollOnButtonDown WRITE setScrollOnButtonDown NOTIFY scrollMethodChanged)
     Q_PROPERTY(quint32 scrollButton READ scrollButton WRITE setScrollButton NOTIFY scrollButtonChanged)
 
     // switches
     Q_PROPERTY(bool switchDevice READ isSwitch CONSTANT)
     Q_PROPERTY(bool lidSwitch READ isLidSwitch CONSTANT)
     Q_PROPERTY(bool tabletModeSwitch READ isTabletModeSwitch CONSTANT)
 
     // Click Methods 
     Q_PROPERTY(bool supportsClickMethodAreas READ supportsClickMethodAreas CONSTANT)
     Q_PROPERTY(bool defaultClickMethodAreas READ defaultClickMethodAreas CONSTANT)
     Q_PROPERTY(bool clickMethodAreas READ isClickMethodAreas WRITE setClickMethodAreas NOTIFY clickMethodChanged)
 
     Q_PROPERTY(bool supportsClickMethodClickfinger READ supportsClickMethodClickfinger CONSTANT)
     Q_PROPERTY(bool defaultClickMethodClickfinger READ defaultClickMethodClickfinger CONSTANT)
     Q_PROPERTY(bool clickMethodClickfinger READ isClickMethodClickfinger WRITE setClickMethodClickfinger NOTIFY clickMethodChanged)
 
 public:
     explicit Device(libinput_device *device, QObject *parent = nullptr);
     ~Device() override;
 
     bool isKeyboard() const {
         return m_keyboard;
     }
     bool isAlphaNumericKeyboard() const {
         return m_alphaNumericKeyboard;
     }
     bool isPointer() const {
         return m_pointer;
     }
     bool isTouchpad() const{
         return m_pointer &&
                 // ignore all combined devices. E.g. a touchpad on a keyboard we don't want to toggle
                 // as that would result in the keyboard going off as well
                 !(m_keyboard || m_touch || m_tabletPad || m_tabletTool) &&
                 // is this a touch pad? We don't really know, let's do some assumptions
                 (m_tapFingerCount > 0  || m_supportsDisableWhileTyping || m_supportsDisableEventsOnExternalMouse);
     }
     bool isTouch() const {
         return m_touch;
     }
     bool isTabletTool() const {
         return m_tabletTool;
     }
     bool isTabletPad() const {
         return m_tabletPad;
     }
     bool supportsGesture() const {
         return m_supportsGesture;
     }
     QString name() const {
         return m_name;
     }
     QString sysName() const {
         return m_sysName;
     }
     QString outputName() const {
         return m_outputName;
     }
     QSizeF size() const {
         return m_size;
     }
     quint32 product() const {
         return m_product;
     }
     quint32 vendor() const {
         return m_vendor;
     }
     Qt::MouseButtons supportedButtons() const {
         return m_supportedButtons;
     }
     int tapFingerCount() const {
         return m_tapFingerCount;
     }
     bool tapToClickEnabledByDefault() const {
         return m_tapToClickEnabledByDefault;
     }
     bool isTapToClick() const {
         return m_tapToClick;
     }
     /**
      * Set the Device to tap to click if @p set is @c true.
      */
     void setTapToClick(bool set);
     bool tapAndDragEnabledByDefault() const {
         return m_tapAndDragEnabledByDefault;
     }
     bool isTapAndDrag() const {
         return m_tapAndDrag;
     }
     void setTapAndDrag(bool set);
     bool tapDragLockEnabledByDefault() const {
         return m_tapDragLockEnabledByDefault;
     }
     bool isTapDragLock() const {
         return m_tapDragLock;
     }
     void setTapDragLock(bool set);
     bool supportsDisableWhileTyping() const {
         return m_supportsDisableWhileTyping;
     }
     bool disableWhileTypingEnabledByDefault() const {
         return m_disableWhileTypingEnabledByDefault;
     }
     bool supportsPointerAcceleration() const {
         return m_supportsPointerAcceleration;
     }
     bool supportsLeftHanded() const {
         return m_supportsLeftHanded;
     }
     bool supportsCalibrationMatrix() const {
         return m_supportsCalibrationMatrix;
     }
     bool supportsDisableEvents() const {
         return m_supportsDisableEvents;
     }
     bool supportsDisableEventsOnExternalMouse() const {
         return m_supportsDisableEventsOnExternalMouse;
     }
     bool supportsMiddleEmulation() const {
         return m_supportsMiddleEmulation;
     }
     bool supportsNaturalScroll() const {
         return m_supportsNaturalScroll;
     }
     bool supportsScrollTwoFinger() const {
         return (m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_2FG);
     }
     bool supportsScrollEdge() const {
         return (m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_EDGE);
     }
     bool supportsScrollOnButtonDown() const {
         return (m_supportedScrollMethods & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
     }
     bool leftHandedEnabledByDefault() const {
         return m_leftHandedEnabledByDefault;
     }
     bool middleEmulationEnabledByDefault() const {
         return m_middleEmulationEnabledByDefault;
     }
     bool naturalScrollEnabledByDefault() const {
         return m_naturalScrollEnabledByDefault;
     }
     enum libinput_config_scroll_method defaultScrollMethod() const {
         return m_defaultScrollMethod;
     }
     quint32 defaultScrollMethodToInt() const {
         return (quint32) m_defaultScrollMethod;
     }
     bool scrollTwoFingerEnabledByDefault() const {
         return m_defaultScrollMethod == LIBINPUT_CONFIG_SCROLL_2FG;
     }
     bool scrollEdgeEnabledByDefault() const {
         return m_defaultScrollMethod == LIBINPUT_CONFIG_SCROLL_EDGE;
     }
     bool scrollOnButtonDownEnabledByDefault() const {
         return m_defaultScrollMethod == LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     }
     bool supportsLmrTapButtonMap() const {
         return m_tapFingerCount > 1;
     }
     bool lmrTapButtonMapEnabledByDefault() const {
         return m_defaultTapButtonMap == LIBINPUT_CONFIG_TAP_MAP_LMR;
     }
 
     void setLmrTapButtonMap(bool set);
     bool lmrTapButtonMap() const {
         return m_tapButtonMap & LIBINPUT_CONFIG_TAP_MAP_LMR;
     }
 
     quint32 defaultScrollButton() const {
         return m_defaultScrollButton;
     }
     bool isMiddleEmulation() const {
         return m_middleEmulation;
     }
     void setMiddleEmulation(bool set);
     bool isNaturalScroll() const {
         return m_naturalScroll;
     }
     void setNaturalScroll(bool set);
     void setScrollMethod(bool set, enum libinput_config_scroll_method method);
     bool isScrollTwoFinger() const {
         return m_scrollMethod & LIBINPUT_CONFIG_SCROLL_2FG;
     }
     void setScrollTwoFinger(bool set) {
         setScrollMethod(set, LIBINPUT_CONFIG_SCROLL_2FG);
     }
     bool isScrollEdge() const {
         return m_scrollMethod & LIBINPUT_CONFIG_SCROLL_EDGE;
     }
     void setScrollEdge(bool set) {
         setScrollMethod(set, LIBINPUT_CONFIG_SCROLL_EDGE);
     }
     bool isScrollOnButtonDown() const {
         return m_scrollMethod & LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN;
     }
     void setScrollOnButtonDown(bool set) {
         setScrollMethod(set, LIBINPUT_CONFIG_SCROLL_ON_BUTTON_DOWN);
     }
     void activateScrollMethodFromInt(quint32 method) {
         setScrollMethod(true, (libinput_config_scroll_method) method);
     }
     quint32 scrollButton() const {
         return m_scrollButton;
     }
     void setScrollButton(quint32 button);
 
     void setDisableWhileTyping(bool set);
     bool isDisableWhileTyping() const {
         return m_disableWhileTyping;
     }
     bool isLeftHanded() const {
         return m_leftHanded;
     }
     /**
      * Sets the Device to left handed mode if @p set is @c true.
      * If @p set is @c false the device is set to right handed mode
      */
     void setLeftHanded(bool set);
 
     qreal defaultPointerAcceleration() const {
         return m_defaultPointerAcceleration;
     }
     qreal pointerAcceleration() const {
         return m_pointerAcceleration;
     }
     /**
      * @param acceleration mapped to range [-1,1] with -1 being the slowest, 1 being the fastest supported acceleration.
      */
     void setPointerAcceleration(qreal acceleration);
     void setPointerAccelerationFromString(QString acceleration) {
         setPointerAcceleration(acceleration.toDouble());
     }
     QString defaultPointerAccelerationToString() const {
         return QString::number(m_pointerAcceleration, 'f', 3);
     }
     bool supportsPointerAccelerationProfileFlat() const {
         return (m_supportedPointerAccelerationProfiles & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     bool supportsPointerAccelerationProfileAdaptive() const {
         return (m_supportedPointerAccelerationProfiles & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     bool defaultPointerAccelerationProfileFlat() const {
         return (m_defaultPointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     bool defaultPointerAccelerationProfileAdaptive() const {
         return (m_defaultPointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     bool pointerAccelerationProfileFlat() const {
         return (m_pointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     bool pointerAccelerationProfileAdaptive() const {
         return (m_pointerAccelerationProfile & LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     void setPointerAccelerationProfile(bool set, enum  libinput_config_accel_profile profile);
     void setPointerAccelerationProfileFlat(bool set) {
         setPointerAccelerationProfile(set, LIBINPUT_CONFIG_ACCEL_PROFILE_FLAT);
     }
     void setPointerAccelerationProfileAdaptive(bool set) {
         setPointerAccelerationProfile(set, LIBINPUT_CONFIG_ACCEL_PROFILE_ADAPTIVE);
     }
     void setPointerAccelerationProfileFromInt(quint32 profile) {
         setPointerAccelerationProfile(true, (libinput_config_accel_profile) profile);
     }
     quint32 defaultPointerAccelerationProfileToInt() const {
         return (quint32) m_defaultPointerAccelerationProfile;
     }
     bool supportsClickMethodAreas() const {
         return (m_supportedClickMethods & LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     bool defaultClickMethodAreas() const {
         return (m_defaultClickMethod == LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     bool isClickMethodAreas() const {
         return (m_clickMethod == LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     bool supportsClickMethodClickfinger() const {
         return (m_supportedClickMethods & LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     bool defaultClickMethodClickfinger() const {
         return (m_defaultClickMethod == LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     bool isClickMethodClickfinger() const {
         return (m_clickMethod == LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     void setClickMethod(bool set, enum libinput_config_click_method method);
     void setClickMethodAreas(bool set) {
         setClickMethod(set, LIBINPUT_CONFIG_CLICK_METHOD_BUTTON_AREAS);
     }
     void setClickMethodClickfinger(bool set) {
         setClickMethod(set, LIBINPUT_CONFIG_CLICK_METHOD_CLICKFINGER);
     }
     void setClickMethodFromInt(quint32 method) {
         setClickMethod(true, (libinput_config_click_method) method);
     }
     quint32 defaultClickMethodToInt() const {
         return (quint32) m_defaultClickMethod;
     }
 
     bool isEnabled() const {
         return m_enabled;
     }
     void setEnabled(bool enabled);
 
     libinput_device *device() const {
         return m_device;
     }
 
     /**
      * Sets the @p config to load the Device configuration from and to store each
      * successful Device configuration.
      */
     void setConfig(const KConfigGroup &config) {
         m_config = config;
     }
 
     /**
      * The id of the screen in KWin identifiers. Set from KWin through setScreenId.
      */
     int screenId() const {
         return m_screenId;
     }
 
     /**
      * Sets the KWin screen id for the device
      */
     void setScreenId(int screenId) {
         m_screenId = screenId;
     }
 
     void setOrientation(Qt::ScreenOrientation orientation);
 
     /**
      * Loads the configuration and applies it to the Device
      */
     void loadConfiguration();
 
     bool isSwitch() const {
         return m_switch;
     }
 
     bool isLidSwitch() const {
         return m_lidSwitch;
     }
 
     bool isTabletModeSwitch() const {
         return m_tabletSwitch;
     }
 
+    int stripsCount() const;
+    int ringsCount() const;
+
     /**
      * All created Devices
      */
     static QVector<Device*> devices() {
         return s_devices;
     }
     /**
      * Gets the Device for @p native. @c null if there is no Device for @p native.
      */
     static Device *getDevice(libinput_device *native);
 
 Q_SIGNALS:
     void tapButtonMapChanged();
     void leftHandedChanged();
     void disableWhileTypingChanged();
     void pointerAccelerationChanged();
     void pointerAccelerationProfileChanged();
     void enabledChanged();
     void tapToClickChanged();
     void tapAndDragChanged();
     void tapDragLockChanged();
     void middleEmulationChanged();
     void naturalScrollChanged();
     void scrollMethodChanged();
     void scrollButtonChanged();
     void clickMethodChanged();
 
 private:
     template <typename T>
     void writeEntry(const ConfigKey &key, const T &value);
     template <typename T, typename Setter>
     void readEntry(const QByteArray &key, const Setter &s, const T &defaultValue = T());
     libinput_device *m_device;
     bool m_keyboard;
     bool m_alphaNumericKeyboard = false;
     bool m_pointer;
     bool m_touch;
     bool m_tabletTool;
     bool m_tabletPad;
     bool m_supportsGesture;
     bool m_switch = false;
     bool m_lidSwitch = false;
     bool m_tabletSwitch = false;
     QString m_name;
     QString m_sysName;
     QString m_outputName;
     QSizeF m_size;
     quint32 m_product;
     quint32 m_vendor;
     Qt::MouseButtons m_supportedButtons = Qt::NoButton;
     int m_tapFingerCount;
     enum libinput_config_tap_button_map m_defaultTapButtonMap;
     enum libinput_config_tap_button_map m_tapButtonMap;
     bool m_tapToClickEnabledByDefault;
     bool m_tapToClick;
     bool m_tapAndDragEnabledByDefault;
     bool m_tapAndDrag;
     bool m_tapDragLockEnabledByDefault;
     bool m_tapDragLock;
     bool m_supportsDisableWhileTyping;
     bool m_supportsPointerAcceleration;
     bool m_supportsLeftHanded;
     bool m_supportsCalibrationMatrix;
     bool m_supportsDisableEvents;
     bool m_supportsDisableEventsOnExternalMouse;
     bool m_supportsMiddleEmulation;
     bool m_supportsNaturalScroll;
     quint32 m_supportedScrollMethods;
     bool m_supportsScrollEdge;
     bool m_supportsScrollOnButtonDown;
     bool m_leftHandedEnabledByDefault;
     bool m_middleEmulationEnabledByDefault;
     bool m_naturalScrollEnabledByDefault;
     enum libinput_config_scroll_method m_defaultScrollMethod;
     quint32 m_defaultScrollButton;
     bool m_disableWhileTypingEnabledByDefault;
     bool m_disableWhileTyping;
     bool m_middleEmulation;
     bool m_leftHanded;
     bool m_naturalScroll;
     enum libinput_config_scroll_method m_scrollMethod;
     quint32 m_scrollButton;
     qreal m_defaultPointerAcceleration;
     qreal m_pointerAcceleration;
     quint32 m_supportedPointerAccelerationProfiles;
     enum libinput_config_accel_profile m_defaultPointerAccelerationProfile;
     enum libinput_config_accel_profile m_pointerAccelerationProfile;
     bool m_enabled;
 
     KConfigGroup m_config;
     bool m_loading = false;
 
     int m_screenId = 0;
     Qt::ScreenOrientation m_orientation = Qt::PrimaryOrientation;
     QMatrix4x4 m_defaultCalibrationMatrix;
     quint32 m_supportedClickMethods;
     enum libinput_config_click_method m_defaultClickMethod;
     enum libinput_config_click_method m_clickMethod;
 
     static QVector<Device*> s_devices;
 };
 
 }
 }
 
 Q_DECLARE_METATYPE(KWin::LibInput::Device*)
 
 #endif
diff --git a/libinput/events.h b/libinput/events.h
index fb8742831..946883d89 100644
--- a/libinput/events.h
+++ b/libinput/events.h
@@ -1,374 +1,377 @@
 /********************************************************************
  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 KWIN_LIBINPUT_EVENTS_H
 #define KWIN_LIBINPUT_EVENTS_H
 
 #include "../input.h"
 
 #include <libinput.h>
 
 namespace KWin
 {
 namespace LibInput
 {
 
 class Device;
 
 class Event
 {
 public:
     virtual ~Event();
 
     libinput_event_type type() const;
     Device *device() const;
     libinput_device *nativeDevice() const;
 
     operator libinput_event*() {
         return m_event;
     }
     operator libinput_event*() const {
         return m_event;
     }
 
     static Event *create(libinput_event *event);
 
 protected:
     Event(libinput_event *event, libinput_event_type type);
 
 private:
     libinput_event *m_event;
     libinput_event_type m_type;
     mutable Device *m_device;
 };
 
 class KeyEvent : public Event
 {
 public:
     KeyEvent(libinput_event *event);
     ~KeyEvent() override;
 
     uint32_t key() const;
     InputRedirection::KeyboardKeyState state() const;
     uint32_t time() const;
 
     operator libinput_event_keyboard*() {
         return m_keyboardEvent;
     }
     operator libinput_event_keyboard*() const {
         return m_keyboardEvent;
     }
 
 private:
     libinput_event_keyboard *m_keyboardEvent;
 };
 
 class PointerEvent : public Event
 {
 public:
     PointerEvent(libinput_event* event, libinput_event_type type);
     ~PointerEvent() override;
 
     QPointF absolutePos() const;
     QPointF absolutePos(const QSize &size) const;
     QSizeF delta() const;
     QSizeF deltaUnaccelerated() const;
     uint32_t button() const;
     InputRedirection::PointerButtonState buttonState() const;
     uint32_t time() const;
     quint64 timeMicroseconds() const;
     QVector<InputRedirection::PointerAxis> axis() const;
     qreal axisValue(InputRedirection::PointerAxis a) const;
     qint32 discreteAxisValue(InputRedirection::PointerAxis axis) const;
     InputRedirection::PointerAxisSource axisSource() const;
 
     operator libinput_event_pointer*() {
         return m_pointerEvent;
     }
     operator libinput_event_pointer*() const {
         return m_pointerEvent;
     }
 
 private:
     libinput_event_pointer *m_pointerEvent;
 };
 
 class TouchEvent : public Event
 {
 public:
     TouchEvent(libinput_event *event, libinput_event_type type);
     ~TouchEvent() override;
 
     quint32 time() const;
     QPointF absolutePos() const;
     QPointF absolutePos(const QSize &size) const;
     qint32 id() const;
 
     operator libinput_event_touch*() {
         return m_touchEvent;
     }
     operator libinput_event_touch*() const {
         return m_touchEvent;
     }
 
 private:
     libinput_event_touch *m_touchEvent;
 };
 
 class GestureEvent : public Event
 {
 public:
     ~GestureEvent() override;
 
     quint32 time() const;
     int fingerCount() const;
 
     QSizeF delta() const;
 
     bool isCancelled() const;
 
     operator libinput_event_gesture*() {
         return m_gestureEvent;
     }
     operator libinput_event_gesture*() const {
         return m_gestureEvent;
     }
 
 protected:
     GestureEvent(libinput_event *event, libinput_event_type type);
     libinput_event_gesture *m_gestureEvent;
 };
 
 class PinchGestureEvent : public GestureEvent
 {
 public:
     PinchGestureEvent(libinput_event *event, libinput_event_type type);
     ~PinchGestureEvent() override;
 
     qreal scale() const;
     qreal angleDelta() const;
 };
 
 class SwipeGestureEvent : public GestureEvent
 {
 public:
     SwipeGestureEvent(libinput_event *event, libinput_event_type type);
     ~SwipeGestureEvent() override;
 };
 
 class SwitchEvent : public Event
 {
 public:
     SwitchEvent(libinput_event *event, libinput_event_type type);
     ~SwitchEvent() override;
 
     enum class State {
         Off,
         On
     };
     State state() const;
 
     quint32 time() const;
     quint64 timeMicroseconds() const;
 
 private:
     libinput_event_switch *m_switchEvent;
 };
 
 class TabletToolEvent : public Event
 {
 public:
     TabletToolEvent(libinput_event *event, libinput_event_type type);
 
+    uint32_t time() const {
+        return libinput_event_tablet_tool_get_time(m_tabletToolEvent);
+    }
     bool xHasChanged() const {
         return libinput_event_tablet_tool_x_has_changed(m_tabletToolEvent);
     }
     bool yHasChanged() const {
         return libinput_event_tablet_tool_y_has_changed(m_tabletToolEvent);
     }
     bool pressureHasChanged() const {
         return libinput_event_tablet_tool_pressure_has_changed(m_tabletToolEvent);
     }
     bool distanceHasChanged() const {
         return libinput_event_tablet_tool_distance_has_changed(m_tabletToolEvent);
     }
     bool tiltXHasChanged() const {
         return libinput_event_tablet_tool_tilt_x_has_changed(m_tabletToolEvent);
     }
     bool tiltYHasChanged() const {
         return libinput_event_tablet_tool_tilt_y_has_changed(m_tabletToolEvent);
     }
     bool rotationHasChanged() const {
         return libinput_event_tablet_tool_rotation_has_changed(m_tabletToolEvent);
     }
     bool sliderHasChanged() const {
         return libinput_event_tablet_tool_slider_has_changed(m_tabletToolEvent);
     }
 
     // uncomment when depending on libinput 1.14 or when implementing totems
     //     bool sizeMajorHasChanged() const { return
     //     libinput_event_tablet_tool_size_major_has_changed(m_tabletToolEvent); } bool
     //     sizeMinorHasChanged() const { return
     //     libinput_event_tablet_tool_size_minor_has_changed(m_tabletToolEvent); }
     bool wheelHasChanged() const {
         return libinput_event_tablet_tool_wheel_has_changed(m_tabletToolEvent);
     }
     QPointF position() const {
         return {libinput_event_tablet_tool_get_x(m_tabletToolEvent),
                 libinput_event_tablet_tool_get_y(m_tabletToolEvent)};
     }
     QPointF delta() const {
         return {libinput_event_tablet_tool_get_dx(m_tabletToolEvent),
                 libinput_event_tablet_tool_get_dy(m_tabletToolEvent)};
     }
     qreal pressure() const {
         return libinput_event_tablet_tool_get_pressure(m_tabletToolEvent);
     }
     qreal distance() const {
         return libinput_event_tablet_tool_get_distance(m_tabletToolEvent);
     }
     int xTilt() const {
         return libinput_event_tablet_tool_get_tilt_x(m_tabletToolEvent);
     }
     int yTilt() const {
         return libinput_event_tablet_tool_get_tilt_y(m_tabletToolEvent);
     }
     qreal rotation() const {
         return libinput_event_tablet_tool_get_rotation(m_tabletToolEvent);
     }
     qreal sliderPosition() const {
         return libinput_event_tablet_tool_get_slider_position(m_tabletToolEvent);
     }
     // Uncomment when depending on libinput 1.14 or when implementing totems
     // qreal sizeMajor() const { return
     //     libinput_event_tablet_tool_get_size_major(m_tabletToolEvent); }
     // qreal sizeMinor() const {
     //     return libinput_event_tablet_tool_get_size_minor(m_tabletToolEvent); }
     qreal wheelDelta() const {
         return libinput_event_tablet_tool_get_wheel_delta(m_tabletToolEvent);
     }
     int wheelDeltaDiscrete() const {
         return libinput_event_tablet_tool_get_wheel_delta_discrete(m_tabletToolEvent);
     }
 
     bool isTipDown() const {
         const auto state = libinput_event_tablet_tool_get_tip_state(m_tabletToolEvent);
         return state == LIBINPUT_TABLET_TOOL_TIP_DOWN;
     }
     bool isNearby() const {
         const auto state = libinput_event_tablet_tool_get_proximity_state(m_tabletToolEvent);
         return state == LIBINPUT_TABLET_TOOL_PROXIMITY_STATE_IN;
     }
 
     QPointF transformedPosition(const QSize &size) const {
         return {libinput_event_tablet_tool_get_x_transformed(m_tabletToolEvent, size.width()),
                 libinput_event_tablet_tool_get_y_transformed(m_tabletToolEvent, size.height())};
     }
 
     struct libinput_tablet_tool *tool() {
         return libinput_event_tablet_tool_get_tool(m_tabletToolEvent);
     }
 
 private:
     libinput_event_tablet_tool *m_tabletToolEvent;
 };
 
 class TabletToolButtonEvent : public Event
 {
 public:
     TabletToolButtonEvent(libinput_event *event, libinput_event_type type);
 
     uint buttonId() const {
         return libinput_event_tablet_tool_get_button(m_tabletToolEvent);
     }
 
     bool isButtonPressed() const {
         const auto state = libinput_event_tablet_tool_get_button_state(m_tabletToolEvent);
         return state == LIBINPUT_BUTTON_STATE_PRESSED;
     }
 
 private:
     libinput_event_tablet_tool *m_tabletToolEvent;
 };
 
 class TabletPadRingEvent : public Event
 {
 public:
     TabletPadRingEvent(libinput_event *event, libinput_event_type type);
 
     int position() const {
         return libinput_event_tablet_pad_get_ring_position(m_tabletPadEvent);
     }
     int number() const {
         return libinput_event_tablet_pad_get_ring_number(m_tabletPadEvent);
     }
     libinput_tablet_pad_ring_axis_source source() const {
         return libinput_event_tablet_pad_get_ring_source(m_tabletPadEvent);
     }
 
 private:
     libinput_event_tablet_pad *m_tabletPadEvent;
 };
 
 class TabletPadStripEvent : public Event
 {
 public:
     TabletPadStripEvent(libinput_event *event, libinput_event_type type);
 
     int position() const {
         return libinput_event_tablet_pad_get_strip_position(m_tabletPadEvent);
     }
     int number() const {
         return libinput_event_tablet_pad_get_strip_number(m_tabletPadEvent);
     }
     libinput_tablet_pad_strip_axis_source source() const {
         return libinput_event_tablet_pad_get_strip_source(m_tabletPadEvent);
     }
 
 private:
     libinput_event_tablet_pad *m_tabletPadEvent;
 };
 
 class TabletPadButtonEvent : public Event
 {
 public:
     TabletPadButtonEvent(libinput_event *event, libinput_event_type type);
 
     uint buttonId() const {
         return libinput_event_tablet_pad_get_button_number(m_tabletPadEvent);
     }
     bool isButtonPressed() const {
         const auto state = libinput_event_tablet_pad_get_button_state(m_tabletPadEvent);
         return state == LIBINPUT_BUTTON_STATE_PRESSED;
     }
 
 private:
     libinput_event_tablet_pad *m_tabletPadEvent;
 };
 
 inline
 libinput_event_type Event::type() const
 {
     return m_type;
 }
 
 }
 }
 
 #endif
diff --git a/modifier_only_shortcuts.cpp b/modifier_only_shortcuts.cpp
index cb47df447..2ab3b69de 100644
--- a/modifier_only_shortcuts.cpp
+++ b/modifier_only_shortcuts.cpp
@@ -1,102 +1,102 @@
 /********************************************************************
  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 "modifier_only_shortcuts.h"
 #include "input_event.h"
 #include "options.h"
 #include "screenlockerwatcher.h"
 #include "workspace.h"
 
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 
 namespace KWin
 {
 
 ModifierOnlyShortcuts::ModifierOnlyShortcuts()
     : QObject()
     , InputEventSpy()
 {
     connect(ScreenLockerWatcher::self(), &ScreenLockerWatcher::locked, this, &ModifierOnlyShortcuts::reset);
 }
 
 ModifierOnlyShortcuts::~ModifierOnlyShortcuts() = default;
 
 void ModifierOnlyShortcuts::keyEvent(KeyEvent *event)
 {
     if (event->isAutoRepeat()) {
         return;
     }
     if (event->type() == QEvent::KeyPress) {
         const bool wasEmpty = m_pressedKeys.isEmpty();
         m_pressedKeys.insert(event->nativeScanCode());
         if (wasEmpty && m_pressedKeys.size() == 1 &&
             !ScreenLockerWatcher::self()->isLocked() &&
             m_buttonPressCount == 0 &&
             m_cachedMods == Qt::NoModifier) {
             m_modifier = Qt::KeyboardModifier(int(event->modifiersRelevantForGlobalShortcuts()));
         } else {
             m_modifier = Qt::NoModifier;
         }
     } else if (!m_pressedKeys.isEmpty()) {
         m_pressedKeys.remove(event->nativeScanCode());
         if (m_pressedKeys.isEmpty() &&
             event->modifiersRelevantForGlobalShortcuts() == Qt::NoModifier &&
-            !workspace()->globalShortcutsDisabled()) {
+            workspace() && !workspace()->globalShortcutsDisabled()) {
             if (m_modifier != Qt::NoModifier) {
                 const auto list = options->modifierOnlyDBusShortcut(m_modifier);
                 if (list.size() >= 4) {
                     auto call = QDBusMessage::createMethodCall(list.at(0), list.at(1), list.at(2), list.at(3));
                     QVariantList args;
                     for (int i = 4; i < list.size(); ++i) {
                         args << list.at(i);
                     }
                     call.setArguments(args);
                     QDBusConnection::sessionBus().asyncCall(call);
                 }
             }
         }
         m_modifier = Qt::NoModifier;
     } else {
         m_modifier = Qt::NoModifier;
     }
     m_cachedMods = event->modifiersRelevantForGlobalShortcuts();
 }
 
 void ModifierOnlyShortcuts::pointerEvent(MouseEvent *event)
 {
     if (event->type() == QEvent::MouseMove) {
         return;
     }
     if (event->type() == QEvent::MouseButtonPress) {
         m_buttonPressCount++;
     } else if (event->type() == QEvent::MouseButtonRelease) {
         m_buttonPressCount--;
     }
     reset();
 }
 
 void ModifierOnlyShortcuts::wheelEvent(WheelEvent *event)
 {
     Q_UNUSED(event)
     reset();
 }
 
 }
diff --git a/tablet_input.cpp b/tablet_input.cpp
index 8c3ef420a..be18ada44 100644
--- a/tablet_input.cpp
+++ b/tablet_input.cpp
@@ -1,163 +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>
 // 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, LibInput::Device *device)
+                                             quint64 toolId,
+                                             InputRedirection::TabletToolType toolType,
+                                             const QVector<InputRedirection::Capability> &capabilities,
+                                             quint32 time, LibInput::Device *device)
 {
-    Q_UNUSED(device)
-    Q_UNUSED(toolId)
     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;
-    QTabletEvent ev(t, pos, pos, QTabletEvent::Stylus, QTabletEvent::Pen, pressure,
+    TabletEvent ev(t, pos, pos, QTabletEvent::Stylus, QTabletEvent::Pen, pressure,
                     xTilt, yTilt,
                     0, // tangentialPressure
                     rotation,
                     0, // z
-                    Qt::NoModifier, serialId, button, button);
+                    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/tablet_input.h b/tablet_input.h
index 9607c8f3b..bce594118 100644
--- a/tablet_input.h
+++ b/tablet_input.h
@@ -1,91 +1,91 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 
 #ifndef KWIN_TABLET_INPUT_H
 #define KWIN_TABLET_INPUT_H
 #include "input.h"
 
 #include <QHash>
 #include <QObject>
 #include <QPointF>
 #include <QPointer>
-#include <QTabletEvent>
 
 namespace KWin
 {
-class InputRedirection;
 class Toplevel;
 
 namespace Decoration
 {
 class DecoratedClientImpl;
 }
 
 namespace LibInput
 {
 class Device;
 }
 
 class TabletInputRedirection : public InputDeviceHandler
 {
     Q_OBJECT
 public:
     explicit TabletInputRedirection(InputRedirection *parent);
     ~TabletInputRedirection() override;
 
     void tabletPad();
 
     void tabletToolEvent(KWin::InputRedirection::TabletEventType type, const QPointF &pos,
                          qreal pressure, int xTilt, int yTilt, qreal rotation, bool tipDown,
-                         bool tipNear, quint64 serialId, quint64 toolId, LibInput::Device *device);
+                         bool tipNear, quint64 serialId, quint64 toolId,
+                         InputRedirection::TabletToolType toolType, const QVector<InputRedirection::Capability> &capabilities,
+                         quint32 time, LibInput::Device *device);
     void tabletToolButtonEvent(uint button, bool isPressed);
 
     void tabletPadButtonEvent(uint button, bool isPressed);
     void tabletPadStripEvent(int number, int position, bool isFinger);
     void tabletPadRingEvent(int number, int position, bool isFinger);
 
     bool positionValid() const override
     {
         return !m_lastPosition.isNull();
     }
     void init() override;
 
     QPointF position() const override
     {
         return m_lastPosition;
     }
 
 private:
     void cleanupDecoration(Decoration::DecoratedClientImpl *old,
                            Decoration::DecoratedClientImpl *now) override;
     void cleanupInternalWindow(QWindow *old, QWindow *now) override;
     void focusUpdate(KWin::Toplevel *old, KWin::Toplevel *now) override;
 
     bool m_tipDown = false;
     bool m_tipNear = false;
 
     QPointF m_lastPosition;
     QSet<uint> m_toolPressedButtons;
     QSet<uint> m_padPressedButtons;
 };
 
 }
 
 #endif
diff --git a/wayland_server.cpp b/wayland_server.cpp
index c2f282e33..502deed66 100644
--- a/wayland_server.cpp
+++ b/wayland_server.cpp
@@ -1,790 +1,792 @@
 /********************************************************************
  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>
 
 // 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;
 
 namespace KWin
 {
 
 KWIN_SINGLETON_FACTORY(WaylandServer)
 
 WaylandServer::WaylandServer(QObject *parent)
     : QObject(parent)
 {
     qRegisterMetaType<KWayland::Server::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) {
         emit foreignTransientChanged(child);
     });
 }
 
 class KWinDisplay : public KWayland::Server::FilteredDisplay
 {
 public:
     KWinDisplay(QObject *parent)
         : KWayland::Server::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 {
         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 {
         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 {
         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, InitalizationFlags 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_xdgShell6 = m_display->createXdgShell(XdgShellInterfaceVersion::UnstableV6, m_display);
     m_xdgShell6->create();
     connect(m_xdgShell6, &XdgShellInterface::surfaceCreated, this, &WaylandServer::createSurface<XdgShellSurfaceInterface>);
     connect(m_xdgShell6, &XdgShellInterface::xdgPopupCreated, this, &WaylandServer::createSurface<XdgShellPopupInterface>);
 
     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 = findClient(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::registerXdgShellClient);
     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 = findClient(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 = findClient(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 = findClient(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 = findClient(deco->surface())) {
                 c->installServerSideDecoration(deco);
             }
             connect(deco, &ServerSideDecorationInterface::modeRequested, this,
                 [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, [this](KWayland::Server::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()
 {
     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;
                 m_windowManagement->setShowingDesktopState(set ?
                     PlasmaWindowManagementInterface::ShowingDesktopState::Enabled :
                     PlasmaWindowManagementInterface::ShowingDesktopState::Disabled
                 );
             }
         );
     }
 
     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()
 {
     ScreenLocker::KSldApp::self();
     ScreenLocker::KSldApp::self()->setWaylandDisplay(m_display);
     ScreenLocker::KSldApp::self()->setGreeterEnvironment(kwinApp()->processStartupEnvironment());
     ScreenLocker::KSldApp::self()->initialize();
 
     connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::greeterClientConnectionChanged, this,
         [this] () {
             m_screenLockerClientConnection = ScreenLocker::KSldApp::self()->greeterClientConnection();
         }
     );
 
     connect(ScreenLocker::KSldApp::self(), &ScreenLocker::KSldApp::unlocked, this,
         [this] () {
             m_screenLockerClientConnection = nullptr;
         }
     );
 
     if (m_initFlags.testFlag(InitalizationFlag::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::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,
         [] {
             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(this);
             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(XdgShellClient *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 XdgShellClient *findClientInList(const QList<XdgShellClient *> &clients, quint32 id)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
         [id] (XdgShellClient *c) {
             return c->windowId() == id;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
 static XdgShellClient *findClientInList(const QList<XdgShellClient *> &clients, KWayland::Server::SurfaceInterface *surface)
 {
     auto it = std::find_if(clients.begin(), clients.end(),
         [surface] (XdgShellClient *c) {
             return c->surface() == surface;
         }
     );
     if (it == clients.end()) {
         return nullptr;
     }
     return *it;
 }
 
 XdgShellClient *WaylandServer::findClient(quint32 id) const
 {
     if (id == 0) {
         return nullptr;
     }
     if (XdgShellClient *c = findClientInList(m_clients, id)) {
         return c;
     }
     return nullptr;
 }
 
 XdgShellClient *WaylandServer::findClient(SurfaceInterface *surface) const
 {
     if (!surface) {
         return nullptr;
     }
     if (XdgShellClient *c = findClientInList(m_clients, surface)) {
         return c;
     }
     return nullptr;
 }
 
 AbstractClient *WaylandServer::findAbstractClient(SurfaceInterface *surface) const
 {
     return 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)
 {
     auto ids = m_clientIds.values().toSet();
     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(InitalizationFlag::NoLockScreenIntegration);
 }
 
 bool WaylandServer::hasGlobalShortcutSupport() const
 {
     return !m_initFlags.testFlag(InitalizationFlag::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 6ff825916..4b3661707 100644
--- a/wayland_server.h
+++ b/wayland_server.h
@@ -1,299 +1,304 @@
 /********************************************************************
  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
 {
 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 InitalizationFlag {
         NoOptions = 0x0,
         LockScreen = 0x1,
         NoLockScreenIntegration = 0x2,
         NoGlobalShortcuts = 0x4
     };
 
     Q_DECLARE_FLAGS(InitalizationFlags, InitalizationFlag)
 
     ~WaylandServer() override;
     bool init(const QByteArray &socketName = QByteArray(), InitalizationFlags flags = InitalizationFlag::NoOptions);
     void terminateClientConnections();
 
     KWayland::Server::Display *display() {
         return m_display;
     }
     KWayland::Server::CompositorInterface *compositor() {
         return m_compositor;
     }
     KWayland::Server::SeatInterface *seat() {
         return m_seat;
     }
+    KWayland::Server::TabletManagerInterface *tabletManager() {
+        return m_tabletManager;
+    }
     KWayland::Server::DataDeviceManagerInterface *dataDeviceManager() {
         return m_dataDeviceManager;
     }
     KWayland::Server::PlasmaVirtualDesktopManagementInterface *virtualDesktopManagement() {
         return m_virtualDesktopManagement;
     }
     KWayland::Server::PlasmaWindowManagementInterface *windowManagement() {
         return m_windowManagement;
     }
     KWayland::Server::ServerSideDecorationManagerInterface *decorationManager() const {
         return m_decorationManager;
     }
     KWayland::Server::XdgOutputManagerInterface *xdgOutputManager() const {
         return m_xdgOutputManager;
     }
     KWayland::Server::LinuxDmabufUnstableV1Interface *linuxDmabuf();
 
     QList<XdgShellClient *> clients() const {
         return m_clients;
     }
     void removeClient(XdgShellClient *c);
     XdgShellClient *findClient(quint32 id) const;
     XdgShellClient *findClient(KWayland::Server::SurfaceInterface *surface) const;
     AbstractClient *findAbstractClient(KWayland::Server::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);
 
     /**
      * @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 {
         return m_xwayland.client;
     }
     KWayland::Server::ClientConnection *inputMethodConnection() const {
         return m_inputMethodServerConnection;
     }
     KWayland::Server::ClientConnection *internalConnection() const {
         return m_internalConnection.server;
     }
     KWayland::Server::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);
 
     /**
      * Struct containing information for a created Wayland connection through a
      * socketpair.
      */
     struct SocketPairConnection {
         /**
          * ServerSide Connection
          */
         KWayland::Server::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 {
         return m_linuxDmabufBuffers;
     }
     void addLinuxDmabufBuffer(KWayland::Server::LinuxDmabufUnstableV1Buffer *buffer) {
         m_linuxDmabufBuffers << buffer;
     }
     void removeLinuxDmabufBuffer(KWayland::Server::LinuxDmabufUnstableV1Buffer *buffer) {
         m_linuxDmabufBuffers.remove(buffer);
     }
 
 Q_SIGNALS:
     void shellClientAdded(KWin::XdgShellClient *);
     void shellClientRemoved(KWin::XdgShellClient *);
     void terminatingInternalClientConnection();
     void initialized();
     void foreignTransientChanged(KWayland::Server::SurfaceInterface *child);
 
 private:
     void shellClientShown(Toplevel *t);
     quint16 createClientId(KWayland::Server::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_xdgShell6 = 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;
     struct {
         KWayland::Server::ClientConnection *client = nullptr;
         QMetaObject::Connection destroyConnection;
     } m_xwayland;
     KWayland::Server::ClientConnection *m_inputMethodServerConnection = nullptr;
     KWayland::Server::ClientConnection *m_screenLockerClientConnection = nullptr;
     struct {
         KWayland::Server::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;
     QList<XdgShellClient *> m_clients;
     QHash<KWayland::Server::ClientConnection*, quint16> m_clientIds;
     InitalizationFlags m_initFlags;
     QVector<KWayland::Server::PlasmaShellSurfaceInterface*> m_plasmaShellSurfaces;
     KWIN_SINGLETON(WaylandServer)
 };
 
 inline
 WaylandServer *waylandServer() {
     return WaylandServer::self();
 }
 
 } // namespace KWin
 
 #endif