diff --git a/CMakeLists.txt b/CMakeLists.txt
index d6deabaa..c49aab00 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,178 +1,178 @@
 project(plasma-workspace)
 set(PROJECT_VERSION "5.8.90")
 set(PROJECT_VERSION_MAJOR 5)
 
 cmake_minimum_required(VERSION 2.8.12 FATAL_ERROR)
 
 set(QT_MIN_VERSION "5.6.1")
 set(KF5_MIN_VERSION "5.29.0")
 set(INSTALL_SDDM_THEME TRUE)
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS Widgets Quick QuickWidgets Concurrent Test Script Network)
 find_package(ECM 1.8.0 REQUIRED NO_MODULE)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR})
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDECompilerSettings NO_POLICY_SCOPE)
 include(ECMPackageConfigHelpers)
 include(ECMMarkNonGuiExecutable)
 include(CMakePackageConfigHelpers)
 include(WriteBasicConfigVersionFile)
 include(CheckIncludeFiles)
 include(FeatureSummary)
 include(ECMOptionalAddSubdirectory)
 include(ECMQtDeclareLoggingCategory)
 include(KDEPackageAppTemplates)
 
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
                     Plasma DocTools Runner JsEmbed NotifyConfig Su NewStuff Wallet KCMUtils
                     IdleTime Declarative TextWidgets KDELibs4Support Crash GlobalAccel
                     DBusAddons Wayland)
 find_package(KF5NetworkManagerQt ${KF5_MIN_VERSION})
 set_package_properties(KF5NetworkManagerQt PROPERTIES DESCRIPTION "Qt wrapper for NetworkManager API"
                        TYPE OPTIONAL
                        PURPOSE "Needed by geolocation data engine."
                       )
 find_package(KF5XmlRpcClient REQUIRED)
 
 # WARNING PlasmaQuick provides unversioned CMake config
 find_package(KF5 REQUIRED COMPONENTS PlasmaQuick)
 find_package(KF5 REQUIRED COMPONENTS SysGuard)
 find_package(KF5 REQUIRED COMPONENTS Package)
 
 find_package(KF5Baloo)
 set_package_properties(KF5Baloo PROPERTIES DESCRIPTION "File Searching"
                        TYPE RECOMMENDED
                        PURPOSE "Needed for the File Search runner."
                       )
 
 find_package(KF5TextEditor)
 find_package(KWinDBusInterface CONFIG REQUIRED)
 
 find_package(KScreenLocker REQUIRED)
 find_package(ScreenSaverDBusInterface CONFIG REQUIRED)
 find_package(KF5Holidays)
 set_package_properties(KF5Holidays PROPERTIES DESCRIPTION "Holidays provider for Plasma calendar"
                        TYPE OPTIONAL
                        PURPOSE "Needed to for holidays plugin for Plasma Calendar."
                       )
 
 find_package(Phonon4Qt5 4.6.60 REQUIRED NO_MODULE)
 set_package_properties(Phonon4Qt5 PROPERTIES
    DESCRIPTION "Qt-based audio library"
    TYPE REQUIRED)
 find_package(KF5Activities ${KF5_MIN_VERSION})
 set_package_properties(KF5Activities PROPERTIES DESCRIPTION "management of Plasma activities"
                        TYPE OPTIONAL
                        PURPOSE "Needed by activity related plasmoids."
                       )
 
 find_package(ZLIB)
 set_package_properties(ZLIB PROPERTIES DESCRIPTION "Support for gzip compressed files and data streams"
                        URL "http://www.zlib.net"
                        TYPE REQUIRED
                       )
 
 find_package(dbusmenu-qt5 CONFIG)
 set_package_properties(dbusmenu-qt5 PROPERTIES DESCRIPTION "Support for notification area menus via the DBusMenu protocol"
                        URL "https://launchpad.net/libdbusmenu-qt"
                        TYPE OPTIONAL
                       )
 
 find_package(X11)
 set_package_properties(X11 PROPERTIES DESCRIPTION "X11 libraries"
                         URL "http://www.x.org"
                         TYPE OPTIONAL
                         PURPOSE "Required for building the X11 based workspace")
 
 if(X11_FOUND)
-  find_package(XCB MODULE REQUIRED COMPONENTS XCB)
+  find_package(XCB MODULE REQUIRED COMPONENTS XCB RANDR)
   set_package_properties(XCB PROPERTIES TYPE REQUIRED)
   if(NOT X11_SM_FOUND)
     message(FATAL_ERROR "\nThe X11 Session Management (SM) development package could not be found.\nPlease install libSM.\n")
   endif(NOT X11_SM_FOUND)
 
   find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS X11Extras)
 endif()
 
 if(X11_FOUND AND XCB_XCB_FOUND)
   set(HAVE_X11 1)
 endif()
 
 include(ConfigureChecks.cmake)
 
 include_directories("${CMAKE_CURRENT_BINARY_DIR}")
 
 configure_file(config-workspace.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-workspace.h)
 configure_file(config-unix.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-unix.h )
 configure_file(config-X11.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-X11.h)
 configure_file(plasma.desktop.cmake ${CMAKE_CURRENT_BINARY_DIR}/plasma.desktop)
 install(FILES
         ${CMAKE_CURRENT_BINARY_DIR}/plasma.desktop
         DESTINATION ${KDE_INSTALL_DATADIR}/xsessions
 )
 
 configure_file(plasmawayland.desktop.cmake ${CMAKE_CURRENT_BINARY_DIR}/plasmawayland.desktop)
 install(FILES
         ${CMAKE_CURRENT_BINARY_DIR}/plasmawayland.desktop
         DESTINATION ${KDE_INSTALL_DATADIR}/wayland-sessions
 )
 
 plasma_install_package(lookandfeel org.kde.breeze.desktop look-and-feel lookandfeel)
 
 if (INSTALL_SDDM_THEME)
 # Install the login theme into the SDDM directory
 # Longer term we need to look at making SDDM load from look and feel somehow.. and allow copying at runtime
     #NOTE this trailing slash is important to rename the directory
     install(DIRECTORY sddm-theme/ DESTINATION ${KDE_INSTALL_FULL_DATADIR}/sddm/themes/breeze PATTERN "README.txt" EXCLUDE PATTERN "components" EXCLUDE PATTERN "dummydata" EXCLUDE)
     install(DIRECTORY lookandfeel/contents/components DESTINATION ${KDE_INSTALL_FULL_DATADIR}/sddm/themes/breeze PATTERN "README.txt" EXCLUDE)
 endif()
 
 add_definitions(-DQT_NO_URL_CAST_FROM_STRING)
 
 add_subdirectory(doc)
 add_subdirectory(libkworkspace)
 add_subdirectory(libtaskmanager)
 add_subdirectory(components)
 
 if(dbusmenu-qt5_FOUND)
   add_subdirectory(appmenu)
 endif()
 
 add_subdirectory(plasma-windowed)
 add_subdirectory(shell)
 add_subdirectory(freespacenotifier)
 add_subdirectory(klipper)
 add_subdirectory(krunner)
 add_subdirectory(ksmserver)
 add_subdirectory(ksplash)
 add_subdirectory(systemmonitor)
 add_subdirectory(statusnotifierwatcher)
 add_subdirectory(startkde)
 add_subdirectory(themes)
 
 add_subdirectory(containmentactions)
 add_subdirectory(runners)
 add_subdirectory(applets)
 add_subdirectory(dataengines)
 add_subdirectory(wallpapers)
 
 add_subdirectory(kioslave)
 add_subdirectory(ktimezoned)
 add_subdirectory(kuiserver)
 add_subdirectory(menu)
 add_subdirectory(phonon)
 add_subdirectory(solidautoeject)
 add_subdirectory(drkonqi)
 
 ecm_optional_add_subdirectory(xembed-sni-proxy)
 
 add_subdirectory(soliduiserver)
 
 if(KF5Holidays_FOUND)
     add_subdirectory(plasmacalendarintegration)
 endif()
 
 add_subdirectory(templates)
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/shell/CMakeLists.txt b/shell/CMakeLists.txt
index 51f92235..629706c4 100644
--- a/shell/CMakeLists.txt
+++ b/shell/CMakeLists.txt
@@ -1,115 +1,115 @@
 # Tell CMake to run moc when necessary:
 set(CMAKE_AUTOMOC ON)
 # As moc files are generated in the binary dir, tell CMake
 # to always look for includes there:
 set(CMAKE_INCLUDE_CURRENT_DIR ON)
 
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 
 find_package(Qt5Qml REQUIRED)
 find_package(Qt5Quick REQUIRED)
 find_package(Qt5DBus REQUIRED)
 find_package(Qt5Script REQUIRED)
 find_package(KF5CoreAddons REQUIRED)
 find_package(KF5Crash REQUIRED)
 find_package(KF5Solid REQUIRED)
 find_package(KF5Activities REQUIRED)
 find_package(KF5DBusAddons ${KF5_MIN_VERSION} REQUIRED)
 find_package(KF5Declarative ${KF5_MIN_VERSION} REQUIRED)
 find_package(KF5Package REQUIRED)
 
 configure_file(config-ktexteditor.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-ktexteditor.h )
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-plasma.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-plasma.h)
 
 add_definitions(-DPLASMA_DEPRECATED=)
 
 set(scripting_SRC
     scripting/appinterface.cpp
     scripting/applet.cpp
     scripting/containment.cpp
     scripting/configgroup.cpp
     scripting/i18n.cpp
     scripting/panel.cpp
     scripting/rect.cpp
     scripting/scriptengine.cpp
     scripting/scriptengine_v1.cpp
     scripting/widget.cpp
 )
 
 set(plasmashell_dbusXML dbus/org.kde.PlasmaShell.xml)
 qt5_add_dbus_adaptor(scripting_SRC ${plasmashell_dbusXML} shellcorona.h ShellCorona plasmashelladaptor)
 
 ecm_qt_declare_logging_category(plasmashell HEADER debug.h
                                                IDENTIFIER PLASMASHELL
                                                CATEGORY_NAME kde.plasmashell
                                                DEFAULT_SEVERITY Info)
 
 set (plasma_shell_SRCS
     alternativeshelper.cpp
     main.cpp
     containmentconfigview.cpp
     currentcontainmentactionsmodel.cpp
     desktopview.cpp
     kidenticongenerator.cpp
     panelview.cpp
     panelconfigview.cpp
     panelshadows.cpp
     shellcorona.cpp
     shellmanager.cpp
     standaloneappcorona
     osd.cpp
     coronatesthelper.cpp
     debug.cpp
     screenpool.cpp
     ${scripting_SRC}
 )
 
 set(krunner_xml ${plasma-workspace_SOURCE_DIR}/krunner/dbus/org.kde.krunner.App.xml)
 qt5_add_dbus_interface(plasma_shell_SRCS ${krunner_xml} krunner_interface)
 
 add_executable(plasmashell
     ${plasma_shell_SRCS}
 )
 
 target_link_libraries(plasmashell
  Qt5::Quick
  Qt5::DBus
  KF5::KIOCore
  KF5::WindowSystem
  KF5::Crash
  KF5::Plasma
  KF5::PlasmaQuick
  Qt5::Script
  KF5::Solid
  KF5::Declarative
  KF5::I18n
  KF5::IconThemes
  KF5::Activities
  KF5::GlobalAccel
  KF5::CoreAddons
  KF5::DBusAddons
  KF5::Declarative
  KF5::QuickAddons
  KF5::XmlGui
  KF5::Package
  KF5::WaylandClient
 )
 target_include_directories(plasmashell PRIVATE "${CMAKE_BINARY_DIR}")
 target_compile_definitions(plasmashell PRIVATE -DPROJECT_VERSION="${PROJECT_VERSION}")
 
 if(HAVE_X11)
-  target_link_libraries(plasmashell ${X11_LIBRARIES} XCB::XCB )
+  target_link_libraries(plasmashell ${X11_LIBRARIES} ${XCB_LIBRARIES} )
   target_link_libraries(plasmashell Qt5::X11Extras)
 endif()
 
 install(TARGETS plasmashell ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 install(FILES plasmashell.desktop DESTINATION ${KDE_INSTALL_AUTOSTARTDIR})
 install( FILES dbus/org.kde.PlasmaShell.xml DESTINATION ${KDE_INSTALL_DBUSINTERFACEDIR} )
 
 install(FILES
    scripting/plasma-layout-template.desktop
    DESTINATION ${KDE_INSTALL_KSERVICETYPES5DIR})
 
 add_subdirectory(packageplugins)
 add_subdirectory(autotests)
diff --git a/shell/autotests/CMakeLists.txt b/shell/autotests/CMakeLists.txt
index 16f1466a..dfc8f0e6 100644
--- a/shell/autotests/CMakeLists.txt
+++ b/shell/autotests/CMakeLists.txt
@@ -1,23 +1,27 @@
 include(ECMAddTests)
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR}/.. ${CMAKE_CURRENT_SOURCE_DIR}/..)
 
 MACRO(PLASMASHELL_UNIT_TESTS)
        FOREACH(_testname ${ARGN})
                add_executable(${_testname} ${_testname}.cpp ../screenpool.cpp )
                target_link_libraries(${_testname}
                             Qt5::Test
                             Qt5::Gui
                             KF5::Service
                                      )
+               if(HAVE_X11)
+                  target_link_libraries(${_testname} ${X11_LIBRARIES} ${XCB_LIBRARIES} )
+                  target_link_libraries(${_testname} Qt5::X11Extras)
+               endif()
                if(QT_QTOPENGL_FOUND)
                    target_link_libraries(${_testname} Qt5::OpenGL)
                endif()
                add_test(${_testname} ${_testname})
                ecm_mark_as_test(${_testname})
        ENDFOREACH(_testname)
 ENDMACRO(PLASMASHELL_UNIT_TESTS)
 
 PLASMASHELL_UNIT_TESTS(
     screenpooltest
 )
diff --git a/shell/desktopview.cpp b/shell/desktopview.cpp
index 55d0eece..11a24be4 100644
--- a/shell/desktopview.cpp
+++ b/shell/desktopview.cpp
@@ -1,324 +1,313 @@
 /*
  *  Copyright 2013 Marco Martin <mart@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "desktopview.h"
 #include "containmentconfigview.h"
 #include "shellcorona.h"
 #include "shellmanager.h"
 #include "krunner_interface.h"
 
 #include <QQmlEngine>
 #include <QQmlContext>
 #include <QScreen>
 #include <qopenglshaderprogram.h>
 
 #include <kwindowsystem.h>
 #include <klocalizedstring.h>
 #include <KAuthorized>
 
 #include <KPackage/Package>
 
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 
 DesktopView::DesktopView(Plasma::Corona *corona, QScreen *targetScreen)
     : PlasmaQuick::ContainmentView(corona, 0),
       m_windowType(Desktop),
       m_shellSurface(nullptr)
 {
     if (targetScreen) {
         setScreenToFollow(targetScreen);
         setScreen(targetScreen);
         setGeometry(targetScreen->geometry());
     }
 
     setFlags(Qt::Window | Qt::FramelessWindowHint);
     setTitle(corona->kPackage().metadata().name());
     setIcon(QIcon::fromTheme(corona->kPackage().metadata().iconName()));
     rootContext()->setContextProperty(QStringLiteral("desktop"), this);
     setSource(QUrl::fromLocalFile(corona->kPackage().filePath("views", QStringLiteral("Desktop.qml"))));
 
     connect(this, &QWindow::screenChanged, this, &DesktopView::adaptToScreen);
 
     QObject::connect(corona, &Plasma::Corona::kPackageChanged,
                      this, &DesktopView::coronaPackageChanged);
 
     connect(this, &DesktopView::sceneGraphInitialized, this,
         [this, corona]() {
             // check whether the GL Context supports OpenGL
             // Note: hasOpenGLShaderPrograms is broken, see QTBUG--39730
             if (!QOpenGLShaderProgram::hasOpenGLShaderPrograms(openglContext())) {
                 qWarning() << "GLSL not available, Plasma won't be functional";
                 QMetaObject::invokeMethod(corona, "showOpenGLNotCompatibleWarning", Qt::QueuedConnection);
             }
         }, Qt::DirectConnection);
 }
 
 DesktopView::~DesktopView()
 {
 }
 
 void DesktopView::showEvent(QShowEvent* e)
 {
     QQuickWindow::showEvent(e);
     adaptToScreen();
 }
 
 void DesktopView::setScreenToFollow(QScreen *screen)
 {
     if (screen == m_screenToFollow) {
         return;
     }
 
-    m_screenName = screen->name();
     m_screenToFollow = screen;
     setScreen(screen);
     adaptToScreen();
 }
 
 QScreen *DesktopView::screenToFollow() const
 {
     return m_screenToFollow;
 }
 
 void DesktopView::adaptToScreen()
 {
     ensureWindowType();
 
     //This happens sometimes, when shutting down the process
     if (!m_screenToFollow || m_oldScreen==m_screenToFollow) {
         return;
     }
 
     if(m_oldScreen) {
         disconnect(m_oldScreen.data(), &QScreen::geometryChanged,
                     this, &DesktopView::screenGeometryChanged);
     }
 //     qDebug() << "adapting to screen" << m_screenToFollow->name() << this;
     if(m_oldScreen) {
         disconnect(m_oldScreen.data(), &QScreen::geometryChanged,
                     this, &DesktopView::screenGeometryChanged);
     }
 
     if ((m_windowType == Desktop || m_windowType == WindowedDesktop) && !ShellManager::s_forceWindowed) {
         screenGeometryChanged();
 
         connect(m_screenToFollow.data(), &QScreen::geometryChanged,
                 this, &DesktopView::screenGeometryChanged, Qt::UniqueConnection);
     }
 
     m_oldScreen = m_screenToFollow;
 }
 
 DesktopView::WindowType DesktopView::windowType() const
 {
     return m_windowType;
 }
 
 void DesktopView::setWindowType(DesktopView::WindowType type)
 {
     if (m_windowType == type) {
         return;
     }
 
     m_windowType = type;
 
     adaptToScreen();
 
     emit windowTypeChanged();
 }
 
 void DesktopView::ensureWindowType()
 {
     //This happens sometimes, when shutting down the process
     if (!screen()) {
         return;
     }
 
     if (m_windowType == Window || ShellManager::s_forceWindowed) {
         setFlags(Qt::Window);
         KWindowSystem::setType(winId(), NET::Normal);
         KWindowSystem::clearState(winId(), NET::FullScreen);
         if (m_shellSurface) {
             m_shellSurface->setRole(KWayland::Client::PlasmaShellSurface::Role::Normal);
             m_shellSurface->setSkipTaskbar(false);
         }
 
     } else if (m_windowType == Desktop) {
         setFlags(Qt::Window | Qt::FramelessWindowHint);
         KWindowSystem::setType(winId(), NET::Desktop);
         KWindowSystem::setState(winId(), NET::KeepBelow);
         if (m_shellSurface) {
             m_shellSurface->setRole(KWayland::Client::PlasmaShellSurface::Role::Desktop);
             m_shellSurface->setSkipTaskbar(true);
         }
 
     } else if (m_windowType == WindowedDesktop) {
         KWindowSystem::setType(winId(), NET::Normal);
         KWindowSystem::clearState(winId(), NET::FullScreen);
         setFlags(Qt::FramelessWindowHint | flags());
         if (m_shellSurface) {
             m_shellSurface->setRole(KWayland::Client::PlasmaShellSurface::Role::Normal);
             m_shellSurface->setSkipTaskbar(false);
         }
 
     } else if (m_windowType == FullScreen) {
         setFlags(Qt::Window);
         KWindowSystem::setType(winId(), NET::Normal);
         KWindowSystem::setState(winId(), NET::FullScreen);
         if (m_shellSurface) {
             m_shellSurface->setRole(KWayland::Client::PlasmaShellSurface::Role::Normal);
             m_shellSurface->setSkipTaskbar(false);
         }
     }
 }
 
 DesktopView::SessionType DesktopView::sessionType() const
 {
     if (qobject_cast<ShellCorona *>(corona())) {
         return ShellSession;
     } else {
         return ApplicationSession;
     }
 }
 
 bool DesktopView::event(QEvent *e)
 {
-    //NOTE: we need this heuristic for the case when there is an
-    //internal laptop screen that gets disabled upon connection of an external one. the only QCreen * pointer gets recycled and there is no dedicated signal to discover this at all
-    //after being moved, the view will get an expose event, so we can check there if the screen has been renamed
-    //see https://bugs.kde.org/show_bug.cgi?id=373880
-    //https://bugreports.qt.io/browse/QTBUG-57785
-    if (e->type() == QEvent::Expose) {
-        if (m_screenToFollow && m_screenToFollow->name() != m_screenName) {
-            m_screenName = m_screenToFollow->name();
-            emit screenRenamed();
-        }
-    } else if (e->type() == QEvent::KeyRelease) {
+    if (e->type() == QEvent::KeyRelease) {
         QKeyEvent *ke = static_cast<QKeyEvent *>(e);
         if (KWindowSystem::showingDesktop() && ke->key() == Qt::Key_Escape) {
             ShellCorona *c = qobject_cast<ShellCorona *>(corona());
             if (c) {
                 KWindowSystem::setShowingDesktop(false);
             }
         }
     } else if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent*>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
                 setupWaylandIntegration();
                 ensureWindowType();
                 break;
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 delete m_shellSurface;
                 m_shellSurface = nullptr;
                 break;
             }
         }
     }
 
     return PlasmaQuick::ContainmentView::event(e);
 }
 
 void DesktopView::keyPressEvent(QKeyEvent *e)
 {
     ContainmentView::keyPressEvent(e);
 
     // When a key is pressed on desktop when nothing else is active forward the key to krunner
     if ((!e->modifiers() || e->modifiers() == Qt::ShiftModifier) && !e->isAccepted()) {
         const QString text = e->text().trimmed();
         if (!text.isEmpty() && text[0].isPrint()) {
             const QString interface(QStringLiteral("org.kde.krunner"));
             if (!KAuthorized::authorize(QStringLiteral("run_command"))) {
                 return;
             }
             org::kde::krunner::App krunner(interface, QStringLiteral("/App"), QDBusConnection::sessionBus());
             krunner.query(text);
             e->accept();
         }
     }
 }
 
 
 void DesktopView::showConfigurationInterface(Plasma::Applet *applet)
 {
     if (m_configView) {
         if (m_configView->applet() != applet) {
             m_configView->hide();
             m_configView->deleteLater();
         } else {
             m_configView->requestActivate();
             return;
         }
     }
 
     if (!applet || !applet->containment()) {
         return;
     }
 
     Plasma::Containment *cont = qobject_cast<Plasma::Containment *>(applet);
 
     if (cont && cont->isContainment()) {
         m_configView = new ContainmentConfigView(cont);
     } else {
         m_configView = new PlasmaQuick::ConfigView(applet);
     }
     m_configView.data()->init();
     m_configView.data()->setTransientParent(this);
     m_configView.data()->show();
 }
 
 void DesktopView::screenGeometryChanged()
 {
     const QRect geo = m_screenToFollow->geometry();
 //     qDebug() << "newGeometry" << this << geo << geometry();
     setGeometry(geo);
     setMinimumSize(geo.size());
     setMaximumSize(geo.size());
     if (m_shellSurface) {
         m_shellSurface->setPosition(geo.topLeft());
     }
 }
 
 
 void DesktopView::coronaPackageChanged(const KPackage::Package &package)
 {
     setContainment(0);
     setSource(QUrl::fromLocalFile(package.filePath("views", QStringLiteral("Desktop.qml"))));
 }
 
 void DesktopView::setupWaylandIntegration()
 {
     if (m_shellSurface) {
         // already setup
         return;
     }
     if (ShellCorona *c = qobject_cast<ShellCorona*>(corona())) {
         using namespace KWayland::Client;
         PlasmaShell *interface = c->waylandPlasmaShellInterface();
         if (!interface) {
             return;
         }
         Surface *s = Surface::fromWindow(this);
         if (!s) {
             return;
         }
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setPosition(m_screenToFollow->geometry().topLeft());
     }
 }
diff --git a/shell/desktopview.h b/shell/desktopview.h
index 98dd47c6..d0696df6 100644
--- a/shell/desktopview.h
+++ b/shell/desktopview.h
@@ -1,106 +1,104 @@
 /*
  *  Copyright 2013 Marco Martin <mart@kde.org>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
  *  the Free Software Foundation; either version 2 of the License, or
  *  (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful,
  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *  GNU General Public License for more details.
  *
  *  You should have received a copy of the GNU General Public License
  *  along with this program; if not, write to the Free Software
  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #ifndef DESKTOVIEW_H
 #define DESKTOVIEW_H
 
 
 #include "plasmaquick/containmentview.h"
 #include "panelconfigview.h"
 #include <QtCore/qpointer.h>
 
 namespace KWayland
 {
     namespace Client
     {
         class PlasmaShellSurface;
     }
 }
 
 class DesktopView : public PlasmaQuick::ContainmentView
 {
     Q_OBJECT
 
     Q_PROPERTY(WindowType windowType READ windowType WRITE setWindowType NOTIFY windowTypeChanged)
 
     //What kind of plasma session we're in: are we in a full workspace, an application?...
     Q_PROPERTY(SessionType sessionType READ sessionType CONSTANT)
 public:
     enum WindowType {
         Window, /** The window is a normal resizable window with titlebar and appears in the taskbar */
         FullScreen, /** The window is fullscreen and goes over all the other windows */
         Desktop, /** The window is the desktop layer, under everything else, doesn't appear in the taskbar */
         WindowedDesktop /** full screen and borderless as Desktop, but can be brought in front and appears in the taskbar */
     };
     Q_ENUM(WindowType)
 
     enum SessionType {
         ApplicationSession, /** our session is a normal application */
         ShellSession /** We are running as the primary user interface of this machine */
     };
     Q_ENUM(SessionType)
 
     explicit DesktopView(Plasma::Corona *corona, QScreen *targetScreen = 0);
     ~DesktopView() override;
 
     /*This is different from screen() as is always there, even if the window is
       temporarly outside the screen or if is hidden: only plasmashell will ever
       change this property, unlike QWindow::screen()*/
     void setScreenToFollow(QScreen *screen);
     QScreen *screenToFollow() const;
 
     void adaptToScreen();
     void showEvent(QShowEvent*) override;
 
     WindowType windowType() const;
     void setWindowType(WindowType type);
 
     SessionType sessionType() const;
 
 protected:
     bool event(QEvent *e) override;
     void keyPressEvent(QKeyEvent *e) override;
 
 protected Q_SLOTS:
     /**
      * It will be called when the configuration is requested
      */
     void showConfigurationInterface(Plasma::Applet *applet) override;
 
 private Q_SLOTS:
     void screenGeometryChanged();
 
 Q_SIGNALS:
     void stayBehindChanged();
     void windowTypeChanged();
-    void screenRenamed();
 
 private:
     void coronaPackageChanged(const KPackage::Package &package);
     void ensureWindowType();
     void setupWaylandIntegration();
 
-    QString m_screenName;
     QPointer<PlasmaQuick::ConfigView> m_configView;
     QPointer<QScreen> m_oldScreen;
     QPointer<QScreen> m_screenToFollow;
     WindowType m_windowType;
     KWayland::Client::PlasmaShellSurface *m_shellSurface;
 };
 
 #endif // DESKTOVIEW_H
diff --git a/shell/screenpool.cpp b/shell/screenpool.cpp
index b60cca12..97daff38 100644
--- a/shell/screenpool.cpp
+++ b/shell/screenpool.cpp
@@ -1,163 +1,206 @@
 /*
  *  Copyright 2016 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "screenpool.h"
+#include <config-plasma.h>
 
 #include <QGuiApplication>
 #include <QScreen>
 
+#if HAVE_X11
+#include <QtX11Extras/QX11Info>
+#include <xcb/xcb.h>
+#include <xcb/randr.h>
+#include <xcb/xcb_event.h>
+#endif
+
 ScreenPool::ScreenPool(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_configGroup(KConfigGroup(config, QStringLiteral("ScreenConnectors")))
 {
+    qApp->installNativeEventFilter(this);
+
     m_configSaveTimer.setSingleShot(true);
     connect(&m_configSaveTimer, &QTimer::timeout, this, [this](){
         m_configGroup.sync();
     });
 }
 
 void ScreenPool::load()
 {
     m_primaryConnector = QString();
     m_connectorForId.clear();
     m_idForConnector.clear();
 
     QScreen *primary = qGuiApp->primaryScreen();
     if (primary) {
         m_primaryConnector = primary->name();
         if (!m_primaryConnector.isEmpty()) {
             m_connectorForId[0] = m_primaryConnector;
             m_idForConnector[m_primaryConnector] = 0;
         }
     }
 
     //restore the known ids to connector mappings
     foreach (const QString &key, m_configGroup.keyList()) {
         QString connector = m_configGroup.readEntry(key, QString());
         if (!key.isEmpty() && !connector.isEmpty() &&
             !m_connectorForId.contains(key.toInt()) &&
             !m_idForConnector.contains(connector)) {
             m_connectorForId[key.toInt()] = connector;
             m_idForConnector[connector] = key.toInt();
         } else if (m_idForConnector.value(connector) != key.toInt()) {
             m_configGroup.deleteEntry(key);
         }
     }
 
     // if there are already connected unknown screens, map those
     // all needs to be populated as soon as possible, otherwise
     // containment->screen() will return an incorrect -1
     // at startup, if it' asked before corona::addOutput()
     // is performed, driving to the creation of a new containment
     for (QScreen* screen : qGuiApp->screens()) {
         if (!m_idForConnector.contains(screen->name())) {
             insertScreenMapping(firstAvailableId(), screen->name());
         }
     }
 }
 
 ScreenPool::~ScreenPool()
 {
     m_configGroup.sync();
 }
 
 QString ScreenPool::primaryConnector() const
 {
     return m_primaryConnector;
 }
 
 void ScreenPool::setPrimaryConnector(const QString &primary)
 {
     if (m_primaryConnector == primary) {
         return;
     }
     Q_ASSERT(m_idForConnector.contains(primary));
 
     int oldIdForPrimary = m_idForConnector.value(primary);
 
     m_idForConnector[primary] = 0;
     m_connectorForId[0] = primary;
     m_idForConnector[m_primaryConnector] = oldIdForPrimary;
     m_connectorForId[oldIdForPrimary] = m_primaryConnector;
     m_primaryConnector = primary;
     save();
 }
 
 void ScreenPool::save()
 {
     QMap<int, QString>::const_iterator i;
     for (i = m_connectorForId.constBegin(); i != m_connectorForId.constEnd(); ++i) {
         m_configGroup.writeEntry(QString::number(i.key()), i.value());
     }
     //write to disck every 30 seconds at most
     m_configSaveTimer.start(30000);
 }
 
 void ScreenPool::insertScreenMapping(int id, const QString &connector)
 {
     Q_ASSERT(!m_connectorForId.contains(id) || m_connectorForId.value(id) == connector);
     Q_ASSERT(!m_idForConnector.contains(connector) || m_idForConnector.value(connector) == id);
 
     if (id == 0) {
         m_primaryConnector = connector;
     }
 
     m_connectorForId[id] = connector;
     m_idForConnector[connector] = id;
     save();
 }
 
 int ScreenPool::id(const QString &connector) const
 {
     if (!m_idForConnector.contains(connector)) {
         return -1;
     }
 
     return m_idForConnector.value(connector);
 }
 
 QString ScreenPool::connector(int id) const
 {
     Q_ASSERT(m_connectorForId.contains(id));
 
     return m_connectorForId.value(id);
 }
 
 int ScreenPool::firstAvailableId() const
 {
     int i = 0;
     //find the first integer not stored in m_connectorForId
     //m_connectorForId is the only map, so the ids are sorted
     foreach (int existingId, m_connectorForId.keys()) {
         if (i != existingId) {
             return i;
         }
         ++i;
     }
 
     return i;
 }
 
 QList <int> ScreenPool::knownIds() const
 {
     return m_connectorForId.keys();
 }
 
+bool ScreenPool::nativeEventFilter(const QByteArray& eventType, void* message, long int* result)
+{
+    Q_UNUSED(result);
+#if HAVE_X11
+    // a particular edge case: when we switch the only enabled screen
+    // we don't have any signal about it, the primary screen changes but we have the same old QScreen* getting recycled
+    // see https://bugs.kde.org/show_bug.cgi?id=373880
+    // if this slot will be invoked many times, their//second time on will do nothing as name and primaryconnector will be the same by then
+    if (eventType != "xcb_generic_event_t") {
+        return false;
+    }
+    
+    xcb_generic_event_t *ev = static_cast<xcb_generic_event_t *>(message);
+
+    const auto responseType = XCB_EVENT_RESPONSE_TYPE(ev);
+
+    const xcb_query_extension_reply_t* reply = xcb_get_extension_data(QX11Info::connection(), &xcb_randr_id);
+
+    if (responseType == reply->first_event + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
+        if (qGuiApp->primaryScreen()->name() != primaryConnector()) {
+            //new screen?
+            if (id(qGuiApp->primaryScreen()->name()) < 0) {
+                insertScreenMapping(firstAvailableId(), qGuiApp->primaryScreen()->name());
+            }
+            //switch the primary screen in the pool
+            setPrimaryConnector(qGuiApp->primaryScreen()->name());
+        }
+    }
+#endif
+    return false;
+}
+
+
 #include "moc_screenpool.cpp"
 
diff --git a/shell/screenpool.h b/shell/screenpool.h
index 9b3a9af4..9baa90b4 100644
--- a/shell/screenpool.h
+++ b/shell/screenpool.h
@@ -1,65 +1,70 @@
 /*
  *  Copyright 2016 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #ifndef SCREENPOOL_H
 #define SCREENPOOL_H
 
 #include <QObject>
 #include <QHash>
 #include <QString>
 #include <QTimer>
+#include <QAbstractNativeEventFilter>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 
-class ScreenPool : public QObject {
+class ScreenPool : public QObject, public QAbstractNativeEventFilter
+{
     Q_OBJECT
 
 public:
     ScreenPool(KSharedConfig::Ptr config, QObject *parent = nullptr);
     void load();
     ~ScreenPool() override;
 
     QString primaryConnector() const;
     void setPrimaryConnector(const QString &primary);
 
     void insertScreenMapping(int id, const QString &connector);
 
     int id(const QString &connector) const;
 
     QString connector(int id) const;
 
     int firstAvailableId() const;
 
     //all ids that are known, included screens not enabled at the moment
     QList <int> knownIds() const;
 
+protected:
+    bool nativeEventFilter(const QByteArray & eventType, void * message, long * result) Q_DECL_OVERRIDE;
+
 private:
     void save();
 
     KConfigGroup m_configGroup;
     QString m_primaryConnector;
     //order is important
     QMap<int, QString> m_connectorForId;
     QHash<QString, int> m_idForConnector;
 
     QTimer m_configSaveTimer;
 };
 
 #endif // SCREENPOOL_H
diff --git a/shell/shellcorona.cpp b/shell/shellcorona.cpp
index 133a7502..a51ada76 100644
--- a/shell/shellcorona.cpp
+++ b/shell/shellcorona.cpp
@@ -1,2093 +1,2080 @@
 /*
  *   Copyright 2008 Aaron Seigo <aseigo@kde.org>
  *   Copyright 2013 Sebastian Kügler <sebas@kde.org>
  *   Copyright 2013 Ivan Cukic <ivan.cukic@kde.org>
  *   Copyright 2013 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "shellcorona.h"
 
 #include <config-plasma.h>
 
 #include <QApplication>
 #include <QDebug>
 #include <QMenu>
 #include <QQmlContext>
 #include <QDBusConnection>
 #include <QUrl>
 
 #include <QJsonObject>
 #include <QJsonDocument>
 
 #include <kactioncollection.h>
 #include <klocalizedstring.h>
 #include <Plasma/Package>
 #include <Plasma/PluginLoader>
 #include <kactivities/controller.h>
 #include <kactivities/consumer.h>
 #include <ksycoca.h>
 #include <KGlobalAccel>
 #include <KAuthorized>
 #include <KWindowSystem>
 #include <kdeclarative/kdeclarative.h>
 #include <kdeclarative/qmlobject.h>
 #include <KMessageBox>
 #include <kdirwatch.h>
 
 #include <KPackage/PackageLoader>
 
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 
 #include "config-ktexteditor.h" // HAVE_KTEXTEDITOR
 
 #include "alternativeshelper.h"
 #include "desktopview.h"
 #include "panelview.h"
 #include "scripting/scriptengine.h"
 #include "plasmaquick/configview.h"
 #include "shellmanager.h"
 #include "osd.h"
 #include "screenpool.h"
 
 #include "plasmashelladaptor.h"
 #include "debug.h"
 #include "futureutil.h"
 
 #ifndef NDEBUG
     #define CHECK_SCREEN_INVARIANTS screenInvariants();
 #else
     #define CHECK_SCREEN_INVARIANTS
 #endif
 
 #if HAVE_X11
 #include <NETWM>
 #include <QtX11Extras/QX11Info>
+#include <xcb/xcb.h>
 #endif
 
 
 static const int s_configSyncDelay = 10000; // 10 seconds
 
 ShellCorona::ShellCorona(QObject *parent)
     : Plasma::Corona(parent),
       m_screenPool(new ScreenPool(KSharedConfig::openConfig(), this)),
       m_activityController(new KActivities::Controller(this)),
       m_addPanelAction(nullptr),
       m_addPanelsMenu(nullptr),
       m_interactiveConsole(nullptr),
       m_waylandPlasmaShell(nullptr)
 {
     setupWaylandIntegration();
     qmlRegisterUncreatableType<DesktopView>("org.kde.plasma.shell", 2, 0, "Desktop", QStringLiteral("It is not possible to create objects of type Desktop"));
     qmlRegisterUncreatableType<PanelView>("org.kde.plasma.shell", 2, 0, "Panel", QStringLiteral("It is not possible to create objects of type Panel"));
 
     m_lookAndFeelPackage = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LookAndFeel"));
     KConfigGroup cg(KSharedConfig::openConfig(QStringLiteral("kdeglobals")), "KDE");
     const QString packageName = cg.readEntry("LookAndFeelPackage", QString());
     if (!packageName.isEmpty()) {
         m_lookAndFeelPackage.setPath(packageName);
     }
 
     connect(this, &Plasma::Corona::containmentCreated, this, [this] (Plasma::Containment *c) {
         executeSetupPlasmoidScript(c, c);
     });
 
     connect(this, &Plasma::Corona::availableScreenRectChanged, this, &Plasma::Corona::availableScreenRegionChanged);
 
     m_appConfigSyncTimer.setSingleShot(true);
     m_appConfigSyncTimer.setInterval(s_configSyncDelay);
     connect(&m_appConfigSyncTimer, &QTimer::timeout, this, &ShellCorona::syncAppConfig);
     //we want our application config with screen mapping to always be in sync with the applets one, so a crash at any time will still
     //leave containments pointing to the correct screens
     connect(this, &Corona::configSynced, this, &ShellCorona::syncAppConfig);
 
     m_waitingPanelsTimer.setSingleShot(true);
     m_waitingPanelsTimer.setInterval(250);
     connect(&m_waitingPanelsTimer, &QTimer::timeout, this, &ShellCorona::createWaitingPanels);
 
     m_reconsiderOutputsTimer.setSingleShot(true);
     m_reconsiderOutputsTimer.setInterval(1000);
     connect(&m_reconsiderOutputsTimer, &QTimer::timeout, this, &ShellCorona::reconsiderOutputs);
 
     m_desktopDefaultsConfig = KConfigGroup(KSharedConfig::openConfig(package().filePath("defaults")), "Desktop");
     m_lnfDefaultsConfig = KConfigGroup(KSharedConfig::openConfig(m_lookAndFeelPackage.filePath("defaults")), "Desktop");
     m_lnfDefaultsConfig = KConfigGroup(&m_lnfDefaultsConfig, QStringLiteral("org.kde.plasma.desktop"));
 
     new PlasmaShellAdaptor(this);
 
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/PlasmaShell"), this);
 
     connect(this, &Plasma::Corona::startupCompleted, this,
             []() {
                 qDebug() << "Plasma Shell startup completed";
                 QDBusMessage ksplashProgressMessage = QDBusMessage::createMethodCall(QStringLiteral("org.kde.KSplash"),
                                                QStringLiteral("/KSplash"),
                                                QStringLiteral("org.kde.KSplash"),
                                                QStringLiteral("setStage"));
                 ksplashProgressMessage.setArguments(QList<QVariant>() << QStringLiteral("desktop"));
                 QDBusConnection::sessionBus().asyncCall(ksplashProgressMessage);
                 //TODO: remove
             });
 
     // Look for theme config in plasmarc, if it isn't configured, take the theme from the
     // LookAndFeel package, if either is set, change the default theme
 
     connect(qApp, &QCoreApplication::aboutToQuit, this, [this]() {
         //saveLayout is a slot but arguments not compatible
         saveLayout();
     });
 
     connect(this, &ShellCorona::containmentAdded,
             this, &ShellCorona::handleContainmentAdded);
 
     QAction *dashboardAction = actions()->addAction(QStringLiteral("show dashboard"));
     QObject::connect(dashboardAction, &QAction::triggered,
                      this, &ShellCorona::setDashboardShown);
     dashboardAction->setText(i18n("Show Desktop"));
     connect(KWindowSystem::self(), &KWindowSystem::showingDesktopChanged, [dashboardAction](bool showing) {
         dashboardAction->setText(showing ? i18n("Hide Desktop") : i18n("Show Desktop"));
         dashboardAction->setChecked(showing);
     });
 
     dashboardAction->setAutoRepeat(true);
     dashboardAction->setCheckable(true);
     dashboardAction->setIcon(QIcon::fromTheme(QStringLiteral("dashboard-show")));
     dashboardAction->setData(Plasma::Types::ControlAction);
     KGlobalAccel::self()->setGlobalShortcut(dashboardAction, Qt::CTRL + Qt::Key_F12);
 
     checkAddPanelAction();
     connect(KSycoca::self(), SIGNAL(databaseChanged(QStringList)), this, SLOT(checkAddPanelAction(QStringList)));
 
 
     //Activity stuff
     QAction *activityAction = actions()->addAction(QStringLiteral("manage activities"));
     connect(activityAction, &QAction::triggered,
             this, &ShellCorona::toggleActivityManager);
     activityAction->setText(i18n("Activities..."));
     activityAction->setIcon(QIcon::fromTheme(QStringLiteral("preferences-activities")));
     activityAction->setData(Plasma::Types::ConfigureAction);
     activityAction->setShortcut(QKeySequence(QStringLiteral("alt+d, alt+a")));
     activityAction->setShortcutContext(Qt::ApplicationShortcut);
 
     KGlobalAccel::self()->setGlobalShortcut(activityAction, Qt::META + Qt::Key_Q);
 
     QAction *stopActivityAction = actions()->addAction(QStringLiteral("stop current activity"));
     QObject::connect(stopActivityAction, &QAction::triggered,
                      this, &ShellCorona::stopCurrentActivity);
 
     stopActivityAction->setText(i18n("Stop Current Activity"));
     stopActivityAction->setData(Plasma::Types::ControlAction);
     stopActivityAction->setVisible(false);
 
 
     KGlobalAccel::self()->setGlobalShortcut(stopActivityAction, Qt::META + Qt::Key_S);
 
     connect(m_activityController, &KActivities::Controller::currentActivityChanged, this, &ShellCorona::currentActivityChanged);
     connect(m_activityController, &KActivities::Controller::activityAdded, this, &ShellCorona::activityAdded);
     connect(m_activityController, &KActivities::Controller::activityRemoved, this, &ShellCorona::activityRemoved);
 
     KActionCollection *taskbarActions = new KActionCollection(this);
     for (int i = 0; i < 10; ++i) {
         const int entryNumber = i + 1;
         const Qt::Key key = static_cast<Qt::Key>(Qt::Key_0 + (entryNumber % 10));
 
         QAction *action = taskbarActions->addAction(QStringLiteral("activate task manager entry %1").arg(QString::number(entryNumber)));
         action->setText(i18n("Activate Task Manager Entry %1", entryNumber));
         KGlobalAccel::setGlobalShortcut(action, QKeySequence(Qt::META + key));
         connect(action, &QAction::triggered, this, [this, i] {
             activateTaskManagerEntry(i);
         });
     }
 
     new Osd(this);
 }
 
 ShellCorona::~ShellCorona()
 {
     while (!containments().isEmpty()) {
         //deleting a containment will remove it from the list due to QObject::destroyed connect in Corona
         delete containments().first();
     }
     qDeleteAll(m_panelViews);
     m_panelViews.clear();
 }
 
 KPackage::Package ShellCorona::lookAndFeelPackage()
 {
     return m_lookAndFeelPackage;
 }
 
 void ShellCorona::setShell(const QString &shell)
 {
     if (m_shell == shell) {
         return;
     }
 
     m_shell = shell;
     KPackage::Package package = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Shell"));
     package.setPath(shell);
     package.setAllowExternalPaths(true);
     setKPackage(package);
     m_desktopDefaultsConfig = KConfigGroup(KSharedConfig::openConfig(package.filePath("defaults")), "Desktop");
     m_lnfDefaultsConfig = KConfigGroup(KSharedConfig::openConfig(m_lookAndFeelPackage.filePath("defaults")), "Desktop");
     m_lnfDefaultsConfig = KConfigGroup(&m_lnfDefaultsConfig, shell);
 
     const QString themeGroupKey = QStringLiteral("Theme");
     const QString themeNameKey = QStringLiteral("name");
 
     QString themeName;
 
     KConfigGroup plasmarc(KSharedConfig::openConfig(QStringLiteral("plasmarc")), themeGroupKey);
     themeName = plasmarc.readEntry(themeNameKey, themeName);
 
     if (themeName.isEmpty()) {
         KConfigGroup shellCfg = KConfigGroup(KSharedConfig::openConfig(package.filePath("defaults")), "Theme");
 
         themeName = shellCfg.readEntry("name", "default");
         KConfigGroup lnfCfg = KConfigGroup(KSharedConfig::openConfig(
                                                 m_lookAndFeelPackage.filePath("defaults")),
                                                 "plasmarc"
                                            );
         lnfCfg = KConfigGroup(&lnfCfg, themeGroupKey);
         themeName = lnfCfg.readEntry(themeNameKey, themeName);
     }
 
     if (!themeName.isEmpty()) {
         Plasma::Theme *t = new Plasma::Theme(this);
         t->setThemeName(themeName);
     }
 
     //FIXME: this would change the runtime platform to a fixed one if available
     // but a different way to load platform specific components is needed beforehand
     // because if we import and use two different components plugin, the second time
     // the import is called it will fail
    /* KConfigGroup cg(KSharedConfig::openConfig(package.filePath("defaults")), "General");
     KDeclarative::KDeclarative::setRuntimePlatform(cg.readEntry("DefaultRuntimePlatform", QStringList()));*/
 
     unload();
 
 
     /*
      * we want to make an initial load once we have the initial screen config and we have loaded the activities _IF_ KAMD is running
      * it is valid for KAMD to not be running.
      *
      * Potentially 2 async jobs
      *
      * here we connect for status changes from KAMD, and fetch the first config from kscreen.
      * load() will check that we have a kscreen config, and m_activityController->serviceStatus() is not loading (i.e not unknown)
      *
      * It might seem that we only need this connection if the activityConsumer is currently in state Unknown, however
      * there is an issue where m_activityController will start the kactivitymanagerd, as KAMD is starting the serviceStatus will be "not running"
      * Whilst we are loading the kscreen config, the event loop runs and we might find KAMD has started.
      * m_activityController will change from "not running" to unknown, and might still be unknown when the kscreen fetching is complete.
      *
      * if that happens we want to continue monitoring for state changes, and only finally load when it is up.
      *
      * See https://bugs.kde.org/show_bug.cgi?id=342431 be careful about changing
      *
      * The unique connection makes sure we don't reload plasma if KAMD ever crashes and reloads, the signal is disconnected in the body of load
      */
 
     connect(m_activityController, &KActivities::Controller::serviceStatusChanged, this, &ShellCorona::load, Qt::UniqueConnection);
 
     if (m_activityController->serviceStatus() == KActivities::Controller::Running) {
         load();
     }
 }
 
 
 QJsonObject dumpconfigGroupJS(const KConfigGroup &rootGroup)
 {
     QJsonObject result;
 
     QStringList hierarchy;
     QStringList escapedHierarchy;
     QList<KConfigGroup> groups{rootGroup};
     QSet<QString> visitedNodes;
 
     const QSet<QString> forbiddenKeys {
             QStringLiteral("activityId"),
             QStringLiteral("ItemsGeometries"),
             QStringLiteral("AppletOrder"),
             QStringLiteral("SystrayContainmentId"),
             QStringLiteral("location"),
             QStringLiteral("plugin")
         };
 
     auto groupID = [&escapedHierarchy]() {
         return '/' + escapedHierarchy.join('/');
     };
 
     // Perform a depth-first tree traversal for config groups
     while (!groups.isEmpty()) {
         KConfigGroup cg = groups.last();
 
         KConfigGroup parentCg = cg;
         //FIXME: name is not enough
 
         hierarchy.clear();
         escapedHierarchy.clear();
         while (parentCg.isValid() && parentCg.name() != rootGroup.name()) {
             const auto name = parentCg.name();
             hierarchy.prepend(name);
             escapedHierarchy.prepend(QString::fromUtf8(QUrl::toPercentEncoding(name.toUtf8())));
             parentCg = parentCg.parent();
         }
 
         visitedNodes.insert(groupID());
         groups.pop_back();
 
         QJsonObject configGroupJson;
 
         if (!cg.keyList().isEmpty()) {
             //TODO: this is conditional if applet or containment
 
             const auto map = cg.entryMap();
             auto i = map.cbegin();
             for (; i != map.cend(); ++i) {
                 //some blacklisted keys we don't want to save
                 if (!forbiddenKeys.contains(i.key())) {
                     configGroupJson.insert(i.key(), i.value());
                 }
             }
         }
 
         foreach (const QString &groupName, cg.groupList()) {
             if (groupName == QStringLiteral("Applets") ||
                 visitedNodes.contains(groupID() + '/' + groupName)) {
                 continue;
             }
             groups << KConfigGroup(&cg, groupName);
         }
 
         if (!configGroupJson.isEmpty()) {
             result.insert(groupID(), configGroupJson);
         }
     }
 
     return result;
 }
 
 QByteArray ShellCorona::dumpCurrentLayoutJS() const
 {
     QJsonObject root;
     root.insert("serializationFormatVersion", "1");
 
     //same gridUnit calculation as ScriptEngine
     int gridUnit = QFontMetrics(QGuiApplication::font()).boundingRect(QStringLiteral("M")).height();
     if (gridUnit % 2 != 0) {
         gridUnit++;
     }
 
     auto isPanel = [] (Plasma::Containment *cont) {
         return
             (cont->formFactor() == Plasma::Types::Horizontal
                 || cont->formFactor() == Plasma::Types::Vertical) &&
             (cont->location() == Plasma::Types::TopEdge
                 || cont->location() == Plasma::Types::BottomEdge
                 || cont->location() == Plasma::Types::LeftEdge
                 || cont->location() == Plasma::Types::RightEdge) &&
             cont->pluginMetaData().pluginId() != QStringLiteral("org.kde.plasma.private.systemtray");
     };
 
     auto isDesktop = [] (Plasma::Containment *cont) {
         return !cont->activity().isEmpty();
     };
 
     const auto containments = ShellCorona::containments();
 
     // Collecting panels
 
     QJsonArray panelsJsonArray;
 
     foreach (Plasma::Containment *cont, containments) {
         if (!isPanel(cont)) {
             continue;
         }
 
         QJsonObject panelJson;
 
         const PanelView *view = m_panelViews.value(cont);
         const auto location = cont->location();
 
         panelJson.insert("location",
                 location == Plasma::Types::TopEdge   ? "top"
               : location == Plasma::Types::LeftEdge  ? "left"
               : location == Plasma::Types::RightEdge ? "right"
               : /* Plasma::Types::BottomEdge */        "bottom");
 
         const qreal height =
                 // If we do not have a panel, fallback to 4 units
                 !view     ?  4
               : (qreal)view->thickness() / gridUnit;
 
         panelJson.insert("height", height);
         if (view) {
             const auto alignment = view->alignment();
             panelJson.insert("maximumLength", (qreal)view->maximumLength() / gridUnit);
             panelJson.insert("minimumLength", (qreal)view->minimumLength() / gridUnit);
             panelJson.insert("offset", (qreal)view->offset() / gridUnit);
             panelJson.insert("alignment",
                  alignment == Qt::AlignRight  ? "right"
                : alignment == Qt::AlignCenter ? "center"
                : "left");
         }
 
         // Saving the config keys
         const KConfigGroup contConfig = cont->config();
 
         panelJson.insert("config", dumpconfigGroupJS(contConfig));
 
         // Generate the applets array
         QJsonArray appletsJsonArray;
 
         // Try to parse the encoded applets order
         const KConfigGroup genericConf(&contConfig, QStringLiteral("General"));
         const QStringList appletsOrderStrings =
             genericConf.readEntry(QStringLiteral("AppletOrder"), QString())
                 .split(QChar(';'));
 
         // Consider the applet order to be valid only if there are as many entries as applets()
         if (appletsOrderStrings.length() == cont->applets().length()) {
             foreach (const QString &appletId, appletsOrderStrings) {
                 KConfigGroup appletConfig(&contConfig, QStringLiteral("Applets"));
                 appletConfig = KConfigGroup(&appletConfig, appletId);
 
                 const QString pluginName =
                     appletConfig.readEntry(QStringLiteral("plugin"), QString());
 
                 if (pluginName.isEmpty()) {
                     continue;
                 }
 
                 QJsonObject appletJson;
 
                 appletJson.insert("plugin", pluginName);
                 appletJson.insert("config", dumpconfigGroupJS(appletConfig));
 
                 appletsJsonArray << appletJson;
             }
 
         } else {
             foreach (Plasma::Applet *applet, cont->applets()) {
                 QJsonObject appletJson;
 
                 KConfigGroup appletConfig = applet->config();
 
                 appletJson.insert("plugin", applet->pluginMetaData().pluginId());
                 appletJson.insert("config", dumpconfigGroupJS(appletConfig));
 
                 appletsJsonArray << appletJson;
             }
         }
 
         panelJson.insert("applets", appletsJsonArray);
 
         panelsJsonArray << panelJson;
     }
 
     root.insert("panels", panelsJsonArray);
 
     // Now we are collecting desktops
 
     QJsonArray desktopsJson;
 
     const auto currentActivity = m_activityController->currentActivity();
 
     foreach (Plasma::Containment *cont, containments) {
         if (!isDesktop(cont) || cont->activity() != currentActivity) {
             continue;
         }
 
         QJsonObject desktopJson;
 
         desktopJson.insert("wallpaperPlugin", cont->wallpaper());
 
         // Get the config for the containment
         KConfigGroup contConfig = cont->config();
         desktopJson.insert("config", dumpconfigGroupJS(contConfig));
 
         // Try to parse the item geometries
         const KConfigGroup genericConf(&contConfig, QStringLiteral("General"));
         const QStringList appletsGeomStrings =
             genericConf.readEntry(QStringLiteral("ItemsGeometries"), QString())
                 .split(QChar(';'));
 
 
         QHash<QString, QRect> appletGeometries;
         foreach (const QString &encoded, appletsGeomStrings) {
             const QStringList keyValue = encoded.split(QChar(':'));
             if (keyValue.length() != 2) {
                 continue;
             }
 
             const QStringList rectPieces = keyValue.last().split(QChar(','));
             if (rectPieces.length() != 5) {
                 continue;
             }
 
             QRect rect(rectPieces[0].toInt(), rectPieces[1].toInt(),
                        rectPieces[2].toInt(), rectPieces[3].toInt());
 
             appletGeometries[keyValue.first()] = rect;
         }
 
         QJsonArray appletsJsonArray;
 
         foreach (Plasma::Applet *applet, cont->applets()) {
             const QRect geometry = appletGeometries.value(
                 QStringLiteral("Applet-") % QString::number(applet->id()));
 
             QJsonObject appletJson;
 
             appletJson.insert("title",      applet->title());
             appletJson.insert("plugin",     applet->pluginMetaData().pluginId());
 
             appletJson.insert("geometry.x",      geometry.x() / gridUnit);
             appletJson.insert("geometry.y",      geometry.y() / gridUnit);
             appletJson.insert("geometry.width",  geometry.width() / gridUnit);
             appletJson.insert("geometry.height", geometry.height() / gridUnit);
 
             KConfigGroup appletConfig = applet->config();
             appletJson.insert("config", dumpconfigGroupJS(appletConfig));
 
             appletsJsonArray << appletJson;
         }
 
         desktopJson.insert("applets", appletsJsonArray);
         desktopsJson << desktopJson;
     }
 
     root.insert("desktops", desktopsJson);
 
     QJsonDocument json;
     json.setObject(root);
 
     return
         "var plasma = getApiVersion(1);\n\n"
         "var layout = " + json.toJson() + ";\n\n"
         "plasma.loadSerializedLayout(layout);\n";
 }
 
 void ShellCorona::loadLookAndFeelDefaultLayout(const QString &packageName)
 {
     KPackage::Package newPack = m_lookAndFeelPackage;
     newPack.setPath(packageName);
 
     if (!newPack.isValid()) {
         return;
     }
 
     KSharedConfig::Ptr conf = KSharedConfig::openConfig(QStringLiteral("plasma-") + m_shell + QStringLiteral("-appletsrc"), KConfig::SimpleConfig);
 
     m_lookAndFeelPackage.setPath(packageName);
 
     //get rid of old config
     for (const QString &group : conf->groupList()) {
         conf->deleteGroup(group);
     }
     conf->sync();
     unload();
     load();
 }
 
 QString ShellCorona::shell() const
 {
     return m_shell;
 }
 
 void ShellCorona::load()
 {
     if (m_shell.isEmpty() ||
         m_activityController->serviceStatus() != KActivities::Controller::Running) {
         return;
     }
 
     disconnect(m_activityController, &KActivities::Controller::serviceStatusChanged, this, &ShellCorona::load);
 
     m_screenPool->load();
 
     //TODO: a kconf_update script is needed
     QString configFileName(QStringLiteral("plasma-") + m_shell + QStringLiteral("-appletsrc"));
 
     loadLayout(configFileName);
 
     checkActivities();
 
     if (containments().isEmpty()) {
         // Seems like we never really get to this point since loadLayout already
         // (virtually) calls loadDefaultLayout if it does not load anything
         // from the config file. Maybe if the config file is not empty,
         // but still does not have any containments
         loadDefaultLayout();
         processUpdateScripts();
     } else {
         processUpdateScripts();
         foreach(Plasma::Containment *containment, containments()) {
             if (containment->containmentType() == Plasma::Types::PanelContainment || containment->containmentType() == Plasma::Types::CustomPanelContainment) {
                 //Don't give a view to containments that don't want one (negative lastscreen)
                 //(this is pretty mucha special case for the systray)
                 //also, make sure we don't have a view already.
                 //this will be true for first startup as the view has already been created at the new Panel JS call
                 if (!m_waitingPanels.contains(containment) && containment->lastScreen() >= 0 && !m_panelViews.contains(containment)) {
                     m_waitingPanels << containment;
                 }
             //historically CustomContainments are treated as desktops
             } else if (containment->containmentType() == Plasma::Types::DesktopContainment || containment->containmentType() == Plasma::Types::CustomContainment) {
                 //FIXME ideally fix this, or at least document the crap out of it
                 int screen = containment->lastScreen();
                 if (screen < 0) {
                     screen = 0;
                     qWarning() << "last screen is < 0 so putting containment on screen " << screen;
                 }
                 insertContainment(containment->activity(), screen, containment);
             }
         }
     }
 
     //NOTE: this is needed in case loadLayout() did *not* call loadDefaultLayout()
     //it needs to be after of loadLayout() as it would always create new
     //containments on each startup otherwise
     for (QScreen* screen : qGuiApp->screens()) {
         //the containments may have been created already by the startup script
         //check their existence in oder to not have duplicated desktopviews
         if (!m_desktopViewforId.contains(m_screenPool->id(screen->name()))) {
             addOutput(screen);
         }
     }
     connect(qGuiApp, &QGuiApplication::screenAdded, this, &ShellCorona::addOutput, Qt::UniqueConnection);
     connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &ShellCorona::primaryOutputChanged, Qt::UniqueConnection);
     connect(qGuiApp, &QGuiApplication::screenRemoved, this, &ShellCorona::screenRemoved, Qt::UniqueConnection);
 
     if (!m_waitingPanels.isEmpty()) {
         m_waitingPanelsTimer.start();
     }
 
     if (config()->isImmutable() ||
         !KAuthorized::authorize(QStringLiteral("plasma/plasmashell/unlockedDesktop"))) {
         setImmutability(Plasma::Types::SystemImmutable);
     } else {
         KConfigGroup coronaConfig(config(), "General");
         setImmutability((Plasma::Types::ImmutabilityType)coronaConfig.readEntry("immutability", (int)Plasma::Types::Mutable));
     }
 }
 
 void ShellCorona::primaryOutputChanged()
 {
     if (!m_desktopViewforId.contains(0)) {
         return;
     }
 
     QScreen *oldPrimary = m_desktopViewforId.value(0)->screen();
     QScreen *newPrimary = qGuiApp->primaryScreen();
     if (!newPrimary || newPrimary == oldPrimary) {
         return;
     }
 
     qWarning()<<"Old primary output:"<<oldPrimary<<"New primary output:"<<newPrimary;
     const int oldIdOfPrimary = m_screenPool->id(newPrimary->name());
     m_screenPool->setPrimaryConnector(newPrimary->name());
     //swap order in m_desktopViewforId
     if (m_desktopViewforId.contains(0) && m_desktopViewforId.contains(oldIdOfPrimary)) {
         DesktopView *primaryDesktop = m_desktopViewforId.value(0);
         DesktopView *oldDesktopOfPrimary = m_desktopViewforId.value(oldIdOfPrimary);
 
         primaryDesktop->setScreenToFollow(newPrimary);
         oldDesktopOfPrimary->setScreenToFollow(oldPrimary);
         primaryDesktop->show();
         oldDesktopOfPrimary->show();
     }
 
     foreach (PanelView *panel, m_panelViews) {
         if (panel->screen() == oldPrimary) {
             panel->setScreenToFollow(newPrimary);
         } else if (panel->screen() == newPrimary) {
             panel->setScreenToFollow(oldPrimary);
         }
     }
 
     CHECK_SCREEN_INVARIANTS
 }
 
 #ifndef NDEBUG
 void ShellCorona::screenInvariants() const
 {
     Q_ASSERT(m_desktopViewforId.keys().count() <= QGuiApplication::screens().count());
 
     QSet<QScreen*> screens;
     foreach (const int id, m_desktopViewforId.keys()) {
         const DesktopView *view = m_desktopViewforId.value(id);
         QScreen *screen = view->screenToFollow();
         Q_ASSERT(!screens.contains(screen));
         Q_ASSERT(!m_redundantOutputs.contains(screen));
 //         commented out because a different part of the code-base is responsible for this
 //         and sometimes is not yet called here.
 //         Q_ASSERT(!view->fillScreen() || view->geometry() == screen->geometry());
         Q_ASSERT(view->containment());
 
         Q_ASSERT(view->containment()->screen() == id || view->containment()->screen() == -1);
         Q_ASSERT(view->containment()->lastScreen() == id || view->containment()->lastScreen() == -1);
         Q_ASSERT(view->isVisible());
 
         foreach (const PanelView *panel, panelsForScreen(screen)) {
             Q_ASSERT(panel->containment());
             Q_ASSERT(panel->containment()->screen() == id || panel->containment()->screen() == -1);
             Q_ASSERT(panel->isVisible());
         }
 
         screens.insert(screen);
     }
 
     foreach (QScreen* out, m_redundantOutputs) {
         Q_ASSERT(isOutputRedundant(out));
     }
 
     if (m_desktopViewforId.isEmpty()) {
         qWarning() << "no screens!!";
     }
 }
 #endif
 
 void ShellCorona::showAlternativesForApplet(Plasma::Applet *applet)
 {
     const QString alternativesQML = package().filePath("appletalternativesui");
     if (alternativesQML.isEmpty()) {
         return;
     }
 
     KDeclarative::QmlObject *qmlObj = new KDeclarative::QmlObject(this);
     qmlObj->setInitializationDelayed(true);
     qmlObj->setSource(QUrl::fromLocalFile(alternativesQML));
 
     AlternativesHelper *helper = new AlternativesHelper(applet, qmlObj);
     qmlObj->rootContext()->setContextProperty(QStringLiteral("alternativesHelper"), helper);
 
     m_alternativesObjects << qmlObj;
     qmlObj->completeInitialization();
     connect(qmlObj->rootObject(), SIGNAL(visibleChanged(bool)),
             this, SLOT(alternativesVisibilityChanged(bool)));
 
     connect(applet, &Plasma::Applet::destroyedChanged, this, [this, qmlObj] (bool destroyed) {
         if (!destroyed) {
             return;
         }
         QMutableListIterator<KDeclarative::QmlObject *> it(m_alternativesObjects);
         while (it.hasNext()) {
             KDeclarative::QmlObject *obj = it.next();
             if (obj == qmlObj) {
                 it.remove();
                 obj->deleteLater();
             }
         }
     });
 }
 
 void ShellCorona::alternativesVisibilityChanged(bool visible)
 {
     if (visible) {
         return;
     }
 
     QObject *root = sender();
 
     QMutableListIterator<KDeclarative::QmlObject *> it(m_alternativesObjects);
     while (it.hasNext()) {
         KDeclarative::QmlObject *obj = it.next();
         if (obj->rootObject() == root) {
             it.remove();
             obj->deleteLater();
         }
     }
 }
 
 void ShellCorona::unload()
 {
     if (m_shell.isEmpty()) {
         return;
     }
     qDeleteAll(m_desktopViewforId);
     m_desktopViewforId.clear();
     qDeleteAll(m_panelViews);
     m_panelViews.clear();
     m_desktopContainments.clear();
     m_waitingPanels.clear();
     m_activityContainmentPlugins.clear();
 
     while (!containments().isEmpty()) {
         //deleting a containment will remove it from the list due to QObject::destroyed connect in Corona
         //this form doesn't crash, while qDeleteAll(containments()) does
         delete containments().first();
     }
 }
 
 KSharedConfig::Ptr ShellCorona::applicationConfig()
 {
     return KSharedConfig::openConfig();
 }
 
 void ShellCorona::requestApplicationConfigSync()
 {
     m_appConfigSyncTimer.start();
 }
 
 void ShellCorona::loadDefaultLayout()
 {
     //pre-startup scripts
     QString script = m_lookAndFeelPackage.filePath("layouts", QString(shell() + "-prelayout.js").toLatin1());
     if (!script.isEmpty()) {
           QFile file(script);
             if (file.open(QIODevice::ReadOnly | QIODevice::Text) ) {
                 QString code = file.readAll();
                 qDebug() << "evaluating pre-startup script:" << script;
 
                 WorkspaceScripting::ScriptEngine scriptEngine(this);
 
                 connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::printError, this,
                         [](const QString &msg) {
                             qWarning() << msg;
                         });
                 connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::print, this,
                         [](const QString &msg) {
                             qDebug() << msg;
                         });
                 if (!scriptEngine.evaluateScript(code, script)) {
                     qWarning() << "failed to initialize layout properly:" << script;
                 }
             }
     }
 
     //NOTE: Is important the containments already exist for each screen
     // at the moment of the script execution,the same loop in :load()
     // is executed too late
     for (QScreen* screen : qGuiApp->screens()) {
         addOutput(screen);
     }
 
     script = ShellManager::s_testModeLayout;
 
     if (script.isEmpty()) {
         script = m_lookAndFeelPackage.filePath("layouts", QString(shell() + "-layout.js").toLatin1());
     }
     if (script.isEmpty()) {
         script = package().filePath("defaultlayout");
     }
 
     QFile file(script);
     if (file.open(QIODevice::ReadOnly | QIODevice::Text) ) {
         QString code = file.readAll();
         qDebug() << "evaluating startup script:" << script;
 
         // We need to know which activities are here in order for
         // the scripting engine to work. activityAdded does not mind
         // if we pass it the same activity multiple times
         QStringList existingActivities = m_activityController->activities();
         foreach (const QString &id, existingActivities) {
             activityAdded(id);
         }
 
         WorkspaceScripting::ScriptEngine scriptEngine(this);
 
         connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::printError, this,
                 [](const QString &msg) {
                     qWarning() << msg;
                 });
         connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::print, this,
                 [](const QString &msg) {
                     qDebug() << msg;
                 });
         if (!scriptEngine.evaluateScript(code, script)) {
             qWarning() << "failed to initialize layout properly:" << script;
         }
     }
 
     Q_EMIT startupCompleted();
 }
 
 void ShellCorona::processUpdateScripts()
 {
     WorkspaceScripting::ScriptEngine scriptEngine(this);
 
     connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::printError, this,
             [](const QString &msg) {
                 qWarning() << msg;
             });
     connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::print, this,
             [](const QString &msg) {
                 qDebug() << msg;
             });
     foreach (const QString &script, WorkspaceScripting::ScriptEngine::pendingUpdateScripts(this)) {
         QFile file(script);
         if (file.open(QIODevice::ReadOnly | QIODevice::Text) ) {
             QString code = file.readAll();
             scriptEngine.evaluateScript(code);
         } else {
             qWarning() << "Unable to open the script file" << script << "for reading";
         }
     }
 }
 
 int ShellCorona::numScreens() const
 {
     return qGuiApp->screens().count();
 }
 
 QRect ShellCorona::screenGeometry(int id) const
 {
     if (!m_desktopViewforId.contains(id)) {
         qWarning() << "requesting unexisting screen" << id;
         QScreen *s = qGuiApp->primaryScreen();
         return s ? s->geometry() : QRect();
     }
     return m_desktopViewforId.value(id)->geometry();
 }
 
 QRegion ShellCorona::availableScreenRegion(int id) const
 {
     if (!m_desktopViewforId.contains(id)) {
         //each screen should have a view
         qWarning() << "requesting unexisting screen" << id;
         QScreen *s = qGuiApp->primaryScreen();
         return s ? s->availableGeometry() : QRegion();
     }
     DesktopView *view = m_desktopViewforId.value(id);
 
     QRegion r = view->geometry();
     foreach (const PanelView *v, m_panelViews) {
         if (v->isVisible() && view->screen() == v->screen() && v->visibilityMode() != PanelView::AutoHide) {
             //if the panel is being moved around, we still want to calculate it from the edge
             r -= v->geometryByDistance(0);
         }
     }
     return r;
 }
 
 QRect ShellCorona::availableScreenRect(int id) const
 {
     if (!m_desktopViewforId.contains(id)) {
         //each screen should have a view
         qWarning() << "requesting unexisting screen" << id;
         QScreen *s = qGuiApp->primaryScreen();
         return s ? s->availableGeometry() : QRect();
     }
 
     DesktopView *view = m_desktopViewforId.value(id);
 
     QRect r = view->geometry();
     foreach (PanelView *v, m_panelViews) {
         if (v->isVisible() && v->screen() == view->screen() && v->visibilityMode() != PanelView::AutoHide) {
             switch (v->location()) {
             case Plasma::Types::LeftEdge:
                 r.setLeft(r.left() + v->thickness());
                 break;
             case Plasma::Types::RightEdge:
                 r.setRight(r.right() - v->thickness());
                 break;
             case Plasma::Types::TopEdge:
                 r.setTop(r.top() + v->thickness());
                 break;
             case Plasma::Types::BottomEdge:
                 r.setBottom(r.bottom() - v->thickness());
             default:
                 break;
             }
         }
     }
     return r;
 }
 
 QStringList ShellCorona::availableActivities() const
 {
     return m_activityContainmentPlugins.keys();
 }
 
 void ShellCorona::removeDesktop(DesktopView *desktopView)
 {
     const int idx = m_screenPool->id(desktopView->screenToFollow()->name());
 
     if (!m_desktopViewforId.contains(idx)) {
         return;
     }
 
     QMutableHashIterator<const Plasma::Containment *, PanelView *> it(m_panelViews);
     while (it.hasNext()) {
         it.next();
         PanelView *panelView = it.value();
 
         if (panelView->containment()->screen() == idx) {
             m_waitingPanels << panelView->containment();
             it.remove();
             delete panelView;
         }
     }
 
     Q_ASSERT(m_desktopViewforId.value(idx) == desktopView);
     delete desktopView;
     m_desktopViewforId.remove(idx);
 }
 
 PanelView *ShellCorona::panelView(Plasma::Containment *containment) const
 {
     return m_panelViews.value(containment);
 }
 
 ///// SLOTS
 
 QList<PanelView *> ShellCorona::panelsForScreen(QScreen *screen) const
 {
     QList<PanelView *> ret;
     foreach (PanelView *v, m_panelViews) {
         if (v->screenToFollow() == screen) {
             ret += v;
         }
     }
     return ret;
 }
 
 DesktopView* ShellCorona::desktopForScreen(QScreen* screen) const
 {
     return m_desktopViewforId.value(m_screenPool->id(screen->name()));
 }
 
 void ShellCorona::screenRemoved(QScreen* screen)
 {
     if (DesktopView* v = desktopForScreen(screen)) {
         removeDesktop(v);
     }
 
     m_reconsiderOutputsTimer.start();
     m_redundantOutputs.remove(screen);
 }
 
 bool ShellCorona::isOutputRedundant(QScreen* screen) const
 {
     Q_ASSERT(screen);
     const QRect geometry = screen->geometry();
 
     //FIXME: QScreen doesn't have any idea of "this qscreen is clone of this other one
     //so this ultra inefficient heuristic has to stay until we have a slightly better api
     foreach (QScreen* s, qGuiApp->screens()) {
         if (screen == s) {
             continue;
         }
 
         const QRect sGeometry = s->geometry();
         if (sGeometry.contains(geometry, false) &&
             sGeometry.width() > geometry.width() &&
             sGeometry.height() > geometry.height()) {
             return true;
         }
     }
 
     return false;
 }
 
 void ShellCorona::reconsiderOutputs()
 {
     foreach (QScreen* screen, qGuiApp->screens()) {
         if (m_redundantOutputs.contains(screen)) {
             if (!isOutputRedundant(screen)) {
 //                 qDebug() << "not redundant anymore" << out;
                 addOutput(screen);
             }
         } else if (isOutputRedundant(screen)) {
             qDebug() << "new redundant screen" << screen;
 
             if (DesktopView* v = desktopForScreen(screen))
                 removeDesktop(v);
 
             m_redundantOutputs.insert(screen);
         }
 //         else
 //             qDebug() << "fine screen" << out;
     }
 
     updateStruts();
 
     CHECK_SCREEN_INVARIANTS
 }
 
 void ShellCorona::addOutput(QScreen* screen)
 {
     Q_ASSERT(screen);
     connect(screen, &QScreen::geometryChanged,
             &m_reconsiderOutputsTimer, static_cast<void (QTimer::*)()>(&QTimer::start),
             Qt::UniqueConnection);
 
     if (isOutputRedundant(screen)) {
         m_redundantOutputs.insert(screen);
         return;
     } else {
         m_redundantOutputs.remove(screen);
     }
 
     int insertPosition = m_screenPool->id(screen->name());
     if (insertPosition < 0) {
         insertPosition = m_screenPool->firstAvailableId();
     }
 
     DesktopView *view = new DesktopView(this, screen);
     connect(view, &QQuickWindow::sceneGraphError, this, &ShellCorona::showOpenGLNotCompatibleWarning);
-    // a particular edge case: when we switch the only enabled screen
-    // we don't have any signal about it, the primary screen changes but we have the same old QScreen* getting recycled
-    // see https://bugs.kde.org/show_bug.cgi?id=373880
-    // if this slot will be invoked many times, their//second time on will do nothing as name and primaryconnector will be the same by then
-    connect(view, &DesktopView::screenRenamed, this, [=](){
-        if (qGuiApp->primaryScreen()->name() != m_screenPool->primaryConnector()) {
-            //new screen?
-            if (m_screenPool->id(qGuiApp->primaryScreen()->name()) < 0) {
-                m_screenPool->insertScreenMapping(m_screenPool->firstAvailableId(), qGuiApp->primaryScreen()->name());
-            }
-            //switch the primary screen in the pool
-            m_screenPool->setPrimaryConnector(qGuiApp->primaryScreen()->name());
-        }
-    });
 
     Plasma::Containment *containment = createContainmentForActivity(m_activityController->currentActivity(), insertPosition);
     Q_ASSERT(containment);
 
     QAction *removeAction = containment->actions()->action(QStringLiteral("remove"));
     if (removeAction) {
         removeAction->deleteLater();
     }
 
     m_screenPool->insertScreenMapping(insertPosition, screen->name());
     m_desktopViewforId[insertPosition] = view;
     view->setContainment(containment);
     view->show();
     Q_ASSERT(screen == view->screen());
 
     //need to specifically call the reactToScreenChange, since when the screen is shown it's not yet
     //in the list. We still don't want to have an invisible view added.
     containment->reactToScreenChange();
 
     //were there any panels for this screen before it popped up?
     if (!m_waitingPanels.isEmpty()) {
         m_waitingPanelsTimer.start();
     }
 
     emit availableScreenRectChanged();
 
     CHECK_SCREEN_INVARIANTS
 }
 
 Plasma::Containment *ShellCorona::createContainmentForActivity(const QString& activity, int screenNum)
 {
     if (m_desktopContainments.contains(activity)) {
         for (Plasma::Containment *cont : m_desktopContainments.value(activity)) {
             //in the case of a corrupt config file
             //with multiple containments with same lastScreen
             //it can happen two insertContainment happen for
             //the same screen, leading to the old containment
             //to be destroyed
             if (!cont->destroyed() && cont->screen() == screenNum && cont->activity() == activity) {
                 return cont;
             }
         }
     }
 
     QString plugin = m_activityContainmentPlugins.value(activity);
 
     if (plugin.isEmpty()) {
         plugin = defaultContainmentPlugin();
     }
 
     Plasma::Containment *containment = containmentForScreen(screenNum, plugin, QVariantList());
     Q_ASSERT(containment);
 
     if (containment) {
         containment->setActivity(activity);
         insertContainment(activity, screenNum, containment);
     }
 
     return containment;
 }
 
 void ShellCorona::createWaitingPanels()
 {
     QList<Plasma::Containment *> stillWaitingPanels;
 
     foreach (Plasma::Containment *cont, m_waitingPanels) {
         //ignore non existing (yet?) screens
         int requestedScreen = cont->lastScreen();
         if (requestedScreen < 0) {
             requestedScreen = 0;
         }
 
         if (!m_desktopViewforId.contains(requestedScreen)) {
             stillWaitingPanels << cont;
             continue;
         }
 
         //TODO: does a similar check make sense?
         //Q_ASSERT(qBound(0, requestedScreen, m_screenPool->count() - 1) == requestedScreen);
         QScreen *screen = m_desktopViewforId.value(requestedScreen)->screenToFollow();
         PanelView* panel = new PanelView(this, screen);
         connect(panel, &QQuickWindow::sceneGraphError, this, &ShellCorona::showOpenGLNotCompatibleWarning);
         connect(panel, &QWindow::visibleChanged, this, &Plasma::Corona::availableScreenRectChanged);
         connect(panel, &PanelView::locationChanged, this, &Plasma::Corona::availableScreenRectChanged);
         connect(panel, &PanelView::visibilityModeChanged, this, &Plasma::Corona::availableScreenRectChanged);
         connect(panel, &PanelView::thicknessChanged, this, &Plasma::Corona::availableScreenRectChanged);
 
         m_panelViews[cont] = panel;
         panel->setContainment(cont);
         cont->reactToScreenChange();
 
         connect(cont, &QObject::destroyed, this, &ShellCorona::panelContainmentDestroyed);
     }
     m_waitingPanels = stillWaitingPanels;
     emit availableScreenRectChanged();
 }
 
 void ShellCorona::panelContainmentDestroyed(QObject *cont)
 {
     auto view = m_panelViews.take(static_cast<Plasma::Containment*>(cont));
     view->deleteLater();
     emit availableScreenRectChanged();
 }
 
 void ShellCorona::handleContainmentAdded(Plasma::Containment *c)
 {
     connect(c, &Plasma::Containment::showAddWidgetsInterface,
             this, &ShellCorona::toggleWidgetExplorer);
     // Why queued? this is usually triggered after a context menu closes
     // due to its sync,modal nature it may eat some mouse event from the scene
     // waiting a bit to create a new window, the dialog seems to reliably
     // avoid the eating of one click in the panel after the context menu is gone
     connect(c, &Plasma::Containment::appletAlternativesRequested,
             this, &ShellCorona::showAlternativesForApplet, Qt::QueuedConnection);
 
     connect(c, &Plasma::Containment::appletCreated, this, [this, c] (Plasma::Applet *applet) {
         executeSetupPlasmoidScript(c, applet);
     });
 }
 
 void ShellCorona::executeSetupPlasmoidScript(Plasma::Containment *containment, Plasma::Applet *applet)
 {
     if (!applet->pluginMetaData().isValid() || !containment->pluginMetaData().isValid()) {
         return;
     }
 
     const QString scriptFile = m_lookAndFeelPackage.filePath("plasmoidsetupscripts", applet->pluginMetaData().pluginId() + ".js");
 
     if (scriptFile.isEmpty()) {
         return;
     }
 
     WorkspaceScripting::ScriptEngine scriptEngine(this);
 
     connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::printError, this,
             [](const QString &msg) {
                 qWarning() << msg;
             });
     connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::print, this,
             [](const QString &msg) {
                 qDebug() << msg;
             });
 
     QFile file(scriptFile);
     if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
         qWarning() << i18n("Unable to load script file: %1", scriptFile);
         return;
     }
 
     QString script = file.readAll();
     if (script.isEmpty()) {
         // qDebug() << "script is empty";
         return;
     }
 
     scriptEngine.globalObject().setProperty(QStringLiteral("applet"), scriptEngine.wrap(applet));
     scriptEngine.globalObject().setProperty(QStringLiteral("containment"), scriptEngine.wrap(containment));
     scriptEngine.evaluateScript(script, scriptFile);
 }
 
 void ShellCorona::toggleWidgetExplorer()
 {
     const QPoint cursorPos = QCursor::pos();
     foreach (DesktopView *view, m_desktopViewforId) {
         if (view->screen()->geometry().contains(cursorPos)) {
             //The view QML has to provide something to display the widget explorer
             view->rootObject()->metaObject()->invokeMethod(view->rootObject(), "toggleWidgetExplorer", Q_ARG(QVariant, QVariant::fromValue(sender())));
             return;
         }
     }
 }
 
 void ShellCorona::toggleActivityManager()
 {
     const QPoint cursorPos = QCursor::pos();
     foreach (DesktopView *view, m_desktopViewforId) {
         if (view->screen()->geometry().contains(cursorPos)) {
             //The view QML has to provide something to display the activity explorer
             view->rootObject()->metaObject()->invokeMethod(view->rootObject(), "toggleActivityManager", Qt::QueuedConnection);
             return;
         }
     }
 }
 
 void ShellCorona::syncAppConfig()
 {
     applicationConfig()->sync();
 }
 
 void ShellCorona::setDashboardShown(bool show)
 {
     KWindowSystem::setShowingDesktop(show);
 }
 
 void ShellCorona::toggleDashboard()
 {
     setDashboardShown(!KWindowSystem::showingDesktop());
 }
 
 void ShellCorona::loadInteractiveConsole()
 {
     if (KSharedConfig::openConfig()->isImmutable() || !KAuthorized::authorize(QStringLiteral("plasma-desktop/scripting_console"))) {
         delete m_interactiveConsole;
         m_interactiveConsole = 0;
         return;
     }
 
     if (!m_interactiveConsole) {
         const QString consoleQML = package().filePath("interactiveconsole");
         if (consoleQML.isEmpty()) {
             return;
         }
 
         m_interactiveConsole = new KDeclarative::QmlObject(this);
         m_interactiveConsole->setInitializationDelayed(true);
         m_interactiveConsole->setSource(QUrl::fromLocalFile(consoleQML));
 
         QObject *engine = new WorkspaceScripting::ScriptEngine(this, m_interactiveConsole);
         m_interactiveConsole->rootContext()->setContextProperty(QStringLiteral("scriptEngine"), engine);
 
         m_interactiveConsole->completeInitialization();
         if (m_interactiveConsole->rootObject()) {
             connect(m_interactiveConsole->rootObject(), SIGNAL(visibleChanged(bool)),
                     this, SLOT(interactiveConsoleVisibilityChanged(bool)));
         }
     }
 }
 
 void ShellCorona::showInteractiveConsole()
 {
     loadInteractiveConsole();
     if (m_interactiveConsole && m_interactiveConsole->rootObject()) {
         m_interactiveConsole->rootObject()->setProperty("mode", "desktop");
         m_interactiveConsole->rootObject()->setProperty("visible", true);
     }
 }
 
 void ShellCorona::loadScriptInInteractiveConsole(const QString &script)
 {
     showInteractiveConsole();
     if (m_interactiveConsole) {
         m_interactiveConsole->rootObject()->setProperty("script", script);
     }
 }
 
 void ShellCorona::showInteractiveKWinConsole()
 {
     loadInteractiveConsole();
 
     if (m_interactiveConsole && m_interactiveConsole->rootObject()) {
         m_interactiveConsole->rootObject()->setProperty("mode", "windowmanager");
         m_interactiveConsole->rootObject()->setProperty("visible", true);
     }
 }
 
 void ShellCorona::loadKWinScriptInInteractiveConsole(const QString &script)
 {
     showInteractiveKWinConsole();
     if (m_interactiveConsole) {
         m_interactiveConsole->rootObject()->setProperty("script", script);
     }
 }
 
 void ShellCorona::evaluateScript(const QString &script) {
     if (immutability() != Plasma::Types::Mutable) {
         if (calledFromDBus()) {
             sendErrorReply(QDBusError::Failed, QStringLiteral("Widgets are locked"));
         }
         return;
     }
 
     WorkspaceScripting::ScriptEngine scriptEngine(this);
 
     connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::printError, this,
         [](const QString &msg) {
             qWarning() << msg;
         });
     connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::print, this,
             [](const QString &msg) {
                 qDebug() << msg;
             });
 
     scriptEngine.evaluateScript(script);
     if (scriptEngine.hasUncaughtException() && calledFromDBus()) {
         sendErrorReply(QDBusError::Failed, scriptEngine.uncaughtException().toString());
     }
 }
 
 void ShellCorona::interactiveConsoleVisibilityChanged(bool visible)
 {
     if (!visible) {
         m_interactiveConsole->deleteLater();
         m_interactiveConsole = nullptr;
     }
 }
 
 void ShellCorona::checkActivities()
 {
     KActivities::Controller::ServiceStatus status = m_activityController->serviceStatus();
     //qDebug() << "$%$%$#%$%$%Status:" << status;
     if (status != KActivities::Controller::Running) {
         //panic and give up - better than causing a mess
         qDebug() << "ShellCorona::checkActivities is called whilst activity daemon is still connecting";
         return;
     }
 
     QStringList existingActivities = m_activityController->activities();
     foreach (const QString &id, existingActivities) {
         activityAdded(id);
     }
 
     // Checking whether the result we got is valid. Just in case.
     Q_ASSERT_X(!existingActivities.isEmpty(), "isEmpty", "There are no activities, and the service is running");
     Q_ASSERT_X(existingActivities[0] != QStringLiteral("00000000-0000-0000-0000-000000000000"),
             "null uuid", "There is a nulluuid activity present");
 
     // Killing the unassigned containments
     foreach (Plasma::Containment *cont, containments()) {
         if ((cont->containmentType() == Plasma::Types::DesktopContainment ||
              cont->containmentType() == Plasma::Types::CustomContainment) &&
             !existingActivities.contains(cont->activity())) {
             cont->destroy();
         }
     }
 }
 
 void ShellCorona::currentActivityChanged(const QString &newActivity)
 {
 //     qDebug() << "Activity changed:" << newActivity;
 
     foreach (int id, m_desktopViewforId.keys()) {
         Plasma::Containment *c = createContainmentForActivity(newActivity, id);
 
         QAction *removeAction = c->actions()->action(QStringLiteral("remove"));
         if (removeAction) {
             removeAction->deleteLater();
         }
         m_desktopViewforId.value(id)->setContainment(c);
     }
 }
 
 void ShellCorona::activityAdded(const QString &id)
 {
     //TODO more sanity checks
     if (m_activityContainmentPlugins.contains(id)) {
         qWarning() << "Activity added twice" << id;
         return;
     }
 
     m_activityContainmentPlugins.insert(id, defaultContainmentPlugin());
 }
 
 void ShellCorona::activityRemoved(const QString &id)
 {
     m_activityContainmentPlugins.remove(id);
     if (m_desktopContainments.contains(id)) {
         for (auto cont : m_desktopContainments.value(id)) {
             cont->destroy();
         }
     }
 }
 
 void ShellCorona::insertActivity(const QString &id, const QString &plugin)
 {
     activityAdded(id);
 
     const QString currentActivityReally = m_activityController->currentActivity();
 
     // TODO: This needs to go away!
     // The containment creation API does not know when we have a
     // new activity to create a containment for, we need to pretend
     // that the current activity has been changed
     QFuture<bool> currentActivity = m_activityController->setCurrentActivity(id);
     awaitFuture(currentActivity);
 
     if (!currentActivity.result()) {
         qDebug() << "Failed to create and switch to the activity";
         return;
     }
 
     while (m_activityController->currentActivity() != id) {
         QCoreApplication::processEvents();
     }
 
     m_activityContainmentPlugins.insert(id, plugin);
     foreach (int screenId, m_desktopViewforId.keys()) {
         Plasma::Containment *c = createContainmentForActivity(id, screenId);
         if (c) {
             c->config().writeEntry("lastScreen", screenId);
         }
     }
 }
 
 Plasma::Containment *ShellCorona::setContainmentTypeForScreen(int screen, const QString &plugin)
 {
     Plasma::Containment *oldContainment = containmentForScreen(screen);
 
     //no valid containment in given screen, giving up
     if (!oldContainment) {
         return 0;
     }
 
     if (plugin.isEmpty()) {
         return oldContainment;
     }
 
     DesktopView *view = 0;
     foreach (DesktopView *v, m_desktopViewforId) {
         if (v->containment() == oldContainment) {
             view = v;
             break;
         }
     }
 
     //no view? give up
     if (!view) {
         return oldContainment;
     }
 
     //create a new containment
     Plasma::Containment *newContainment = createContainmentDelayed(plugin);
 
     //if creation failed or invalid plugin, give up
     if (!newContainment) {
         return oldContainment;
     } else if (!newContainment->pluginMetaData().isValid()) {
         newContainment->deleteLater();
         return oldContainment;
     }
 
     newContainment->setWallpaper(oldContainment->wallpaper());
 
     //At this point we have a valid new containment from plugin and a view
     //copy all configuration groups (excluded applets)
     KConfigGroup oldCg = oldContainment->config();
 
     //newCg *HAS* to be from a KSharedConfig, because some KConfigSkeleton will need to be synced
     //this makes the configscheme work
     KConfigGroup newCg(KSharedConfig::openConfig(oldCg.config()->name()), "Containments");
     newCg = KConfigGroup(&newCg, QString::number(newContainment->id()));
 
     //this makes containment->config() work, is a separate thing from its configscheme
     KConfigGroup newCg2 = newContainment->config();
 
     foreach (const QString &group, oldCg.groupList()) {
         if (group != QLatin1String("Applets")) {
             KConfigGroup subGroup(&oldCg, group);
             KConfigGroup newSubGroup(&newCg, group);
             subGroup.copyTo(&newSubGroup);
 
             KConfigGroup newSubGroup2(&newCg2, group);
             subGroup.copyTo(&newSubGroup2);
         }
     }
 
     newContainment->init();
     newCg.writeEntry("activityId", oldContainment->activity());
     newContainment->restore(newCg);
     newContainment->updateConstraints(Plasma::Types::StartupCompletedConstraint);
     newContainment->flushPendingConstraintsEvents();
     emit containmentAdded(newContainment);
 
     //Move the applets
     foreach (Plasma::Applet *applet, oldContainment->applets()) {
         newContainment->addApplet(applet);
     }
 
     //remove the "remove" action
     QAction *removeAction = newContainment->actions()->action(QStringLiteral("remove"));
     if (removeAction) {
         removeAction->deleteLater();
     }
     view->setContainment(newContainment);
     newContainment->setActivity(oldContainment->activity());
     m_desktopContainments.remove(oldContainment->activity());
     insertContainment(oldContainment->activity(), screen, newContainment);
 
     //removing the focus from the item that is going to be destroyed
     //fixes a crash
     //delayout the destruction of the old containment fixes another crash
     view->rootObject()->setFocus(true, Qt::MouseFocusReason);
     QTimer::singleShot(2500, oldContainment, &Plasma::Applet::destroy);
 
     //Save now as we now have a screen, so lastScreen will not be -1
     newContainment->save(newCg);
     requestConfigSync();
     emit availableScreenRectChanged();
 
     return newContainment;
 }
 
 void ShellCorona::checkAddPanelAction(const QStringList &sycocaChanges)
 {
     if (!sycocaChanges.isEmpty() && !sycocaChanges.contains(QStringLiteral("services"))) {
         return;
     }
 
     delete m_addPanelAction;
     m_addPanelAction = 0;
 
     delete m_addPanelsMenu;
     m_addPanelsMenu = 0;
 
     KPluginInfo::List panelContainmentPlugins = Plasma::PluginLoader::listContainmentsOfType(QStringLiteral("Panel"));
 
     auto filter = [](const KPluginMetaData &md) -> bool
     {
         return md.value(QStringLiteral("NoDisplay")) != QStringLiteral("true") && md.value(QStringLiteral("X-Plasma-ContainmentCategories")).contains(QStringLiteral("panel"));
     };
     QList<KPluginMetaData> templates = KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/LayoutTemplate"), QString(), filter);
 
     if (panelContainmentPlugins.count() + templates.count() == 1) {
         m_addPanelAction = new QAction(i18n("Add Panel"), this);
         m_addPanelAction->setData(Plasma::Types::AddAction);
         connect(m_addPanelAction, SIGNAL(triggered(bool)), this, SLOT(addPanel()));
     } else if (!panelContainmentPlugins.isEmpty()) {
         m_addPanelsMenu = new QMenu;
         m_addPanelAction = m_addPanelsMenu->menuAction();
         m_addPanelAction->setText(i18n("Add Panel"));
         m_addPanelAction->setData(Plasma::Types::AddAction);
         connect(m_addPanelsMenu, &QMenu::aboutToShow, this, &ShellCorona::populateAddPanelsMenu);
         connect(m_addPanelsMenu, SIGNAL(triggered(QAction*)), this, SLOT(addPanel(QAction*)));
     }
 
     if (m_addPanelAction) {
         m_addPanelAction->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
         actions()->addAction(QStringLiteral("add panel"), m_addPanelAction);
     }
 }
 
 void ShellCorona::populateAddPanelsMenu()
 {
     m_addPanelsMenu->clear();
     const KPluginInfo emptyInfo;
 
     KPluginInfo::List panelContainmentPlugins = Plasma::PluginLoader::listContainmentsOfType(QStringLiteral("Panel"));
     QMap<QString, QPair<KPluginInfo, KPluginMetaData> > sorted;
     foreach (const KPluginInfo &plugin, panelContainmentPlugins) {
         if (plugin.property(QStringLiteral("NoDisplay")).toString() == QStringLiteral("true")) {
             continue;
         }
         sorted.insert(plugin.name(), qMakePair(plugin, KPluginMetaData()));
     }
 
     auto filter = [](const KPluginMetaData &md) -> bool
     {
         return md.value(QStringLiteral("NoDisplay")) != QStringLiteral("true") && md.value(QStringLiteral("X-Plasma-ContainmentCategories")).contains(QStringLiteral("panel"));
     };
     const QList<KPluginMetaData> templates = KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/LayoutTemplate"), QString(), filter);
     for (auto tpl : templates) {
         sorted.insert(tpl.name(), qMakePair(emptyInfo, tpl));
     }
 
     QMapIterator<QString, QPair<KPluginInfo, KPluginMetaData> > it(sorted);
     KPackage::Package package = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LayoutTemplate"));
     while (it.hasNext()) {
         it.next();
         QPair<KPluginInfo, KPluginMetaData> pair = it.value();
         if (pair.first.isValid()) {
             KPluginInfo plugin = pair.first;
             QAction *action = m_addPanelsMenu->addAction(i18n("Empty %1", plugin.name()));
             if (!plugin.icon().isEmpty()) {
                 action->setIcon(QIcon::fromTheme(plugin.icon()));
             }
 
             action->setData(plugin.pluginName());
         } else {
             KPluginInfo info(pair.second);
             package.setPath(info.pluginName());
             const QString scriptFile = package.filePath("mainscript");
             if (!scriptFile.isEmpty()) {
                 QAction *action = m_addPanelsMenu->addAction(info.name());
                 action->setData(QStringLiteral("plasma-desktop-template:%1").arg(info.pluginName()));
             }
         }
     }
 }
 
 void ShellCorona::addPanel()
 {
     KPluginInfo::List panelPlugins = Plasma::PluginLoader::listContainmentsOfType(QStringLiteral("Panel"));
 
     if (!panelPlugins.isEmpty()) {
         addPanel(panelPlugins.first().pluginName());
     }
 }
 
 void ShellCorona::addPanel(QAction *action)
 {
     const QString plugin = action->data().toString();
     if (plugin.startsWith(QLatin1String("plasma-desktop-template:"))) {
         WorkspaceScripting::ScriptEngine scriptEngine(this);
 
         connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::printError, this,
                 [](const QString &msg) {
                     qWarning() << msg;
                 });
         connect(&scriptEngine, &WorkspaceScripting::ScriptEngine::print, this,
                 [](const QString &msg) {
                     qDebug() << msg;
                 });
         const QString templateName = plugin.right(plugin.length() - qstrlen("plasma-desktop-template:"));
 
         scriptEngine.evaluateScript(QStringLiteral("loadTemplate(\"%1\")").arg(templateName));
     } else if (!plugin.isEmpty()) {
         addPanel(plugin);
     }
 }
 
 Plasma::Containment *ShellCorona::addPanel(const QString &plugin)
 {
     Plasma::Containment *panel = createContainment(plugin);
     if (!panel) {
         return 0;
     }
 
     QList<Plasma::Types::Location> availableLocations;
     availableLocations << Plasma::Types::LeftEdge << Plasma::Types::TopEdge << Plasma::Types::RightEdge << Plasma::Types::BottomEdge;
 
     foreach (const Plasma::Containment *cont, m_panelViews.keys()) {
         availableLocations.removeAll(cont->location());
     }
 
     Plasma::Types::Location loc;
     if (availableLocations.isEmpty()) {
         loc = Plasma::Types::TopEdge;
     } else {
         loc = availableLocations.first();
     }
 
     panel->setLocation(loc);
     switch (loc) {
     case Plasma::Types::LeftEdge:
     case Plasma::Types::RightEdge:
         panel->setFormFactor(Plasma::Types::Vertical);
         break;
     default:
         panel->setFormFactor(Plasma::Types::Horizontal);
         break;
     }
 
     Q_ASSERT(panel);
     m_waitingPanels << panel;
     //not creating the panel view yet in order to have the same code path
     //between the first and subsequent plasma starts. we want to have the panel appearing only when its layout is completed, to not have
     //many visible relayouts. otherwise we had even panel resizes at startup that
     //made al lthe full representations be loaded.
     m_waitingPanelsTimer.start();
 
     const QPoint cursorPos(QCursor::pos());
     foreach (QScreen *screen, QGuiApplication::screens()) {
         //m_panelViews.contains(panel) == false iff addPanel is executed in a startup script
         if (screen->geometry().contains(cursorPos) && m_panelViews.contains(panel)) {
             m_panelViews[panel]->setScreenToFollow(screen);
             break;
         }
     }
     return panel;
 }
 
 int ShellCorona::screenForContainment(const Plasma::Containment *containment) const
 {
     //case in which this containment is child of an applet, hello systray :)
     if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
         if (Plasma::Containment* cont = parentApplet->containment()) {
             return screenForContainment(cont);
         } else {
             return -1;
         }
     }
 
     //if the desktop views already exist, base the decision upon them
     foreach (int id, m_desktopViewforId.keys()) {
         if (m_desktopViewforId.value(id)->containment() == containment && containment->activity() == m_activityController->currentActivity()) {
             return id;
         }
     }
 
     //if the panel views already exist, base upon them
     PanelView *view = m_panelViews.value(containment);
     if (view && view->screenToFollow()) {
         return m_screenPool->id(view->screenToFollow()->name());
     }
 
     //Failed? fallback on lastScreen()
     //lastScreen() is the correct screen for panels
     //It is also correct for desktops *that have the correct activity()*
     //a containment with lastScreen() == 0 but another activity,
     //won't be associated to a screen
 //     qDebug() << "ShellCorona screenForContainment: " << containment << " Last screen is " << containment->lastScreen();
 
     for (auto screen : qGuiApp->screens()) {
         // containment->lastScreen() == m_screenPool->id(screen->name()) to check if the lastScreen refers to a screen that exists/it's known
         if (containment->lastScreen() == m_screenPool->id(screen->name()) &&
             (containment->activity() == m_activityController->currentActivity() ||
             containment->containmentType() == Plasma::Types::PanelContainment || containment->containmentType() == Plasma::Types::CustomPanelContainment)) {
             return containment->lastScreen();
         }
     }
 
     return -1;
 }
 
 void ShellCorona::nextActivity()
 {
     const QStringList list = m_activityController->activities(KActivities::Info::Running);
     if (list.isEmpty()) {
         return;
     }
 
     const int start = list.indexOf(m_activityController->currentActivity());
     const int i = (start + 1) % list.size();
 
     m_activityController->setCurrentActivity(list.at(i));
 }
 
 void ShellCorona::previousActivity()
 {
     const QStringList list = m_activityController->activities(KActivities::Info::Running);
     if (list.isEmpty()) {
         return;
     }
 
     const int start = list.indexOf(m_activityController->currentActivity());
     int i = start - 1;
     if(i < 0) {
         i = list.size() - 1;
     }
 
     m_activityController->setCurrentActivity(list.at(i));
 }
 
 void ShellCorona::stopCurrentActivity()
 {
     const QStringList list = m_activityController->activities(KActivities::Info::Running);
     if (list.isEmpty()) {
         return;
     }
 
     m_activityController->stopActivity(m_activityController->currentActivity());
 }
 
 void ShellCorona::insertContainment(const QString &activity, int screenNum, Plasma::Containment *containment)
 {
     Plasma::Containment *cont = nullptr;
     for (Plasma::Containment *c : m_desktopContainments.value(activity)) {
         if (c->screen() == screenNum) {
             cont = c;
             if (containment == cont) {
                 return;
             }
             break;
         }
     }
 
     Q_ASSERT(!m_desktopContainments.value(activity).values().contains(containment));
 
     if (cont) {
         disconnect(cont, SIGNAL(destroyed(QObject*)),
                 this, SLOT(desktopContainmentDestroyed(QObject*)));
         cont->destroy();
     }
     m_desktopContainments[activity].insert(containment);
 
     //when a containment gets deleted update our map of containments
     connect(containment, SIGNAL(destroyed(QObject*)), this, SLOT(desktopContainmentDestroyed(QObject*)));
 }
 
 void ShellCorona::desktopContainmentDestroyed(QObject *obj)
 {
     // when QObject::destroyed arrives, ~Plasma::Containment has run,
     // members of Containment are not accessible anymore,
     // so keep ugly bookeeping by hand
     auto containment = static_cast<Plasma::Containment*>(obj);
     for (auto a : m_desktopContainments) {
         QMutableSetIterator<Plasma::Containment *> it(a);
         while (it.hasNext()) {
             it.next();
             if (it.value() == containment) {
                 it.remove();
                 return;
             }
         }
     }
 }
 
 void ShellCorona::showOpenGLNotCompatibleWarning()
 {
     static bool s_multipleInvokations = false;
     if (s_multipleInvokations) {
         return;
     }
     s_multipleInvokations = true;
 
     QCoreApplication::setAttribute(Qt::AA_ForceRasterWidgets);
     QMessageBox::critical(nullptr, i18n("Plasma Failed To Start"),
                           i18n("Plasma is unable to start as it could not correctly use OpenGL 2.\n Please check that your graphic drivers are set up correctly."));
     qCritical("Open GL context could not be created");
 
     // this doesn't work and I have no idea why.
     QCoreApplication::exit(1);
 }
 
 void ShellCorona::setupWaylandIntegration()
 {
     if (!KWindowSystem::isPlatformWayland()) {
         return;
     }
     using namespace KWayland::Client;
     ConnectionThread *connection = ConnectionThread::fromApplication(this);
     if (!connection) {
         return;
     }
     Registry *registry = new Registry(this);
     registry->create(connection);
     connect(registry, &Registry::plasmaShellAnnounced, this,
         [this, registry] (quint32 name, quint32 version) {
             m_waylandPlasmaShell = registry->createPlasmaShell(name, version, this);
         }
     );
     registry->setup();
 }
 
 KWayland::Client::PlasmaShell *ShellCorona::waylandPlasmaShellInterface() const
 {
     return m_waylandPlasmaShell;
 }
 
 ScreenPool *ShellCorona::screenPool() const
 {
     return m_screenPool;
 }
 
 QList<int> ShellCorona::screenIds() const
 {
     return m_desktopViewforId.keys();
 }
 
 QString ShellCorona::defaultContainmentPlugin() const
 {
     QString plugin = m_lnfDefaultsConfig.readEntry("Containment", QString());
     if (plugin.isEmpty()) {
         plugin = m_desktopDefaultsConfig.readEntry("Containment", "org.kde.desktopcontainment");
     }
     return plugin;
 }
 
 void ShellCorona::updateStruts()
 {
     foreach(PanelView* view, m_panelViews) {
         view->updateStruts();
     }
 }
 
 
 void ShellCorona::activateLauncherMenu()
 {
     for (auto it = m_panelViews.constBegin(), end = m_panelViews.constEnd(); it != end; ++it) {
         const auto applets = it.key()->applets();
         for (auto applet : applets) {
             const auto provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
             if (provides.contains(QLatin1String("org.kde.plasma.launchermenu"))) {
                 if (!applet->globalShortcut().isEmpty()) {
                     emit applet->activated();
                     return;
                 }
             }
         }
     }
 }
 
 void ShellCorona::activateTaskManagerEntry(int index)
 {
     auto activateTaskManagerEntryOnContainment = [this](const Plasma::Containment *c, int index) {
         const auto &applets = c->applets();
         for (auto *applet : applets) {
             const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
             if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
                 if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                     const auto &childItems = appletInterface->childItems();
                     if (childItems.isEmpty()) {
                         continue;
                     }
 
                     for (QQuickItem *item : childItems) {
                         if (auto *metaObject = item->metaObject()) {
                             // not using QMetaObject::invokeMethod to avoid warnings when calling
                             // this on applets that don't have it or other child items since this
                             // is pretty much trial and error.
 
                             // Also, "var" arguments are treated as QVariant in QMetaObject
                             int methodIndex = metaObject->indexOfMethod("activateTaskAtIndex(QVariant)");
                             if (methodIndex == -1) {
                                 continue;
                             }
 
                             QMetaMethod method = metaObject->method(methodIndex);
                             if (method.invoke(item, Q_ARG(QVariant, index))) {
                                 return true;
                             }
                         }
                     }
                 }
             }
         }
         return false;
     };
 
     // To avoid overly complex configuration, we'll try to get the 90% usecase to work
     // which is activating a task on the task manager on a panel on the primary screen.
 
     for (auto it = m_panelViews.constBegin(), end = m_panelViews.constEnd(); it != end; ++it) {
         if (it.value()->screen() != qGuiApp->primaryScreen()) {
             continue;
         }
         if (activateTaskManagerEntryOnContainment(it.key(), index)) {
             return;
         }
     }
 
     // we didn't find anything on primary, try all the panels
     for (auto it = m_panelViews.constBegin(), end = m_panelViews.constEnd(); it != end; ++it) {
         if (activateTaskManagerEntryOnContainment(it.key(), index)) {
             return;
         }
     }
 }
 
 // Desktop corona handler
 
 
 #include "moc_shellcorona.cpp"
 
diff --git a/shell/shellcorona.h b/shell/shellcorona.h
index 25ba1cd2..10e335d0 100644
--- a/shell/shellcorona.h
+++ b/shell/shellcorona.h
@@ -1,253 +1,254 @@
 /*
  *   Copyright 2008 Aaron Seigo <aseigo@kde.org>
  *   Copyright 2013 Sebastian Kügler <sebas@kde.org>
  *   Copyright 2013 Ivan Cukic <ivan.cukic@kde.org>
  *   Copyright 2013 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, 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 Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #ifndef SHELLCORONA_H
 #define SHELLCORONA_H
 
 #include "plasma/corona.h"
 
 #include <QSet>
 #include <QTimer>
 #include <QDBusVariant>
 #include <QDBusContext>
 
 #include <KPackage/Package>
 
 class DesktopView;
 class PanelView;
 class QMenu;
 class QScreen;
 class ScreenPool;
 
 namespace KActivities
 {
     class Controller;
 } // namespace KActivities
 
 namespace KDeclarative
 {
     class QmlObject;
 } // namespace KDeclarative
 
 namespace KScreen {
     class Output;
 } // namespace KScreen
 
 namespace Plasma
 {
     class Applet;
 } // namespace Plasma
 
 namespace KWayland
 {
     namespace Client
     {
         class PlasmaShell;
     }
 }
 
 class ShellCorona : public Plasma::Corona, QDBusContext
 {
     Q_OBJECT
     Q_PROPERTY(QString shell READ shell WRITE setShell)
     Q_PROPERTY(int numScreens READ numScreens)
     Q_CLASSINFO("D-Bus Interface", "org.kde.PlasmaShell")
 
 public:
     explicit ShellCorona(QObject *parent = 0);
     ~ShellCorona() override;
 
     KPackage::Package lookAndFeelPackage();
 
     /**
      * Where to save global configuration that doesn't have anything to do with the scene (e.g. views)
      */
     KSharedConfig::Ptr applicationConfig();
 
     int numScreens() const override;
     Q_INVOKABLE QRect screenGeometry(int id) const override;
     Q_INVOKABLE QRegion availableScreenRegion(int id) const override;
     Q_INVOKABLE QRect availableScreenRect(int id) const override;
 
     Q_INVOKABLE QStringList availableActivities() const;
 
     PanelView *panelView(Plasma::Containment *containment) const;
 
     // This one is a bit of an hack but are just for desktop scripting
     void insertActivity(const QString &id, const QString &plugin);
 
     Plasma::Containment *setContainmentTypeForScreen(int screen, const QString &plugin);
 
     void removeDesktop(DesktopView *desktopView);
 
     /**
      * @returns a new containment associated with the specified @p activity and @p screen.
      */
     Plasma::Containment *createContainmentForActivity(const QString &activity, int screenNum);
 
     KWayland::Client::PlasmaShell *waylandPlasmaShellInterface() const;
 
 
     ScreenPool *screenPool() const;
 
     QList<int> screenIds() const;
 
     QString defaultContainmentPlugin() const;
 
 public Q_SLOTS:
     /**
      * Request saving applicationConfig on disk, it's event compressed, not immediate
      */
     void requestApplicationConfigSync();
 
     /**
      * Sets the shell that the corona should display
      */
     void setShell(const QString &shell);
 
     /**
      * Gets the currently shown shell
      */
     QString shell() const;
 
     ///DBUS methods
     void toggleDashboard();
     void setDashboardShown(bool show);
     void loadInteractiveConsole();
     void showInteractiveConsole();
     void loadScriptInInteractiveConsole(const QString &script);
     void showInteractiveKWinConsole();
     void loadKWinScriptInInteractiveConsole(const QString &script);
     void toggleActivityManager();
     void toggleWidgetExplorer();    
     void evaluateScript(const QString &string);
     void activateLauncherMenu();
 
     QByteArray dumpCurrentLayoutJS() const;
 
     /**
      * loads the shell layout from a look and feel package,
      * resetting it to the default layout exported in the
      * look and feel package
      */
     void loadLookAndFeelDefaultLayout(const QString &layout);
 
 
     Plasma::Containment *addPanel(const QString &plugin);
 
     void nextActivity();
     void previousActivity();
     void stopCurrentActivity();
 
 protected Q_SLOTS:
     /**
      * Loads the layout and performs the needed checks
      */
     void load();
 
     /**
      * Unloads everything
      */
     void unload();
 
     /**
      * Loads the default (system wide) layout for this user
      **/
     void loadDefaultLayout() override;
 
     /**
      * Execute any update script
      */
     void processUpdateScripts();
 
     int screenForContainment(const Plasma::Containment *containment) const override;
 
     void showAlternativesForApplet(Plasma::Applet *applet);
 
 private Q_SLOTS:
     void createWaitingPanels();
     void handleContainmentAdded(Plasma::Containment *c);
     void syncAppConfig();
     void checkActivities();
     void currentActivityChanged(const QString &newActivity);
     void activityAdded(const QString &id);
     void activityRemoved(const QString &id);
     void checkAddPanelAction(const QStringList &sycocaChanges = QStringList());
     void addPanel();
     void addPanel(QAction *action);
     void populateAddPanelsMenu();
 
     void addOutput(QScreen* screen);
     void primaryOutputChanged();
 
     void panelContainmentDestroyed(QObject* cont);
     void desktopContainmentDestroyed(QObject*);
     void showOpenGLNotCompatibleWarning();
     void alternativesVisibilityChanged(bool visible);
     void interactiveConsoleVisibilityChanged(bool visible);
     void screenRemoved(QScreen* screen);
 
     void activateTaskManagerEntry(int index);
 
 private:
     void updateStruts();
     bool isOutputRedundant(QScreen* screen) const;
     void reconsiderOutputs();
     QList<PanelView *> panelsForScreen(QScreen *screen) const;
     DesktopView* desktopForScreen(QScreen *screen) const;
     void setupWaylandIntegration();
     void executeSetupPlasmoidScript(Plasma::Containment *containment, Plasma::Applet *applet);
 
 #ifndef NDEBUG
     void screenInvariants() const;
 #endif
 
     void insertContainment(const QString &activity, int screenNum, Plasma::Containment *containment);
 
     ScreenPool *m_screenPool;
     QString m_shell;
     KActivities::Controller *m_activityController;
     //map from screen number to desktop view, qmap as order is important
     QMap<int, DesktopView *> m_desktopViewforId;
     QHash<const Plasma::Containment *, PanelView *> m_panelViews;
     KConfigGroup m_desktopDefaultsConfig;
     KConfigGroup m_lnfDefaultsConfig;
     QList<Plasma::Containment *> m_waitingPanels;
     QHash<QString, QString> m_activityContainmentPlugins;
     QHash<QString, QSet<Plasma::Containment *> > m_desktopContainments;
     QAction *m_addPanelAction;
     QMenu *m_addPanelsMenu;
     KPackage::Package m_lookAndFeelPackage;
     QSet<QScreen*> m_redundantOutputs;
     QList<KDeclarative::QmlObject *> m_alternativesObjects;
     KDeclarative::QmlObject *m_interactiveConsole;
+    int m_eventBase;
 
     QTimer m_waitingPanelsTimer;
     QTimer m_appConfigSyncTimer;
     QTimer m_reconsiderOutputsTimer;
 
     KWayland::Client::PlasmaShell *m_waylandPlasmaShell;
 };
 
 #endif // SHELLCORONA_H