diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2c1ed0dfb..6c5754252 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,654 +1,655 @@
 project(KWIN)
 set(PROJECT_VERSION "5.9.90")
 set(PROJECT_VERSION_MAJOR 5)
 
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 set(QT_MIN_VERSION "5.7.0")
 set(KF5_MIN_VERSION "5.26.0")
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH} )
 
 find_package(ECM 0.0.11 REQUIRED NO_MODULE)
 
 include(FeatureSummary)
 include(WriteBasicConfigVersionFile)
 include(GenerateExportHeader)
 
 # where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
 set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
     Concurrent
     Core
     DBus
     Quick
     QuickWidgets
     Script
     UiTools
     Widgets
     X11Extras
 )
 
 find_package(Qt5Test ${QT_MIN_VERSION} CONFIG QUIET)
 set_package_properties(Qt5Test PROPERTIES
          PURPOSE "Required for tests"
          TYPE OPTIONAL
          )
 add_feature_info("Qt5Test" Qt5Test_FOUND "Required for building tests")
 if (NOT Qt5Test_FOUND)
     set(BUILD_TESTING OFF CACHE BOOL "Build the testing tree.")
 endif()
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 
 include(ECMInstallIcons)
 include(ECMOptionalAddSubdirectory)
 
 add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0 -DQT_USE_QSTRINGBUILDER)
 
 set(CMAKE_CXX_STANDARD 11)
 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
     Init
     Notifications
     Package
     Plasma
     WidgetsAddons
     WindowSystem
     IconThemes
     IdleTime
     Wayland
 )
 # required frameworks by config modules
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Completion
     Declarative
     KCMUtils
     KIO
     TextWidgets
     NewStuff
     Service
     XmlGui
 )
 
 find_package(Threads)
 set_package_properties(Threads PROPERTIES
          PURPOSE "Needed for VirtualTerminal support in KWin Wayland"
          TYPE REQUIRED
          )
 
 # optional frameworks
 find_package(KF5Activities ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Activities PROPERTIES
          PURPOSE "Enable building of KWin with kactivities support"
          TYPE OPTIONAL
          )
 add_feature_info("KF5Activities" KF5Activities_FOUND "Enable building of KWin with kactivities support")
 
 find_package(KF5DocTools ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5DocTools PROPERTIES
          PURPOSE "Enable building documentation"
          TYPE OPTIONAL
          )
 add_feature_info("KF5DocTools" KF5DocTools_FOUND "Enable building documentation")
 
 find_package(KDecoration2 CONFIG REQUIRED)
 
 find_package(KScreenLocker CONFIG REQUIRED)
 set_package_properties(KScreenLocker PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "For screenlocker integration in kwin_wayland")
 
 find_package(Breeze 5.9.0 CONFIG)
 set_package_properties(Breeze PROPERTIES
                        TYPE OPTIONAL
                        PURPOSE "For setting the default window decoration plugin")
 if(${Breeze_FOUND})
     if(${BREEZE_WITH_KDECORATION})
         set(HAVE_BREEZE_DECO true)
     else()
         set(HAVE_BREEZE_DECO FALSE)
     endif()
 else()
     set(HAVE_BREEZE_DECO FALSE)
 endif()
 add_feature_info("Breeze-Decoration" HAVE_BREEZE_DECO "Default decoration plugin Breeze")
 
 find_package(EGL)
 set_package_properties(EGL PROPERTIES
                        TYPE RUNTIME
                        PURPOSE "Required to build KWin with EGL support"
                       )
 
 find_package(epoxy)
 set_package_properties(epoxy PROPERTIES DESCRIPTION "libepoxy"
                        URL "http://github.com/anholt/libepoxy"
                        TYPE REQUIRED
                        PURPOSE "OpenGL dispatch library"
                       )
 
 set(HAVE_DL_LIBRARY FALSE)
 if(epoxy_HAS_GLX)
     find_library(DL_LIBRARY dl)
     if(DL_LIBRARY)
         set(HAVE_DL_LIBRARY TRUE)
     endif()
 endif()
 
 find_package(Wayland 1.2 REQUIRED COMPONENTS Cursor OPTIONAL_COMPONENTS Egl)
 set_package_properties(Wayland PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "Required for building KWin with Wayland support"
                       )
 add_feature_info("Wayland::EGL" Wayland_Egl_FOUND "Enable building of Wayland backend and QPA with EGL support.")
 set(HAVE_WAYLAND_EGL FALSE)
 if(Wayland_Egl_FOUND)
     set(HAVE_WAYLAND_EGL TRUE)
 endif()
 
 find_package(XKB 0.7.0)
 set_package_properties(XKB PROPERTIES
                        TYPE REQUIRED
                        PURPOSE "Required for building KWin with Wayland support"
                       )
 
 find_package(Libinput 1.5)
 set_package_properties(Libinput PROPERTIES TYPE OPTIONAL PURPOSE "Required for input handling on Wayland.")
 
 find_package(UDev)
 set_package_properties(UDev PROPERTIES  URL "http://www.freedesktop.org/software/systemd/libudev/"
                                         DESCRIPTION "Linux device library."
                                         TYPE OPTIONAL
                                         PURPOSE "Required for input handling on Wayland."
                         )
 set(HAVE_INPUT FALSE)
 if (Libinput_FOUND AND UDEV_FOUND)
     set(HAVE_INPUT TRUE)
 endif()
 set(HAVE_UDEV FALSE)
 if (UDEV_FOUND)
     set(HAVE_UDEV TRUE)
 endif()
 
 find_package(Libdrm 2.4.62)
 set_package_properties(Libdrm PROPERTIES TYPE OPTIONAL PURPOSE "Required for drm output on Wayland.")
 set(HAVE_DRM FALSE)
 if(Libdrm_FOUND AND UDEV_FOUND)
     set(HAVE_DRM TRUE)
 endif()
 
 find_package(gbm)
 set_package_properties(gbm PROPERTIES TYPE OPTIONAL PURPOSE "Required for egl ouput of drm backend.")
 set(HAVE_GBM FALSE)
 if(HAVE_DRM AND gbm_FOUND)
     set(HAVE_GBM TRUE)
 endif()
 
 find_package(libhybris)
 set_package_properties(libhybris PROPERTIES TYPE OPTIONAL PURPOSE "Required for libhybris backend")
 set(HAVE_LIBHYBRIS ${libhybris_FOUND})
 
 find_package(X11)
 set_package_properties(X11 PROPERTIES DESCRIPTION "X11 libraries"
                         URL "http://www.x.org"
                         TYPE REQUIRED
                     )
 add_feature_info("XInput" X11_Xinput_FOUND "Required for poll-free mouse cursor updates")
 set(HAVE_X11_XINPUT ${X11_Xinput_FOUND})
 
 # All the required XCB components
 find_package(XCB 1.10
     REQUIRED COMPONENTS
         XCB
         XFIXES
         DAMAGE
         COMPOSITE
         SHAPE
         SYNC
         RENDER
         RANDR
         KEYSYMS
         IMAGE
         SHM
         GLX
         CURSOR
     OPTIONAL_COMPONENTS
         ICCCM
 )
 set_package_properties(XCB PROPERTIES TYPE REQUIRED)
 
 # and the optional XCB dependencies
 if (XCB_ICCCM_VERSION VERSION_LESS "0.4")
     set(XCB_ICCCM_FOUND FALSE)
 endif()
 add_feature_info("XCB-ICCCM" XCB_ICCCM_FOUND "Required for building test applications for KWin")
 
 find_package(X11_XCB)
 set_package_properties(X11_XCB PROPERTIES
                        PURPOSE "Required for building X11 windowed backend of kwin_wayland"
                        TYPE OPTIONAL)
 
 # dependencies for QPA plugin
 if(Qt5Core_VERSION VERSION_LESS "5.8.0")
     find_package(Qt5PlatformSupport REQUIRED)
 else()
     find_package(Qt5FontDatabaseSupport REQUIRED)
     find_package(Qt5ThemeSupport REQUIRED)
     find_package(Qt5EventDispatcherSupport REQUIRED)
 endif()
 
 find_package(Freetype REQUIRED)
 set_package_properties(Freetype PROPERTIES DESCRIPTION "A font rendering engine"
                        URL "http://www.freetype.org"
                        TYPE REQUIRED
                        PURPOSE "Needed for KWin's QPA plugin."
                       )
 find_package(Fontconfig REQUIRED)
 set_package_properties(Fontconfig PROPERTIES DESCRIPTION "Font access configuration library"
                        URL "http://www.freedesktop.org/wiki/Software/fontconfig"
                        TYPE REQUIRED
                        PURPOSE "Needed for KWin's QPA plugin."
                       )
 
 find_package(Xwayland)
 set_package_properties(Xwayland PROPERTIES
     URL "http://x.org"
     DESCRIPTION "Xwayland X server"
     TYPE RUNTIME
     PURPOSE "Needed for running kwin_wayland"
     )
 
 ########### configure tests ###############
 include(CMakeDependentOption)
 
 option(KWIN_BUILD_DECORATIONS "Enable building of KWin decorations." ON)
 option(KWIN_BUILD_KCMS "Enable building of KWin configuration modules." ON)
 option(KWIN_BUILD_TABBOX "Enable building of KWin Tabbox functionality" ON)
 option(KWIN_BUILD_XRENDER_COMPOSITING "Enable building of KWin with XRender Compositing support" ON)
 cmake_dependent_option(KWIN_BUILD_ACTIVITIES "Enable building of KWin with kactivities support" ON "KF5Activities_FOUND" OFF)
 
 # Binary name of KWin
 set(KWIN_NAME "kwin")
 set(KWIN_INTERNAL_NAME_X11 "kwin_x11")
 set(KWIN_INTERNAL_NAME_WAYLAND "kwin_wayland")
 set(KWIN_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 
 # KWIN_HAVE_XRENDER_COMPOSITING - whether XRender-based compositing support is available: may be disabled
 if( KWIN_BUILD_XRENDER_COMPOSITING )
     set( KWIN_HAVE_XRENDER_COMPOSITING 1 )
 endif()
 
 include_directories(${XKB_INCLUDE_DIR})
 
 include_directories(${epoxy_INCLUDE_DIR})
 set(HAVE_EPOXY_GLX ${epoxy_HAS_GLX})
 
 # for things that are also used by kwin libraries
 configure_file(libkwineffects/kwinconfig.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/libkwineffects/kwinconfig.h )
 # for kwin internal things
 set(HAVE_X11_XCB ${X11_XCB_FOUND})
 
 include(CheckIncludeFile)
 include(CheckIncludeFiles)
 include(CheckSymbolExists)
 check_include_files(unistd.h HAVE_UNISTD_H)
 check_include_files(malloc.h HAVE_MALLOC_H)
 
 check_include_file("sys/prctl.h" HAVE_SYS_PRCTL_H)
 check_symbol_exists(PR_SET_DUMPABLE "sys/prctl.h" HAVE_PR_SET_DUMPABLE)
 check_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")
 
 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
     )
 
 add_subdirectory( libkwineffects )
 if(KWIN_BUILD_KCMS)
     add_subdirectory( kcmkwin )
 endif()
 
 add_subdirectory( data )
 
 add_subdirectory( effects )
 add_subdirectory( scripts )
 add_subdirectory( tabbox )
 add_subdirectory(scripting)
 add_subdirectory(helpers)
 
 ########### next target ###############
 
 set(kwin_KDEINIT_SRCS
    workspace.cpp
    dbusinterface.cpp
    abstract_client.cpp
    client.cpp
    client_machine.cpp
    cursor.cpp
    debug_console.cpp
    tabgroup.cpp
    focuschain.cpp
    globalshortcuts.cpp
    input.cpp
    input_event.cpp
    input_event_spy.cpp
    keyboard_input.cpp
    keyboard_layout.cpp
+   keyboard_layout_switching.cpp
    keyboard_repeat.cpp
    pointer_input.cpp
    touch_input.cpp
    netinfo.cpp
    placement.cpp
    atoms.cpp
    utils.cpp
    layers.cpp
    main.cpp
    options.cpp
    outline.cpp
    events.cpp
    killwindow.cpp
    geometrytip.cpp
    screens.cpp
    shadow.cpp
    sm.cpp
    group.cpp
    manage.cpp
    overlaywindow.cpp
    activation.cpp
    useractions.cpp
    geometry.cpp
    rules.cpp
    composite.cpp
    toplevel.cpp
    unmanaged.cpp
    scene.cpp
    scene_xrender.cpp
    scene_opengl.cpp
    scene_qpainter.cpp
    screenlockerwatcher.cpp
    thumbnailitem.cpp
    lanczosfilter.cpp
    deleted.cpp
    effects.cpp
    effectloader.cpp
    virtualdesktops.cpp
    xcbutils.cpp
    x11eventfilter.cpp
    logind.cpp
    onscreennotification.cpp
    osd.cpp
     screenedge.cpp
     scripting/scripting.cpp
     scripting/workspace_wrapper.cpp
     scripting/meta.cpp
     scripting/scriptedeffect.cpp
     scripting/scriptingutils.cpp
     scripting/timer.cpp
     scripting/scripting_model.cpp
     scripting/dbuscall.cpp
     scripting/screenedgeitem.cpp
     scripting/scripting_logging.cpp
     decorations/decoratedclient.cpp
     decorations/decorationbridge.cpp
     decorations/decorationpalette.cpp
     decorations/settings.cpp
     decorations/decorationrenderer.cpp
     decorations/decorations_logging.cpp
     abstract_egl_backend.cpp
     platform.cpp
     shell_client.cpp
     wayland_server.cpp
     wayland_cursor_theme.cpp
     virtualkeyboard.cpp
     appmenu.cpp
     modifier_only_shortcuts.cpp
     xkb.cpp
     gestures.cpp
     popup_input_filter.cpp
    )
 
 if(KWIN_BUILD_TABBOX)
     set(
         kwin_KDEINIT_SRCS ${kwin_KDEINIT_SRCS}
         tabbox/tabbox.cpp
         tabbox/clientmodel.cpp
         tabbox/desktopchain.cpp
         tabbox/desktopmodel.cpp
         tabbox/switcheritem.cpp
         tabbox/tabboxconfig.cpp
         tabbox/tabboxhandler.cpp
         tabbox/tabbox_logging.cpp
   )
 endif()
 
 if(KWIN_BUILD_ACTIVITIES)
     set(
         kwin_KDEINIT_SRCS ${kwin_KDEINIT_SRCS}
         activities.cpp
     )
 endif()
 
 if(UDEV_FOUND)
     set(kwin_KDEINIT_SRCS
         ${kwin_KDEINIT_SRCS}
         udev.cpp
     )
 endif()
 
 if(HAVE_INPUT)
     set(kwin_KDEINIT_SRCS
         ${kwin_KDEINIT_SRCS}
         libinput/context.cpp
         libinput/connection.cpp
         libinput/device.cpp
         libinput/events.cpp
         libinput/libinput_logging.cpp
         virtual_terminal.cpp
     )
 endif()
 
 kconfig_add_kcfg_files(kwin_KDEINIT_SRCS settings.kcfgc)
 
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.KWin.xml dbusinterface.h KWin::DBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS org.kde.kwin.Compositing.xml dbusinterface.h KWin::CompositorDBusInterface )
 qt5_add_dbus_adaptor( kwin_KDEINIT_SRCS ${kwin_effects_dbus_xml} effects.h KWin::EffectsHandlerImpl )
 
 qt5_add_dbus_interface( kwin_KDEINIT_SRCS ${CMAKE_CURRENT_SOURCE_DIR}/org.freedesktop.ScreenSaver.xml screenlocker_interface)
 
 qt5_add_dbus_interface( kwin_KDEINIT_SRCS org.kde.kappmenu.xml appmenu_interface )
 
 qt5_add_resources( kwin_KDEINIT_SRCS resources.qrc )
 
 ki18n_wrap_ui(kwin_KDEINIT_SRCS
     debug_console.ui
     shortcutdialog.ui
 )
 
 ########### target link libraries ###############
 
 set(kwin_OWN_LIBS
     kwineffects
     kwinxrenderutils
     kwin4_effect_builtins
 )
 
 set(kwin_QT_LIBS
     Qt5::Concurrent
     Qt5::DBus
     Qt5::Quick
     Qt5::Script
     Qt5::X11Extras
 )
 
 set(kwin_KDE_LIBS
     KF5::ConfigCore
     KF5::CoreAddons
     KF5::ConfigWidgets
     KF5::GlobalAccel
     KF5::GlobalAccelPrivate
     KF5::I18n
     KF5::Notifications
     KF5::Package
     KF5::Plasma
     KF5::WindowSystem
     KDecoration2::KDecoration
     KDecoration2::KDecoration2Private
     PW::KScreenLocker
 )
 
 set(kwin_XLIB_LIBS
     ${X11_X11_LIB}
     ${X11_ICE_LIB}
     ${X11_SM_LIB}
 )
 
 set(kwin_XCB_LIBS
     XCB::XCB
     XCB::XFIXES
     XCB::DAMAGE
     XCB::COMPOSITE
     XCB::SHAPE
     XCB::SYNC
     XCB::RENDER
     XCB::RANDR
     XCB::KEYSYMS
     XCB::SHM
     XCB::GLX
 )
 
 set(kwin_WAYLAND_LIBS
     XKB::XKB
     KF5::WaylandClient
     KF5::WaylandServer
     Wayland::Cursor
     ${CMAKE_THREAD_LIBS_INIT}
 )
 
 if(KWIN_BUILD_ACTIVITIES)
     set(kwin_KDE_LIBS ${kwin_KDE_LIBS} KF5::Activities)
 endif()
 
 set(kwinLibs
     ${kwin_OWN_LIBS}
     ${kwin_QT_LIBS}
     ${kwin_KDE_LIBS}
     ${kwin_XLIB_LIBS}
     ${kwin_XCB_LIBS}
     ${kwin_WAYLAND_LIBS}
 )
 
 if(UDEV_FOUND)
     set(kwinLibs ${kwinLibs} ${UDEV_LIBS})
 endif()
 
 if(HAVE_INPUT)
     set(kwinLibs ${kwinLibs} Libinput::Libinput)
 endif()
 
 add_library(kwin SHARED ${kwin_KDEINIT_SRCS})
 
 set_target_properties(kwin PROPERTIES
    VERSION ${PROJECT_VERSION}
    SOVERSION ${PROJECT_VERSION_MAJOR}
    )
 
 target_link_libraries(kwin ${kwinLibs})
 generate_export_header(kwin EXPORT_FILE_NAME kwin_export.h)
 
 target_link_libraries(kwin kwinglutils ${epoxy_LIBRARY})
 
 kf5_add_kdeinit_executable(kwin_x11 main_x11.cpp)
 target_link_libraries(kdeinit_kwin_x11 kwin KF5::Crash)
 
 install(TARGETS kwin             ${INSTALL_TARGETS_DEFAULT_ARGS} LIBRARY NAMELINK_SKIP )
 install(TARGETS kdeinit_kwin_x11 ${INSTALL_TARGETS_DEFAULT_ARGS} )
 install(TARGETS kwin_x11         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 add_executable(kwin_wayland main_wayland.cpp)
 target_link_libraries(kwin_wayland kwin)
 
 install(TARGETS kwin_wayland         ${INSTALL_TARGETS_DEFAULT_ARGS} )
 
 add_subdirectory(plugins)
 
 ########### install files ###############
 
 install( FILES kwin.kcfg  DESTINATION  ${KCFG_INSTALL_DIR} RENAME ${KWIN_NAME}.kcfg )
 install( FILES kwin.notifyrc  DESTINATION  ${KNOTIFYRC_INSTALL_DIR} RENAME ${KWIN_NAME}.notifyrc)
 install(
     FILES
         org.kde.KWin.xml
         org.kde.kwin.Compositing.xml
         org.kde.kwin.Effects.xml
     DESTINATION
         ${KDE_INSTALL_DBUSINTERFACEDIR}
 )
 install( FILES ${CMAKE_CURRENT_BINARY_DIR}/kwin_export.h DESTINATION ${INCLUDE_INSTALL_DIR} COMPONENT Devel)
 
 # Install the KWin/Script service type
 install( FILES scripting/kwinscript.desktop DESTINATION ${SERVICETYPES_INSTALL_DIR} )
 
 ecm_install_icons(
     ICONS
         16-apps-kwin.png
         32-apps-kwin.png
         48-apps-kwin.png
         sc-apps-kwin.svgz
     DESTINATION
         ${ICON_INSTALL_DIR}
     THEME
         hicolor
 )
 
 add_subdirectory(qml)
 add_subdirectory(autotests)
 add_subdirectory(tests)
 add_subdirectory(packageplugins)
 
 if (KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
 
 include(ECMPackageConfigHelpers)
 set(CMAKECONFIG_INSTALL_DIR "${CMAKECONFIG_INSTALL_PREFIX}/KWinDBusInterface")
 ecm_configure_package_config_file(KWinDBusInterfaceConfig.cmake.in
     "${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake"
     PATH_VARS KDE_INSTALL_DBUSINTERFACEDIR
     INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/KWinDBusInterfaceConfig.cmake
     DESTINATION ${CMAKECONFIG_INSTALL_DIR})
diff --git a/autotests/integration/keyboard_layout_test.cpp b/autotests/integration/keyboard_layout_test.cpp
index 0152edb27..db7232c76 100644
--- a/autotests/integration/keyboard_layout_test.cpp
+++ b/autotests/integration/keyboard_layout_test.cpp
@@ -1,279 +1,341 @@
 /********************************************************************
 KWin - the KDE window manager
 This file is part of the KDE project.
 
 Copyright (C) 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 "kwin_wayland_test.h"
 #include "keyboard_input.h"
 #include "keyboard_layout.h"
 #include "platform.h"
+#include "virtualdesktops.h"
 #include "wayland_server.h"
 
 #include <KConfigGroup>
 #include <KGlobalAccel>
 
 #include <QAction>
 #include <QDBusConnection>
 #include <QDBusConnectionInterface>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 
 #include <linux/input.h>
 
 using namespace KWin;
 using namespace KWayland::Client;
 
 static const QString s_socketName = QStringLiteral("wayland_test_kwin_keyboard_laout-0");
 
 class KeyboardLayoutTest : public QObject
 {
     Q_OBJECT
 private Q_SLOTS:
     void initTestCase();
     void init();
     void cleanup();
 
     void testReconfigure();
     void testChangeLayoutThroughDBus();
     void testPerLayoutShortcut();
     void testDBusServiceExport();
+    void testVirtualDesktopPolicy();
 
 private:
     void reconfigureLayouts();
 };
 
 void KeyboardLayoutTest::reconfigureLayouts()
 {
     // create DBus signal to reload
     QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/Layouts"), QStringLiteral("org.kde.keyboard"), QStringLiteral("reloadConfig"));
     QDBusConnection::sessionBus().send(message);
 }
 
 void KeyboardLayoutTest::initTestCase()
 {
     QSignalSpy workspaceCreatedSpy(kwinApp(), &Application::workspaceCreated);
     QVERIFY(workspaceCreatedSpy.isValid());
     kwinApp()->platform()->setInitialWindowSize(QSize(1280, 1024));
     QVERIFY(waylandServer()->init(s_socketName.toLocal8Bit()));
 
     kwinApp()->setConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
     kwinApp()->setKxkbConfig(KSharedConfig::openConfig(QString(), KConfig::SimpleConfig));
 
     kwinApp()->start();
     QVERIFY(workspaceCreatedSpy.wait());
     waylandServer()->initWorkspace();
 }
 
 void KeyboardLayoutTest::init()
 {
 }
 
 void KeyboardLayoutTest::cleanup()
 {
 }
 
 class LayoutChangedSignalWrapper : public QObject
 {
     Q_OBJECT
 public:
     LayoutChangedSignalWrapper()
         : QObject()
     {
         QDBusConnection::sessionBus().connect(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("currentLayoutChanged"), this, SIGNAL(layoutChanged(QString)));
     }
 
 Q_SIGNALS:
     void layoutChanged(const QString &name);
 };
 
 void KeyboardLayoutTest::testReconfigure()
 {
     // verifies that we can change the keymap
 
     // default should be a keymap with only us layout
     auto xkb = input()->keyboard()->xkb();
     QCOMPARE(xkb->numberOfLayouts(), 1u);
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     auto layouts = xkb->layoutNames();
     QCOMPARE(layouts.size(), 1);
     QVERIFY(layouts.contains(0));
     QCOMPARE(layouts[0], QStringLiteral("English (US)"));
 
     // create a new keymap
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("de,us"));
     layoutGroup.sync();
 
     reconfigureLayouts();
     // now we should have two layouts
     QTRY_COMPARE(xkb->numberOfLayouts(), 2u);
     // default layout is German
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     layouts = xkb->layoutNames();
     QCOMPARE(layouts.size(), 2);
     QVERIFY(layouts.contains(0));
     QVERIFY(layouts.contains(1));
     QCOMPARE(layouts[0], QStringLiteral("German"));
     QCOMPARE(layouts[1], QStringLiteral("English (US)"));
 }
 
 void KeyboardLayoutTest::testChangeLayoutThroughDBus()
 {
     // this test verifies that the layout can be changed through DBus
     // first configure layouts
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("de,us,de(neo)"));
     layoutGroup.sync();
     reconfigureLayouts();
     // now we should have two layouts
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     // default layout is German
     xkb->switchToLayout(0);
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
 
     LayoutChangedSignalWrapper wrapper;
     QSignalSpy layoutChangedSpy(&wrapper, &LayoutChangedSignalWrapper::layoutChanged);
     QVERIFY(layoutChangedSpy.isValid());
 
     // now change through DBus to english
     auto changeLayout = [] (const QString &layoutName) {
         QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("setLayout"));
         msg << layoutName;
         return QDBusConnection::sessionBus().asyncCall(msg);
     };
     auto reply = changeLayout(QStringLiteral("English (US)"));
     reply.waitForFinished();
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), true);
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 1);
     layoutChangedSpy.clear();
 
     // switch to a layout which does not exist
     reply = changeLayout(QStringLiteral("French"));
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), false);
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     QVERIFY(!layoutChangedSpy.wait());
     QVERIFY(layoutChangedSpy.isEmpty());
 
     // switch to another layout should work
     reply = changeLayout(QStringLiteral("German"));
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), true);
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(layoutChangedSpy.count(), 1);
     layoutChangedSpy.clear();
 
     // switching to same layout should also work
     reply = changeLayout(QStringLiteral("German"));
     QVERIFY(!reply.isError());
     QCOMPARE(reply.reply().arguments().first().toBool(), true);
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     QVERIFY(!layoutChangedSpy.wait());
     QVERIFY(layoutChangedSpy.isEmpty());
 }
 
 void KeyboardLayoutTest::testPerLayoutShortcut()
 {
     // this test verifies that per-layout global shortcuts are working correctly.
     // first configure layouts
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de,de(neo)"));
     layoutGroup.sync();
 
     // and create the global shortcuts
     const QString componentName = QStringLiteral("KDE Keyboard Layout Switcher");
     QAction *a = new QAction(this);
     a->setObjectName(QStringLiteral("Switch keyboard layout to English (US)"));
     a->setProperty("componentName", componentName);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>{Qt::CTRL+Qt::ALT+Qt::Key_1}, KGlobalAccel::NoAutoloading);
     delete a;
     a = new QAction(this);
     a->setObjectName(QStringLiteral("Switch keyboard layout to German"));
     a->setProperty("componentName", componentName);
     KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>{Qt::CTRL+Qt::ALT+Qt::Key_2}, KGlobalAccel::NoAutoloading);
     delete a;
 
     reconfigureLayouts();
     // now we should have three layouts
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
     // default layout is English
     xkb->switchToLayout(0);
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
 
     LayoutChangedSignalWrapper wrapper;
     QSignalSpy layoutChangedSpy(&wrapper, &LayoutChangedSignalWrapper::layoutChanged);
     QVERIFY(layoutChangedSpy.isValid());
 
     // now switch to English through the global shortcut
     quint32 timestamp = 1;
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTCTRL, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyPressed(KEY_2, timestamp++);
     QVERIFY(layoutChangedSpy.wait());
     // now layout should be German
     QCOMPARE(xkb->layoutName(), QStringLiteral("German"));
     // release keys again
     kwinApp()->platform()->keyboardKeyReleased(KEY_2, timestamp++);
     // switch back to English
     kwinApp()->platform()->keyboardKeyPressed(KEY_1, timestamp++);
     QVERIFY(layoutChangedSpy.wait());
     QCOMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     // release keys again
     kwinApp()->platform()->keyboardKeyReleased(KEY_1, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTALT, timestamp++);
     kwinApp()->platform()->keyboardKeyReleased(KEY_LEFTCTRL, timestamp++);
 }
 
 void KeyboardLayoutTest::testDBusServiceExport()
 {
     // verifies that the dbus service is only exported if there are at least two layouts
 
     // first configure layouts, with just one layout
     KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us"));
     layoutGroup.sync();
     reconfigureLayouts();
     auto xkb = input()->keyboard()->xkb();
     QTRY_COMPARE(xkb->numberOfLayouts(), 1u);
     // default layout is English
     QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
     // with one layout we should not have the dbus interface
     QTRY_VERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.keyboard")).value());
 
     // reconfigure to two layouts
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de"));
     layoutGroup.sync();
     reconfigureLayouts();
     QTRY_COMPARE(xkb->numberOfLayouts(), 2u);
     QTRY_VERIFY(QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.keyboard")).value());
 
     // and back to one layout
     layoutGroup.writeEntry("LayoutList", QStringLiteral("us"));
     layoutGroup.sync();
     reconfigureLayouts();
     QTRY_COMPARE(xkb->numberOfLayouts(), 1u);
     QTRY_VERIFY(!QDBusConnection::sessionBus().interface()->isServiceRegistered(QStringLiteral("org.kde.keyboard")).value());
 }
 
+void KeyboardLayoutTest::testVirtualDesktopPolicy()
+{
+    KConfigGroup layoutGroup = kwinApp()->kxkbConfig()->group("Layout");
+    layoutGroup.writeEntry("LayoutList", QStringLiteral("us,de,de(neo)"));
+    layoutGroup.writeEntry("SwitchMode", QStringLiteral("Desktop"));
+    layoutGroup.sync();
+    reconfigureLayouts();
+    auto xkb = input()->keyboard()->xkb();
+    QTRY_COMPARE(xkb->numberOfLayouts(), 3u);
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
+
+    VirtualDesktopManager::self()->setCount(4);
+    QCOMPARE(VirtualDesktopManager::self()->count(), 4u);
+
+    auto changeLayout = [] (const QString &layoutName) {
+        QDBusMessage msg = QDBusMessage::createMethodCall(QStringLiteral("org.kde.keyboard"), QStringLiteral("/Layouts"), QStringLiteral("org.kde.KeyboardLayouts"), QStringLiteral("setLayout"));
+        msg << layoutName;
+        return QDBusConnection::sessionBus().asyncCall(msg);
+    };
+    auto reply = changeLayout(QStringLiteral("German"));
+    reply.waitForFinished();
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
+
+    // switch to another virtual desktop
+    auto desktops = VirtualDesktopManager::self()->desktops();
+    QCOMPARE(desktops.count(), 4);
+    QCOMPARE(desktops.first(), VirtualDesktopManager::self()->currentDesktop());
+    VirtualDesktopManager::self()->setCurrent(desktops.at(1));
+    QCOMPARE(desktops.at(1), VirtualDesktopManager::self()->currentDesktop());
+    // should be reset to English
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));reply = changeLayout(QStringLiteral("German (Neo 2)"));
+    reply.waitForFinished();
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
+
+    // back to desktop 0 -> German
+    VirtualDesktopManager::self()->setCurrent(desktops.at(0));
+    QCOMPARE(desktops.first(), VirtualDesktopManager::self()->currentDesktop());
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
+    // desktop 2 -> English
+    VirtualDesktopManager::self()->setCurrent(desktops.at(2));
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
+    // desktop 1 -> Neo
+    VirtualDesktopManager::self()->setCurrent(desktops.at(1));
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German (Neo 2)"));
+
+    // remove virtual desktops
+    VirtualDesktopManager::self()->setCount(1);
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("German"));
+
+    // add another desktop
+    VirtualDesktopManager::self()->setCount(2);
+    // switching to it should result in going to default
+    desktops = VirtualDesktopManager::self()->desktops();
+    QCOMPARE(desktops.count(), 2);
+    QCOMPARE(desktops.first(), VirtualDesktopManager::self()->currentDesktop());
+    VirtualDesktopManager::self()->setCurrent(desktops.last());
+    QTRY_COMPARE(xkb->layoutName(), QStringLiteral("English (US)"));
+
+}
+
 WAYLANDTEST_MAIN(KeyboardLayoutTest)
 #include "keyboard_layout_test.moc"
diff --git a/keyboard_layout.cpp b/keyboard_layout.cpp
index ee052d886..810dd5d9e 100644
--- a/keyboard_layout.cpp
+++ b/keyboard_layout.cpp
@@ -1,336 +1,342 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2016, 2017 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "keyboard_layout.h"
+#include "keyboard_layout_switching.h"
 #include "keyboard_input.h"
 #include "input_event.h"
 #include "main.h"
 #include "platform.h"
 #include "utils.h"
 
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KNotifications/KStatusNotifierItem>
 #include <QAction>
 #include <QDBusConnection>
 #include <QDBusMessage>
 #include <QDBusPendingCall>
 #include <QMenu>
 
 namespace KWin
 {
 
 KeyboardLayout::KeyboardLayout(Xkb *xkb)
     : QObject()
     , m_xkb(xkb)
     , m_notifierItem(nullptr)
 {
 }
 
 KeyboardLayout::~KeyboardLayout() = default;
 
 static QString translatedLayout(const QString &layout)
 {
     return i18nd("xkeyboard-config", layout.toUtf8().constData());
 }
 
 void KeyboardLayout::init()
 {
     QAction *switchKeyboardAction = new QAction(this);
     switchKeyboardAction->setObjectName(QStringLiteral("Switch to Next Keyboard Layout"));
     switchKeyboardAction->setProperty("componentName", QStringLiteral("KDE Keyboard Layout Switcher"));
     const QKeySequence sequence = QKeySequence(Qt::ALT+Qt::CTRL+Qt::Key_K);
     KGlobalAccel::self()->setDefaultShortcut(switchKeyboardAction, QList<QKeySequence>({sequence}));
     KGlobalAccel::self()->setShortcut(switchKeyboardAction, QList<QKeySequence>({sequence}));
     kwinApp()->platform()->setupActionForGlobalAccel(switchKeyboardAction);
     connect(switchKeyboardAction, &QAction::triggered, this, &KeyboardLayout::switchToNextLayout);
 
     QDBusConnection::sessionBus().connect(QString(),
                                           QStringLiteral("/Layouts"),
                                           QStringLiteral("org.kde.keyboard"),
                                           QStringLiteral("reloadConfig"),
                                           this,
                                           SLOT(reconfigure()));
 
     reconfigure();
 }
 
 void KeyboardLayout::initDBusInterface()
 {
     if (m_xkb->numberOfLayouts() <= 1) {
         delete m_dbusInterface;
         m_dbusInterface = nullptr;
         return;
     }
     if (m_dbusInterface) {
         return;
     }
     m_dbusInterface = new KeyboardLayoutDBusInterface(m_xkb, this);
     connect(this, &KeyboardLayout::layoutChanged, m_dbusInterface,
         [this] {
             emit m_dbusInterface->currentLayoutChanged(m_xkb->layoutName());
         }
     );
     // TODO: the signal might be emitted even if the list didn't change
     connect(this, &KeyboardLayout::layoutsReconfigured, m_dbusInterface, &KeyboardLayoutDBusInterface::layoutListChanged);
 }
 
 void KeyboardLayout::initNotifierItem()
 {
     bool showNotifier = true;
     bool showSingle = false;
     if (m_config) {
         const auto config = m_config->group(QStringLiteral("Layout"));
         showNotifier = config.readEntry("ShowLayoutIndicator", true);
         showSingle = config.readEntry("ShowSingle", false);
     }
     const bool shouldShow = showNotifier && (showSingle || m_xkb->numberOfLayouts() > 1);
     if (shouldShow) {
         if (m_notifierItem) {
             return;
         }
     } else {
         delete m_notifierItem;
         m_notifierItem = nullptr;
         return;
     }
 
     m_notifierItem = new KStatusNotifierItem(this);
     m_notifierItem->setCategory(KStatusNotifierItem::Hardware);
     m_notifierItem->setStatus(KStatusNotifierItem::Active);
     m_notifierItem->setToolTipTitle(i18nc("tooltip title", "Keyboard Layout"));
     m_notifierItem->setTitle(i18nc("tooltip title", "Keyboard Layout"));
     m_notifierItem->setToolTipIconByName(QStringLiteral("preferences-desktop-keyboard"));
     m_notifierItem->setStandardActionsEnabled(false);
 
     // TODO: proper icon
     m_notifierItem->setIconByName(QStringLiteral("preferences-desktop-keyboard"));
 
     connect(m_notifierItem, &KStatusNotifierItem::activateRequested, this, &KeyboardLayout::switchToNextLayout);
     connect(m_notifierItem, &KStatusNotifierItem::scrollRequested, this,
         [this] (int delta, Qt::Orientation orientation) {
             if (orientation == Qt::Horizontal) {
                 return;
             }
             if (delta > 0) {
                 switchToNextLayout();
             } else {
                 switchToPreviousLayout();
             }
         }
     );
 
     m_notifierItem->setStatus(KStatusNotifierItem::Active);
 }
 
 void KeyboardLayout::switchToNextLayout()
 {
     m_xkb->switchToNextLayout();
     checkLayoutChange();
 }
 
 void KeyboardLayout::switchToPreviousLayout()
 {
     m_xkb->switchToPreviousLayout();
     checkLayoutChange();
 }
 
 void KeyboardLayout::switchToLayout(xkb_layout_index_t index)
 {
     m_xkb->switchToLayout(index);
     checkLayoutChange();
 }
 
 void KeyboardLayout::reconfigure()
 {
     if (m_config) {
         m_config->reparseConfiguration();
+        const QString policyKey = m_config->group(QStringLiteral("Layout")).readEntry("SwitchMode", QStringLiteral("Global"));
+        if (!m_policy || m_policy->name() != policyKey) {
+            delete m_policy;
+            m_policy = KeyboardLayoutSwitching::Policy::create(m_xkb, this, policyKey);
+        }
     }
     m_xkb->reconfigure();
     resetLayout();
 }
 
 void KeyboardLayout::resetLayout()
 {
     m_layout = m_xkb->currentLayout();
     initNotifierItem();
     updateNotifier();
     reinitNotifierMenu();
     loadShortcuts();
     emit layoutsReconfigured();
 
     initDBusInterface();
 }
 
 void KeyboardLayout::loadShortcuts()
 {
     qDeleteAll(m_layoutShortcuts);
     m_layoutShortcuts.clear();
     const auto layouts = m_xkb->layoutNames();
     const QString componentName = QStringLiteral("KDE Keyboard Layout Switcher");
     for (auto it = layouts.begin(); it != layouts.end(); it++) {
         // layout name is translated in the action name in keyboard kcm!
         const QString action = QStringLiteral("Switch keyboard layout to %1").arg(translatedLayout(it.value()));
         const auto shortcuts = KGlobalAccel::self()->globalShortcut(componentName, action);
         if (shortcuts.isEmpty()) {
             continue;
         }
         QAction *a = new QAction(this);
         a->setObjectName(action);
         a->setProperty("componentName", componentName);
         connect(a, &QAction::triggered, this,
                 std::bind(&KeyboardLayout::switchToLayout, this, it.key()));
         KGlobalAccel::self()->setShortcut(a, shortcuts, KGlobalAccel::Autoloading);
         m_layoutShortcuts << a;
     }
 }
 
 void KeyboardLayout::keyEvent(KeyEvent *event)
 {
     if (!event->isAutoRepeat()) {
         checkLayoutChange();
     }
 }
 
 void KeyboardLayout::checkLayoutChange()
 {
     const auto layout = m_xkb->currentLayout();
     if (m_layout == layout) {
         return;
     }
     m_layout = layout;
     notifyLayoutChange();
     updateNotifier();
     emit layoutChanged();
 }
 
 void KeyboardLayout::notifyLayoutChange()
 {
     // notify OSD service about the new layout
     QDBusMessage msg = QDBusMessage::createMethodCall(
         QStringLiteral("org.kde.plasmashell"),
         QStringLiteral("/org/kde/osdService"),
         QStringLiteral("org.kde.osdService"),
         QStringLiteral("kbdLayoutChanged"));
 
     msg << translatedLayout(m_xkb->layoutName());
 
     QDBusConnection::sessionBus().asyncCall(msg);
 }
 
 void KeyboardLayout::updateNotifier()
 {
     if (!m_notifierItem) {
         return;
     }
     m_notifierItem->setToolTipSubTitle(translatedLayout(m_xkb->layoutName()));
     // TODO: update icon
 }
 
 void KeyboardLayout::reinitNotifierMenu()
 {
     if (!m_notifierItem) {
         return;
     }
     const auto layouts = m_xkb->layoutNames();
 
     QMenu *menu = new QMenu;
     for (auto it = layouts.begin(); it != layouts.end(); it++) {
         menu->addAction(translatedLayout(it.value()), std::bind(&KeyboardLayout::switchToLayout, this, it.key()));
     }
 
     menu->addSeparator();
     menu->addAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("Configure Layouts..."), this,
         [this] {
             // TODO: introduce helper function to start kcmshell5
             QProcess *p = new Process(this);
             p->setArguments(QStringList{QStringLiteral("--args=--tab=layouts"), QStringLiteral("kcm_keyboard")});
             p->setProcessEnvironment(kwinApp()->processStartupEnvironment());
             p->setProgram(QStringLiteral("kcmshell5"));
             connect(p, static_cast<void (QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished), p, &QProcess::deleteLater);
             connect(p, static_cast<void (QProcess::*)(QProcess::ProcessError)>(&QProcess::error), this,
                 [p] (QProcess::ProcessError e) {
                     if (e == QProcess::FailedToStart) {
                         qCDebug(KWIN_CORE) << "Failed to start kcmshell5";
                     }
                 }
             );
             p->start();
         }
     );
 
     m_notifierItem->setContextMenu(menu);
 }
 
 static const QString s_keyboardService = QStringLiteral("org.kde.keyboard");
 static const QString s_keyboardObject = QStringLiteral("/Layouts");
 
 KeyboardLayoutDBusInterface::KeyboardLayoutDBusInterface(Xkb *xkb, KeyboardLayout *parent)
     : QObject(parent)
     , m_xkb(xkb)
     , m_keyboardLayout(parent)
 {
     QDBusConnection::sessionBus().registerService(s_keyboardService);
     QDBusConnection::sessionBus().registerObject(s_keyboardObject, this, QDBusConnection::ExportAllSlots | QDBusConnection::ExportAllSignals);
 }
 
 KeyboardLayoutDBusInterface::~KeyboardLayoutDBusInterface()
 {
     QDBusConnection::sessionBus().unregisterService(s_keyboardService);
 }
 
 bool KeyboardLayoutDBusInterface::setLayout(const QString &layout)
 {
     const auto layouts = m_xkb->layoutNames();
     auto it = layouts.begin();
     for (; it !=layouts.end(); it++) {
         if (it.value() == layout) {
             break;
         }
     }
     if (it == layouts.end()) {
         return false;
     }
     m_xkb->switchToLayout(it.key());
     m_keyboardLayout->checkLayoutChange();
     return true;
 }
 
 QString KeyboardLayoutDBusInterface::getCurrentLayout()
 {
     return m_xkb->layoutName();
 }
 
 QStringList KeyboardLayoutDBusInterface::getLayoutsList()
 {
     const auto layouts = m_xkb->layoutNames();
     QStringList ret;
     for (auto it = layouts.begin(); it != layouts.end(); it++) {
         ret << it.value();
     }
     return ret;
 }
 
 QString KeyboardLayoutDBusInterface::getLayoutDisplayName(const QString &layout)
 {
     return translatedLayout(layout);
 }
 
 }
diff --git a/keyboard_layout.h b/keyboard_layout.h
index 5e42d97b3..643bdbf41 100644
--- a/keyboard_layout.h
+++ b/keyboard_layout.h
@@ -1,107 +1,113 @@
 /********************************************************************
  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/>.
 *********************************************************************/
 #ifndef KWIN_KEYBOARD_LAYOUT_H
 #define KWIN_KEYBOARD_LAYOUT_H
 
 #include "input_event_spy.h"
 #include <QObject>
 #include <QVector>
 
 #include <KSharedConfig>
 typedef uint32_t xkb_layout_index_t;
 
 class KStatusNotifierItem;
 class QAction;
 
 namespace KWin
 {
 class Xkb;
 class KeyboardLayoutDBusInterface;
 
+namespace KeyboardLayoutSwitching
+{
+class Policy;
+}
+
 class KeyboardLayout : public QObject, public InputEventSpy
 {
     Q_OBJECT
 public:
     explicit KeyboardLayout(Xkb *xkb);
     ~KeyboardLayout() override;
 
     void setConfig(KSharedConfigPtr config) {
         m_config = config;
     }
 
     void init();
 
     void checkLayoutChange();
     void resetLayout();
 
     void keyEvent(KeyEvent *event) override;
 
 Q_SIGNALS:
     void layoutChanged();
     void layoutsReconfigured();
 
 private Q_SLOTS:
     void reconfigure();
 
 private:
     void initDBusInterface();
     void notifyLayoutChange();
     void initNotifierItem();
     void switchToNextLayout();
     void switchToPreviousLayout();
     void switchToLayout(xkb_layout_index_t index);
     void updateNotifier();
     void reinitNotifierMenu();
     void loadShortcuts();
     Xkb *m_xkb;
     xkb_layout_index_t m_layout = 0;
     KStatusNotifierItem *m_notifierItem;
     KSharedConfigPtr m_config;
     QVector<QAction*> m_layoutShortcuts;
     KeyboardLayoutDBusInterface *m_dbusInterface = nullptr;
+    KeyboardLayoutSwitching::Policy *m_policy = nullptr;
 };
 
 class KeyboardLayoutDBusInterface : public QObject
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.KeyboardLayouts")
 
 public:
     explicit KeyboardLayoutDBusInterface(Xkb *xkb, KeyboardLayout *parent);
     ~KeyboardLayoutDBusInterface() override;
 
 public Q_SLOTS:
     bool setLayout(const QString &layout);
     QString getCurrentLayout();
     QStringList getLayoutsList();
     QString getLayoutDisplayName(const QString &layout);
 
 Q_SIGNALS:
     void currentLayoutChanged(QString layout);
     void layoutListChanged();
 
 private:
     Xkb *m_xkb;
     KeyboardLayout *m_keyboardLayout;
 };
 
 }
 
 #endif
diff --git a/keyboard_layout_switching.cpp b/keyboard_layout_switching.cpp
new file mode 100644
index 000000000..198da9882
--- /dev/null
+++ b/keyboard_layout_switching.cpp
@@ -0,0 +1,119 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2017 Martin Gräßlin <mgraesslin@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#include "keyboard_layout_switching.h"
+#include "keyboard_layout.h"
+#include "virtualdesktops.h"
+#include "xkb.h"
+
+namespace KWin
+{
+
+namespace KeyboardLayoutSwitching
+{
+
+Policy::Policy(Xkb *xkb, KeyboardLayout *layout)
+    : QObject(layout)
+    , m_xkb(xkb)
+    , m_layout(layout)
+{
+    connect(m_layout, &KeyboardLayout::layoutsReconfigured, this, &Policy::clearCache);
+    connect(m_layout, &KeyboardLayout::layoutChanged, this, &Policy::layoutChanged);
+}
+
+Policy::~Policy() = default;
+
+void Policy::setLayout(quint32 layout)
+{
+    m_xkb->switchToLayout(layout);
+}
+
+quint32 Policy::layout() const
+{
+    return m_xkb->currentLayout();
+}
+
+Policy *Policy::create(Xkb *xkb, KeyboardLayout *layout, const QString &policy)
+{
+    if (policy.toLower() == QStringLiteral("desktop")) {
+        return new VirtualDesktopPolicy(xkb, layout);
+    }
+    return new GlobalPolicy(xkb, layout);
+}
+
+GlobalPolicy::GlobalPolicy(Xkb *xkb, KeyboardLayout *layout)
+    : Policy(xkb, layout)
+{
+}
+
+GlobalPolicy::~GlobalPolicy() = default;
+
+VirtualDesktopPolicy::VirtualDesktopPolicy(Xkb *xkb, KeyboardLayout *layout)
+    : Policy(xkb, layout)
+{
+    connect(VirtualDesktopManager::self(), &VirtualDesktopManager::currentChanged, this, &VirtualDesktopPolicy::desktopChanged);
+}
+
+VirtualDesktopPolicy::~VirtualDesktopPolicy() = default;
+
+void VirtualDesktopPolicy::clearCache()
+{
+    m_layouts.clear();
+}
+
+void VirtualDesktopPolicy::desktopChanged()
+{
+    auto d = VirtualDesktopManager::self()->currentDesktop();
+    if (!d) {
+        return;
+    }
+    auto it = m_layouts.constFind(d);
+    if (it == m_layouts.constEnd()) {
+        // new desktop - go to default;
+        setLayout(0);
+    } else {
+        setLayout(it.value());
+    }
+}
+
+void VirtualDesktopPolicy::layoutChanged()
+{
+    auto d = VirtualDesktopManager::self()->currentDesktop();
+    if (!d) {
+        return;
+    }
+    auto it = m_layouts.find(d);
+    const auto l = layout();
+    if (it == m_layouts.constEnd()) {
+        m_layouts.insert(d, l);
+        connect(d, &VirtualDesktop::aboutToBeDestroyed, this,
+            [this, d] {
+                m_layouts.remove(d);
+            }
+        );
+    } else {
+        if (it.value() == l) {
+            return;
+        }
+        it.value() = l;
+    }
+}
+
+}
+}
diff --git a/keyboard_layout_switching.h b/keyboard_layout_switching.h
new file mode 100644
index 000000000..abb20cd8f
--- /dev/null
+++ b/keyboard_layout_switching.h
@@ -0,0 +1,98 @@
+/********************************************************************
+ KWin - the KDE window manager
+ This file is part of the KDE project.
+
+Copyright (C) 2017 Martin Gräßlin <mgraesslin@kde.org>
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*********************************************************************/
+#ifndef KWIN_KEYBOARD_LAYOUT_SWITCHING_H
+#define KWIN_KEYBOARD_LAYOUT_SWITCHING_H
+
+#include <QObject>
+#include <QHash>
+
+namespace KWin
+{
+
+class KeyboardLayout;
+class Xkb;
+class VirtualDesktop;
+
+namespace KeyboardLayoutSwitching
+{
+
+class Policy : public QObject
+{
+    Q_OBJECT
+public:
+    virtual ~Policy();
+
+    virtual QString name() const = 0;
+
+    static Policy *create(Xkb *xkb, KeyboardLayout *layout, const QString &policy);
+
+protected:
+    explicit Policy(Xkb *xkb, KeyboardLayout *layout);
+    virtual void clearCache() = 0;
+    virtual void layoutChanged() = 0;
+
+    void setLayout(quint32 layout);
+    quint32 layout() const;
+
+private:
+    Xkb *m_xkb;
+    KeyboardLayout *m_layout;
+};
+
+class GlobalPolicy : public Policy
+{
+    Q_OBJECT
+public:
+    explicit GlobalPolicy(Xkb *xkb, KeyboardLayout *layout);
+    ~GlobalPolicy() override;
+
+    QString name() const override {
+        return QStringLiteral("Global");
+    }
+
+protected:
+    void clearCache() override {}
+    void layoutChanged() override {}
+};
+
+class VirtualDesktopPolicy : public Policy
+{
+    Q_OBJECT
+public:
+    explicit VirtualDesktopPolicy(Xkb *xkb, KeyboardLayout *layout);
+    ~VirtualDesktopPolicy() override;
+
+    QString name() const override {
+        return QStringLiteral("Desktop");
+    }
+
+protected:
+    void clearCache() override;
+    void layoutChanged() override;
+
+private:
+    void desktopChanged();
+    QHash<VirtualDesktop *, quint32> m_layouts;
+};
+
+}
+}
+
+#endif
diff --git a/virtualdesktops.cpp b/virtualdesktops.cpp
index 53cdaaab5..6b52d5ec4 100644
--- a/virtualdesktops.cpp
+++ b/virtualdesktops.cpp
@@ -1,643 +1,651 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2009 Lucas Murray <lmurray@undefinedfire.com>
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #include "virtualdesktops.h"
 #include "input.h"
 // KDE
 #include <KConfigGroup>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <NETWM>
 // Qt
 #include <QAction>
 
 #include <algorithm>
 
 namespace KWin {
 
 extern int screen_number;
 
 VirtualDesktop::VirtualDesktop(QObject *parent)
     : QObject(parent)
 {
 }
 
-VirtualDesktop::~VirtualDesktop() = default;
+VirtualDesktop::~VirtualDesktop()
+{
+    emit aboutToBeDestroyed();
+}
 
 void VirtualDesktop::setId(const QByteArray &id)
 {
     Q_ASSERT(m_id.isEmpty());
     m_id = id;
 }
 
 void VirtualDesktop::setX11DesktopNumber(uint number)
 {
     Q_ASSERT(m_x11DesktopNumber == 0);
     m_x11DesktopNumber = number;
 }
 
 void VirtualDesktop::setName(const QString &name)
 {
     if (m_name == name) {
         return;
     }
     m_name = name;
     emit nameChanged();
 }
 
 VirtualDesktopGrid::VirtualDesktopGrid()
     : m_size(1, 2) // Default to tow rows
     , m_grid(QVector<QVector<VirtualDesktop*>>{QVector<VirtualDesktop*>{}, QVector<VirtualDesktop*>{}})
 {
 }
 
 VirtualDesktopGrid::~VirtualDesktopGrid() = default;
 
 void VirtualDesktopGrid::update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop*> &desktops)
 {
     // Set private variables
     m_size = size;
     const uint width = size.width();
     const uint height = size.height();
 
     m_grid.clear();
     auto it = desktops.begin();
     auto end = desktops.end();
     if (orientation == Qt::Horizontal) {
         for (uint y = 0; y < height; ++y) {
             QVector<VirtualDesktop*> row;
             for (uint x = 0; x < width && it != end; ++x) {
                 row << *it;
                 it++;
             }
             m_grid << row;
         }
     } else {
         for (uint y = 0; y < height; ++y) {
             m_grid << QVector<VirtualDesktop*>();
         }
         for (uint x = 0; x < width; ++x) {
             for (uint y = 0; y < height && it != end; ++y) {
                 auto &row = m_grid[y];
                 row << *it;
                 it++;
             }
         }
     }
 }
 
 QPoint VirtualDesktopGrid::gridCoords(uint id) const
 {
     return gridCoords(VirtualDesktopManager::self()->desktopForX11Id(id));
 }
 
 QPoint VirtualDesktopGrid::gridCoords(VirtualDesktop *vd) const
 {
     for (int y = 0; y < m_grid.count(); ++y) {
         const auto &row = m_grid.at(y);
         for (int x = 0; x < row.count(); ++x) {
             if (row.at(x) == vd) {
                 return QPoint(x, y);
             }
         }
     }
     return QPoint(-1, -1);
 }
 
 VirtualDesktop *VirtualDesktopGrid::at(const QPoint &coords) const
 {
     if (coords.y() >= m_grid.count()) {
         return nullptr;
     }
     const auto &row = m_grid.at(coords.y());
     if (coords.x() >= row.count()) {
         return nullptr;
     }
     return row.at(coords.x());
 }
 
 KWIN_SINGLETON_FACTORY_VARIABLE(VirtualDesktopManager, s_manager)
 
 VirtualDesktopManager::VirtualDesktopManager(QObject *parent)
     : QObject(parent)
     , m_navigationWrapsAround(false)
     , m_rootInfo(NULL)
 {
 }
 
 VirtualDesktopManager::~VirtualDesktopManager()
 {
     s_manager = NULL;
 }
 
 QString VirtualDesktopManager::name(uint desktop) const
 {
     if (!m_rootInfo) {
         return defaultName(desktop);
     }
     return QString::fromUtf8(m_rootInfo->desktopName(desktop));
 }
 
 uint VirtualDesktopManager::above(uint id, bool wrap) const
 {
     auto vd = above(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::above(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.ry()--;
         if (coords.y() < 0) {
             if (wrap) {
                 coords.setY(m_grid.height() - 1);
             } else {
                 return desktop; // Already at the top-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::toRight(uint id, bool wrap) const
 {
     auto vd = toRight(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::toRight(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.rx()++;
         if (coords.x() >= m_grid.width()) {
             if (wrap) {
                 coords.setX(0);
             } else {
                 return desktop; // Already at the right-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::below(uint id, bool wrap) const
 {
     auto vd = below(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::below(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.ry()++;
         if (coords.y() >= m_grid.height()) {
             if (wrap) {
                 coords.setY(0);
             } else {
                 // Already at the bottom-most desktop
                 return desktop;
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 uint VirtualDesktopManager::toLeft(uint id, bool wrap) const
 {
     auto vd = toLeft(desktopForX11Id(id), wrap);
     return vd ? vd->x11DesktopNumber() : 0;
 }
 
 VirtualDesktop *VirtualDesktopManager::toLeft(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     QPoint coords = m_grid.gridCoords(desktop);
     Q_ASSERT(coords.x() >= 0);
     while (true) {
         coords.rx()--;
         if (coords.x() < 0) {
             if (wrap) {
                 coords.setX(m_grid.width() - 1);
             } else {
                 return desktop; // Already at the left-most desktop
             }
         }
         if (VirtualDesktop *vd = m_grid.at(coords)) {
             return vd;
         }
     }
     return nullptr;
 }
 
 VirtualDesktop *VirtualDesktopManager::next(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     auto it = std::find(m_desktops.begin(), m_desktops.end(), desktop);
     Q_ASSERT(it != m_desktops.end());
     it++;
     if (it == m_desktops.end()) {
         if (wrap) {
             return m_desktops.first();
         } else {
             return desktop;
         }
     }
     return *it;
 }
 
 VirtualDesktop *VirtualDesktopManager::previous(VirtualDesktop *desktop, bool wrap) const
 {
     Q_ASSERT(m_current);
     if (!desktop) {
         desktop = m_current;
     }
     auto it = std::find(m_desktops.begin(), m_desktops.end(), desktop);
     Q_ASSERT(it != m_desktops.end());
     if (it == m_desktops.begin()) {
         if (wrap) {
             return m_desktops.last();
         } else {
             return desktop;
         }
     }
     it--;
     return *it;
 }
 
 VirtualDesktop *VirtualDesktopManager::desktopForX11Id(uint id) const
 {
     if (id == 0 || id > count()) {
         return nullptr;
     }
     return m_desktops.at(id - 1);
 }
 
 uint VirtualDesktopManager::current() const
 {
     return m_current ? m_current->x11DesktopNumber() : 0;
 }
 
+VirtualDesktop *VirtualDesktopManager::currentDesktop() const
+{
+    return m_current;
+}
+
 bool VirtualDesktopManager::setCurrent(uint newDesktop)
 {
     if (newDesktop < 1 || newDesktop > count() || newDesktop == current()) {
         return false;
     }
     auto d = desktopForX11Id(newDesktop);
     Q_ASSERT(d);
     return setCurrent(d);
 }
 
 bool VirtualDesktopManager::setCurrent(VirtualDesktop *newDesktop)
 {
     Q_ASSERT(newDesktop);
     if (m_current == newDesktop) {
         return false;
     }
     const uint oldDesktop = current();
     m_current = newDesktop;
     emit currentChanged(oldDesktop, newDesktop->x11DesktopNumber());
     return true;
 }
 
 void VirtualDesktopManager::setCount(uint count)
 {
     count = qBound<uint>(1, count, VirtualDesktopManager::maximum());
     if (count == uint(m_desktops.count())) {
         // nothing to change
         return;
     }
     const uint oldCount = m_desktops.count();
     const uint oldCurrent = current();
     while (uint(m_desktops.count()) > count) {
         delete m_desktops.takeLast();
     }
     while (uint(m_desktops.count()) < count) {
         auto vd = new VirtualDesktop(this);
         vd->setX11DesktopNumber(m_desktops.count() + 1);
         m_desktops << vd;
     }
     if (oldCount > count) {
         handleDesktopsRemoved(oldCount, oldCurrent);
     }
 
     updateRootInfo();
 
     save();
     emit countChanged(oldCount, m_desktops.count());
 }
 
 void VirtualDesktopManager::handleDesktopsRemoved(uint previousCount, uint previousCurrent)
 {
     if (!m_current) {
         m_current = m_desktops.last();
         emit currentChanged(previousCurrent, m_current->x11DesktopNumber());
     }
     emit desktopsRemoved(previousCount);
 }
 
 void VirtualDesktopManager::updateRootInfo()
 {
     if (!m_rootInfo) {
         // Make sure the layout is still valid
         updateLayout();
         return;
     }
     const int n = count();
     m_rootInfo->setNumberOfDesktops(n);
     NETPoint *viewports = new NETPoint[n];
     m_rootInfo->setDesktopViewport(n, *viewports);
     delete[] viewports;
     // Make sure the layout is still valid
     updateLayout();
 }
 
 void VirtualDesktopManager::updateLayout()
 {
     int width = 0;
     int height = 0;
     Qt::Orientation orientation = Qt::Horizontal;
     if (m_rootInfo) {
         // TODO: Is there a sane way to avoid overriding the existing grid?
         width = m_rootInfo->desktopLayoutColumnsRows().width();
         height = m_rootInfo->desktopLayoutColumnsRows().height();
         orientation = m_rootInfo->desktopLayoutOrientation() == NET::OrientationHorizontal ? Qt::Horizontal : Qt::Vertical;
     }
     if (width == 0 && height == 0) {
         // Not given, set default layout
         height = count() == 1u ? 1 : 2;
     }
     setNETDesktopLayout(orientation,
         width, height, 0 //rootInfo->desktopLayoutCorner() // Not really worth implementing right now.
     );
 }
 
 static bool s_loadingDesktopSettings = false;
 
 void VirtualDesktopManager::load()
 {
     s_loadingDesktopSettings = true;
     if (!m_config) {
         return;
     }
     QString groupname;
     if (screen_number == 0) {
         groupname = QStringLiteral("Desktops");
     } else {
         groupname.sprintf("Desktops-screen-%d", screen_number);
     }
     KConfigGroup group(m_config, groupname);
     const int n = group.readEntry("Number", 1);
     setCount(n);
     if (m_rootInfo) {
         for (int i = 1; i <= n; i++) {
             QString s = group.readEntry(QStringLiteral("Name_%1").arg(i), i18n("Desktop %1", i));
             m_rootInfo->setDesktopName(i, s.toUtf8().data());
             // TODO: update desktop focus chain, why?
 //         m_desktopFocusChain.value()[i-1] = i;
         }
 
         int rows = group.readEntry<int>("Rows", 2);
         rows = qBound(1, rows, n);
         // avoid weird cases like having 3 rows for 4 desktops, where the last row is unused
         int columns = n / rows;
         if (n % rows > 0) {
             columns++;
         }
         m_rootInfo->setDesktopLayout(NET::OrientationHorizontal, columns, rows, NET::DesktopLayoutCornerTopLeft);
         m_rootInfo->activate();
     }
     s_loadingDesktopSettings = false;
 }
 
 void VirtualDesktopManager::save()
 {
     if (s_loadingDesktopSettings) {
         return;
     }
     if (!m_config) {
         return;
     }
     QString groupname;
     if (screen_number == 0) {
         groupname = QStringLiteral("Desktops");
     } else {
         groupname.sprintf("Desktops-screen-%d", screen_number);
     }
     KConfigGroup group(m_config, groupname);
 
     group.writeEntry("Number", count());
     for (uint i = 1; i <= count(); ++i) {
         QString s = name(i);
         const QString defaultvalue = defaultName(i);
         if (s.isEmpty()) {
             s = defaultvalue;
             if (m_rootInfo) {
                 m_rootInfo->setDesktopName(i, s.toUtf8().data());
             }
         }
 
         if (s != defaultvalue) {
             group.writeEntry(QStringLiteral("Name_%1").arg(i), s);
         } else {
             QString currentvalue = group.readEntry(QStringLiteral("Name_%1").arg(i), QString());
             if (currentvalue != defaultvalue) {
                 group.deleteEntry(QStringLiteral("Name_%1").arg(i));
             }
         }
     }
 
     // Save to disk
     group.sync();
 }
 
 QString VirtualDesktopManager::defaultName(int desktop) const
 {
     return i18n("Desktop %1", desktop);
 }
 
 void VirtualDesktopManager::setNETDesktopLayout(Qt::Orientation orientation, uint width, uint height, int startingCorner)
 {
     Q_UNUSED(startingCorner);   // Not really worth implementing right now.
     const uint count = m_desktops.count();
 
     // Calculate valid grid size
     Q_ASSERT(width > 0 || height > 0);
     if ((width <= 0) && (height > 0)) {
         width = (count + height - 1) / height;
     } else if ((height <= 0) && (width > 0)) {
         height = (count + width - 1) / width;
     }
     while (width * height < count) {
         if (orientation == Qt::Horizontal) {
             ++width;
         } else {
             ++height;
         }
     }
 
     m_grid.update(QSize(width, height), orientation, m_desktops);
     // TODO: why is there no call to m_rootInfo->setDesktopLayout?
     emit layoutChanged(width, height);
 }
 
 void VirtualDesktopManager::initShortcuts()
 {
     initSwitchToShortcuts();
 
     QAction *nextAction = addAction(QStringLiteral("Switch to Next Desktop"), i18n("Switch to Next Desktop"), &VirtualDesktopManager::slotNext);
     input()->registerTouchpadSwipeShortcut(SwipeDirection::Right, nextAction);
     QAction *previousAction = addAction(QStringLiteral("Switch to Previous Desktop"), i18n("Switch to Previous Desktop"), &VirtualDesktopManager::slotPrevious);
     input()->registerTouchpadSwipeShortcut(SwipeDirection::Left, previousAction);
     addAction(QStringLiteral("Switch One Desktop to the Right"), i18n("Switch One Desktop to the Right"), &VirtualDesktopManager::slotRight);
     addAction(QStringLiteral("Switch One Desktop to the Left"), i18n("Switch One Desktop to the Left"), &VirtualDesktopManager::slotLeft);
     addAction(QStringLiteral("Switch One Desktop Up"), i18n("Switch One Desktop Up"), &VirtualDesktopManager::slotUp);
     addAction(QStringLiteral("Switch One Desktop Down"), i18n("Switch One Desktop Down"), &VirtualDesktopManager::slotDown);
 
     // axis events
     input()->registerAxisShortcut(Qt::ControlModifier | Qt::AltModifier, PointerAxisDown,
                                   findChild<QAction*>(QStringLiteral("Switch to Next Desktop")));
     input()->registerAxisShortcut(Qt::ControlModifier | Qt::AltModifier, PointerAxisUp,
                                   findChild<QAction*>(QStringLiteral("Switch to Previous Desktop")));
 }
 
 void VirtualDesktopManager::initSwitchToShortcuts()
 {
     const QString toDesktop = QStringLiteral("Switch to Desktop %1");
     const KLocalizedString toDesktopLabel = ki18n("Switch to Desktop %1");
     addAction(toDesktop, toDesktopLabel, 1, QKeySequence(Qt::CTRL + Qt::Key_F1), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 2, QKeySequence(Qt::CTRL + Qt::Key_F2), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 3, QKeySequence(Qt::CTRL + Qt::Key_F3), &VirtualDesktopManager::slotSwitchTo);
     addAction(toDesktop, toDesktopLabel, 4, QKeySequence(Qt::CTRL + Qt::Key_F4), &VirtualDesktopManager::slotSwitchTo);
 
     for (uint i = 5; i <= maximum(); ++i) {
         addAction(toDesktop, toDesktopLabel, i, QKeySequence(), &VirtualDesktopManager::slotSwitchTo);
     }
 }
 
 QAction *VirtualDesktopManager::addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)())
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(name.arg(value));
     a->setText(label.subs(value).toString());
     a->setData(value);
     KGlobalAccel::setGlobalShortcut(a, key);
     input()->registerShortcut(key, a, this, slot);
     return a;
 }
 
 QAction *VirtualDesktopManager::addAction(const QString &name, const QString &label, void (VirtualDesktopManager::*slot)())
 {
     QAction *a = new QAction(this);
     a->setProperty("componentName", QStringLiteral(KWIN_NAME));
     a->setObjectName(name);
     a->setText(label);
     KGlobalAccel::setGlobalShortcut(a, QKeySequence());
     input()->registerShortcut(QKeySequence(), a, this, slot);
     return a;
 }
 
 void VirtualDesktopManager::slotSwitchTo()
 {
     QAction *act = qobject_cast<QAction*>(sender());
     if (!act) {
         return;
     }
     bool ok = false;
     const uint i = act->data().toUInt(&ok);
     if (!ok) {
         return;
     }
     setCurrent(i);
 }
 
 void VirtualDesktopManager::setNavigationWrappingAround(bool enabled)
 {
     if (enabled == m_navigationWrapsAround) {
         return;
     }
     m_navigationWrapsAround = enabled;
     emit navigationWrappingAroundChanged();
 }
 
 void VirtualDesktopManager::slotDown()
 {
     moveTo<DesktopBelow>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotLeft()
 {
     moveTo<DesktopLeft>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotPrevious()
 {
     moveTo<DesktopPrevious>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotNext()
 {
     moveTo<DesktopNext>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotRight()
 {
     moveTo<DesktopRight>(isNavigationWrappingAround());
 }
 
 void VirtualDesktopManager::slotUp()
 {
     moveTo<DesktopAbove>(isNavigationWrappingAround());
 }
 
 } // KWin
diff --git a/virtualdesktops.h b/virtualdesktops.h
index da80e007f..3fca27a22 100644
--- a/virtualdesktops.h
+++ b/virtualdesktops.h
@@ -1,681 +1,692 @@
 /********************************************************************
  KWin - the KDE window manager
  This file is part of the KDE project.
 
 Copyright (C) 2012 Martin Gräßlin <mgraesslin@kde.org>
 
 This program is free software; you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation; either version 2 of the License, or
 (at your option) any later version.
 
 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.
 
 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *********************************************************************/
 #ifndef KWIN_VIRTUAL_DESKTOPS_H
 #define KWIN_VIRTUAL_DESKTOPS_H
 // KWin
 #include <kwinglobals.h>
+#include <kwin_export.h>
 // Qt includes
 #include <QObject>
 #include <QPoint>
 #include <QPointer>
 #include <QSize>
 // KDE includes
 #include <KConfig>
 #include <KSharedConfig>
 
 class KLocalizedString;
 class NETRootInfo;
 class QAction;
 
 namespace KWin {
 
-class VirtualDesktop : public QObject
+class KWIN_EXPORT VirtualDesktop : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QByteArray id READ id CONSTANT)
     Q_PROPERTY(uint x11DesktopNumber READ x11DesktopNumber CONSTANT)
     Q_PROPERTY(QString name READ name WRITE setName NOTIFY nameChanged)
 public:
     explicit VirtualDesktop(QObject *parent = nullptr);
     virtual ~VirtualDesktop();
 
     void setId(const QByteArray &id);
     QByteArray id() const {
         return m_id;
     }
 
     void setName(const QString &name);
     QString name() const {
         return m_name;
     }
 
     void setX11DesktopNumber(uint number);
     uint x11DesktopNumber() const {
         return m_x11DesktopNumber;
     }
 
 Q_SIGNALS:
     void nameChanged();
+    /**
+     * Emitted just before the desktop gets destroyed.
+     **/
+    void aboutToBeDestroyed();
 
 private:
     QByteArray m_id;
     QString m_name;
     int m_x11DesktopNumber = 0;
 
 };
 
 /**
  * @brief Two dimensional grid containing the ID of the virtual desktop at a specific position
  * in the grid.
  *
  * The VirtualDesktopGrid represents a visual layout of the Virtual Desktops as they are in e.g.
  * a Pager. This grid is used for getting a desktop next to a given desktop in any direction by
  * making use of the layout information. This allows navigation like move to desktop on left.
  **/
 class VirtualDesktopGrid
 {
 public:
     VirtualDesktopGrid();
     ~VirtualDesktopGrid();
     void update(const QSize &size, Qt::Orientation orientation, const QVector<VirtualDesktop*> &desktops);
     /**
      * @returns The coords of desktop @a id in grid units.
      */
     QPoint gridCoords(uint id) const;
     /**
      * @returns The coords of desktop @a vd in grid units.
      */
     QPoint gridCoords(VirtualDesktop *vd) const;
     /**
      * @returns The desktop at the point @a coords or 0 if no desktop exists at that
      * point. @a coords is to be in grid units.
      */
     VirtualDesktop *at(const QPoint &coords) const;
     int width() const;
     int height() const;
     const QSize &size() const;
 private:
     QSize m_size;
     QVector<QVector<VirtualDesktop*>> m_grid;
 };
 
 /**
  * @brief Manages the number of available virtual desktops, the layout of those and which virtual
  * desktop is the current one.
  *
  * This manager is responsible for Virtual Desktop handling inside KWin. It has a property for the
  * count of available virtual desktops and a property for the currently active virtual desktop. All
  * changes to the number of virtual desktops and the current virtual desktop need to go through this
  * manager.
  *
  * On all changes a signal is emitted and interested parties should connect to the signal. The manager
  * itself does not interact with other parts of the system. E.g. it does not hide/show windows of
  * desktop changes. This is outside the scope of this manager.
  *
  * Internally the manager organizes the virtual desktops in a grid allowing to navigate over the
  * virtual desktops. For this a set of convenient methods are available which allow to get the id
  * of an adjacent desktop or to switch to an adjacent desktop. Interested parties should make use of
  * these methods and not replicate the logic to switch to the next desktop.
  **/
-class VirtualDesktopManager : public QObject
+class KWIN_EXPORT VirtualDesktopManager : public QObject
 {
     Q_OBJECT
     /**
      * The number of virtual desktops currently available.
      * The ids of the virtual desktops are in the range [1, VirtualDesktopManager::maximum()].
      **/
     Q_PROPERTY(uint count READ count WRITE setCount NOTIFY countChanged)
     /**
      * The id of the virtual desktop which is currently in use.
      **/
     Q_PROPERTY(uint current READ current WRITE setCurrent NOTIFY currentChanged)
     /**
      * Whether navigation in the desktop layout wraps around at the borders.
      **/
     Q_PROPERTY(bool navigationWrappingAround READ isNavigationWrappingAround WRITE setNavigationWrappingAround NOTIFY navigationWrappingAroundChanged)
 public:
     virtual ~VirtualDesktopManager();
     /**
      * @internal
      **/
     void setRootInfo(NETRootInfo *info);
     /**
      * @internal
      **/
     void setConfig(KSharedConfig::Ptr config);
     /**
      * @returns Total number of desktops currently in existence.
      * @see setCount
      * @see countChanged
      */
     uint count() const;
     /**
      * @returns The ID of the current desktop.
      * @see setCurrent
      * @see currentChanged
      */
     uint current() const;
+    /**
+     * @returns The current desktop
+     * @see setCurrent
+     * @see currentChanged
+     **/
+    VirtualDesktop *currentDesktop() const;
     /**
      * Moves to the desktop through the algorithm described by Direction.
      * @param wrap If @c true wraps around to the other side of the layout
      * @see setCurrent
      **/
     template <typename Direction>
     void moveTo(bool wrap = false);
 
     /**
      * @returns The name of the @p desktop
      **/
     QString name(uint desktop) const;
 
     /**
      * @returns @c true if navigation at borders of layout wraps around, @c false otherwise
      * @see setNavigationWrappingAround
      * @see navigationWrappingAroundChanged
      **/
     bool isNavigationWrappingAround() const;
 
     /**
      * @returns The layout aware virtual desktop grid used by this manager.
      **/
     const VirtualDesktopGrid &grid() const;
 
     /**
      * @returns The ID of the desktop above desktop @a id. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint above(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop above desktop @a desktop. Wraps around to the bottom of
      * the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *above(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop to the right of desktop @a id. Wraps around to the
      * left of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint toRight(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop to the right of desktop @a desktop. Wraps around to the
      * left of the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *toRight(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop below desktop @a id. Wraps around to the top of the
      * layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint below(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop below desktop @a desktop. Wraps around to the top of the
      * layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *below(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The ID of the desktop to the left of desktop @a id. Wraps around to the
      * right of the layout if @a wrap is set. If @a id is not set use the current one.
      */
     uint toLeft(uint id = 0, bool wrap = true) const;
     /**
      * @returns The desktop to the left of desktop @a desktop. Wraps around to the
      * right of the layout if @a wrap is set. If @a desktop is @c null use the current one.
      */
     VirtualDesktop *toLeft(VirtualDesktop *desktop, bool wrap = true) const;
     /**
      * @returns The desktop after the desktop @a desktop. Wraps around to the first
      * desktop if @a wrap is set. If @a desktop is @c null use the current desktop.
      **/
     VirtualDesktop *next(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
     /**
      * @returns The desktop in front of the desktop @a desktop. Wraps around to the
      * last desktop if @a wrap is set. If @a desktop is @c null use the current desktop.
      **/
     VirtualDesktop *previous(VirtualDesktop *desktop = nullptr, bool wrap = true) const;
 
     void initShortcuts();
 
     /**
      * @returns all currently managed VirtualDesktops
      **/
     QVector<VirtualDesktop*> desktops() const {
         return m_desktops;
     }
 
     /**
      * @returns The VirtualDesktop for the x11 @p id, if no such VirtualDesktop @c null is returned
      **/
     VirtualDesktop *desktopForX11Id(uint id) const;
 
     /**
      * @returns The maximum number of desktops that KWin supports.
      */
     static uint maximum();
 
 public Q_SLOTS:
     /**
      * Set the number of available desktops to @a count. This function overrides any previous
      * grid layout.
      * There needs to be at least one virtual desktop and the new value is capped at the maximum
      * number of desktops. A caller of this function cannot expect that the change has been applied.
      * It is the callers responsibility to either check the @link numberOfDesktops or connect to the
      * @link countChanged signal.
      *
      * In case the @link current desktop is on a desktop higher than the new count, the current desktop
      * is changed to be the new desktop with highest id. In that situation the signal @link desktopsRemoved
      * is emitted.
      * @param count The new number of desktops to use
      * @see count
      * @see maximum
      * @see countChanged
      * @see desktopsRemoved
      */
     void setCount(uint count);
     /**
      * Set the current desktop to @a current.
      * @returns True on success, false otherwise.
      * @see current
      * @see currentChanged
      * @see moveTo
      */
     bool setCurrent(uint current);
     /**
      * Set the current desktop to @a current.
      * @returns True on success, false otherwise.
      * @see current
      * @see currentChanged
      * @see moveTo
      **/
     bool setCurrent(VirtualDesktop *current);
     /**
      * Called from within setCount() to ensure the desktop layout is still valid.
      */
     void updateLayout();
     /**
      * @param enable wrapping around borders for navigation in desktop layout
      * @see isNavigationWrappingAround
      * @see navigationWrappingAroundChanged
      **/
     void setNavigationWrappingAround(bool enabled);
     /**
      * Loads number of desktops and names from configuration file
      **/
     void load();
     /**
      * Saves number of desktops and names to configuration file
      **/
     void save();
 
 Q_SIGNALS:
     /**
      * Signal emitted whenever the number of virtual desktops changes.
      * @param previousCount The number of desktops prior to the change
      * @param newCount The new current number of desktops
      **/
     void countChanged(uint previousCount, uint newCount);
     /**
      * Signal emitted whenever the number of virtual desktops changes in a way
      * that existing desktops are removed.
      *
      * The signal is emitted after the @c count property has been updated but prior
      * to the @link countChanged signal being emitted.
      * @param previousCount The number of desktops prior to the change.
      * @see countChanged
      * @see setCount
      * @see count
      **/
     void desktopsRemoved(uint previousCount);
     /**
      * Signal emitted whenever the current desktop changes.
      * @param previousDesktop The virtual desktop changed from
      * @param newDesktop The virtual desktop changed to
      **/
     void currentChanged(uint previousDesktop, uint newDesktop);
     /**
      * Signal emitted whenever the desktop layout changes.
      * @param columns The new number of columns in the layout
      * @param rows The new number of rows in the layout
      **/
     void layoutChanged(int columns, int rows);
     /**
      * Signal emitted whenever the navigationWrappingAround property changes.
      **/
     void navigationWrappingAroundChanged();
 
 private Q_SLOTS:
     /**
      * Common slot for all "Switch to Desktop n" shortcuts.
      * This method uses the sender() method to access some data.
      * DO NOT CALL DIRECTLY! ONLY TO BE USED FROM AN ACTION!
      **/
     void slotSwitchTo();
     /**
      * Slot for switch to next desktop action.
      **/
     void slotNext();
     /**
      * Slot for switch to previous desktop action.
      **/
     void slotPrevious();
     /**
      * Slot for switch to right desktop action.
      **/
     void slotRight();
     /**
      * Slot for switch to left desktop action.
      **/
     void slotLeft();
     /**
      * Slot for switch to desktop above action.
      **/
     void slotUp();
     /**
      * Slot for switch to desktop below action.
      **/
     void slotDown();
 
 private:
     /**
      * This method is called when the number of desktops is updated in a way that desktops
      * are removed. At the time when this method is invoked the count property is already
      * updated but the corresponding signal has not been emitted yet.
      *
      * Ensures that in case the current desktop is on one of the removed
      * desktops the last desktop after the change becomes the new desktop.
      * Emits the signal @link desktopsRemoved.
      *
      * @param previousCount The number of desktops prior to the change.
      * @param previousCurrent The number of the previously current desktop.
      * @see setCount
      * @see desktopsRemoved
      **/
     void handleDesktopsRemoved(uint previousCount, uint previousCurrent);
     /**
      * Generate a desktop layout from EWMH _NET_DESKTOP_LAYOUT property parameters.
      */
     void setNETDesktopLayout(Qt::Orientation orientation, uint width, uint height, int startingCorner);
     /**
      * Updates the net root info for new number of desktops
      **/
     void updateRootInfo();
     /**
      * @returns A default name for the given @p desktop
      **/
     QString defaultName(int desktop) const;
     /**
      * Creates all the global keyboard shortcuts for "Switch To Desktop n" actions.
      **/
     void initSwitchToShortcuts();
     /**
      * Creates an action and connects it to the @p slot in this Manager. This method is
      * meant to be used for the case that an additional information needs to be stored in
      * the action and the label.
      * @param name The name of the action to be created
      * @param label The localized name for the action to be created
      * @param value An additional value added to the label and to the created action
      * @param key The global shortcut for the action
      * @param slot The slot to invoke when the action is triggered
      **/
     QAction *addAction(const QString &name, const KLocalizedString &label, uint value, const QKeySequence &key, void (VirtualDesktopManager::*slot)());
     /**
      * Creates an action and connects it to the @p slot in this Manager.
      * Overloaded method for the case that no additional value needs to be passed to the action and
      * no global shortcut is defined by default.
      * @param name The name of the action to be created
      * @param label The localized name for the action to be created
      * @param slot The slot to invoke when the action is triggered
      **/
     QAction *addAction(const QString &name, const QString &label, void (VirtualDesktopManager::*slot)());
 
     QVector<VirtualDesktop*> m_desktops;
     QPointer<VirtualDesktop> m_current;
     bool m_navigationWrapsAround;
     VirtualDesktopGrid m_grid;
     // TODO: QPointer
     NETRootInfo *m_rootInfo;
     KSharedConfig::Ptr m_config;
 
     KWIN_SINGLETON_VARIABLE(VirtualDesktopManager, s_manager)
 };
 
 /**
  * Function object to select the desktop above in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopAbove
 {
 public:
     DesktopAbove() {}
     /**
      * @param desktop The desktop from which the desktop above should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already topmost desktop
      * @returns Id of the desktop above @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop above should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already topmost desktop
      * @returns the desktop above @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->above(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop below in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopBelow
 {
 public:
     DesktopBelow() {}
     /**
      * @param desktop The desktop from which the desktop below should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already lowest desktop
      * @returns Id of the desktop below @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop below should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already lowest desktop
      * @returns the desktop below @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->below(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop to the left in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopLeft
 {
 public:
     DesktopLeft() {}
     /**
      * @param desktop The desktop from which the desktop on the left should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already leftmost desktop
      * @returns Id of the desktop left of @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop on the left should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already leftmost desktop
      * @returns the desktop left of @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->toLeft(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the desktop to the right in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopRight
 {
 public:
     DesktopRight() {}
     /**
      * @param desktop The desktop from which the desktop on the right should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already rightmost desktop
      * @returns Id of the desktop right of @p desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the desktop on the right should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already rightmost desktop
      * @returns the desktop right of @p desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->toRight(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the next desktop in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopNext
 {
 public:
     DesktopNext() {}
     /**
      * @param desktop The desktop from which the next desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already last desktop
      * @returns Id of the next desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the next desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already last desktop
      * @returns the next desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->next(desktop, wrap);
     }
 };
 
 /**
  * Function object to select the previous desktop in the layout.
  * Note: does not switch to the desktop!
  **/
 class DesktopPrevious
 {
 public:
     DesktopPrevious() {}
     /**
      * @param desktop The desktop from which the previous desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already first desktop
      * @returns Id of the previous desktop
      **/
     uint operator() (uint desktop, bool wrap) {
         return (*this)(VirtualDesktopManager::self()->desktopForX11Id(desktop), wrap)->x11DesktopNumber();
     }
     /**
      * @param desktop The desktop from which the previous desktop should be selected. If @c 0 the current desktop is used
      * @param wrap Whether to wrap around if already first desktop
      * @returns the previous desktop
      **/
     VirtualDesktop *operator() (VirtualDesktop *desktop, bool wrap) {
         return VirtualDesktopManager::self()->previous(desktop, wrap);
     }
 };
 
 /**
  * Helper function to get the ID of a virtual desktop in the direction from
  * the given @p desktop. If @c 0 the current desktop is used as a starting point.
  * @param desktop The desktop from which the desktop in given Direction should be selected.
  * @param wrap Whether desktop navigation wraps around at the borders of the layout
  * @returns The next desktop in specified direction
  **/
 template <typename Direction>
 uint getDesktop(int desktop = 0, bool wrap = true);
 
 template <typename Direction>
 uint getDesktop(int d, bool wrap)
 {
     Direction direction;
     return direction(d, wrap);
 }
 
 inline
 int VirtualDesktopGrid::width() const
 {
     return m_size.width();
 }
 
 inline
 int VirtualDesktopGrid::height() const
 {
     return m_size.height();
 }
 
 inline
 const QSize &VirtualDesktopGrid::size() const
 {
     return m_size;
 }
 
 inline
 uint VirtualDesktopManager::maximum()
 {
     return 20;
 }
 
 inline
 uint VirtualDesktopManager::count() const
 {
     return m_desktops.count();
 }
 
 inline
 bool VirtualDesktopManager::isNavigationWrappingAround() const
 {
     return m_navigationWrapsAround;
 }
 
 inline
 void VirtualDesktopManager::setRootInfo(NETRootInfo *info)
 {
     m_rootInfo = info;
 }
 
 inline
 void VirtualDesktopManager::setConfig(KSharedConfig::Ptr config)
 {
     m_config = config;
 }
 
 inline
 const VirtualDesktopGrid &VirtualDesktopManager::grid() const
 {
     return m_grid;
 }
 
 template <typename Direction>
 void VirtualDesktopManager::moveTo(bool wrap)
 {
     Direction functor;
     setCurrent(functor(nullptr, wrap));
 }
 
 } // namespace KWin
 #endif