diff --git a/CMakeLists.txt b/CMakeLists.txt
index f94165708..b86bece6e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,784 +1,793 @@
 cmake_minimum_required(VERSION 3.1 FATAL_ERROR)
 
 project(KWin)
 set(PROJECT_VERSION "5.19.80")
 set(PROJECT_VERSION_MAJOR 5)
 
 set(QT_MIN_VERSION "5.14.0")
 set(KF5_MIN_VERSION "5.70.0")
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 find_package(ECM 5.38 REQUIRED NO_MODULE)
 
 include(FeatureSummary)
 include(WriteBasicConfigVersionFile)
 include(GenerateExportHeader)
 
 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
     Concurrent
     Core
     DBus
     Quick
     QuickWidgets
     Script
     Sensors
     UiTools
     Widgets
     X11Extras
 )
 
 find_package(Qt5Test ${QT_MIN_VERSION} CONFIG QUIET)
 set_package_properties(Qt5Test PROPERTIES
     PURPOSE "Required for tests"
     TYPE OPTIONAL
 )
 add_feature_info("Qt5Test" Qt5Test_FOUND "Required for building tests")
 if (NOT Qt5Test_FOUND)
     set(BUILD_TESTING OFF CACHE BOOL "Build the testing tree.")
 endif()
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(KDEClangFormat)
 
 include(ECMInstallIcons)
 include(ECMOptionalAddSubdirectory)
 
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0 -DQT_USE_QSTRINGBUILDER -DQT_NO_URL_CAST_FROM_STRING)
 
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 find_package(Qt5Multimedia QUIET)
 set_package_properties(Qt5Multimedia PROPERTIES
     PURPOSE "Runtime-only dependency for effect video playback"
     TYPE RUNTIME
 )
 
 # required frameworks by Core
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Config
     ConfigWidgets
     CoreAddons
     Crash
     GlobalAccel
     I18n
     IconThemes
     IdleTime
     Notifications
     Package
     Plasma
     Wayland
     WidgetsAddons
     WindowSystem
 )
 # required frameworks by config modules
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Completion
     Declarative
     KCMUtils
     KIO
     NewStuff
     Service
     TextWidgets
     XmlGui
 )
 
 find_package(Threads)
 set_package_properties(Threads PROPERTIES
     PURPOSE "Needed for VirtualTerminal support in KWin Wayland"
     TYPE REQUIRED
 )
 
 # optional frameworks
 find_package(KF5Activities ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Activities PROPERTIES
     PURPOSE "Enable building of KWin with kactivities support"
     TYPE OPTIONAL
 )
 add_feature_info("KF5Activities" KF5Activities_FOUND "Enable building of KWin with kactivities support")
 
 find_package(KF5DocTools ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5DocTools PROPERTIES
     PURPOSE "Enable building documentation"
     TYPE OPTIONAL
 )
 add_feature_info("KF5DocTools" KF5DocTools_FOUND "Enable building documentation")
 
 find_package(KF5Kirigami2 ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Kirigami2 PROPERTIES
     DESCRIPTION "A QtQuick based components set"
     PURPOSE "Required at runtime for Virtual desktop KCM and the virtual keyboard"
     TYPE RUNTIME
 )
 
 find_package(KDecoration2 5.18.0 CONFIG REQUIRED)
 
 find_package(KScreenLocker CONFIG REQUIRED)
 set_package_properties(KScreenLocker PROPERTIES
     TYPE REQUIRED
     PURPOSE "For screenlocker integration in kwin_wayland"
 )
 
 find_package(KWaylandServer CONFIG REQUIRED)
 set_package_properties(KWaylandServer PROPERTIES
     TYPE REQUIRED
     PURPOSE "For Wayland integration"
 )
 
 find_package(Breeze 5.9.0 CONFIG)
 set_package_properties(Breeze PROPERTIES
     TYPE OPTIONAL
     PURPOSE "For setting the default window decoration plugin"
 )
 if (${Breeze_FOUND})
     if (${BREEZE_WITH_KDECORATION})
         set(HAVE_BREEZE_DECO true)
     else()
         set(HAVE_BREEZE_DECO FALSE)
     endif()
 else()
     set(HAVE_BREEZE_DECO FALSE)
 endif()
 add_feature_info("Breeze-Decoration" HAVE_BREEZE_DECO "Default decoration plugin Breeze")
 
 find_package(EGL)
 set_package_properties(EGL PROPERTIES
     TYPE RUNTIME
     PURPOSE "Required to build KWin with EGL support"
 )
 
 find_package(epoxy)
 set_package_properties(epoxy PROPERTIES
     DESCRIPTION "libepoxy"
     URL "https://github.com/anholt/libepoxy"
     TYPE REQUIRED
     PURPOSE "OpenGL dispatch library"
 )
 
 set(HAVE_DL_LIBRARY FALSE)
 if (epoxy_HAS_GLX)
     find_library(DL_LIBRARY dl)
     if (DL_LIBRARY)
         set(HAVE_DL_LIBRARY TRUE)
     endif()
 endif()
 
 find_package(Wayland 1.2 REQUIRED COMPONENTS Cursor OPTIONAL_COMPONENTS Egl)
 set_package_properties(Wayland PROPERTIES
     TYPE REQUIRED
     PURPOSE "Required for building KWin with Wayland support"
 )
 add_feature_info("Wayland::EGL" Wayland_Egl_FOUND "Enable building of Wayland backend and QPA with EGL support.")
 set(HAVE_WAYLAND_EGL FALSE)
 if (Wayland_Egl_FOUND)
     set(HAVE_WAYLAND_EGL TRUE)
 endif()
 
 find_package(XKB 0.7.0)
 set_package_properties(XKB PROPERTIES
     TYPE REQUIRED
     PURPOSE "Required for building KWin with Wayland support"
 )
 
 find_package(Libinput 1.9)
 set_package_properties(Libinput PROPERTIES TYPE REQUIRED PURPOSE "Required for input handling on Wayland.")
 
 find_package(UDev)
 set_package_properties(UDev PROPERTIES
     URL "https://www.freedesktop.org/wiki/Software/systemd/"
     DESCRIPTION "Linux device library."
     TYPE REQUIRED
     PURPOSE "Required for input handling on Wayland."
 )
 
 find_package(Libdrm 2.4.62)
 set_package_properties(Libdrm PROPERTIES TYPE OPTIONAL PURPOSE "Required for drm output on Wayland.")
 set(HAVE_DRM FALSE)
 if (Libdrm_FOUND)
     set(HAVE_DRM TRUE)
 endif()
 
 find_package(gbm)
 set_package_properties(gbm PROPERTIES TYPE OPTIONAL PURPOSE "Required for egl output of drm backend.")
 set(HAVE_GBM FALSE)
 if (HAVE_DRM AND gbm_FOUND)
     set(HAVE_GBM TRUE)
 endif()
 
 option(KWIN_BUILD_EGL_STREAM_BACKEND "Enable building of EGLStream based DRM backend" ON)
 if (HAVE_DRM AND KWIN_BUILD_EGL_STREAM_BACKEND)
     set(HAVE_EGL_STREAMS TRUE)
 endif()
 
 find_package(libhybris)
 set_package_properties(libhybris PROPERTIES TYPE OPTIONAL PURPOSE "Required for libhybris backend")
 set(HAVE_LIBHYBRIS ${libhybris_FOUND})
 
 find_package(X11)
 set_package_properties(X11 PROPERTIES
     DESCRIPTION "X11 libraries"
     URL "https://www.x.org"
     TYPE REQUIRED
 )
 add_feature_info("XInput" X11_Xinput_FOUND "Required for poll-free mouse cursor updates")
 set(HAVE_X11_XINPUT ${X11_Xinput_FOUND})
 
 # All the required XCB components
 find_package(XCB 1.10 REQUIRED COMPONENTS
     COMPOSITE
     CURSOR
     DAMAGE
     GLX
     ICCCM
     IMAGE
     KEYSYMS
     RANDR
     RENDER
     SHAPE
     SHM
     SYNC
     XCB
     XFIXES
 )
 set_package_properties(XCB PROPERTIES TYPE REQUIRED)
 
 # and the optional XCB dependencies
 if (XCB_ICCCM_VERSION VERSION_LESS "0.4")
     set(XCB_ICCCM_FOUND FALSE)
 endif()
 add_feature_info("XCB-ICCCM" XCB_ICCCM_FOUND "Required for building test applications for KWin")
 
 find_package(X11_XCB)
 set_package_properties(X11_XCB PROPERTIES
     PURPOSE "Required for building X11 windowed backend of kwin_wayland"
     TYPE OPTIONAL
 )
 
 # dependencies for QPA plugin
 find_package(Qt5FontDatabaseSupport REQUIRED)
 find_package(Qt5ThemeSupport REQUIRED)
 find_package(Qt5EventDispatcherSupport REQUIRED)
 
 find_package(Freetype REQUIRED)
 set_package_properties(Freetype PROPERTIES
     DESCRIPTION "A font rendering engine"
     URL "https://www.freetype.org"
     TYPE REQUIRED
     PURPOSE "Needed for KWin's QPA plugin."
 )
 find_package(Fontconfig REQUIRED)
 set_package_properties(Fontconfig PROPERTIES
     TYPE REQUIRED
     PURPOSE "Needed for KWin's QPA plugin."
 )
 
 find_package(Xwayland)
 set_package_properties(Xwayland PROPERTIES
     URL "https://x.org"
     DESCRIPTION "Xwayland X server"
     TYPE RUNTIME
     PURPOSE "Needed for running kwin_wayland"
 )
 
 find_package(Libcap)
 set_package_properties(Libcap PROPERTIES
     TYPE OPTIONAL
     PURPOSE "Needed for running kwin_wayland with real-time scheduling policy"
 )
 set(HAVE_LIBCAP ${Libcap_FOUND})
 
 find_package(hwdata)
 set_package_properties(hwdata PROPERTIES
     TYPE RUNTIME
     PURPOSE "Runtime-only dependency needed for mapping monitor hardware vendor IDs to full names"
     URL "https://github.com/vcrhonek/hwdata"
 )
 
+find_package(QAccessibilityClient CONFIG)
+set_package_properties(QAccessibilityClient PROPERTIES
+    URL "https://www.kde.org"
+    DESCRIPTION "KDE client-side accessibility library"
+    TYPE OPTIONAL
+    PURPOSE "Required to enable accessibility features"
+)
+set(HAVE_ACCESSIBILITY ${QAccessibilityClient_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)
 qt5_add_dbus_interface(effects_interface_SRCS ${kwin_effects_dbus_xml} kwineffects_interface)
 add_library(KWinEffectsInterface STATIC ${effects_interface_SRCS})
 target_link_libraries(KWinEffectsInterface Qt5::DBus)
 
 include_directories(BEFORE
     ${CMAKE_CURRENT_BINARY_DIR}/libkwineffects
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}/libkwineffects
     ${CMAKE_CURRENT_SOURCE_DIR}/effects
     ${CMAKE_CURRENT_SOURCE_DIR}/tabbox
     ${CMAKE_CURRENT_SOURCE_DIR}/platformsupport
 )
 
 add_subdirectory(libkwineffects)
 if (KWIN_BUILD_KCMS)
     add_subdirectory(kcmkwin)
 endif()
 
 add_subdirectory(data)
 
 add_subdirectory(effects)
 add_subdirectory(scripts)
 add_subdirectory(tabbox)
 add_subdirectory(scripting)
 add_subdirectory(helpers)
 
 ########### next target ###############
 
 set(kwin_SRCS
     abstract_client.cpp
     abstract_opengl_context_attribute_builder.cpp
     abstract_output.cpp
     abstract_wayland_output.cpp
     activation.cpp
     appmenu.cpp
     atoms.cpp
     client_machine.cpp
     colorcorrection/clockskewnotifier.cpp
     colorcorrection/clockskewnotifierengine.cpp
     colorcorrection/colorcorrectdbusinterface.cpp
     colorcorrection/manager.cpp
     colorcorrection/suncalc.cpp
     composite.cpp
     cursor.cpp
     dbusinterface.cpp
     debug_console.cpp
     decorations/decoratedclient.cpp
     decorations/decorationbridge.cpp
     decorations/decorationpalette.cpp
     decorations/decorationrenderer.cpp
     decorations/decorations_logging.cpp
     decorations/settings.cpp
     deleted.cpp
     effectloader.cpp
     effects.cpp
     egl_context_attribute_builder.cpp
     events.cpp
     focuschain.cpp
     geometrytip.cpp
     gestures.cpp
     globalshortcuts.cpp
     group.cpp
     idle_inhibition.cpp
     input.cpp
     input_event.cpp
     input_event_spy.cpp
     internal_client.cpp
     keyboard_input.cpp
     keyboard_layout.cpp
     keyboard_layout_switching.cpp
     keyboard_repeat.cpp
     killwindow.cpp
     layers.cpp
     libinput/connection.cpp
     libinput/context.cpp
     libinput/device.cpp
     libinput/events.cpp
     libinput/libinput_logging.cpp
     linux_dmabuf.cpp
     logind.cpp
     main.cpp
     modifier_only_shortcuts.cpp
     moving_client_x11_filter.cpp
     netinfo.cpp
     onscreennotification.cpp
     options.cpp
     osd.cpp
     outline.cpp
     outputscreens.cpp
     overlaywindow.cpp
     placement.cpp
     platform.cpp
     pointer_input.cpp
     popup_input_filter.cpp
     rootinfo_filter.cpp
     rules.cpp
     rulebooksettings.cpp
     scene.cpp
     screenedge.cpp
     screenlockerwatcher.cpp
     screens.cpp
     scripting/dbuscall.cpp
     scripting/meta.cpp
     scripting/screenedgeitem.cpp
     scripting/scriptedeffect.cpp
     scripting/scripting.cpp
     scripting/scripting_logging.cpp
     scripting/scripting_model.cpp
     scripting/scriptingutils.cpp
     scripting/timer.cpp
     scripting/workspace_wrapper.cpp
     shadow.cpp
     sm.cpp
     subsurfacemonitor.cpp
     syncalarmx11filter.cpp
     thumbnailitem.cpp
     toplevel.cpp
     touch_hide_cursor_spy.cpp
     tablet_input.cpp
     touch_input.cpp
     udev.cpp
     unmanaged.cpp
     useractions.cpp
     utils.cpp
     virtualdesktops.cpp
     virtualdesktopsdbustypes.cpp
     virtualkeyboard.cpp
     virtualkeyboard_dbus.cpp
     was_user_interaction_x11_filter.cpp
     wayland_cursor_theme.cpp
     wayland_server.cpp
     window_property_notify_x11_filter.cpp
     workspace.cpp
     x11client.cpp
     x11eventfilter.cpp
     xcbutils.cpp
     xdgshellclient.cpp
     xkb.cpp
     xwaylandclient.cpp
     xwl/xwayland_interface.cpp
 )
 
 if (CMAKE_SYSTEM_NAME MATCHES "Linux")
     set(kwin_SRCS
         ${kwin_SRCS}
         colorcorrection/clockskewnotifierengine_linux.cpp
     )
 endif()
 
 include(ECMQtDeclareLoggingCategory)
 ecm_qt_declare_logging_category(kwin_SRCS
     HEADER
         colorcorrect_logging.h
     IDENTIFIER
         KWIN_COLORCORRECTION
     CATEGORY_NAME
         kwin_colorcorrection
     DEFAULT_SEVERITY
         Critical
 )
 
 if (KWIN_BUILD_TABBOX)
     include_directories(${Qt5Gui_PRIVATE_INCLUDE_DIRS})
     set(kwin_SRCS ${kwin_SRCS}
         tabbox/clientmodel.cpp
         tabbox/desktopchain.cpp
         tabbox/desktopmodel.cpp
         tabbox/switcheritem.cpp
         tabbox/tabbox.cpp
         tabbox/tabbox_logging.cpp
         tabbox/tabboxconfig.cpp
         tabbox/tabboxhandler.cpp
         tabbox/x11_filter.cpp
     )
 endif()
 
 if (KWIN_BUILD_ACTIVITIES)
     set(kwin_SRCS ${kwin_SRCS}
         activities.cpp
     )
 endif()
 
 if (HAVE_LINUX_VT_H)
     set(kwin_SRCS ${kwin_SRCS}
         virtual_terminal.cpp
     )
 endif()
 
 kconfig_add_kcfg_files(kwin_SRCS settings.kcfgc)
 kconfig_add_kcfg_files(kwin_SRCS colorcorrection/colorcorrect_settings.kcfgc)
 kconfig_add_kcfg_files(kwin_SRCS rulesettings.kcfgc)
 kconfig_add_kcfg_files(kwin_SRCS rulebooksettingsbase.kcfgc)
 
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.xml dbusinterface.h KWin::DBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.Compositing.xml dbusinterface.h KWin::CompositorDBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.kwin.ColorCorrect.xml colorcorrection/colorcorrectdbusinterface.h KWin::ColorCorrect::ColorCorrectDBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.VirtualDesktopManager.xml dbusinterface.h KWin::VirtualDesktopManagerDBusInterface)
 qt5_add_dbus_adaptor(kwin_SRCS org.kde.KWin.Session.xml sm.h KWin::SessionManager)
 
 qt5_add_dbus_interface(kwin_SRCS ${KSCREENLOCKER_DBUS_INTERFACES_DIR}/kf5_org.freedesktop.ScreenSaver.xml screenlocker_interface)
 qt5_add_dbus_interface(kwin_SRCS ${KSCREENLOCKER_DBUS_INTERFACES_DIR}/org.kde.screensaver.xml kscreenlocker_interface)
 qt5_add_dbus_interface(kwin_SRCS org.kde.kappmenu.xml appmenu_interface)
 
 ki18n_wrap_ui(kwin_SRCS
     debug_console.ui
     shortcutdialog.ui
 )
 
 ########### target link libraries ###############
 
 set(kwin_OWN_LIBS
     kwineffects
     kwin4_effect_builtins
 )
 
 set(kwin_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::Script
     Qt5::Sensors
 )
 
 set(kwin_KDE_LIBS
     KF5::ConfigCore
     KF5::ConfigWidgets
     KF5::CoreAddons
     KF5::GlobalAccel
     KF5::GlobalAccelPrivate
     KF5::I18n
     KF5::Notifications
     KF5::Package
     KF5::Plasma
     KF5::QuickAddons
     KF5::WindowSystem
 
     KDecoration2::KDecoration
     KDecoration2::KDecoration2Private
 
     PW::KScreenLocker
 )
 
 set(kwin_XLIB_LIBS
     ${X11_ICE_LIB}
     ${X11_SM_LIB}
     ${X11_X11_LIB}
 )
 
 set(kwin_XCB_LIBS
     XCB::COMPOSITE
     XCB::DAMAGE
     XCB::GLX
     XCB::ICCCM
     XCB::KEYSYMS
     XCB::RANDR
     XCB::RENDER
     XCB::SHAPE
     XCB::SHM
     XCB::SYNC
     XCB::XCB
     XCB::XFIXES
 )
 
 set(kwin_WAYLAND_LIBS
     KF5::WaylandClient
     Plasma::KWaylandServer
     Wayland::Cursor
     XKB::XKB
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
 if (KWIN_BUILD_ACTIVITIES)
     set(kwin_KDE_LIBS ${kwin_KDE_LIBS} KF5::Activities)
 endif()
 
 set(kwinLibs
     ${kwin_OWN_LIBS}
     ${kwin_QT_LIBS}
     ${kwin_KDE_LIBS}
     ${kwin_XLIB_LIBS}
     ${kwin_XCB_LIBS}
     ${kwin_WAYLAND_LIBS}
     ${UDEV_LIBS}
     Libinput::Libinput
 )
 
 add_library(kwin SHARED ${kwin_SRCS})
 if (Libinput_VERSION_STRING VERSION_GREATER 1.14)
     target_compile_definitions(kwin PRIVATE -DLIBINPUT_HAS_TOTEM)
 endif ()
 
 set_target_properties(kwin PROPERTIES
    VERSION ${PROJECT_VERSION}
    SOVERSION ${PROJECT_VERSION_MAJOR}
 )
 
 target_link_libraries(kwin ${kwinLibs})
 generate_export_header(kwin EXPORT_FILE_NAME kwin_export.h)
 
 target_link_libraries(kwin kwinglutils ${epoxy_LIBRARY})
 
 add_executable(kwin_x11 main_x11.cpp)
 target_link_libraries(kwin_x11 kwin KF5::Crash Qt5::X11Extras)
 
 install(TARGETS kwin ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP)
 install(TARGETS kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS})
 
 set(kwin_XWAYLAND_SRCS
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/clipboard.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/databridge.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/dnd.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/drag.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/drag_wl.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/drag_x.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/selection.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/selection_source.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/transfer.cpp
    ${CMAKE_CURRENT_SOURCE_DIR}/xwl/xwayland.cpp
 )
 include(ECMQtDeclareLoggingCategory)
 ecm_qt_declare_logging_category(kwin_XWAYLAND_SRCS
     HEADER
         xwayland_logging.h
     IDENTIFIER
         KWIN_XWL
     CATEGORY_NAME
         kwin_xwl
     DEFAULT_SEVERITY
         Critical
 )
 
 set(kwin_WAYLAND_SRCS
    main_wayland.cpp
    tabletmodemanager.cpp
 )
 
 add_executable(kwin_wayland ${kwin_WAYLAND_SRCS} ${kwin_XWAYLAND_SRCS})
 target_link_libraries(kwin_wayland kwin KF5::Crash)
 if (HAVE_LIBCAP)
     target_link_libraries(kwin_wayland ${Libcap_LIBRARIES})
 endif()
 
 install(TARGETS kwin_wayland ${INSTALL_TARGETS_DEFAULT_ARGS})
 if (HAVE_LIBCAP)
     install(
     CODE "execute_process(
             COMMAND
                 ${SETCAP_EXECUTABLE}
                 CAP_SYS_NICE=+ep
                 \$ENV{DESTDIR}${CMAKE_INSTALL_FULL_BINDIR}/kwin_wayland)"
     )
 endif()
 
 add_subdirectory(platformsupport)
 add_subdirectory(plugins)
 
 ########### install files ###############
 
 install(FILES kwin.kcfg DESTINATION ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}.kcfg)
 install(FILES colorcorrection/colorcorrect_settings.kcfg DESTINATION ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}_colorcorrect.kcfg)
 install(FILES kwin.notifyrc DESTINATION ${KNOTIFYRC_INSTALL_DIR} RENAME ${KWIN_NAME}.notifyrc)
 install(
     FILES
         org.kde.KWin.VirtualDesktopManager.xml
         org.kde.KWin.xml
         org.kde.kwin.ColorCorrect.xml
         org.kde.kwin.Compositing.xml
         org.kde.kwin.Effects.xml
     DESTINATION
         ${KDE_INSTALL_DBUSINTERFACEDIR}
 )
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/kwin_export.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
 
 # Install the KWin/Script service type
 install(FILES scripting/kwinscript.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR})
 
 add_subdirectory(qml)
 
 if (BUILD_TESTING)
     add_subdirectory(autotests)
     add_subdirectory(tests)
 endif()
 
 if (KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 add_subdirectory(kconf_update)
 
 # add clang-format target for all our real source files
 file(GLOB_RECURSE ALL_CLANG_FORMAT_SOURCE_FILES *.cpp *.h)
 kde_clang_format(${ALL_CLANG_FORMAT_SOURCE_FILES})
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 include(CMakePackageConfigHelpers)
 set(CMAKECONFIG_INSTALL_DIR "${CMAKECONFIG_INSTALL_PREFIX}/KWinDBusInterface")
 configure_package_config_file(KWinDBusInterfaceConfig.cmake.in
     "${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake"
     PATH_VARS KDE_INSTALL_DBUSINTERFACEDIR
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake
     DESTINATION ${CMAKECONFIG_INSTALL_DIR})
diff --git a/config-kwin.h.cmake b/config-kwin.h.cmake
index 90efb3e58..9e900d65f 100644
--- a/config-kwin.h.cmake
+++ b/config-kwin.h.cmake
@@ -1,43 +1,44 @@
 #cmakedefine KWIN_BUILD_DECORATIONS 1
 #cmakedefine KWIN_BUILD_TABBOX 1
 #cmakedefine KWIN_BUILD_ACTIVITIES 1
 #define KWIN_NAME "${KWIN_NAME}"
 #define KWIN_INTERNAL_NAME_X11 "${KWIN_INTERNAL_NAME_X11}"
 #define KWIN_CONFIG "${KWIN_NAME}rc"
 #define KWIN_VERSION_STRING "${PROJECT_VERSION}"
 #define XCB_VERSION_STRING "${XCB_VERSION}"
 #define KWIN_KILLER_BIN "${CMAKE_INSTALL_FULL_LIBEXECDIR}/kwin_killer_helper"
 #define KWIN_RULES_DIALOG_BIN "${CMAKE_INSTALL_FULL_LIBEXECDIR}/kwin_rules_dialog"
 #define KWIN_XCLIPBOARD_SYNC_BIN "${CMAKE_INSTALL_FULL_LIBEXECDIR}/org_kde_kwin_xclipboard_syncer"
 #cmakedefine01 HAVE_X11_XCB
 #cmakedefine01 HAVE_X11_XINPUT
 #cmakedefine01 HAVE_DRM
 #cmakedefine01 HAVE_GBM
 #cmakedefine01 HAVE_EGL_STREAMS
 #cmakedefine01 HAVE_LIBHYBRIS
 #cmakedefine01 HAVE_WAYLAND_EGL
 #cmakedefine01 HAVE_SYS_PRCTL_H
 #cmakedefine01 HAVE_PR_SET_DUMPABLE
 #cmakedefine01 HAVE_PR_SET_PDEATHSIG
 #cmakedefine01 HAVE_SYS_PROCCTL_H
 #cmakedefine01 HAVE_PROC_TRACE_CTL
 #cmakedefine01 HAVE_SYS_SYSMACROS_H
 #cmakedefine01 HAVE_BREEZE_DECO
 #cmakedefine01 HAVE_LIBCAP
 #cmakedefine01 HAVE_SCHED_RESET_ON_FORK
+#cmakedefine01 HAVE_ACCESSIBILITY
 #if HAVE_BREEZE_DECO
 #define BREEZE_KDECORATION_PLUGIN_ID "${BREEZE_KDECORATION_PLUGIN_ID}"
 #endif
 
 /* Define to 1 if you have the <unistd.h> header file. */
 #cmakedefine HAVE_UNISTD_H 1
 
 /* Define to 1 if you have the <malloc.h> header file. */
 #cmakedefine HAVE_MALLOC_H 1
 
 #cmakedefine XCB_ICCCM_FOUND 1
 #ifndef XCB_ICCCM_FOUND
 #define XCB_ICCCM_WM_STATE_WITHDRAWN 0
 #define XCB_ICCCM_WM_STATE_NORMAL 1
 #define XCB_ICCCM_WM_STATE_ICONIC 3
 #endif
diff --git a/effects/CMakeLists.txt b/effects/CMakeLists.txt
index 386812d78..0ad5b212c 100644
--- a/effects/CMakeLists.txt
+++ b/effects/CMakeLists.txt
@@ -1,205 +1,220 @@
 # KI18N Translation Domain for this library
 add_definitions(-DTRANSLATION_DOMAIN=\"kwin_effects\" -DEFFECT_BUILTINS)
 
 include_directories(${KWin_SOURCE_DIR}) # for xcbutils.h
 
+if (HAVE_ACCESSIBILITY)
+    include_directories(${QACCESSIBILITYCLIENT_INCLUDE_DIR})
+endif()
+
 set(kwin_effect_OWN_LIBS
     kwineffects
 )
 
 if (KWIN_HAVE_XRENDER_COMPOSITING)
     set(kwin_effect_OWN_LIBS ${kwin_effect_OWN_LIBS} kwinxrenderutils)
 endif()
 
 set(kwin_effect_KDE_LIBS
     KF5::ConfigGui
     KF5::ConfigWidgets
     KF5::GlobalAccel
     KF5::I18n
     KF5::Notifications # screenshot effect
     KF5::Plasma # screenedge effect
     KF5::WindowSystem
 )
 
+if (HAVE_ACCESSIBILITY)
+    set(kwin_effect_KDE_LIBS ${kwin_effect_KDE_LIBS} ${QACCESSIBILITYCLIENT_LIBRARY})
+endif()
+
 set(kwin_effect_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::X11Extras
 )
 
 set(kwin_effect_XLIB_LIBS
     ${X11_X11_LIB}
 )
 
 set(kwin_effect_XCB_LIBS
     XCB::IMAGE
     XCB::XCB
     XCB::XFIXES
 )
 
 if (KWIN_HAVE_XRENDER_COMPOSITING)
     set(kwin_effect_XCB_LIBS ${kwin_effect_XCB_LIBS} XCB::RENDER)
 endif()
 
 set(kwin_effect_OWN_LIBS ${kwin_effect_OWN_LIBS} kwinglutils)
 
 macro(KWIN4_ADD_EFFECT_BACKEND name)
     add_library(${name} SHARED ${ARGN})
     target_link_libraries(${name} PRIVATE
         ${kwin_effect_KDE_LIBS}
         ${kwin_effect_OWN_LIBS}
         ${kwin_effect_QT_LIBS}
         ${kwin_effect_XCB_LIBS}
         ${kwin_effect_XLIB_LIBS}
     )
 endmacro()
 
 # Adds effect plugin with given name. Sources are given after the name
 macro(KWIN4_ADD_EFFECT name)
     kwin4_add_effect_backend(kwin4_effect_${name} ${ARGN})
 
     set_target_properties(kwin4_effect_${name} PROPERTIES VERSION 1.0.0 SOVERSION 1)
     set_target_properties(kwin4_effect_${name} PROPERTIES OUTPUT_NAME ${KWIN_NAME}4_effect_${name})
     install(TARGETS kwin4_effect_${name} ${INSTALL_TARGETS_DEFAULT_ARGS})
 endmacro()
 
 # Install the KWin/Effect service type
 install(FILES kwineffect.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR})
 
 # Create initial variables
 set(kwin4_effect_include_directories)
 
 set(kwin4_effect_builtins_sources
     blur/blur.cpp
     blur/blurshader.cpp
     colorpicker/colorpicker.cpp
     coverswitch/coverswitch.cpp
     cube/cube.cpp
     cube/cube_proxy.cpp
     cubeslide/cubeslide.cpp
     desktopgrid/desktopgrid.cpp
     diminactive/diminactive.cpp
     effect_builtins.cpp
     flipswitch/flipswitch.cpp
     glide/glide.cpp
     invert/invert.cpp
     logging.cpp
     lookingglass/lookingglass.cpp
     magiclamp/magiclamp.cpp
     magnifier/magnifier.cpp
     mouseclick/mouseclick.cpp
     mousemark/mousemark.cpp
     presentwindows/presentwindows.cpp
     presentwindows/presentwindows_proxy.cpp
     resize/resize.cpp
     showfps/showfps.cpp
     showpaint/showpaint.cpp
     slide/slide.cpp
     thumbnailaside/thumbnailaside.cpp
     touchpoints/touchpoints.cpp
     trackmouse/trackmouse.cpp
     windowgeometry/windowgeometry.cpp
     wobblywindows/wobblywindows.cpp
     zoom/zoom.cpp
 )
 
+if (HAVE_ACCESSIBILITY)
+    set(kwin4_effect_builtins_sources
+        zoom/accessibilityintegration.cpp
+        ${kwin4_effect_builtins_sources}
+    )
+endif()
+
 qt5_add_resources(kwin4_effect_builtins_sources shaders.qrc)
 
 kconfig_add_kcfg_files(kwin4_effect_builtins_sources
     blur/blurconfig.kcfgc
     coverswitch/coverswitchconfig.kcfgc
     cube/cubeconfig.kcfgc
     cubeslide/cubeslideconfig.kcfgc
     desktopgrid/desktopgridconfig.kcfgc
     diminactive/diminactiveconfig.kcfgc
     fallapart/fallapartconfig.kcfgc
     flipswitch/flipswitchconfig.kcfgc
     glide/glideconfig.kcfgc
     lookingglass/lookingglassconfig.kcfgc
     magiclamp/magiclampconfig.kcfgc
     magnifier/magnifierconfig.kcfgc
     mouseclick/mouseclickconfig.kcfgc
     mousemark/mousemarkconfig.kcfgc
     presentwindows/presentwindowsconfig.kcfgc
     resize/resizeconfig.kcfgc
     showfps/showfpsconfig.kcfgc
     slide/slideconfig.kcfgc
     slidingpopups/slidingpopupsconfig.kcfgc
     thumbnailaside/thumbnailasideconfig.kcfgc
     trackmouse/trackmouseconfig.kcfgc
     windowgeometry/windowgeometryconfig.kcfgc
     wobblywindows/wobblywindowsconfig.kcfgc
     zoom/zoomconfig.kcfgc
 )
 
 # scripted effects
 function(install_scripted_effect name)
     kpackage_install_package(${name}/package kwin4_effect_${name} effects kwin)
 
     # necessary so tests are found without installing
     file(COPY ${name}/package/contents ${name}/package/metadata.desktop DESTINATION ${CMAKE_BINARY_DIR}/bin/kwin/effects/kwin4_effect_${name})
 endfunction()
 install_scripted_effect(dialogparent)
 install_scripted_effect(dimscreen)
 install_scripted_effect(eyeonscreen)
 install_scripted_effect(fade)
 install_scripted_effect(fadedesktop)
 install_scripted_effect(fadingpopups)
 install_scripted_effect(frozenapp)
 install_scripted_effect(login)
 install_scripted_effect(logout)
 install_scripted_effect(maximize)
 install_scripted_effect(morphingpopups)
 install_scripted_effect(scale)
 install_scripted_effect(squash)
 install_scripted_effect(translucency)
 install_scripted_effect(windowaperture)
 install_scripted_effect(sessionquit)
 
 ###############################################################################
 # Built-in effects go here
 
 # Common effects
 add_subdirectory(desktopgrid)
 add_subdirectory(diminactive)
 include(fallapart/CMakeLists.txt)
 include(highlightwindow/CMakeLists.txt)
 include(kscreen/CMakeLists.txt)
 add_subdirectory(magiclamp)
 add_subdirectory(presentwindows)
 add_subdirectory(resize)
 include(screenedge/CMakeLists.txt)
 add_subdirectory(showfps)
 add_subdirectory(showpaint)
 add_subdirectory(slide)
 include(slideback/CMakeLists.txt)
 include(slidingpopups/CMakeLists.txt)
 add_subdirectory(thumbnailaside)
 add_subdirectory(windowgeometry)
 add_subdirectory(zoom)
 
 # OpenGL-specific effects
 add_subdirectory(blur)
 include(backgroundcontrast/CMakeLists.txt)
 add_subdirectory(coverswitch)
 add_subdirectory(cube)
 add_subdirectory(cubeslide)
 add_subdirectory(flipswitch)
 add_subdirectory(glide)
 add_subdirectory(invert)
 add_subdirectory(lookingglass)
 add_subdirectory(magnifier)
 add_subdirectory(mouseclick)
 add_subdirectory(mousemark)
 include(screenshot/CMakeLists.txt)
 include(sheet/CMakeLists.txt)
 include(snaphelper/CMakeLists.txt)
 include(startupfeedback/CMakeLists.txt)
 add_subdirectory(trackmouse)
 add_subdirectory(wobblywindows)
 
 ###############################################################################
 
 # Add the builtins plugin
 kwin4_add_effect(builtins ${kwin4_effect_builtins_sources})
diff --git a/effects/zoom/accessibilityintegration.cpp b/effects/zoom/accessibilityintegration.cpp
new file mode 100644
index 000000000..088c7c407
--- /dev/null
+++ b/effects/zoom/accessibilityintegration.cpp
@@ -0,0 +1,91 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+
+#include "accessibilityintegration.h"
+
+using namespace QAccessibleClient; // Whatever, sue me...
+
+namespace KWin
+{
+
+ZoomAccessibilityIntegration::ZoomAccessibilityIntegration(QObject *parent)
+    : QObject(parent)
+{
+}
+
+void ZoomAccessibilityIntegration::setFocusTrackingEnabled(bool enabled)
+{
+    if (m_isFocusTrackingEnabled == enabled) {
+        return;
+    }
+    m_isFocusTrackingEnabled = enabled;
+    updateAccessibilityRegistry();
+}
+
+bool ZoomAccessibilityIntegration::isFocusTrackingEnabled() const
+{
+    return m_isFocusTrackingEnabled;
+}
+
+void ZoomAccessibilityIntegration::updateAccessibilityRegistry()
+{
+    Registry::EventListeners eventListeners = Registry::NoEventListeners;
+
+    if (isFocusTrackingEnabled()) {
+        eventListeners |= Registry::Focus;
+    }
+
+    if (eventListeners == Registry::NoEventListeners) {
+        destroyAccessibilityRegistry();
+        return;
+    }
+    if (!m_accessibilityRegistry) {
+        createAccessibilityRegistry();
+    }
+
+    m_accessibilityRegistry->subscribeEventListeners(eventListeners);
+}
+
+void ZoomAccessibilityIntegration::createAccessibilityRegistry()
+{
+    m_accessibilityRegistry = new Registry(this);
+
+    connect(m_accessibilityRegistry, &Registry::focusChanged,
+            this, &ZoomAccessibilityIntegration::slotFocusChanged);
+}
+
+void ZoomAccessibilityIntegration::destroyAccessibilityRegistry()
+{
+    if (!m_accessibilityRegistry) {
+        return;
+    }
+
+    disconnect(m_accessibilityRegistry, nullptr, this, nullptr);
+
+    m_accessibilityRegistry->deleteLater();
+    m_accessibilityRegistry = nullptr;
+}
+
+void ZoomAccessibilityIntegration::slotFocusChanged(const AccessibleObject &object)
+{
+    emit focusPointChanged(object.focusPoint());
+}
+
+} // namespace KWin
diff --git a/effects/zoom/accessibilityintegration.h b/effects/zoom/accessibilityintegration.h
new file mode 100644
index 000000000..99942177f
--- /dev/null
+++ b/effects/zoom/accessibilityintegration.h
@@ -0,0 +1,53 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2020 Vlad Zahorodnii <vlad.zahorodnii@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+
+#pragma once
+
+#include <qaccessibilityclient/registry.h>
+
+namespace KWin
+{
+
+class ZoomAccessibilityIntegration : public QObject
+{
+    Q_OBJECT
+
+public:
+    explicit ZoomAccessibilityIntegration(QObject *parent = nullptr);
+
+    void setFocusTrackingEnabled(bool enabled);
+    bool isFocusTrackingEnabled() const;
+
+Q_SIGNALS:
+    void focusPointChanged(const QPoint &point);
+
+private Q_SLOTS:
+    void slotFocusChanged(const QAccessibleClient::AccessibleObject &object);
+
+private:
+    void createAccessibilityRegistry();
+    void destroyAccessibilityRegistry();
+    void updateAccessibilityRegistry();
+
+    QAccessibleClient::Registry *m_accessibilityRegistry = nullptr;
+    bool m_isFocusTrackingEnabled = false;
+};
+
+} // namespace KWin
diff --git a/effects/zoom/zoom.cpp b/effects/zoom/zoom.cpp
index d88426277..95231a0a3 100644
--- a/effects/zoom/zoom.cpp
+++ b/effects/zoom/zoom.cpp
@@ -1,534 +1,529 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010 Sebastian Sauer <sebsauer@kdab.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "zoom.h"
 // KConfigSkeleton
 #include "zoomconfig.h"
 
+#if HAVE_ACCESSIBILITY
+#include "accessibilityintegration.h"
+#endif
+
 #include <QAction>
 #include <QApplication>
 #include <QStyle>
 #include <QVector2D>
-#include <QDBusConnection>
 #include <kstandardaction.h>
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 
 #include <kwinglutils.h>
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
 #include <kwinxrenderutils.h>
 #include <xcb/render.h>
 #endif
 
 namespace KWin
 {
 
 ZoomEffect::ZoomEffect()
     : Effect()
     , zoom(1)
     , target_zoom(1)
     , polling(false)
     , zoomFactor(1.25)
     , mouseTracking(MouseTrackingProportional)
-    , enableFocusTracking(false)
-    , followFocus(true)
     , mousePointer(MousePointerScale)
     , focusDelay(350)   // in milliseconds
     , imageWidth(0)
     , imageHeight(0)
     , isMouseHidden(false)
     , xMove(0)
     , yMove(0)
     , moveFactor(20.0)
 {
     initConfig<ZoomConfig>();
     QAction* a = nullptr;
     a = KStandardAction::zoomIn(this, SLOT(zoomIn()), this);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Equal);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Equal);
     effects->registerGlobalShortcut(Qt::META + Qt::Key_Equal, a);
     effects->registerAxisShortcut(Qt::ControlModifier | Qt::MetaModifier, PointerAxisDown, a);
 
     a = KStandardAction::zoomOut(this, SLOT(zoomOut()), this);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Minus);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Minus);
     effects->registerGlobalShortcut(Qt::META + Qt::Key_Minus, a);
     effects->registerAxisShortcut(Qt::ControlModifier | Qt::MetaModifier, PointerAxisUp, a);
 
     a = KStandardAction::actualSize(this, SLOT(actualSize()), this);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_0);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_0);
     effects->registerGlobalShortcut(Qt::META + Qt::Key_0, a);
 
     a = new QAction(this);
     a->setObjectName(QStringLiteral("MoveZoomLeft"));
     a->setText(i18n("Move Zoomed Area to Left"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>());
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>());
     effects->registerGlobalShortcut(QKeySequence(), a);
     connect(a, &QAction::triggered, this, &ZoomEffect::moveZoomLeft);
 
     a = new QAction(this);
     a->setObjectName(QStringLiteral("MoveZoomRight"));
     a->setText(i18n("Move Zoomed Area to Right"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>());
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>());
     effects->registerGlobalShortcut(QKeySequence(), a);
     connect(a, &QAction::triggered, this, &ZoomEffect::moveZoomRight);
 
     a = new QAction(this);
     a->setObjectName(QStringLiteral("MoveZoomUp"));
     a->setText(i18n("Move Zoomed Area Upwards"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>());
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>());
     effects->registerGlobalShortcut(QKeySequence(), a);
     connect(a, &QAction::triggered, this, &ZoomEffect::moveZoomUp);
 
     a = new QAction(this);
     a->setObjectName(QStringLiteral("MoveZoomDown"));
     a->setText(i18n("Move Zoomed Area Downwards"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>());
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>());
     effects->registerGlobalShortcut(QKeySequence(), a);
     connect(a, &QAction::triggered, this, &ZoomEffect::moveZoomDown);
 
     // TODO: these two actions don't belong into the effect. They need to be moved into KWin core
     a = new QAction(this);
     a->setObjectName(QStringLiteral("MoveMouseToFocus"));
     a->setText(i18n("Move Mouse to Focus"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F5);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F5);
     effects->registerGlobalShortcut(Qt::META + Qt::Key_F5, a);
     connect(a, &QAction::triggered, this, &ZoomEffect::moveMouseToFocus);
 
     a = new QAction(this);
     a->setObjectName(QStringLiteral("MoveMouseToCenter"));
     a->setText(i18n("Move Mouse to Center"));
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F6);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F6);
     effects->registerGlobalShortcut(Qt::META + Qt::Key_F6, a);
     connect(a, &QAction::triggered, this, &ZoomEffect::moveMouseToCenter);
 
     timeline.setDuration(350);
     timeline.setFrameRange(0, 100);
     connect(&timeline, &QTimeLine::frameChanged, this, &ZoomEffect::timelineFrameChanged);
     connect(effects, &EffectsHandler::mouseChanged, this, &ZoomEffect::slotMouseChanged);
 
+#if HAVE_ACCESSIBILITY
+    m_accessibilityIntegration = new ZoomAccessibilityIntegration(this);
+    connect(m_accessibilityIntegration, &ZoomAccessibilityIntegration::focusPointChanged, this, &ZoomEffect::moveFocus);
+#endif
+
     source_zoom = -1; // used to trigger initialZoom reading
     reconfigure(ReconfigureAll);
 }
 
 ZoomEffect::~ZoomEffect()
 {
     // switch off and free resources
     showCursor();
     // Save the zoom value.
     ZoomConfig::setInitialZoom(target_zoom);
     ZoomConfig::self()->save();
 }
 
+bool ZoomEffect::isFocusTrackingEnabled() const
+{
+#if HAVE_ACCESSIBILITY
+    return m_accessibilityIntegration->isFocusTrackingEnabled();
+#else
+    return false;
+#endif
+}
+
 void ZoomEffect::showCursor()
 {
     if (isMouseHidden) {
         disconnect(effects, &EffectsHandler::cursorShapeChanged, this, &ZoomEffect::recreateTexture);
         // show the previously hidden mouse-pointer again and free the loaded texture/picture.
         effects->showCursor();
         texture.reset();
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
         xrenderPicture.reset();
 #endif
         isMouseHidden = false;
     }
 }
 
 void ZoomEffect::hideCursor()
 {
     if (mouseTracking == MouseTrackingProportional && mousePointer == MousePointerKeep)
         return; // don't replace the actual cursor by a static image for no reason.
     if (!isMouseHidden) {
         // try to load the cursor-theme into a OpenGL texture and if successful then hide the mouse-pointer
         recreateTexture();
         bool shouldHide = false;
         if (effects->isOpenGLCompositing()) {
             shouldHide = !texture.isNull();
         } else if (effects->compositingType() == XRenderCompositing) {
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
             shouldHide = !xrenderPicture.isNull();
 #endif
         }
         if (shouldHide) {
             effects->hideCursor();
             connect(effects, &EffectsHandler::cursorShapeChanged, this, &ZoomEffect::recreateTexture);
             isMouseHidden = true;
         }
     }
 }
 
 void ZoomEffect::recreateTexture()
 {
     effects->makeOpenGLContextCurrent();
     const auto cursor = effects->cursorImage();
     if (!cursor.image().isNull()) {
         imageWidth = cursor.image().width();
         imageHeight = cursor.image().height();
         cursorHotSpot = cursor.hotSpot();
         if (effects->isOpenGLCompositing()) {
             texture.reset(new GLTexture(cursor.image()));
             texture->setWrapMode(GL_CLAMP_TO_EDGE);
         }
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
         if (effects->compositingType() == XRenderCompositing)
             xrenderPicture.reset(new XRenderPicture(cursor.image()));
 #endif
     }
     else {
         qCDebug(KWINEFFECTS) << "Falling back to proportional mouse tracking!";
         mouseTracking = MouseTrackingProportional;
     }
 }
 
 void ZoomEffect::reconfigure(ReconfigureFlags)
 {
     ZoomConfig::self()->read();
     // On zoom-in and zoom-out change the zoom by the defined zoom-factor.
     zoomFactor = qMax(0.1, ZoomConfig::zoomFactor());
     // Visibility of the mouse-pointer.
     mousePointer = MousePointerType(ZoomConfig::mousePointer());
     // Track moving of the mouse.
     mouseTracking = MouseTrackingType(ZoomConfig::mouseTracking());
+#if HAVE_ACCESSIBILITY
     // Enable tracking of the focused location.
-    bool _enableFocusTracking = ZoomConfig::enableFocusTracking();
-    if (enableFocusTracking != _enableFocusTracking) {
-        enableFocusTracking = _enableFocusTracking;
-        if (QDBusConnection::sessionBus().isConnected()) {
-            if (enableFocusTracking)
-                QDBusConnection::sessionBus().connect(QStringLiteral("org.kde.kaccessibleapp"),
-                                                      QStringLiteral("/Adaptor"),
-                                                      QStringLiteral("org.kde.kaccessibleapp.Adaptor"),
-                                                      QStringLiteral("focusChanged"),
-                                                      this, SLOT(focusChanged(int,int,int,int,int,int)));
-            else
-                QDBusConnection::sessionBus().disconnect(QStringLiteral("org.kde.kaccessibleapp"),
-                                                         QStringLiteral("/Adaptor"),
-                                                         QStringLiteral("org.kde.kaccessibleapp.Adaptor"),
-                                                         QStringLiteral("focusChanged"),
-                                                         this, SLOT(focusChanged(int,int,int,int,int,int)));
-        }
-    }
-    // When the focus changes, move the zoom area to the focused location.
-    followFocus = ZoomConfig::enableFollowFocus();
+    m_accessibilityIntegration->setFocusTrackingEnabled(ZoomConfig::enableFocusTracking());
+#endif
     // The time in milliseconds to wait before a focus-event takes away a mouse-move.
     focusDelay = qMax(uint(0), ZoomConfig::focusDelay());
     // The factor the zoom-area will be moved on touching an edge on push-mode or using the navigation KAction's.
     moveFactor = qMax(0.1, ZoomConfig::moveFactor());
     if (source_zoom < 0) {
         // Load the saved zoom value.
         source_zoom = 1.0;
         target_zoom = ZoomConfig::initialZoom();
         if (target_zoom > 1.0)
             zoomIn(target_zoom);
     } else {
         source_zoom = 1.0;
     }
 }
 
 void ZoomEffect::prePaintScreen(ScreenPrePaintData& data, int time)
 {
     if (zoom != target_zoom) {
         const float zoomDist = qAbs(target_zoom - source_zoom);
         if (target_zoom > zoom)
             zoom = qMin(zoom + ((zoomDist * time) / animationTime(150*zoomFactor)), target_zoom);
         else
             zoom = qMax(zoom - ((zoomDist * time) / animationTime(150*zoomFactor)), target_zoom);
     }
 
     if (zoom == 1.0) {
         showCursor();
     } else {
         hideCursor();
         data.mask |= PAINT_SCREEN_TRANSFORMED;
     }
 
     effects->prePaintScreen(data, time);
 }
 
 void ZoomEffect::paintScreen(int mask, const QRegion &region, ScreenPaintData& data)
 {
     if (zoom != 1.0) {
         data *= QVector2D(zoom, zoom);
         const QSize screenSize = effects->virtualScreenSize();
 
         // mouse-tracking allows navigation of the zoom-area using the mouse.
         switch(mouseTracking) {
         case MouseTrackingProportional:
             data.setXTranslation(- int(cursorPoint.x() * (zoom - 1.0)));
             data.setYTranslation(- int(cursorPoint.y() * (zoom - 1.0)));
             prevPoint = cursorPoint;
             break;
         case MouseTrackingCentred:
             prevPoint = cursorPoint;
             // fall through
         case MouseTrackingDisabled:
             data.setXTranslation(qMin(0, qMax(int(screenSize.width() - screenSize.width() * zoom), int(screenSize.width() / 2 - prevPoint.x() * zoom))));
             data.setYTranslation(qMin(0, qMax(int(screenSize.height() - screenSize.height() * zoom), int(screenSize.height() / 2 - prevPoint.y() * zoom))));
             break;
         case MouseTrackingPush: {
                 // touching an edge of the screen moves the zoom-area in that direction.
                 int x = cursorPoint.x() * zoom - prevPoint.x() * (zoom - 1.0);
                 int y = cursorPoint.y() * zoom - prevPoint.y() * (zoom - 1.0);
                 int threshold = 4;
                 xMove = yMove = 0;
                 if (x < threshold)
                     xMove = (x - threshold) / zoom;
                 else if (x + threshold > screenSize.width())
                     xMove = (x + threshold - screenSize.width()) / zoom;
                 if (y < threshold)
                     yMove = (y - threshold) / zoom;
                 else if (y + threshold > screenSize.height())
                     yMove = (y + threshold - screenSize.height()) / zoom;
                 if (xMove)
                     prevPoint.setX(qMax(0, qMin(screenSize.width(), prevPoint.x() + xMove)));
                 if (yMove)
                     prevPoint.setY(qMax(0, qMin(screenSize.height(), prevPoint.y() + yMove)));
                 data.setXTranslation(- int(prevPoint.x() * (zoom - 1.0)));
                 data.setYTranslation(- int(prevPoint.y() * (zoom - 1.0)));
                 break;
             }
         }
 
         // use the focusPoint if focus tracking is enabled
-        if (enableFocusTracking && followFocus) {
+        if (isFocusTrackingEnabled()) {
             bool acceptFocus = true;
             if (mouseTracking != MouseTrackingDisabled && focusDelay > 0) {
                 // Wait some time for the mouse before doing the switch. This serves as threshold
                 // to prevent the focus from jumping around to much while working with the mouse.
                 const int msecs = lastMouseEvent.msecsTo(lastFocusEvent);
                 acceptFocus = msecs > focusDelay;
             }
             if (acceptFocus) {
                 data.setXTranslation(- int(focusPoint.x() * (zoom - 1.0)));
                 data.setYTranslation(- int(focusPoint.y() * (zoom - 1.0)));
                 prevPoint = focusPoint;
             }
         }
     }
 
     effects->paintScreen(mask, region, data);
 
     if (zoom != 1.0 && mousePointer != MousePointerHide) {
         // Draw the mouse-texture at the position matching to zoomed-in image of the desktop. Hiding the
         // previous mouse-cursor and drawing our own fake mouse-cursor is needed to be able to scale the
         // mouse-cursor up and to re-position those mouse-cursor to match to the chosen zoom-level.
         int w = imageWidth;
         int h = imageHeight;
         if (mousePointer == MousePointerScale) {
             w *= zoom;
             h *= zoom;
         }
         const QPoint p = effects->cursorPos() - cursorHotSpot;
         QRect rect(p.x() * zoom + data.xTranslation(), p.y() * zoom + data.yTranslation(), w, h);
 
         if (texture) {
             texture->bind();
             glEnable(GL_BLEND);
             glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
             auto s = ShaderManager::instance()->pushShader(ShaderTrait::MapTexture);
             QMatrix4x4 mvp = data.projectionMatrix();
             mvp.translate(rect.x(), rect.y());
             s->setUniform(GLShader::ModelViewProjectionMatrix, mvp);
             texture->render(region, rect);
             ShaderManager::instance()->popShader();
             texture->unbind();
             glDisable(GL_BLEND);
         }
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
         if (xrenderPicture) {
 #define DOUBLE_TO_FIXED(d) ((xcb_render_fixed_t) ((d) * 65536))
             static const xcb_render_transform_t xrenderIdentity = {
                 DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
                 DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1), DOUBLE_TO_FIXED(0),
                 DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
             };
             if (mousePointer == MousePointerScale) {
                 xcb_render_set_picture_filter(xcbConnection(), *xrenderPicture, 4, const_cast<char*>("good"), 0, nullptr);
                 const xcb_render_transform_t xform = {
                     DOUBLE_TO_FIXED(1.0 / zoom), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0),
                     DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1.0 / zoom), DOUBLE_TO_FIXED(0),
                     DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(0), DOUBLE_TO_FIXED(1)
                 };
                 xcb_render_set_picture_transform(xcbConnection(), *xrenderPicture, xform);
             }
             xcb_render_composite(xcbConnection(), XCB_RENDER_PICT_OP_OVER, *xrenderPicture, XCB_RENDER_PICTURE_NONE,
                                  effects->xrenderBufferPicture(), 0, 0, 0, 0, rect.x(), rect.y(), rect.width(), rect.height());
             if (mousePointer == MousePointerScale)
                 xcb_render_set_picture_transform(xcbConnection(), *xrenderPicture, xrenderIdentity);
 #undef DOUBLE_TO_FIXED
         }
 #endif
     }
 }
 
 void ZoomEffect::postPaintScreen()
 {
     if (zoom != target_zoom)
         effects->addRepaintFull();
     effects->postPaintScreen();
 }
 
 void ZoomEffect::zoomIn(double to)
 {
     source_zoom = zoom;
     if (to < 0.0)
         target_zoom *= zoomFactor;
     else
         target_zoom = to;
     if (!polling) {
         polling = true;
         effects->startMousePolling();
     }
     cursorPoint = effects->cursorPos();
     if (mouseTracking == MouseTrackingDisabled)
         prevPoint = cursorPoint;
     effects->addRepaintFull();
 }
 
 void ZoomEffect::zoomOut()
 {
     source_zoom = zoom;
     target_zoom /= zoomFactor;
     if ((zoomFactor > 1 && target_zoom < 1.01) || (zoomFactor < 1 && target_zoom > 0.99)) {
         target_zoom = 1;
         if (polling) {
             polling = false;
             effects->stopMousePolling();
         }
     }
     if (mouseTracking == MouseTrackingDisabled)
         prevPoint = effects->cursorPos();
     effects->addRepaintFull();
 }
 
 void ZoomEffect::actualSize()
 {
     source_zoom = zoom;
     target_zoom = 1;
     if (polling) {
         polling = false;
         effects->stopMousePolling();
     }
     effects->addRepaintFull();
 }
 
 void ZoomEffect::timelineFrameChanged(int /* frame */)
 {
     const QSize screenSize = effects->virtualScreenSize();
     prevPoint.setX(qMax(0, qMin(screenSize.width(), prevPoint.x() + xMove)));
     prevPoint.setY(qMax(0, qMin(screenSize.height(), prevPoint.y() + yMove)));
     cursorPoint = prevPoint;
     effects->addRepaintFull();
 }
 
 void ZoomEffect::moveZoom(int x, int y)
 {
     if (timeline.state() == QTimeLine::Running)
         timeline.stop();
 
     const QSize screenSize = effects->virtualScreenSize();
     if (x < 0)
         xMove = - qMax(1.0, screenSize.width() / zoom / moveFactor);
     else if (x > 0)
         xMove = qMax(1.0, screenSize.width() / zoom  / moveFactor);
     else
         xMove = 0;
 
     if (y < 0)
         yMove = - qMax(1.0, screenSize.height() / zoom / moveFactor);
     else if (y > 0)
         yMove = qMax(1.0, screenSize.height() / zoom / moveFactor);
     else
         yMove = 0;
 
     timeline.start();
 }
 
 void ZoomEffect::moveZoomLeft()
 {
     moveZoom(-1, 0);
 }
 
 void ZoomEffect::moveZoomRight()
 {
     moveZoom(1, 0);
 }
 
 void ZoomEffect::moveZoomUp()
 {
     moveZoom(0, -1);
 }
 
 void ZoomEffect::moveZoomDown()
 {
     moveZoom(0, 1);
 }
 
 void ZoomEffect::moveMouseToFocus()
 {
     QCursor::setPos(focusPoint.x(), focusPoint.y());
 }
 
 void ZoomEffect::moveMouseToCenter()
 {
     const QRect r = effects->virtualScreenGeometry();
     QCursor::setPos(r.x() + r.width() / 2, r.y() + r.height() / 2);
 }
 
 void ZoomEffect::slotMouseChanged(const QPoint& pos, const QPoint& old, Qt::MouseButtons,
                               Qt::MouseButtons, Qt::KeyboardModifiers, Qt::KeyboardModifiers)
 {
     if (zoom == 1.0)
         return;
     cursorPoint = pos;
     if (pos != old) {
         lastMouseEvent = QTime::currentTime();
         effects->addRepaintFull();
     }
 }
 
-void ZoomEffect::focusChanged(int px, int py, int rx, int ry, int rwidth, int rheight)
+void ZoomEffect::moveFocus(const QPoint &point)
 {
     if (zoom == 1.0)
         return;
-    const QSize screenSize = effects->virtualScreenSize();
-    focusPoint = (px >= 0 && py >= 0) ? QPoint(px, py) : QPoint(rx + qMax(0, (qMin(screenSize.width(), rwidth) / 2) - 60), ry + qMax(0, (qMin(screenSize.height(), rheight) / 2) - 60));
-    if (enableFocusTracking) {
-        lastFocusEvent = QTime::currentTime();
-        effects->addRepaintFull();
-    }
+    focusPoint = point;
+    lastFocusEvent = QTime::currentTime();
+    effects->addRepaintFull();
 }
 
 bool ZoomEffect::isActive() const
 {
     return zoom != 1.0 || zoom != target_zoom;
 }
 
 } // namespace
 
diff --git a/effects/zoom/zoom.h b/effects/zoom/zoom.h
index 61fe5ee29..2c7bff41a 100644
--- a/effects/zoom/zoom.h
+++ b/effects/zoom/zoom.h
@@ -1,134 +1,135 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2006 Lubos Lunak <l.lunak@kde.org>
 Copyright (C) 2010 Sebastian Sauer <sebsauer@kdab.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #ifndef KWIN_ZOOM_H
 #define KWIN_ZOOM_H
 
+#include <config-kwin.h>
+
 #include <kwineffects.h>
 #include <QTime>
 #include <QTimeLine>
 
 namespace KWin
 {
 
+#if HAVE_ACCESSIBILITY
+class ZoomAccessibilityIntegration;
+#endif
+
 class GLTexture;
 class XRenderPicture;
 
 class ZoomEffect
     : public Effect
 {
     Q_OBJECT
     Q_PROPERTY(qreal zoomFactor READ configuredZoomFactor)
     Q_PROPERTY(int mousePointer READ configuredMousePointer)
     Q_PROPERTY(int mouseTracking READ configuredMouseTracking)
-    Q_PROPERTY(bool enableFocusTracking READ isEnableFocusTracking)
-    Q_PROPERTY(bool followFocus READ isFollowFocus)
+    Q_PROPERTY(bool focusTrackingEnabled READ isFocusTrackingEnabled)
     Q_PROPERTY(int focusDelay READ configuredFocusDelay)
     Q_PROPERTY(qreal moveFactor READ configuredMoveFactor)
     Q_PROPERTY(qreal targetZoom READ targetZoom)
 public:
     ZoomEffect();
     ~ZoomEffect() override;
     void reconfigure(ReconfigureFlags flags) override;
     void prePaintScreen(ScreenPrePaintData& data, int time) override;
     void paintScreen(int mask, const QRegion &region, ScreenPaintData& data) override;
     void postPaintScreen() override;
     bool isActive() const override;
     // for properties
     qreal configuredZoomFactor() const {
         return zoomFactor;
     }
     int configuredMousePointer() const {
         return mousePointer;
     }
     int configuredMouseTracking() const {
         return mouseTracking;
     }
-    bool isEnableFocusTracking() const {
-        return enableFocusTracking;
-    }
-    bool isFollowFocus() const {
-        return followFocus;
-    }
+    bool isFocusTrackingEnabled() const;
     int configuredFocusDelay() const {
         return focusDelay;
     }
     qreal configuredMoveFactor() const {
         return moveFactor;
     }
     qreal targetZoom() const {
         return target_zoom;
     }
 private Q_SLOTS:
     inline void zoomIn() { zoomIn(-1.0); };
     void zoomIn(double to);
     void zoomOut();
     void actualSize();
     void moveZoomLeft();
     void moveZoomRight();
     void moveZoomUp();
     void moveZoomDown();
     void moveMouseToFocus();
     void moveMouseToCenter();
     void timelineFrameChanged(int frame);
-    void focusChanged(int px, int py, int rx, int ry, int rwidth, int rheight);
+    void moveFocus(const QPoint &point);
     void slotMouseChanged(const QPoint& pos, const QPoint& old,
                               Qt::MouseButtons buttons, Qt::MouseButtons oldbuttons,
                               Qt::KeyboardModifiers modifiers, Qt::KeyboardModifiers oldmodifiers);
     void recreateTexture();
 private:
     void showCursor();
     void hideCursor();
     void moveZoom(int x, int y);
 private:
+#if HAVE_ACCESSIBILITY
+    ZoomAccessibilityIntegration *m_accessibilityIntegration = nullptr;
+#endif
     double zoom;
     double target_zoom;
     double source_zoom;
     bool polling; // Mouse polling
     double zoomFactor;
     enum MouseTrackingType { MouseTrackingProportional = 0, MouseTrackingCentred = 1, MouseTrackingPush = 2, MouseTrackingDisabled = 3 };
     MouseTrackingType mouseTracking;
-    bool enableFocusTracking;
-    bool followFocus;
     enum MousePointerType { MousePointerScale = 0, MousePointerKeep = 1, MousePointerHide = 2 };
     MousePointerType mousePointer;
     int focusDelay;
     QPoint cursorPoint;
     QPoint cursorHotSpot;
     QPoint focusPoint;
     QPoint prevPoint;
     QTime lastMouseEvent;
     QTime lastFocusEvent;
     QScopedPointer<GLTexture> texture;
 #ifdef KWIN_HAVE_XRENDER_COMPOSITING
     QScopedPointer<XRenderPicture> xrenderPicture;
 #endif
     int imageWidth;
     int imageHeight;
     bool isMouseHidden;
     QTimeLine timeline;
     int xMove, yMove;
     double moveFactor;
 };
 
 } // namespace
 
 #endif
diff --git a/effects/zoom/zoom.kcfg b/effects/zoom/zoom.kcfg
index c706906a7..af37db08e 100644
--- a/effects/zoom/zoom.kcfg
+++ b/effects/zoom/zoom.kcfg
@@ -1,33 +1,31 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <kcfg xmlns="http://www.kde.org/standards/kcfg/1.0"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.kde.org/standards/kcfg/1.0
                           http://www.kde.org/standards/kcfg/1.0/kcfg.xsd" >
     <kcfgfile arg="true"/>
     <group name="Effect-Zoom">
         <entry name="ZoomFactor" type="Double">
             <default>1.2</default>
         </entry>
         <entry name="MousePointer" type="UInt">
             <default>0</default>
         </entry>
         <entry name="MouseTracking" type="UInt">
             <default>0</default>
         </entry>
         <entry name="EnableFocusTracking" type="Bool">
             <default>false</default>
         </entry>
-        <entry name="EnableFollowFocus" type="Bool">
-            <default>true</default>
         </entry>
         <entry name="FocusDelay" type="UInt">
             <default>350</default>
         </entry>
         <entry name="MoveFactor" type="Double">
             <default>20.0</default>
         </entry>
         <entry name="InitialZoom" type="Double">
             <default>1.0</default>
         </entry>
     </group>
 </kcfg>
diff --git a/effects/zoom/zoom_config.cpp b/effects/zoom/zoom_config.cpp
index 78dafd2bf..9fc1f8610 100644
--- a/effects/zoom/zoom_config.cpp
+++ b/effects/zoom/zoom_config.cpp
@@ -1,150 +1,154 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2007 Rivo Laks <rivolaks@hot.ee>
 Copyright (C) 2010 Sebastian Sauer <sebsauer@kdab.com>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 
 #include "zoom_config.h"
 // KConfigSkeleton
 #include "zoomconfig.h"
 #include <config-kwin.h>
 #include <kwineffects_interface.h>
 
 #include <QAction>
 
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KActionCollection>
 #include <KAboutData>
 #include <KPluginFactory>
 
 #include <QVBoxLayout>
 
 K_PLUGIN_FACTORY_WITH_JSON(ZoomEffectConfigFactory,
                            "zoom_config.json",
                            registerPlugin<KWin::ZoomEffectConfig>();)
 
 namespace KWin
 {
 
 ZoomEffectConfigForm::ZoomEffectConfigForm(QWidget* parent) : QWidget(parent)
 {
     setupUi(this);
 }
 
 ZoomEffectConfig::ZoomEffectConfig(QWidget* parent, const QVariantList& args) :
     KCModule(KAboutData::pluginData(QStringLiteral("zoom")), parent, args)
 {
     ZoomConfig::instance(KWIN_CONFIG);
     m_ui = new ZoomEffectConfigForm(this);
 
     QVBoxLayout* layout = new QVBoxLayout(this);
     layout->addWidget(m_ui);
 
     addConfig(ZoomConfig::self(), m_ui);
 
     connect(m_ui->editor, &KShortcutsEditor::keyChange, this, &ZoomEffectConfig::markAsChanged);
 
+#if !HAVE_ACCESSIBILITY
+    m_ui->kcfg_EnableFocusTracking->setVisible(false);
+#endif
+
     // Shortcut config. The shortcut belongs to the component "kwin"!
     KActionCollection *actionCollection = new KActionCollection(this, QStringLiteral("kwin"));
     actionCollection->setComponentDisplayName(i18n("KWin"));
     actionCollection->setConfigGroup(QStringLiteral("Zoom"));
     actionCollection->setConfigGlobal(true);
 
     QAction* a;
     a = actionCollection->addAction(KStandardAction::ZoomIn);
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Equal);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Equal);
 
     a = actionCollection->addAction(KStandardAction::ZoomOut);
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Minus);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_Minus);
 
     a = actionCollection->addAction(KStandardAction::ActualSize);
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_0);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_0);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomLeft"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-previous")));
     a->setText(i18n("Move Left"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Left);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Left);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomRight"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-next")));
     a->setText(i18n("Move Right"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Right);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Right);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomUp"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
     a->setText(i18n("Move Up"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Up);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Up);
 
     a = actionCollection->addAction(QStringLiteral("MoveZoomDown"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
     a->setText(i18n("Move Down"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Down);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::CTRL + Qt::Key_Down);
 
     a = actionCollection->addAction(QStringLiteral("MoveMouseToFocus"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("view-restore")));
     a->setText(i18n("Move Mouse to Focus"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F5);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F5);
 
     a = actionCollection->addAction(QStringLiteral("MoveMouseToCenter"));
     a->setIcon(QIcon::fromTheme(QStringLiteral("view-restore")));
     a->setText(i18n("Move Mouse to Center"));
     a->setProperty("isConfigurationAction", true);
     KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F6);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << Qt::META + Qt::Key_F6);
 
     m_ui->editor->addCollection(actionCollection);
 
     load();
 }
 
 ZoomEffectConfig::~ZoomEffectConfig()
 {
     // Undo (only) unsaved changes to global key shortcuts
     m_ui->editor->undoChanges();
 }
 
 void ZoomEffectConfig::save()
 {
     m_ui->editor->save(); // undo() will restore to this state from now on
     KCModule::save();
     OrgKdeKwinEffectsInterface interface(QStringLiteral("org.kde.KWin"),
                                          QStringLiteral("/Effects"),
                                          QDBusConnection::sessionBus());
     interface.reconfigureEffect(QStringLiteral("zoom"));
 }
 
 } // namespace
 
 #include "zoom_config.moc"
diff --git a/effects/zoom/zoom_config.ui b/effects/zoom/zoom_config.ui
index 3fb45bd71..5b387b2a4 100644
--- a/effects/zoom/zoom_config.ui
+++ b/effects/zoom/zoom_config.ui
@@ -1,215 +1,181 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>KWin::ZoomEffectConfigForm</class>
  <widget class="QWidget" name="KWin::ZoomEffectConfigForm">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
     <width>304</width>
-    <height>212</height>
+    <height>288</height>
    </rect>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <widget class="QGroupBox" name="groupSize">
      <property name="title">
       <string/>
      </property>
      <layout class="QHBoxLayout" name="horizontalLayout">
       <item>
        <layout class="QGridLayout" name="gridLayout">
         <item row="0" column="0">
          <widget class="QLabel" name="label">
           <property name="whatsThis">
            <string>On zoom-in and zoom-out change the zoom by the defined zoom-factor.</string>
           </property>
           <property name="text">
            <string>Zoom Factor:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="buddy">
            <cstring>kcfg_ZoomFactor</cstring>
           </property>
          </widget>
         </item>
         <item row="0" column="1">
          <widget class="QDoubleSpinBox" name="kcfg_ZoomFactor">
           <property name="whatsThis">
            <string>On zoom-in and zoom-out change the zoom by the defined zoom-factor.</string>
           </property>
           <property name="suffix">
            <string/>
           </property>
           <property name="decimals">
            <number>2</number>
           </property>
           <property name="maximum">
            <double>9999.000000000000000</double>
           </property>
           <property name="singleStep">
            <double>0.050000000000000</double>
           </property>
           <property name="value">
            <double>1.250000000000000</double>
           </property>
          </widget>
         </item>
         <item row="4" column="0" colspan="2">
          <widget class="QCheckBox" name="kcfg_EnableFocusTracking">
           <property name="toolTip">
            <string/>
           </property>
           <property name="whatsThis">
-           <string>Enable tracking of the focused location. This needs QAccessible to be enabled per application (&quot;export QT_ACCESSIBILITY=1&quot;).</string>
+           <string>Enable tracking of the focused location. This needs QAccessible to be enabled per application (&quot;export QT_LINUX_ACCESSIBILITY_ALWAYS_ON=1&quot;).</string>
           </property>
           <property name="text">
            <string>Enable Focus Tracking</string>
           </property>
          </widget>
         </item>
-        <item row="5" column="0" colspan="2">
-         <widget class="QCheckBox" name="kcfg_EnableFollowFocus">
-          <property name="enabled">
-           <bool>false</bool>
-          </property>
-          <property name="whatsThis">
-           <string>When the focus changes, move the zoom area to the focused location.</string>
-          </property>
-          <property name="text">
-           <string>Follow Focus</string>
-          </property>
-         </widget>
-        </item>
         <item row="2" column="0">
          <widget class="QLabel" name="label_2">
           <property name="text">
            <string>Mouse Pointer:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="buddy">
            <cstring>kcfg_MousePointer</cstring>
           </property>
          </widget>
         </item>
         <item row="2" column="1">
          <widget class="QComboBox" name="kcfg_MousePointer">
           <property name="whatsThis">
            <string>Visibility of the mouse-pointer.</string>
           </property>
           <item>
            <property name="text">
             <string>Scale</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Keep</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Hide</string>
            </property>
           </item>
          </widget>
         </item>
         <item row="3" column="1">
          <widget class="QComboBox" name="kcfg_MouseTracking">
           <property name="whatsThis">
            <string>Track moving of the mouse.</string>
           </property>
           <item>
            <property name="text">
             <string>Proportional</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Centered</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Push</string>
            </property>
           </item>
           <item>
            <property name="text">
             <string>Disabled</string>
            </property>
           </item>
          </widget>
         </item>
         <item row="3" column="0">
          <widget class="QLabel" name="label_3">
           <property name="text">
            <string>Mouse Tracking:</string>
           </property>
           <property name="alignment">
            <set>Qt::AlignRight|Qt::AlignTrailing|Qt::AlignVCenter</set>
           </property>
           <property name="buddy">
            <cstring>kcfg_MouseTracking</cstring>
           </property>
          </widget>
         </item>
        </layout>
       </item>
      </layout>
     </widget>
    </item>
    <item>
-    <widget class="KShortcutsEditor" name="editor" native="true">
+    <widget class="KShortcutsEditor" name="editor">
      <property name="sizePolicy">
       <sizepolicy hsizetype="Preferred" vsizetype="Expanding">
        <horstretch>0</horstretch>
        <verstretch>0</verstretch>
       </sizepolicy>
      </property>
-     <property name="actionTypes">
-      <enum>KShortcutsEditor::GlobalAction</enum>
-     </property>
     </widget>
    </item>
   </layout>
  </widget>
  <customwidgets>
   <customwidget>
    <class>KShortcutsEditor</class>
    <extends>QWidget</extends>
-   <header location="global">KShortcutsEditor</header>
+   <header>kshortcutseditor.h</header>
    <container>1</container>
   </customwidget>
  </customwidgets>
  <tabstops>
   <tabstop>kcfg_ZoomFactor</tabstop>
   <tabstop>kcfg_MousePointer</tabstop>
   <tabstop>kcfg_MouseTracking</tabstop>
   <tabstop>kcfg_EnableFocusTracking</tabstop>
-  <tabstop>kcfg_EnableFollowFocus</tabstop>
  </tabstops>
  <resources/>
- <connections>
-  <connection>
-   <sender>kcfg_EnableFocusTracking</sender>
-   <signal>toggled(bool)</signal>
-   <receiver>kcfg_EnableFollowFocus</receiver>
-   <slot>setEnabled(bool)</slot>
-   <hints>
-    <hint type="sourcelabel">
-     <x>152</x>
-     <y>73</y>
-    </hint>
-    <hint type="destinationlabel">
-     <x>152</x>
-     <y>98</y>
-    </hint>
-   </hints>
-  </connection>
- </connections>
+ <connections/>
 </ui>