diff --git a/autotests/CMakeLists.txt b/autotests/CMakeLists.txt
index 7a6505d8f..713e6256c 100644
--- a/autotests/CMakeLists.txt
+++ b/autotests/CMakeLists.txt
@@ -1,80 +1,79 @@
 find_package(Qt5Test ${REQUIRED_QT_VERSION} REQUIRED NO_MODULE)
 set_package_properties(Qt5Test PROPERTIES PURPOSE "Required for tests")
 
 set(EXECUTABLE_OUTPUT_PATH ${CMAKE_CURRENT_BINARY_DIR})
 remove_definitions(-DQT_NO_CAST_FROM_ASCII -DQT_STRICT_ITERATORS -DQT_NO_CAST_FROM_BYTEARRAY -DQT_NO_KEYWORDS)
 
 include(ECMMarkAsTest)
 include(ECMAddTests)
 
 find_package(KF5CoreAddons REQUIRED)
 find_package(KF5XmlGui REQUIRED)
 find_package(Qt5Widgets REQUIRED)
 
 # add_definitions( -DKDESRCDIR=${CMAKE_CURRENT_SOURCE_DIR} )
 
 if(KDE_PLATFORM_FEATURE_BINARY_COMPATIBLE_FEATURE_REDUCTION)
-    set(PLASMA_NO_KIO TRUE)
     set(PLASMA_NO_PACKAGEKIT TRUE)
     set(PLASMA_NO_PACKAGE_EXTRADATA TRUE)
 endif()
 
 MACRO(PLASMA_UNIT_TESTS)
        FOREACH(_testname ${ARGN})
                set(libs Qt5::Qml Qt5::Test KF5::Plasma KF5::PlasmaQuick
                         KF5::Archive KF5::CoreAddons KF5::ConfigGui KF5::I18n
                         KF5::KIOCore KF5::Service KF5::IconThemes
                         KF5::Declarative)
                if(QT_QTOPENGL_FOUND)
                    list(APPEND libs Qt5::OpenGL)
                endif()
                ecm_add_test(${_testname}.cpp
                             LINK_LIBRARIES ${libs}
                             NAME_PREFIX "plasma-")
                target_include_directories(${_testname} PRIVATE "$<BUILD_INTERFACE:$<TARGET_PROPERTY:KF5PlasmaQuick,INCLUDE_DIRECTORIES>>;")
        ENDFOREACH(_testname)
 ENDMACRO(PLASMA_UNIT_TESTS)
 
 PLASMA_UNIT_TESTS(
     dialogqmltest
     dialogstatetest
     fallbackpackagetest
     packagestructuretest
     pluginloadertest
     framesvgtest
     iconitemtest
     themetest
     configmodeltest
     #    plasmoidpackagetest
 )
 
 set(storagetest_libs Qt5::Gui Qt5::Test Qt5::Sql KF5::KIOCore KF5::Plasma KF5::CoreAddons)
 if(QT_QTOPENGL_FOUND)
     list(APPEND storagetest_libs Qt5::OpenGL)
 endif()
 set(storagetest_srcs storagetest.cpp ../src/plasma/private/storage.cpp ../src/plasma/private/storagethread.cpp ../src/plasma/debug_p.cpp)
 ecm_add_test(${storagetest_srcs} TEST_NAME plasma-storagetest LINK_LIBRARIES ${storagetest_libs})
 
 if(HAVE_X11)
     set(dialognativetest_srcs dialognativetest.cpp)
     ecm_add_test(${dialognativetest_srcs} TEST_NAME dialognativetest LINK_LIBRARIES Qt5::Gui Qt5::Test Qt5::Qml Qt5::Quick KF5::WindowSystem KF5::Plasma KF5::PlasmaQuick)
 endif()
 
 set(coronatest_srcs coronatest.cpp)
 qt5_add_resources(coronatest_srcs coronatestresources.qrc)
 ecm_add_test(${coronatest_srcs} TEST_NAME coronatest LINK_LIBRARIES Qt5::Gui Qt5::Widgets Qt5::Test KF5::KIOCore KF5::Plasma KF5::CoreAddons KF5::XmlGui)
 
 set(sortfiltermodeltest_srcs
     sortfiltermodeltest.cpp
     ../src/declarativeimports/core/datamodel.cpp
     ../src/declarativeimports/core/datasource.cpp
     )
 ecm_add_test(${sortfiltermodeltest_srcs} TEST_NAME plasma-sortfiltermodeltest LINK_LIBRARIES KF5::Plasma Qt5::Gui Qt5::Test KF5::I18n KF5::Service Qt5::Qml)
 
 
 #Add a test that i18n is not used directly in any import.
 # It should /always/ be i18nd
 find_program(SH bash)
 if(SH)
     add_test(i18ndcheck ${SH} ${CMAKE_CURRENT_SOURCE_DIR}/i18ndcheck.sh ${CMAKE_SOURCE_DIR}/src/declarativeimports)
 endif()
diff --git a/src/plasma/CMakeLists.txt b/src/plasma/CMakeLists.txt
index 8be8afb5c..b3a85551a 100644
--- a/src/plasma/CMakeLists.txt
+++ b/src/plasma/CMakeLists.txt
@@ -1,240 +1,239 @@
 add_subdirectory(packagestructure)
 
 # This option should be removed, or moved down as far as possible.
 # That means porting the existing frameworks to the CMake automoc
 # feature. Porting is mostly removing explicit moc includes, and
 # leaving the ones which are truly needed (ie, if you remove
 # them, the build fails).
 set(CMAKE_AUTOMOC_RELAXED_MODE ON)
 
 if(KDE_PLATFORM_FEATURE_BINARY_COMPATIBLE_FEATURE_REDUCTION)
-    set(PLASMA_NO_KIO TRUE)
     set(PLASMA_NO_PACKAGEKIT TRUE)
     set(PLASMA_NO_PACKAGE_EXTRADATA TRUE)
 endif()
 
 if(NOT HAVE_X11)
     set(PLASMA_NO_PACKAGEKIT TRUE)
 endif()
 
 #find_package(KdepimLibs 4.5.60)
 #find_package(Gpgme)
 #set_package_properties(KDEPIMLIBS PROPERTIES DESCRIPTION "KDE PIM libraries"
 #                       URL "http://www.kde.org" TYPE OPTIONAL
 #                       PURPOSE "Needed for building several Plasma DataEngines")
 
 if(NOT PLASMA_NO_PACKAGEKIT)
     add_definitions(-DPLASMA_ENABLE_PACKAGEKIT_SUPPORT=1)
     set(PLASMA_EXTRA_LIBS ${PLASMA_EXTRA_LIBS} Qt5::DBus)
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-plasma.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-plasma.h)
 
 #FIXME: gpgme++ is in kdepimlibs, must move somewhere else!
 include_directories(${KDEPIMLIBS_INCLUDE_DIRS} ${GPGME_INCLUDES})
 
 add_definitions(-DKDE_DEFAULT_DEBUG_AREA=1209)
 
 ########### next target ###############
 
 set(Plasma_LIB_SRCS
 #global
     plasma.cpp
     pluginloader.cpp
     version.cpp
     private/componentinstaller.cpp
 
 #applets,containments,corona
     applet.cpp
     containment.cpp
     containmentactions.cpp
     corona.cpp
     private/applet_p.cpp
     private/associatedapplicationmanager.cpp
     private/containment_p.cpp
     private/timetracker.cpp
 
 #Dataengines, services
     datacontainer.cpp
     dataengine.cpp
     dataengineconsumer.cpp
     service.cpp
     servicejob.cpp
     private/datacontainer_p.cpp
     private/dataenginemanager.cpp
     private/storage.cpp
     private/storagethread.cpp
 
 #packages
     package.cpp
     packagestructure.cpp
 
 #graphics
     framesvg.cpp
     svg.cpp
     theme.cpp
     private/theme_p.cpp
 
 #scripting
     scripting/appletscript.cpp
     scripting/dataenginescript.cpp
     scripting/scriptengine.cpp
 )
 
 if(HAVE_X11)
     set(Plasma_LIB_SRCS ${Plasma_LIB_SRCS} private/effectwatcher.cpp)
 endif()
 
 kconfig_add_kcfg_files(Plasma_LIB_SRCS data/kconfigxt/libplasma-theme-global.kcfgc)
 
 #NEPOMUK_GENERATE_FROM_ONTOLOGY(
 #   nwc.nrl
 #   ${metadata_test_BINARY_DIR}
 #   TEST_HEADERS
 #   TEST_SOURCES
 #   TEST_INCLUDES
 #)
 
 ecm_qt_declare_logging_category(Plasma_LIB_SRCS HEADER debug_p.h IDENTIFIER LOG_PLASMA CATEGORY_NAME org.kde.plasma)
 
 add_library(KF5Plasma ${Plasma_LIB_SRCS})
 add_library(KF5::Plasma ALIAS KF5Plasma)
 
 if(HAVE_X11)
     set(PLASMA_EXTRA_LIBS ${PLASMA_EXTRA_LIBS} Qt5::X11Extras ${X11_LIBRARIES} XCB::XCB)
 endif()
 
 if(DL_LIBRARY)
     set(PLASMA_EXTRA_LIBS ${PLASMA_EXTRA_LIBS} ${DL_LIBRARY})
 endif()
 
 target_link_libraries(KF5Plasma
 PUBLIC
     KF5::Service # For kplugininfo.h and kservice.h
     Qt5::Gui
     KF5::Package
 PRIVATE
     Qt5::Sql
     Qt5::Svg
     Qt5::DBus
     KF5::Archive
     KF5::GuiAddons #kimagecache
     KF5::I18n
     KF5::KIOCore    #ServiceJob
     KF5::KIOWidgets  #KRun
     KF5::WindowSystem #compositingActive
     KF5::Declarative #runtimePlatform
     KF5::XmlGui   #KActionCollection
     KF5::GlobalAccel #Applet::setGlobalShortcut
     KF5::Notifications
     KF5::IconThemes
     ${PLASMA_EXTRA_LIBS}
 )
 
 target_include_directories(KF5Plasma PUBLIC
   "$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/..;${CMAKE_CURRENT_BINARY_DIR};${CMAKE_CURRENT_BINARY_DIR}/Plasma>"
 )
 target_include_directories(KF5Plasma INTERFACE
   "$<INSTALL_INTERFACE:${KDE_INSTALL_INCLUDEDIR_KF5};${KF5_INCLUDE_INSTALL_DIR}/Plasma>"
 )
 
 set_target_properties(KF5Plasma PROPERTIES
                                 VERSION ${PLASMA_VERSION_STRING}
                                 SOVERSION ${PLASMA_SOVERSION}
                                 EXPORT_NAME Plasma
                       )
 
 ########### install files ###############
 generate_export_header(KF5Plasma
     BASE_NAME Plasma
     EXPORT_FILE_NAME plasma/plasma_export.h)
 ecm_generate_headers(Plasma_CamelCase_HEADERS
     HEADER_NAMES
         Applet
         Containment
         ContainmentActions
         Corona
         DataContainer
         DataEngine
         DataEngineConsumer
         PluginLoader
         FrameSvg
         Package
         PackageStructure
         Service
         ServiceJob
         Svg
         Theme
         Plasma
     REQUIRED_HEADERS Plasma_HEADERS
     PREFIX Plasma
 )
 
 set(Plasma_HEADERS
     ${Plasma_HEADERS}
     version.h
 )
 
 set(PlasmaScripting_HEADERS
     scripting/appletscript.h
     scripting/dataenginescript.h
     scripting/scriptengine.h
 )
 
 
 install(FILES
         ${Plasma_HEADERS}
         ${CMAKE_CURRENT_BINARY_DIR}/plasma/plasma_export.h
         DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/plasma COMPONENT Devel)
 
 install(FILES ${Plasma_CamelCase_HEADERS}
         DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/Plasma COMPONENT Devel)
 
 
 install(FILES ${PlasmaScripting_HEADERS}
     DESTINATION ${KDE_INSTALL_INCLUDEDIR_KF5}/plasma/scripting COMPONENT Devel)
 
 install(FILES
    data/servicetypes/plasma-applet.desktop
    data/servicetypes/plasma-containment.desktop
    data/servicetypes/plasma-containmentactions.desktop
    data/servicetypes/plasma-dataengine.desktop
    data/servicetypes/plasma-generic.desktop
    data/servicetypes/plasma-packagestructure.desktop
    data/servicetypes/plasma-scriptengine.desktop
    data/servicetypes/plasma-service.desktop
    data/servicetypes/plasma-shell.desktop
    data/servicetypes/plasma-lookandfeel.desktop
    DESTINATION ${KDE_INSTALL_KSERVICETYPES5DIR})
 
 install(FILES data/operations/dataengineservice.operations DESTINATION ${PLASMA_DATA_INSTALL_DIR}/services)
 install(FILES data/operations/plasmoidservice.operations DESTINATION ${PLASMA_DATA_INSTALL_DIR}/services)
 install(FILES data/operations/storage.operations DESTINATION ${PLASMA_DATA_INSTALL_DIR}/services)
 
 install(TARGETS KF5Plasma EXPORT KF5PlasmaTargets ${KF5_INSTALL_TARGETS_DEFAULT_ARGS})
 
 if(BUILD_QCH)
     ecm_add_qch(
         KF5Plasma_QCH
         NAME Plasma
         BASE_NAME KF5Plasma
         VERSION ${KF5_VERSION}
         ORG_DOMAIN org.kde
         SOURCES # using only public headers, to cover only public API
             ${Plasma_HEADERS}
             ${PlasmaScripting_HEADERS}
             Mainpage.dox
         MD_MAINPAGE "${CMAKE_SOURCE_DIR}/README.md"
         LINK_QCHS
             Qt5Gui_QCH
             KF5Service_QCH
             KF5Package_QCH
         BLANK_MACROS
             PLASMA_EXPORT
             PLASMA_DEPRECATED
             PLASMA_DEPRECATED_EXPORT
         TAGFILE_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
         QCH_INSTALL_DESTINATION ${KDE_INSTALL_QTQCHDIR}
         COMPONENT Devel
     )
 endif()
diff --git a/src/plasma/config-plasma.h.cmake b/src/plasma/config-plasma.h.cmake
index 48aaee99a..f46bffe00 100644
--- a/src/plasma/config-plasma.h.cmake
+++ b/src/plasma/config-plasma.h.cmake
@@ -1,9 +1,8 @@
 #cmakedefine01 PLASMA_NO_KDEWEBKIT
-#cmakedefine01 PLASMA_NO_KIO
 #cmakedefine01 PLASMA_NO_KUTILS
 #cmakedefine01 HAVE_X11
 #cmakedefine01 HAVE_GLX
 #cmakedefine01 HAVE_EGL
 #cmakedefine01 HAVE_KWAYLAND
 
 #define PLASMA_RELATIVE_DATA_INSTALL_DIR "@PLASMA_RELATIVE_DATA_INSTALL_DIR@"
diff --git a/src/plasma/containment.cpp b/src/plasma/containment.cpp
index 86d680905..49b67418e 100644
--- a/src/plasma/containment.cpp
+++ b/src/plasma/containment.cpp
@@ -1,605 +1,599 @@
 /*
  *   Copyright 2007 by Aaron Seigo <aseigo@kde.org>
  *   Copyright 2008 by Ménard Alexis <darktears31@gmail.com>
  *   Copyright 2009 Chani Armitage <chani@kde.org>
  *   Copyright 2012 Marco Martin <notmart@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 "containment.h"
 #include "private/containment_p.h"
 
 #include "config-plasma.h"
 
 #include <QClipboard>
 #include <QDebug>
 #include <QFile>
 #include <QContextMenuEvent>
 #include <QMimeData>
 #include <QPainter>
 #include <qtemporaryfile.h>
 #include <qmimedatabase.h>
 
 #include <QDebug>
 #include <kauthorized.h>
 #include <klocalizedstring.h>
 #include <KConfigSkeleton>
 #include <KConfigLoader>
 
-#if !PLASMA_NO_KIO
-#include "kio/jobclasses.h" // for KIO::JobFlags
-#include "kio/job.h"
-#include "kio/scheduler.h"
-#endif
-
 #include "containmentactions.h"
 #include "corona.h"
 #include "pluginloader.h"
 #include "debug_p.h"
 
 #include "private/applet_p.h"
 
 #include "plasma/plasma.h"
 
 namespace Plasma
 {
 
 Containment::Containment(QObject *parent,
                          const QString &serviceId,
                          uint containmentId)
     : Applet(parent, serviceId, containmentId),
       d(new ContainmentPrivate(this))
 {
     // WARNING: do not access config() OR globalConfig() in this method!
     //          that requires a scene, which is not available at this point
     setContainmentType(Types::CustomContainment);
     setHasConfigurationInterface(true);
 }
 
 Containment::Containment(QObject *parent, const QVariantList &args)
     : Applet(parent, args),
       d(new ContainmentPrivate(this))
 {
     // WARNING: do not access config() OR globalConfig() in this method!
     //          that requires a scene, which is not available at this point
     setHasConfigurationInterface(true);
 }
 
 Containment::Containment(const KPluginMetaData &md, uint appletId)
     : Applet(md, nullptr, appletId),
       d(new ContainmentPrivate(this))
 {
     // WARNING: do not access config() OR globalConfig() in this method!
     //          that requires a scene, which is not available at this point
     setHasConfigurationInterface(true);
 }
 
 Containment::~Containment()
 {
     qDeleteAll(d->localActionPlugins);
     delete d;
 }
 
 void Containment::init()
 {
     Applet::init();
     static_cast<Applet *>(this)->d->setupScripting();
 
     if (d->type == Types::NoContainmentType) {
         //setContainmentType(Plasma::Types::DesktopContainment);
         //Try to determine the containment type. It must be done as soon as possible
         QString type = pluginMetaData().value(QStringLiteral("X-Plasma-ContainmentType"));
 
         if (type == QLatin1String("Panel")) {
             setContainmentType(Plasma::Types::PanelContainment);
         } else if (type == QLatin1String("Custom")) {
             setContainmentType(Plasma::Types::CustomContainment);
         } else if (type == QLatin1String("CustomPanel")) {
             setContainmentType(Plasma::Types::CustomPanelContainment);
             //default to desktop
         } else {
             setContainmentType(Plasma::Types::DesktopContainment);
         }
     }
 
     //connect actions
     ContainmentPrivate::addDefaultActions(actions(), this);
     bool unlocked = immutability() == Types::Mutable;
 
     //fix the text of the actions that need title()
     //btw, do we really want to use title() when it's a desktopcontainment?
     QAction *closeApplet = actions()->action(QStringLiteral("remove"));
     if (closeApplet) {
         closeApplet->setText(i18nc("%1 is the name of the applet", "Remove %1", title()));
     }
 
     QAction *configAction = actions()->action(QStringLiteral("configure"));
     if (configAction) {
         configAction->setText(i18nc("%1 is the name of the applet", "Configure %1...", title()));
     }
 
     QAction *appletBrowserAction = actions()->action(QStringLiteral("add widgets"));
     if (appletBrowserAction) {
         appletBrowserAction->setVisible(unlocked);
         appletBrowserAction->setEnabled(unlocked);
         connect(appletBrowserAction, SIGNAL(triggered()), this, SLOT(triggerShowAddWidgets()));
     }
 
     if (immutability() != Types::SystemImmutable && corona()) {
         QAction *lockDesktopAction = corona()->actions()->action(QStringLiteral("lock widgets"));
         //keep a pointer so nobody notices it moved to corona
         if (lockDesktopAction) {
             actions()->addAction(QStringLiteral("lock widgets"), lockDesktopAction);
         }
     }
 
     //HACK: this is valid only in the systray case
     connect(this, &Containment::configureRequested, this, [=] (Plasma::Applet *a) {
         if (Plasma::Applet *p = qobject_cast<Plasma::Applet *>(parent())) {
             emit p->containment()->configureRequested(a);
         }
     });
 }
 
 // helper function for sorting the list of applets
 bool appletConfigLessThan(const KConfigGroup &c1, const KConfigGroup &c2)
 {
     int i1 = c1.readEntry("id", 0);
     int i2 = c2.readEntry("id", 0);
 
     return (i1 < i2);
 }
 
 void Containment::restore(KConfigGroup &group)
 {
     /*
     #ifndef NDEBUG
     // qCDebug(LOG_PLASMA) << "!!!!!!!!!!!!initConstraints" << group.name() << d->type;
     // qCDebug(LOG_PLASMA) << "    location:" << group.readEntry("location", (int)d->location);
     // qCDebug(LOG_PLASMA) << "    geom:" << group.readEntry("geometry", geometry());
     // qCDebug(LOG_PLASMA) << "    formfactor:" << group.readEntry("formfactor", (int)d->formFactor);
     // qCDebug(LOG_PLASMA) << "    screen:" << group.readEntry("screen", d->screen);
     #endif
     */
     setLocation((Plasma::Types::Location)group.readEntry("location", (int)d->location));
     setFormFactor((Plasma::Types::FormFactor)group.readEntry("formfactor", (int)d->formFactor));
     d->lastScreen = group.readEntry("lastScreen", d->lastScreen);
 
     setWallpaper(group.readEntry("wallpaperplugin", ContainmentPrivate::defaultWallpaper));
 
     d->activityId = group.readEntry("activityId", QString());
 
     flushPendingConstraintsEvents();
     restoreContents(group);
     setImmutability((Types::ImmutabilityType)group.readEntry("immutability", (int)Types::Mutable));
 
     if (isContainment() && KAuthorized::authorize(QStringLiteral("plasma/containment_actions"))) {
         KConfigGroup cfg = KConfigGroup(corona()->config(), "ActionPlugins");
         cfg = KConfigGroup(&cfg, QString::number(containmentType()));
 
         //qCDebug(LOG_PLASMA) << cfg.keyList();
         if (cfg.exists()) {
             foreach (const QString &key, cfg.keyList()) {
                 //qCDebug(LOG_PLASMA) << "loading" << key;
                 setContainmentActions(key, cfg.readEntry(key, QString()));
             }
         } else { //shell defaults
             KConfigGroup defaultActionsCfg;
 
             switch (d->type) {
                 case Plasma::Types::PanelContainment:
                     /* fall through*/
                 case Plasma::Types::CustomPanelContainment:
                     defaultActionsCfg = KConfigGroup(KSharedConfig::openConfig(corona()->kPackage().filePath("defaults")), "Panel");
                     break;
                 case Plasma::Types::DesktopContainment:
                     defaultActionsCfg = KConfigGroup(KSharedConfig::openConfig(corona()->kPackage().filePath("defaults")), "Desktop");
                     break;
                 default:
                     //for any other type of containment, there are no defaults
                     break;
             }
             if (defaultActionsCfg.isValid()) {
                 defaultActionsCfg = KConfigGroup(&defaultActionsCfg, "ContainmentActions");
                 foreach (const QString &key, defaultActionsCfg.keyList()) {
                     setContainmentActions(key, defaultActionsCfg.readEntry(key, QString()));
                 }
             }
         }
     }
 
     /*
     #ifndef NDEBUG
     // qCDebug(LOG_PLASMA) << "Containment" << id() <<
     #endif
                 "screen" << screen() <<
                 "geometry is" << geometry() <<
                 "config entries" << group.entryMap();
     */
 }
 
 void Containment::save(KConfigGroup &g) const
 {
     if (Applet::d->transient) {
         return;
     }
 
     KConfigGroup group = g;
     if (!group.isValid()) {
         group = config();
     }
 
     // locking is saved in Applet::save
     Applet::save(group);
 
 //     group.writeEntry("screen", d->screen);
     group.writeEntry("lastScreen", d->lastScreen);
     group.writeEntry("formfactor", (int)d->formFactor);
     group.writeEntry("location", (int)d->location);
     group.writeEntry("activityId", d->activityId);
 
     group.writeEntry("wallpaperplugin", d->wallpaper);
 
     saveContents(group);
 }
 
 void Containment::saveContents(KConfigGroup &group) const
 {
     KConfigGroup applets(&group, "Applets");
     foreach (const Applet *applet, d->applets) {
         KConfigGroup appletConfig(&applets, QString::number(applet->id()));
         applet->save(appletConfig);
     }
 }
 
 void Containment::restoreContents(KConfigGroup &group)
 {
     KConfigGroup applets(&group, "Applets");
 
     //restore the applets ordered by id
     QStringList groups = applets.groupList();
     qSort(groups.begin(), groups.end());
 
     // Sort the applet configs in order of geometry to ensure that applets
     // are added from left to right or top to bottom for a panel containment
     QList<KConfigGroup> appletConfigs;
     foreach (const QString &appletGroup, groups) {
         //qCDebug(LOG_PLASMA) << "reading from applet group" << appletGroup;
         KConfigGroup appletConfig(&applets, appletGroup);
         appletConfigs.append(appletConfig);
     }
     qStableSort(appletConfigs.begin(), appletConfigs.end(), appletConfigLessThan);
 
     QMutableListIterator<KConfigGroup> it(appletConfigs);
     while (it.hasNext()) {
         KConfigGroup &appletConfig = it.next();
         int appId = appletConfig.name().toUInt();
         QString plugin = appletConfig.readEntry("plugin", QString());
 
         if (plugin.isEmpty()) {
             continue;
         }
 
         d->createApplet(plugin, QVariantList(), appId);
     }
 
     //if there are no applets, none of them is "loading"
     if (Containment::applets().isEmpty()) {
         d->appletsUiReady = true;
     }
     foreach (Applet *applet, Containment::applets()) {
         if (!applet->pluginMetaData().isValid()) {
             applet->updateConstraints(Plasma::Types::UiReadyConstraint);
         }
     }
 }
 
 Plasma::Types::ContainmentType Containment::containmentType() const
 {
     return d->type;
 }
 
 void Containment::setContainmentType(Plasma::Types::ContainmentType type)
 {
     if (d->type == type) {
         return;
     }
 
     d->type = type;
     emit containmentTypeChanged();
 }
 
 Corona *Containment::corona() const
 {
     if(Plasma::Corona* corona = qobject_cast<Corona *>(parent())) {
         return corona;
     //case in which this containment is child of an applet, hello systray :)
     } else {
         Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(parent());
         if (parentApplet && parentApplet->containment()) {
             return parentApplet->containment()->corona();
         }
     }
 
     return nullptr;
 }
 
 void Containment::setFormFactor(Types::FormFactor formFactor)
 {
     if (d->formFactor == formFactor) {
         return;
     }
 
     //qCDebug(LOG_PLASMA) << "switching FF to " << formFactor;
     d->formFactor = formFactor;
 
     updateConstraints(Plasma::Types::FormFactorConstraint);
 
     KConfigGroup c = config();
     c.writeEntry("formfactor", (int)formFactor);
     emit configNeedsSaving();
     emit formFactorChanged(formFactor);
 }
 
 void Containment::setLocation(Types::Location location)
 {
     if (d->location == location) {
         return;
     }
 
     d->location = location;
 
     foreach (Applet *applet, d->applets) {
         applet->updateConstraints(Plasma::Types::LocationConstraint);
     }
 
     updateConstraints(Plasma::Types::LocationConstraint);
 
     KConfigGroup c = config();
     c.writeEntry("location", (int)location);
     emit configNeedsSaving();
     emit locationChanged(location);
 }
 
 Applet *Containment::createApplet(const QString &name, const QVariantList &args)
 {
     Plasma::Applet *applet = d->createApplet(name, args);
     if (applet) {
         emit appletCreated(applet);
     }
     return applet;
 }
 
 void Containment::addApplet(Applet *applet)
 {
     if (!applet) {
 #ifndef NDEBUG
         // qCDebug(LOG_PLASMA) << "adding null applet!?!";
 #endif
         return;
     }
 
     if (immutability() != Types::Mutable && !applet->property("org.kde.plasma:force-create").toBool()) {
         return;
     }
 
 #ifndef NDEBUG
     if (d->applets.contains(applet)) {
         // qCDebug(LOG_PLASMA) << "already have this applet!";
     }
 #endif
 
     Containment *currentContainment = applet->containment();
 
     if (currentContainment && currentContainment != this) {
         emit currentContainment->appletRemoved(applet);
 
         disconnect(applet, nullptr, currentContainment, nullptr);
         KConfigGroup oldConfig = applet->config();
         currentContainment->d->applets.removeAll(applet);
         applet->setParent(this);
 
         // now move the old config to the new location
         //FIXME: this doesn't seem to get the actual main config group containing plugin=, etc
         KConfigGroup c = config().group("Applets").group(QString::number(applet->id()));
         oldConfig.reparent(&c);
         applet->d->resetConfigurationObject();
 
         disconnect(applet, SIGNAL(activated()), currentContainment, SIGNAL(activated()));
         //change the group to its configloader, if any
         //FIXME: this is very, very brutal
         if (applet->configScheme()) {
             const QString oldGroupPrefix = QStringLiteral("Containments") + QString::number(currentContainment->id()) + QStringLiteral("Applets");
             const QString newGroupPrefix = QStringLiteral("Containments") + QString::number(id()) + QStringLiteral("Applets");
 
             applet->configScheme()->setCurrentGroup(applet->configScheme()->currentGroup().replace(0, oldGroupPrefix.length(), newGroupPrefix));
 
             foreach (KConfigSkeletonItem *item, applet->configScheme()->items()) {
                 item->setGroup(item->group().replace(0, oldGroupPrefix.length(), newGroupPrefix));
             }
         }
     } else {
         applet->setParent(this);
     }
 
     //make sure the applets are sorted by id
     auto position = std::lower_bound(d->applets.begin(), d->applets.end(), applet, [](Plasma::Applet *a1,  Plasma::Applet *a2) {
         return a1->id() < a2->id();
     });
     d->applets.insert(position, applet);
 
     if (!d->uiReady) {
         d->loadingApplets << applet;
     }
 
     connect(applet, SIGNAL(configNeedsSaving()), this, SIGNAL(configNeedsSaving()));
     connect(applet, SIGNAL(appletDeleted(Plasma::Applet*)), this, SLOT(appletDeleted(Plasma::Applet*)));
     connect(applet, SIGNAL(statusChanged(Plasma::Types::ItemStatus)), this, SLOT(checkStatus(Plasma::Types::ItemStatus)));
     connect(applet, SIGNAL(activated()), this, SIGNAL(activated()));
 
     if (!currentContainment) {
         const bool isNew = applet->d->mainConfigGroup()->entryMap().isEmpty();
 
         if (!isNew) {
             applet->restore(*applet->d->mainConfigGroup());
         }
 
         applet->init();
         applet->d->setupScripting();
 
         if (isNew) {
             applet->save(*applet->d->mainConfigGroup());
             emit configNeedsSaving();
         }
         //FIXME: an on-appear animation would be nice to have again
     }
 
     applet->updateConstraints(Plasma::Types::AllConstraints);
     applet->flushPendingConstraintsEvents();
 
     emit appletAdded(applet);
 
     if (!currentContainment) {
         applet->updateConstraints(Plasma::Types::StartupCompletedConstraint);
         applet->flushPendingConstraintsEvents();
     }
 
     applet->d->scheduleModificationNotification();
 }
 
 QList<Applet *> Containment::applets() const
 {
     return d->applets;
 }
 
 int Containment::screen() const
 {
     Q_ASSERT(corona());
     if (Corona* c = corona()) {
         return c->screenForContainment(this);
     } else {
         return -1;
     }
 }
 
 int Containment::lastScreen() const
 {
     return d->lastScreen;
 }
 
 void Containment::setWallpaper(const QString &pluginName)
 {
     if (pluginName != d->wallpaper) {
         d->wallpaper = pluginName;
 
         KConfigGroup cfg = config();
         cfg.writeEntry("wallpaperplugin", d->wallpaper);
         emit configNeedsSaving();
         emit wallpaperChanged();
     }
 }
 
 QString Containment::wallpaper() const
 {
     return d->wallpaper;
 }
 
 void Containment::setContainmentActions(const QString &trigger, const QString &pluginName)
 {
     KConfigGroup cfg = d->containmentActionsConfig();
     ContainmentActions *plugin = nullptr;
 
     plugin = containmentActions().value(trigger);
     if (plugin && plugin->pluginInfo().pluginName() != pluginName) {
         containmentActions().remove(trigger);
         delete plugin;
         plugin = nullptr;
     }
 
     if (pluginName.isEmpty()) {
         cfg.deleteEntry(trigger);
     } else if (plugin) {
         //it already existed, just reload config
         plugin->setContainment(this); //to be safe
         //FIXME make a truly unique config group
         KConfigGroup pluginConfig = KConfigGroup(&cfg, trigger);
         plugin->restore(pluginConfig);
 
     } else {
         plugin = PluginLoader::self()->loadContainmentActions(this, pluginName);
 
         if (plugin) {
             cfg.writeEntry(trigger, pluginName);
             containmentActions().insert(trigger, plugin);
             plugin->setContainment(this);
             KConfigGroup pluginConfig = KConfigGroup(&cfg, trigger);
             plugin->restore(pluginConfig);
         } else {
             //bad plugin... gets removed. is this a feature or a bug?
             cfg.deleteEntry(trigger);
         }
     }
 
     emit configNeedsSaving();
 }
 
 QHash<QString, ContainmentActions *> &Containment::containmentActions()
 {
     return d->localActionPlugins;
 }
 
 bool Containment::isUiReady() const
 {
     return d->uiReady && d->appletsUiReady && Applet::d->started;
 }
 
 void Containment::setActivity(const QString &activityId)
 {
     if (activityId.isEmpty() || d->activityId == activityId) {
         return;
     }
 
     d->activityId = activityId;
     KConfigGroup c = config();
     c.writeEntry("activityId", activityId);
 
     emit configNeedsSaving();
     emit activityChanged(activityId);
 }
 
 QString Containment::activity() const
 {
     return d->activityId;
 }
 
 void Containment::reactToScreenChange()
 {
     int newScreen = screen();
 
     if (newScreen >= 0) {
         d->lastScreen = newScreen;
         KConfigGroup c = config();
         c.writeEntry("lastScreen", d->lastScreen);
         emit configNeedsSaving();
     }
 
     emit screenChanged(newScreen);
 }
 
 } // Plasma namespace
 
 #include "moc_containment.cpp"
diff --git a/src/plasma/pluginloader.cpp b/src/plasma/pluginloader.cpp
index daf5e661b..8faefa442 100644
--- a/src/plasma/pluginloader.cpp
+++ b/src/plasma/pluginloader.cpp
@@ -1,924 +1,920 @@
 /*
  *   Copyright 2010 Ryan Rix <ry@n.rix.si>
  *
  *   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 "pluginloader.h"
 
 #include <QPointer>
 #include <QStandardPaths>
 
 #include <QDebug>
 #include <kservice.h>
 #include <kservicetypetrader.h>
 #include <kplugintrader.h>
 #include <KPluginLoader>
 #include <kpackage/packageloader.h>
 
 #include "config-plasma.h"
 
-#if !PLASMA_NO_KIO
-#include <kio/job.h>
-#endif
-
 #include "applet.h"
 #include "containment.h"
 #include "containmentactions.h"
 #include "dataengine.h"
 #include "package.h"
 #include "private/applet_p.h"
 #include "private/service_p.h" // for NullService
 #include "private/storage_p.h"
 #include "private/package_p.h"
 #include "private/packagestructure_p.h"
 #include <plasma/version.h>
 #include "debug_p.h"
 
 namespace Plasma
 {
 
 static PluginLoader *s_pluginLoader = nullptr;
 
 class PluginLoaderPrivate
 {
 public:
     PluginLoaderPrivate()
         : isDefaultLoader(false)
     {
     }
 
     static QSet<QString> knownCategories();
     static QString parentAppConstraint(const QString &parentApp = QString());
 
     static QSet<QString> s_customCategories;
     QHash<QString, QPointer<PackageStructure> > structures;
     bool isDefaultLoader;
 
     static QString s_dataEnginePluginDir;
     static QString s_packageStructurePluginDir;
     static QString s_plasmoidsPluginDir;
     static QString s_servicesPluginDir;
     static QString s_containmentActionsPluginDir;
 
     // We only use this cache during start of the process to speed up many consecutive calls
     // After that, we're too afraid to produce race conditions and it's not that time-critical anyway
     // the 20 seconds here means that the cache is only used within 20sec during startup, after that,
     // complexity goes up and we'd have to update the cache in order to avoid subtle bugs
     // just not using the cache is way easier then, since it doesn't make *that* much of a difference,
     // anyway
     int maxCacheAge = 20;
     qint64 pluginCacheAge = 0;
     QHash<QString, QVector<KPluginMetaData>> pluginCache;
 };
 
 QSet<QString> PluginLoaderPrivate::s_customCategories;
 
 QString PluginLoaderPrivate::s_dataEnginePluginDir = QStringLiteral("plasma/dataengine");
 QString PluginLoaderPrivate::s_packageStructurePluginDir = QStringLiteral("plasma/packagestructure");
 QString PluginLoaderPrivate::s_plasmoidsPluginDir = QStringLiteral("plasma/applets");
 QString PluginLoaderPrivate::s_servicesPluginDir = QStringLiteral("plasma/services");
 QString PluginLoaderPrivate::s_containmentActionsPluginDir = QStringLiteral("plasma/containmentactions");
 
 QSet<QString> PluginLoaderPrivate::knownCategories()
 {
     // this is to trick the tranlsation tools into making the correct
     // strings for translation
     QSet<QString> categories = s_customCategories;
     categories << QStringLiteral(I18N_NOOP("Accessibility")).toLower()
                << QStringLiteral(I18N_NOOP("Application Launchers")).toLower()
                << QStringLiteral(I18N_NOOP("Astronomy")).toLower()
                << QStringLiteral(I18N_NOOP("Date and Time")).toLower()
                << QStringLiteral(I18N_NOOP("Development Tools")).toLower()
                << QStringLiteral(I18N_NOOP("Education")).toLower()
                << QStringLiteral(I18N_NOOP("Environment and Weather")).toLower()
                << QStringLiteral(I18N_NOOP("Examples")).toLower()
                << QStringLiteral(I18N_NOOP("File System")).toLower()
                << QStringLiteral(I18N_NOOP("Fun and Games")).toLower()
                << QStringLiteral(I18N_NOOP("Graphics")).toLower()
                << QStringLiteral(I18N_NOOP("Language")).toLower()
                << QStringLiteral(I18N_NOOP("Mapping")).toLower()
                << QStringLiteral(I18N_NOOP("Miscellaneous")).toLower()
                << QStringLiteral(I18N_NOOP("Multimedia")).toLower()
                << QStringLiteral(I18N_NOOP("Online Services")).toLower()
                << QStringLiteral(I18N_NOOP("Productivity")).toLower()
                << QStringLiteral(I18N_NOOP("System Information")).toLower()
                << QStringLiteral(I18N_NOOP("Utilities")).toLower()
                << QStringLiteral(I18N_NOOP("Windows and Tasks")).toLower()
                << QStringLiteral(I18N_NOOP("Clipboard")).toLower()
                << QStringLiteral(I18N_NOOP("Tasks")).toLower();
     return categories;
 }
 
 QString PluginLoaderPrivate::parentAppConstraint(const QString &parentApp)
 {
     if (parentApp.isEmpty()) {
         QCoreApplication *app = QCoreApplication::instance();
         if (!app) {
             return QString();
         }
 
         return QStringLiteral("((not exist [X-KDE-ParentApp] or [X-KDE-ParentApp] == '') or [X-KDE-ParentApp] == '%1')")
                .arg(app->applicationName());
     }
 
     return QStringLiteral("[X-KDE-ParentApp] == '%1'").arg(parentApp);
 }
 
 PluginLoader::PluginLoader()
     : d(new PluginLoaderPrivate)
 {
 }
 
 PluginLoader::~PluginLoader()
 {
     typedef QPointer<PackageStructure> pswp;
     foreach (pswp wp, d->structures) {
         delete wp.data();
     }
     delete d;
 }
 
 void PluginLoader::setPluginLoader(PluginLoader *loader)
 {
     if (!s_pluginLoader) {
         s_pluginLoader = loader;
     } else {
 #ifndef NDEBUG
         // qCDebug(LOG_PLASMA) << "Cannot set pluginLoader, already set!" << s_pluginLoader;
 #endif
     }
 }
 
 PluginLoader *PluginLoader::self()
 {
     if (!s_pluginLoader) {
         // we have been called before any PluginLoader was set, so just use the default
         // implementation. this prevents plugins from nefariously injecting their own
         // plugin loader if the app doesn't
         s_pluginLoader = new PluginLoader;
         s_pluginLoader->d->isDefaultLoader = true;
     }
 
     return s_pluginLoader;
 }
 
 Applet *PluginLoader::loadApplet(const QString &name, uint appletId, const QVariantList &args)
 {
     if (name.isEmpty()) {
         return nullptr;
     }
 
     Applet *applet = d->isDefaultLoader ? nullptr : internalLoadApplet(name, appletId, args);
     if (applet) {
         return applet;
     }
 
     if (appletId == 0) {
         appletId = ++AppletPrivate::s_maxAppletId;
     }
 
     const qint64 now = qRound64(QDateTime::currentMSecsSinceEpoch() / 1000.0);
     bool useRuntimeCache = true;
     if (now - d->pluginCacheAge > d->maxCacheAge && d->pluginCacheAge != 0) {
         // cache is old and we're not within a few seconds of startup anymore
         useRuntimeCache = false;
         d->pluginCache.clear();
     }
 
     if (d->pluginCacheAge == 0) {
         // Find all the plugins now, but only once
         d->pluginCacheAge = now;
 
         auto insertIntoCache = [this](const QString &pluginPath) {
             KPluginMetaData metadata(pluginPath);
             if (!metadata.isValid()) {
                 return;
             }
 
             d->pluginCache[metadata.pluginId()].append(metadata);
         };
 
         KPluginLoader::forEachPlugin(PluginLoaderPrivate::s_plasmoidsPluginDir, insertIntoCache);
         // COMPAT CODE for applets installed into the toplevel plugins dir by mistake.
         KPluginLoader::forEachPlugin(QString(), insertIntoCache);
     }
 
     //if name wasn't a path, pluginName == name
     const QString pluginName = name.section(QLatin1Char('/'), -1);
 
     QVector<KPluginMetaData> plugins;
 
     if (useRuntimeCache) {
         auto it = d->pluginCache.constFind(pluginName);
         if (it != d->pluginCache.constEnd()) {
             plugins = *it;
         }
     } else {
         plugins = KPluginLoader::findPluginsById(PluginLoaderPrivate::s_plasmoidsPluginDir, pluginName);
         // COMPAT CODE for applets installed into the toplevel plugins dir by mistake.
         if (plugins.isEmpty()) {
             plugins = KPluginLoader::findPluginsById(QString(), pluginName);
         }
     }
 
     const KPackage::Package p = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Applet"), name);
 
     if (!plugins.isEmpty()) {
         KPluginLoader loader(plugins.first().fileName());
         if (!isPluginVersionCompatible(loader)) {
             return nullptr;
         }
         KPluginFactory *factory = loader.factory();
         if (factory) {
             QVariantList allArgs;
             allArgs << QVariant::fromValue(p) << loader.metaData().toVariantMap() << appletId << args;
             applet = factory->create<Plasma::Applet>(nullptr, allArgs);
         }
     }
     if (applet) {
         return applet;
     }
 
 
     if (!applet) {
         //qCDebug(LOG_PLASMA) << name << "not a C++ applet: Falling back to an empty one";
 
         QVariantList allArgs;
         allArgs << QVariant::fromValue(p) << p.metadata().fileName() << appletId << args;
 
         if (p.metadata().serviceTypes().contains(QStringLiteral("Plasma/Containment"))) {
             applet = new Containment(nullptr, allArgs);
         } else {
             applet = new Applet(nullptr, allArgs);
         }
 
     }
 
    const QString localePath = p.filePath("translations");
     if (!localePath.isEmpty()) {
         KLocalizedString::addDomainLocaleDir(QByteArray("plasma_applet_") + name.toLatin1(), localePath);
     }
     return applet;
 }
 
 DataEngine *PluginLoader::loadDataEngine(const QString &name)
 {
     DataEngine *engine = d->isDefaultLoader ? nullptr : internalLoadDataEngine(name);
     if (engine) {
         return engine;
     }
 
     // Look for C++ plugins first
     auto filter = [&name](const KPluginMetaData &md) -> bool
     {
         return md.pluginId() == name;
     };
     QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_dataEnginePluginDir, filter);
 
     if (!plugins.isEmpty()) {
         KPluginLoader loader(plugins.first().fileName());
         const QVariantList argsWithMetaData = QVariantList() << loader.metaData().toVariantMap();
         KPluginFactory *factory = loader.factory();
         if (factory) {
             engine = factory->create<Plasma::DataEngine>(nullptr, argsWithMetaData);
         }
     }
     if (engine) {
         return engine;
     }
 
     const KPackage::Package p = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/DataEngine"), name);
     if (!p.isValid()) {
         return nullptr;
     }
 
     return new DataEngine(KPluginInfo(p.metadata().fileName()), nullptr);
 }
 
 QStringList PluginLoader::listAllEngines(const QString &parentApp)
 {
     QStringList engines;
     // Look for C++ plugins first
     auto filter = [&parentApp](const KPluginMetaData &md) -> bool
     {
         return md.value(QStringLiteral("X-KDE-ParentApp")) == parentApp;
     };
     QVector<KPluginMetaData> plugins;
     if (parentApp.isEmpty()) {
         plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_dataEnginePluginDir);
     } else {
         plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_dataEnginePluginDir, filter);
     }
 
     foreach (auto& plugin, plugins) {
         engines << plugin.pluginId();
     }
 
     const QList<KPluginMetaData> packagePlugins = KPackage::PackageLoader::self()->listPackages(QStringLiteral("Plasma/DataEngine"));
     for (auto& plugin : packagePlugins) {
         engines << plugin.pluginId();
     }
 
     return engines;
 }
 
 KPluginInfo::List PluginLoader::listEngineInfo(const QString &parentApp)
 {
     return PluginLoader::self()->listDataEngineInfo(parentApp);
 }
 
 KPluginInfo::List PluginLoader::listEngineInfoByCategory(const QString &category, const QString &parentApp)
 {
     KPluginInfo::List list;
 
     // Look for C++ plugins first
     auto filterNormal = [&category](const KPluginMetaData &md) -> bool
     {
         return md.value(QStringLiteral("X-KDE-PluginInfo-Category")) == category;
     };
     auto filterParentApp = [&category, &parentApp](const KPluginMetaData &md) -> bool
     {
         return md.value(QStringLiteral("X-KDE-ParentApp")) == parentApp
             && md.value(QStringLiteral("X-KDE-PluginInfo-Category")) == category;
     };
     QVector<KPluginMetaData> plugins;
     if (parentApp.isEmpty()) {
         plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_dataEnginePluginDir, filterNormal);
     } else {
         plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_dataEnginePluginDir, filterParentApp);
     }
 
     list = KPluginInfo::fromMetaData(plugins);
 
 
     //TODO FIXME: PackageLoader needs to have a function to inject packageStructures
     const QList<KPluginMetaData> packagePlugins = KPackage::PackageLoader::self()->listPackages(QStringLiteral("Plasma/DataEngine"));
     list << KPluginInfo::fromMetaData(packagePlugins.toVector());
 
     return list;
 }
 
 Service *PluginLoader::loadService(const QString &name, const QVariantList &args, QObject *parent)
 {
     Service *service = d->isDefaultLoader ? nullptr : internalLoadService(name, args, parent);
     if (service) {
         return service;
     }
 
     //TODO: scripting API support
     if (name.isEmpty()) {
         return new NullService(QString(), parent);
     } else if (name == QLatin1String("org.kde.servicestorage")) {
         return new Storage(parent);
     }
 
 
     // Look for C++ plugins first
     auto filter = [&name](const KPluginMetaData &md) -> bool
     {
         return md.pluginId() == name;
     };
     QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_servicesPluginDir, filter);
 
     if (!plugins.isEmpty()) {
         KPluginLoader loader(plugins.first().fileName());
         if (!isPluginVersionCompatible(loader)) {
             return nullptr;
         }
         KPluginFactory *factory = loader.factory();
         if (factory) {
             service = factory->create<Plasma::Service>(nullptr, args);
         }
     }
 
     if (service) {
         if (service->name().isEmpty()) {
             service->setName(name);
         }
         return service;
     } else {
         return new NullService(name, parent);
     }
 }
 
 ContainmentActions *PluginLoader::loadContainmentActions(Containment *parent, const QString &name, const QVariantList &args)
 {
     if (name.isEmpty()) {
         return nullptr;
     }
 
     ContainmentActions *actions = d->isDefaultLoader ? nullptr : internalLoadContainmentActions(parent, name, args);
     if (actions) {
         return actions;
     }
 
 
     // Look for C++ plugins first
     auto filter = [&name](const KPluginMetaData &md) -> bool
     {
         return md.pluginId() == name;
     };
     QVector<KPluginMetaData> plugins = KPluginLoader::findPlugins(PluginLoaderPrivate::s_containmentActionsPluginDir, filter);
 
     if (!plugins.isEmpty()) {
         KPluginLoader loader(plugins.first().fileName());
         const QVariantList argsWithMetaData = QVariantList() << loader.metaData().toVariantMap();
         KPluginFactory *factory = loader.factory();
         if (factory) {
             actions = factory->create<Plasma::ContainmentActions>(nullptr, argsWithMetaData);
         }
     }
     if (actions) {
         return actions;
     }
 
     //FIXME: this is only for backwards compatibility, but probably will have to stay
     //for the time being
     QString constraint = QStringLiteral("[X-KDE-PluginInfo-Name] == '%1'").arg(name);
     KService::List offers = KServiceTypeTrader::self()->query(QStringLiteral("Plasma/ContainmentActions"), constraint);
 
     if (offers.isEmpty()) {
 #ifndef NDEBUG
         qCDebug(LOG_PLASMA) << "offers is empty for " << name;
 #endif
         return nullptr;
     }
 
     KService::Ptr offer = offers.first();
     KPluginLoader plugin(*offer);
 
     if (!isPluginVersionCompatible(plugin)) {
         return nullptr;
     }
 
     QVariantList allArgs;
     allArgs << offer->storageId() << args;
     QString error;
     actions = offer->createInstance<Plasma::ContainmentActions>(parent, allArgs, &error);
 
     if (!actions) {
 #ifndef NDEBUG
         // qCDebug(LOG_PLASMA) << "Couldn't load containmentActions \"" << name << "\"! reason given: " << error;
 #endif
     }
 
     return actions;
 }
 
 #ifndef PLASMA_NO_DEPRECATED
 Package PluginLoader::loadPackage(const QString &packageFormat, const QString &specialization)
 {
     if (!d->isDefaultLoader) {
         Package p = internalLoadPackage(packageFormat, specialization);
         if (p.hasValidStructure()) {
             return p;
         }
     }
 
     if (packageFormat.isEmpty()) {
         return Package();
     }
 
     const QString hashkey = packageFormat + QLatin1Char('%') + specialization;
     PackageStructure *structure = d->structures.value(hashkey).data();
 
     if (structure) {
         return Package(structure);
     }
 
     KPackage::PackageStructure *internalStructure = KPackage::PackageLoader::self()->loadPackageStructure(packageFormat);
 
     if (internalStructure) {
         structure = new PackageStructure();
         structure->d->internalStructure = internalStructure;
     //fallback to old structures
     } else {
         const QString constraint = QStringLiteral("[X-KDE-PluginInfo-Name] == '%1'").arg(packageFormat);
         structure = KPluginTrader::createInstanceFromQuery<Plasma::PackageStructure>(PluginLoaderPrivate::s_packageStructurePluginDir, QStringLiteral("Plasma/PackageStructure"), constraint, nullptr);
         if (structure) {
             structure->d->internalStructure = new PackageStructureWrapper(structure);
         }
     }
 
 
     if (structure) {
         d->structures.insert(hashkey, structure);
         return Package(structure);
     }
 
 #ifndef NDEBUG
         // qCDebug(LOG_PLASMA) << "Couldn't load Package for" << packageFormat << "! reason given: " << error;
 #endif
 
     return Package();
 }
 #endif
 
 QList<KPluginMetaData> PluginLoader::listAppletMetaData(const QString &category, const QString &parentApp)
 {
     //FIXME: this assumes we are always use packages.. no pure c++
     std::function<bool(const KPluginMetaData&)> filter;
     if (category.isEmpty()) { //use all but the excluded categories
         KConfigGroup group(KSharedConfig::openConfig(), "General");
         QStringList excluded = group.readEntry("ExcludeCategories", QStringList());
 
         filter = [excluded, parentApp](const KPluginMetaData &md) -> bool
         {
             const QString pa = md.value(QStringLiteral("X-KDE-ParentApp"));
             return (pa.isEmpty() || pa == parentApp) && !excluded.contains(md.category());
         };
     } else { //specific category (this could be an excluded one - is that bad?)
 
         filter = [category, parentApp](const KPluginMetaData &md) -> bool
         {
             const QString pa = md.value(QStringLiteral("X-KDE-ParentApp"));
             if (category == QLatin1String("Miscellaneous")) {
                 return (pa.isEmpty() || pa == parentApp) && (md.category() == category || md.category().isEmpty());
             } else {
                 return (pa.isEmpty() || pa == parentApp) && md.category() == category;
             }
         };
     }
 
     QList<KPluginMetaData> list;
     if (!d->isDefaultLoader && (parentApp.isEmpty() || parentApp == QCoreApplication::instance()->applicationName())) {
         list = KPluginInfo::toMetaData(internalAppletInfo(category)).toList();
     }
     return KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), filter);
 }
 
 KPluginInfo::List PluginLoader::listAppletInfo(const QString &category, const QString &parentApp)
 {
     KPluginInfo::List list;
     const auto plugins = listAppletMetaData(category, parentApp);
 
     //NOTE: it still produces kplugininfos from KServices because some user code expects
     //info.sevice() to be valid and would crash ohtherwise
     foreach (auto& md, plugins) {
         auto pi = md.metaDataFileName().endsWith(QLatin1String(".json")) ? KPluginInfo(md) : KPluginInfo(KService::serviceByStorageId(md.metaDataFileName()));
         if (!pi.isValid()) {
             qCWarning(LOG_PLASMA) << "Could not load plugin info for plugin :" << md.pluginId() << "skipping plugin";
             continue;
         }
         list << pi;
     }
     return list;
 }
 
 QList<KPluginMetaData> PluginLoader::listAppletMetaDataForMimeType(const QString &mimeType)
 {
     auto filter = [&mimeType](const KPluginMetaData &md) -> bool
     {
         return KPluginMetaData::readStringList(md.rawData(), QStringLiteral("X-Plasma-DropMimeTypes")).contains(mimeType);
     };
     return KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), filter);
 }
 
 KPluginInfo::List PluginLoader::listAppletInfoForMimeType(const QString &mimeType)
 {
     return KPluginInfo::fromMetaData(listAppletMetaDataForMimeType(mimeType).toVector());
 }
 
 QList<KPluginMetaData> PluginLoader::listAppletMetaDataForUrl(const QUrl &url)
 {
     QString parentApp;
     QCoreApplication *app = QCoreApplication::instance();
     if (app) {
         parentApp = app->applicationName();
     }
 
     auto filter = [&parentApp](const KPluginMetaData &md) -> bool
     {
         const QString pa = md.value(QStringLiteral("X-KDE-ParentApp"));
         return (pa.isEmpty() || pa == parentApp) && !KPluginMetaData::readStringList(md.rawData(), QStringLiteral("X-Plasma-DropUrlPatterns")).isEmpty();
     };
     const QList<KPluginMetaData> allApplets = KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), filter);
 
     QList<KPluginMetaData> filtered;
     foreach (const KPluginMetaData &md, allApplets) {
         QStringList urlPatterns = KPluginMetaData::readStringList(md.rawData(), QStringLiteral("X-Plasma-DropUrlPatterns"));
         foreach (const QString &glob, urlPatterns) {
             QRegExp rx(glob);
             rx.setPatternSyntax(QRegExp::Wildcard);
             if (rx.exactMatch(url.toString())) {
 #ifndef NDEBUG
                 // qCDebug(LOG_PLASMA) << md.name() << "matches" << glob << url;
 #endif
                 filtered << md;
             }
         }
     }
 
     return filtered;
 }
 
 KPluginInfo::List PluginLoader::listAppletInfoForUrl(const QUrl &url)
 {
     return KPluginInfo::fromMetaData(listAppletMetaDataForUrl(url).toVector());
 }
 
 QStringList PluginLoader::listAppletCategories(const QString &parentApp, bool visibleOnly)
 {
     KConfigGroup group(KSharedConfig::openConfig(), "General");
     const QStringList excluded = group.readEntry("ExcludeCategories", QStringList());
     auto filter = [&parentApp, &excluded, visibleOnly](const KPluginMetaData &md) -> bool
     {
         const QString pa = md.value(QStringLiteral("X-KDE-ParentApp"));
         return (pa.isEmpty() || pa == parentApp)
             && (excluded.isEmpty() || excluded.contains(md.value(QStringLiteral("X-KDE-PluginInfo-Category"))))
             && (!visibleOnly || !md.isHidden());
     };
     const QList<KPluginMetaData> allApplets = KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), filter);
 
 
     QStringList categories;
     foreach (auto& plugin, allApplets) {
         if (plugin.category().isEmpty()) {
             if (!categories.contains(i18nc("misc category", "Miscellaneous"))) {
                 categories << i18nc("misc category", "Miscellaneous");
             }
         } else {
             categories << plugin.category();
         }
     }
     categories.sort();
     return categories;
 }
 
 void PluginLoader::setCustomAppletCategories(const QStringList &categories)
 {
     PluginLoaderPrivate::s_customCategories = QSet<QString>::fromList(categories);
 }
 
 QStringList PluginLoader::customAppletCategories() const
 {
     return PluginLoaderPrivate::s_customCategories.toList();
 }
 
 QString PluginLoader::appletCategory(const QString &appletName)
 {
     if (appletName.isEmpty()) {
         return QString();
     }
 
     const KPackage::Package p = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/Applet"), appletName);
     if (!p.isValid()) {
         return QString();
     }
 
     return p.metadata().category();
 }
 
 KPluginInfo::List PluginLoader::listContainments(const QString &category,
         const QString &parentApp)
 {
     return listContainmentsOfType(QString(), category, parentApp);
 }
 
 KPluginInfo::List PluginLoader::listContainmentsOfType(const QString &type,
         const QString &category,
         const QString &parentApp)
 {
     KConfigGroup group(KSharedConfig::openConfig(), "General");
     const QStringList excluded = group.readEntry("ExcludeCategories", QStringList());
     auto filter = [&type, &category, &parentApp](const KPluginMetaData &md) -> bool
     {
         if (!md.serviceTypes().contains(QStringLiteral("Plasma/Containment"))) {
             return false;
         }
         const QString pa = md.value(QStringLiteral("X-KDE-ParentApp"));
         if (!pa.isEmpty() && pa != parentApp) {
             return false;
         }
 
         if (!type.isEmpty() && md.value(QStringLiteral("X-Plasma-ContainmentType")) != type) {
             return false;
         }
 
         if (!category.isEmpty() && md.value(QStringLiteral("X-KDE-PluginInfo-Category")) != category) {
             return false;
         }
 
         return true;
     };
 
     return KPluginInfo::fromMetaData(KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), filter).toVector());
 }
 
 KPluginInfo::List PluginLoader::listContainmentsForMimeType(const QString &mimeType)
 {
     auto filter = [&mimeType](const KPluginMetaData &md) -> bool
     {
         return md.serviceTypes().contains(QLatin1String("Plasma/Containment"))
             && KPluginMetaData::readStringList(md.rawData(), QStringLiteral("X-Plasma-DropMimeTypes")).contains(mimeType);
     };
 
     return KPluginInfo::fromMetaData(KPackage::PackageLoader::self()->findPackages(QStringLiteral("Plasma/Applet"), QString(), filter).toVector());
 }
 
 QStringList PluginLoader::listContainmentTypes()
 {
     KPluginInfo::List containmentInfos = listContainments();
     QSet<QString> types;
 
     foreach (const KPluginInfo &containmentInfo, containmentInfos) {
         QStringList theseTypes = containmentInfo.service()->property(QStringLiteral("X-Plasma-ContainmentType")).toStringList();
         foreach (const QString &type, theseTypes) {
             types.insert(type);
         }
     }
 
     return types.toList();
 }
 
 KPluginInfo::List PluginLoader::listDataEngineInfo(const QString &parentApp)
 {
     KPluginInfo::List list;
 
     if (!d->isDefaultLoader && (parentApp.isEmpty() || parentApp == QCoreApplication::instance()->applicationName())) {
         list = internalDataEngineInfo();
     }
 
     QString constraint;
     if (parentApp.isEmpty()) {
         constraint = QStringLiteral("not exist [X-KDE-ParentApp]");
     } else {
         constraint = QLatin1String("[X-KDE-ParentApp] == '") + parentApp + QLatin1Char('\'');
     }
 
     list.append(KPluginTrader::self()->query(PluginLoaderPrivate::s_dataEnginePluginDir, QStringLiteral("Plasma/DataEngine"), constraint));
     return list;
 }
 
 KPluginInfo::List PluginLoader::listContainmentActionsInfo(const QString &parentApp)
 {
     KPluginInfo::List list;
 
     if (!d->isDefaultLoader && (parentApp.isEmpty() || parentApp == QCoreApplication::instance()->applicationName())) {
         list = internalContainmentActionsInfo();
     }
 
     QString constraint;
     if (parentApp.isEmpty()) {
         constraint = QStringLiteral("not exist [X-KDE-ParentApp]");
     } else {
         constraint = QLatin1String("[X-KDE-ParentApp] == '") + parentApp + QLatin1Char('\'');
     }
 
     list.append(KPluginTrader::self()->query(PluginLoaderPrivate::s_containmentActionsPluginDir, QStringLiteral("Plasma/ContainmentActions"), constraint));
 
     QSet<QString> knownPlugins;
     foreach (const KPluginInfo &p, list) {
         knownPlugins.insert(p.pluginName());
     }
 
     //FIXME: this is only for backwards compatibility, but probably will have to stay
     //for the time being
     KService::List offers = KServiceTypeTrader::self()->query(QStringLiteral("Plasma/ContainmentActions"), constraint);
     foreach (KService::Ptr s, offers) {
         if (!knownPlugins.contains(s->pluginKeyword())) {
             list.append(KPluginInfo(s));
         }
     }
     return list;
 }
 
 Applet *PluginLoader::internalLoadApplet(const QString &name, uint appletId, const QVariantList &args)
 {
     Q_UNUSED(name)
     Q_UNUSED(appletId)
     Q_UNUSED(args)
     return nullptr;
 }
 
 DataEngine *PluginLoader::internalLoadDataEngine(const QString &name)
 {
     Q_UNUSED(name)
     return nullptr;
 }
 
 ContainmentActions *PluginLoader::internalLoadContainmentActions(Containment *containment, const QString &name, const QVariantList &args)
 {
     Q_UNUSED(containment)
     Q_UNUSED(name)
     Q_UNUSED(args)
     return nullptr;
 }
 
 Service *PluginLoader::internalLoadService(const QString &name, const QVariantList &args, QObject *parent)
 {
     Q_UNUSED(name)
     Q_UNUSED(args)
     Q_UNUSED(parent)
     return nullptr;
 }
 
 
 #ifndef PLASMA_NO_DEPRECATED
 Package PluginLoader::internalLoadPackage(const QString &name, const QString &specialization)
 {
     Q_UNUSED(name);
     Q_UNUSED(specialization);
     return Package();
 }
 #endif
 
 KPluginInfo::List PluginLoader::internalAppletInfo(const QString &category) const
 {
     Q_UNUSED(category)
     return KPluginInfo::List();
 }
 
 KPluginInfo::List PluginLoader::internalDataEngineInfo() const
 {
     return KPluginInfo::List();
 }
 
 KPluginInfo::List PluginLoader::internalServiceInfo() const
 {
     return KPluginInfo::List();
 }
 
 KPluginInfo::List PluginLoader::internalContainmentActionsInfo() const
 {
     return KPluginInfo::List();
 }
 
 static KPluginInfo::List standardInternalInfo(const QString &type, const QString &category = QString())
 {
     QStringList files = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation,
                         QLatin1String(PLASMA_RELATIVE_DATA_INSTALL_DIR "/internal/") + type + QLatin1String("/*.desktop"),
                         QStandardPaths::LocateFile);
 
     KPluginInfo::List allInfo = KPluginInfo::fromFiles(files);
 
     if (category.isEmpty() || allInfo.isEmpty()) {
         return allInfo;
     }
 
     KPluginInfo::List matchingInfo;
     foreach (const KPluginInfo &info, allInfo) {
         if (info.category().compare(category, Qt::CaseInsensitive) == 0) {
             matchingInfo << info;
         }
     }
 
     return matchingInfo;
 }
 
 KPluginInfo::List PluginLoader::standardInternalAppletInfo(const QString &category) const
 {
     return standardInternalInfo(QStringLiteral("applets"), category);
 }
 
 KPluginInfo::List PluginLoader::standardInternalDataEngineInfo() const
 {
     return standardInternalInfo(QStringLiteral("dataengines"));
 }
 
 KPluginInfo::List PluginLoader::standardInternalServiceInfo() const
 {
     return standardInternalInfo(QStringLiteral("services"));
 }
 
 bool PluginLoader::isPluginVersionCompatible(KPluginLoader &loader)
 {
     const quint32 version = loader.pluginVersion();
     if (version == quint32(-1)) {
         // unversioned, just let it through
         qCWarning(LOG_PLASMA) << loader.fileName() << "unversioned plugin detected, may result in instability";
         return true;
     }
 
     // we require PLASMA_VERSION_MAJOR and PLASMA_VERSION_MINOR
     const quint32 minVersion = PLASMA_MAKE_VERSION(PLASMA_VERSION_MAJOR, 0, 0);
     const quint32 maxVersion = PLASMA_MAKE_VERSION(PLASMA_VERSION_MAJOR, PLASMA_VERSION_MINOR, 60);
 
     if (version < minVersion || version > maxVersion) {
 #ifndef NDEBUG
         qCDebug(LOG_PLASMA) << loader.fileName() << ": this plugin is compiled against incompatible Plasma version" << version
                 << "This build is compatible with" << PLASMA_VERSION_MAJOR << ".0.0 (" << minVersion
                 << ") to" << PLASMA_VERSION_STRING << "(" << maxVersion << ")";
 #endif
         return false;
     }
 
     return true;
 }
 
 } // Plasma Namespace
 
diff --git a/src/plasma/private/associatedapplicationmanager.cpp b/src/plasma/private/associatedapplicationmanager.cpp
index 1244556cc..5d5beb78f 100644
--- a/src/plasma/private/associatedapplicationmanager.cpp
+++ b/src/plasma/private/associatedapplicationmanager.cpp
@@ -1,234 +1,213 @@
 /*
  *   Copyright 2009 Marco Martin <notmart@gmail.com>
  *
  *   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 "associatedapplicationmanager_p.h"
 
 #include "config-plasma.h"
 #include "debug_p.h"
 
 #include <QAction>
 #include <QHash>
 #include <QFile>
 #include <QDebug>
 #include <QMimeDatabase>
 #include <KSycoca>
 
 #include <qstandardpaths.h>
 #include <klocalizedstring.h>
 #include <kactioncollection.h>
 #include <KMimeTypeTrader>
 
-#if !PLASMA_NO_KIO
-#include <krun.h>
-#else
-#include <QProcess>
-#include <QDesktopServices>
-#endif
+#include <KRun>
 
 #include "plasma/applet.h"
 
 namespace Plasma
 {
 
 class AssociatedApplicationManagerPrivate
 {
 public:
     AssociatedApplicationManagerPrivate()
     {
     }
 
     ~AssociatedApplicationManagerPrivate()
     {
     }
 
     void cleanupApplet(QObject *obj)
     {
         Plasma::Applet *applet = static_cast<Plasma::Applet *>(obj);
         applicationNames.remove(applet);
         urlLists.remove(applet);
     }
 
     void updateActionNames()
     {
         QMimeDatabase mimeDb;
 
         QHash<const Plasma::Applet *, QList<QUrl> >::iterator i;
         for (i = urlLists.begin(); i != urlLists.end(); ++i) {
             QAction *a = i.key()->actions()->action(QStringLiteral("run associated application"));
             if (a) {
                 const QString mimeType = mimeDb.mimeTypeForUrl(i.value().first()).name();
                 const KService::List apps = KMimeTypeTrader::self()->query(mimeType);
                 if (!apps.isEmpty()) {
                     a->setIcon(QIcon::fromTheme(apps.first()->icon()));
                     a->setText(i18n("Open with %1", apps.first()->genericName().isEmpty() ? apps.first()->genericName() : apps.first()->name()));
                 } else {
                     a->setIcon(QIcon::fromTheme(QStringLiteral("system-run")));
                     a->setText(i18n("Run the Associated Application"));
                 }
             }
         }
     }
 
     QHash<const Plasma::Applet *, QString> applicationNames;
     QHash<const Plasma::Applet *, QList<QUrl> > urlLists;
 };
 
 class AssociatedApplicationManagerSingleton
 {
 public:
     AssociatedApplicationManager self;
 };
 
 Q_GLOBAL_STATIC(AssociatedApplicationManagerSingleton, privateAssociatedApplicationManagerSelf)
 
 AssociatedApplicationManager::AssociatedApplicationManager(QObject *parent)
     : QObject(parent),
       d(new AssociatedApplicationManagerPrivate())
 {
     connect(KSycoca::self(), SIGNAL(databaseChanged()), this, SLOT(updateActionNames()));
 }
 
 AssociatedApplicationManager::~AssociatedApplicationManager()
 {
     delete d;
 }
 
 AssociatedApplicationManager *AssociatedApplicationManager::self()
 {
     return &privateAssociatedApplicationManagerSelf()->self;
 }
 
 void AssociatedApplicationManager::setApplication(Plasma::Applet *applet, const QString &application)
 {
     const bool hasAppBefore = d->applicationNames.contains(applet);
     const bool hasUrls = d->urlLists.contains(applet);
 
     // unsetting the application?
     if (application.isEmpty()) {
         if (hasAppBefore) {
             d->applicationNames.remove(applet);
             if (!hasUrls) {
                 disconnect(applet, SIGNAL(destroyed(QObject*)), this, SLOT(cleanupApplet(QObject*)));
             }
         }
         return;
     }
 
     KService::Ptr service = KService::serviceByDesktopName(application);
     if (service || !QStandardPaths::findExecutable(application).isNull() || QFile::exists(application)) {
         d->applicationNames[applet] = application;
 
         if (hasUrls) {
             QAction *a = applet->actions()->action(QStringLiteral("run associated application"));
             if (a) {
                 a->setIcon(QIcon::fromTheme(QStringLiteral("system-run")));
                 a->setText(i18n("Run the Associated Application"));
             }
         } else if (!hasAppBefore) {
             connect(applet, SIGNAL(destroyed(QObject*)), this, SLOT(cleanupApplet(QObject*)));
         }
     }
 }
 
 QString AssociatedApplicationManager::application(const Plasma::Applet *applet) const
 {
     return d->applicationNames.value(applet);
 }
 
 void AssociatedApplicationManager::setUrls(Plasma::Applet *applet, const QList<QUrl> &urls)
 {
     const bool hasApp = d->applicationNames.contains(applet);
     const bool hasUrlsBefore = d->urlLists.contains(applet);
 
     // unsetting the urls?
     if (urls.isEmpty()) {
         if (hasUrlsBefore) {
             d->urlLists.remove(applet);
             if (!hasApp) {
                 disconnect(applet, SIGNAL(destroyed(QObject*)), this, SLOT(cleanupApplet(QObject*)));
             }
         }
         return;
     }
 
     d->urlLists[applet] = urls;
 
     if (!hasApp) {
         QAction *a = applet->actions()->action(QStringLiteral("run associated application"));
         if (a) {
             QMimeDatabase mimeDb;
             const QString mimeType = mimeDb.mimeTypeForUrl(urls.first()).name();
             const KService::List apps = KMimeTypeTrader::self()->query(mimeType);
             if (!apps.isEmpty()) {
                 a->setIcon(QIcon::fromTheme(apps.first()->icon()));
                 a->setText(i18n("Open with %1", apps.first()->genericName().isEmpty() ? apps.first()->genericName() : apps.first()->name()));
             } else {
                 a->setIcon(QIcon::fromTheme(QStringLiteral("system-run")));
                 a->setText(i18n("Run the Associated Application"));
             }
         }
         if (!hasUrlsBefore) {
             connect(applet, SIGNAL(destroyed(QObject*)), this, SLOT(cleanupApplet(QObject*)));
         }
     }
 }
 //TODO: updateAction slot, called on setting of url or app, and on sycoca change
 QList<QUrl> AssociatedApplicationManager::urls(const Plasma::Applet *applet) const
 {
     return d->urlLists.value(applet);
 }
 
 void AssociatedApplicationManager::run(Plasma::Applet *applet)
 {
     if (d->applicationNames.contains(applet)) {
-#if !PLASMA_NO_KIO
         bool success = KRun::run(d->applicationNames.value(applet), d->urlLists.value(applet), nullptr);
         if (!success) {
             qCWarning(LOG_PLASMA) << "couldn't run" << d->applicationNames.value(applet) << d->urlLists.value(applet);
         }
-#else
-        QString execCommand = d->applicationNames.value(applet);
-
-        // Clean-up the %u and friends from the exec command (KRun expect them, not QProcess)
-        execCommand = execCommand.replace(QRegExp("%[a-z]"), QString());
-        execCommand = execCommand.trimmed();
-
-        QStringList parameters = d->urlLists.value(applet).toStringList();
-        QProcess::startDetached(execCommand, parameters);
-#endif
-
     } else if (d->urlLists.contains(applet)) {
-#if !PLASMA_NO_KIO
         KRun *krun = new KRun(d->urlLists.value(applet).first(), nullptr);
         krun->setAutoDelete(true);
-#else
-        QDesktopServices::openUrl(d->urlLists.value(applet).first());
-#endif
     }
 }
 
 bool AssociatedApplicationManager::appletHasValidAssociatedApplication(const Plasma::Applet *applet) const
 {
     return (d->applicationNames.contains(applet) || d->urlLists.contains(applet));
 }
 
 } // namespace Plasma
 
 #include <moc_associatedapplicationmanager_p.cpp>
 
diff --git a/src/scriptengines/qml/CMakeLists.txt b/src/scriptengines/qml/CMakeLists.txt
index fd953d63b..68499f091 100644
--- a/src/scriptengines/qml/CMakeLists.txt
+++ b/src/scriptengines/qml/CMakeLists.txt
@@ -1,48 +1,47 @@
 # APPLET
 
 if(KDE_PLATFORM_FEATURE_BINARY_COMPATIBLE_FEATURE_REDUCTION)
     set(PLASMA_NO_KDEWEBKIT TRUE)
     set(PLASMA_NO_SOLID TRUE)
-    set(PLASMA_NO_KIO TRUE)
 endif()
 
 #DECLARATIVE APPLET
 set(declarative_appletscript_SRCS
     plasmoid/declarativeappletscript.cpp
 
     plasmoid/appletinterface.cpp
     plasmoid/containmentinterface.cpp
     plasmoid/declarativeappletscript.cpp
     plasmoid/wallpaperinterface.cpp
     )
 
 add_library(plasma_appletscript_declarative MODULE ${declarative_appletscript_SRCS} )
 set_target_properties(plasma_appletscript_declarative PROPERTIES PREFIX "")
 
 kcoreaddons_desktop_to_json(
     plasma_appletscript_declarative data/plasma-scriptengine-applet-declarative.desktop
     SERVICE_TYPES ${CMAKE_SOURCE_DIR}/src/plasma/data/servicetypes/plasma-scriptengine.desktop
 )
 
 
 target_link_libraries(plasma_appletscript_declarative
     Qt5::Quick
     Qt5::Qml
     KF5::Activities
     KF5::KIOCore
     KF5::KIOWidgets
     KF5::Declarative
     KF5::I18n
     KF5::XmlGui # KActionCollection
     KF5::Plasma
     KF5::PlasmaQuick
     KF5::Package
     KF5::Notifications
 )
 
 
 install(TARGETS plasma_appletscript_declarative DESTINATION ${KDE_INSTALL_PLUGINDIR}/plasma/scriptengines)
 install(FILES data/plasma-scriptengine-applet-declarative.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR})
 install(FILES data/plasma-wallpaper.desktop DESTINATION ${KDE_INSTALL_KSERVICETYPES5DIR})
 
 
diff --git a/src/scriptengines/qml/plasmoid/containmentinterface.cpp b/src/scriptengines/qml/plasmoid/containmentinterface.cpp
index 7fa070c73..3c4bb3359 100644
--- a/src/scriptengines/qml/plasmoid/containmentinterface.cpp
+++ b/src/scriptengines/qml/plasmoid/containmentinterface.cpp
@@ -1,1238 +1,1226 @@
 /*
  *   Copyright 2008 Chani Armitage <chani@kde.org>
  *   Copyright 2008, 2009 Aaron Seigo <aseigo@kde.org>
  *   Copyright 2010 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 "containmentinterface.h"
 #include "wallpaperinterface.h"
 #include <kdeclarative/qmlobject.h>
 
 #include <QClipboard>
 #include <QQmlExpression>
 #include <QQmlProperty>
 #include <QMimeData>
 #include <QVersionNumber>
 
 #include <kactioncollection.h>
 #include <KAcceleratorManager>
 #include <kauthorized.h>
 #include <QDebug>
 #include <klocalizedstring.h>
 #include <kurlmimedata.h>
 #include <QMimeDatabase>
 #include <KNotification>
 
-#ifndef PLASMA_NO_KIO
-#include "kio/jobclasses.h" // for KIO::JobFlags
-#include "kio/job.h"
-#include "kio/scheduler.h"
 #include <KIO/DropJob>
-#endif
+#include <KIO/MimetypeJob>
+#include <KIO/TransferJob>
 
 #include <plasma.h>
 #include <Plasma/ContainmentActions>
 #include <Plasma/Corona>
 #include <Plasma/PluginLoader>
 
 #include <KPackage/Package>
 #include <KPackage/PackageLoader>
 
 #include <kactivities/info.h>
 
 #include "kdeclarative/configpropertymap.h"
 #include <packageurlinterceptor.h>
 
 ContainmentInterface::ContainmentInterface(DeclarativeAppletScript *parent, const QVariantList &args)
     : AppletInterface(parent, args),
       m_wallpaperInterface(nullptr),
       m_activityInfo(nullptr),
       m_wheelDelta(0),
       m_editMode(false)
 {
     m_containment = static_cast<Plasma::Containment *>(appletScript()->applet()->containment());
 
     setAcceptedMouseButtons(Qt::AllButtons);
 
     connect(m_containment.data(), &Plasma::Containment::appletRemoved,
             this, &ContainmentInterface::appletRemovedForward);
     connect(m_containment.data(), &Plasma::Containment::appletAdded,
             this, &ContainmentInterface::appletAddedForward);
 
     if (!m_appletInterfaces.isEmpty()) {
         emit appletsChanged();
     }
 }
 
 void ContainmentInterface::init()
 {
     if (qmlObject()->rootObject()) {
         return;
     }
 
     m_activityInfo = new KActivities::Info(m_containment->activity(), this);
     connect(m_activityInfo, &KActivities::Info::nameChanged,
             this, &ContainmentInterface::activityNameChanged);
     emit activityNameChanged();
 
     AppletInterface::init();
 
     //Create the ToolBox
     if (m_containment) {
         KConfigGroup defaults;
         if (m_containment->containmentType() == Plasma::Types::DesktopContainment) {
             defaults = KConfigGroup(KSharedConfig::openConfig(m_containment->corona()->kPackage().filePath("defaults")), "Desktop");
         } else if (m_containment->containmentType() == Plasma::Types::PanelContainment) {
             defaults = KConfigGroup(KSharedConfig::openConfig(m_containment->corona()->kPackage().filePath("defaults")), "Panel");
         }
 
         if (defaults.isValid()) {
             KPackage::Package pkg = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("KPackage/GenericQML"));
             pkg.setDefaultPackageRoot(QStringLiteral("plasma/packages"));
 
             if (defaults.isValid()) {
                 pkg.setPath(defaults.readEntry("ToolBox", "org.kde.desktoptoolbox"));
             } else {
                 pkg.setPath(QStringLiteral("org.kde.desktoptoolbox"));
             }
 
             PlasmaQuick::PackageUrlInterceptor *interceptor = dynamic_cast<PlasmaQuick::PackageUrlInterceptor *>(qmlObject()->engine()->urlInterceptor());
             if (interceptor) {
                 interceptor->addAllowedPath(pkg.path());
             }
 
             if (pkg.metadata().isValid() && !pkg.metadata().isHidden()) {
                 if (pkg.isValid()) {
                     QObject *containmentGraphicObject = qmlObject()->rootObject();
 
                     QVariantHash toolboxProperties;
                     toolboxProperties[QStringLiteral("parent")] = QVariant::fromValue(this);
                     QObject *toolBoxObject = qmlObject()->createObjectFromSource(pkg.fileUrl("mainscript"), nullptr, toolboxProperties);
                     if (toolBoxObject && containmentGraphicObject) {
                         containmentGraphicObject->setProperty("toolBox", QVariant::fromValue(toolBoxObject));
                     }
                 } else {
                     qWarning() << "Could not load toolbox package." << pkg.path();
                 }
             } else {
                 qWarning() << "Toolbox not loading, toolbox package is either invalid or disabled.";
             }
         }
 
     }
 
     //set parent, both as object hierarchically and visually
     //do this only for containments, applets will do it in compactrepresentationcheck
     if (qmlObject()->rootObject()) {
         qmlObject()->rootObject()->setProperty("parent", QVariant::fromValue(this));
 
         //set anchors
         QQmlExpression expr(qmlObject()->engine()->rootContext(), qmlObject()->rootObject(), QStringLiteral("parent"));
         QQmlProperty prop(qmlObject()->rootObject(), QStringLiteral("anchors.fill"));
         prop.write(expr.evaluate());
     }
 
     if (!m_containment->wallpaper().isEmpty()) {
         loadWallpaper();
     }
 
     connect(m_containment.data(), &Plasma::Containment::activityChanged,
             this, &ContainmentInterface::activityChanged);
     connect(m_containment.data(), &Plasma::Containment::activityChanged,
             [ = ]() {
                 delete m_activityInfo;
                 m_activityInfo = new KActivities::Info(m_containment->activity(), this);
                 connect(m_activityInfo, &KActivities::Info::nameChanged,
                         this, &ContainmentInterface::activityNameChanged);
                 emit activityNameChanged();
             });
     connect(m_containment.data(), &Plasma::Containment::wallpaperChanged,
             this, &ContainmentInterface::loadWallpaper);
     connect(m_containment.data(), &Plasma::Containment::containmentTypeChanged,
             this, &ContainmentInterface::containmentTypeChanged);
 
     connect(m_containment.data()->actions(), &KActionCollection::inserted,
             this, &ContainmentInterface::actionsChanged);
     connect(m_containment.data()->actions(), &KActionCollection::removed,
             this, &ContainmentInterface::actionsChanged);
 
     if (m_containment->corona()) {
         connect(m_containment->corona(), &Plasma::Corona::availableScreenRegionChanged,
                 this, &ContainmentInterface::availableScreenRegionChanged);
         connect(m_containment->corona(), &Plasma::Corona::availableScreenRectChanged,
                 this, &ContainmentInterface::availableScreenRectChanged);
     }
 }
 
 QList <QObject *> ContainmentInterface::applets()
 {
     return m_appletInterfaces;
 }
 
 Plasma::Types::ContainmentType ContainmentInterface::containmentType() const
 {
     return appletScript()->containmentType();
 }
 
 void ContainmentInterface::setContainmentType(Plasma::Types::ContainmentType type)
 {
     appletScript()->setContainmentType(type);
 }
 
 Plasma::Applet *ContainmentInterface::createApplet(const QString &plugin, const QVariantList &args, const QPoint &pos)
 {
     return createApplet(plugin, args, QRectF(pos, QSize()));
 }
 
 Plasma::Applet *ContainmentInterface::createApplet(const QString &plugin, const QVariantList &args, const QRectF &geom)
 {
     //HACK
     //This is necessary to delay the appletAdded signal (of containmentInterface) AFTER the applet graphics object has been created
     blockSignals(true);
     Plasma::Applet *applet = m_containment->createApplet(plugin, args);
 
     if (applet) {
         QQuickItem *appletGraphicObject = applet->property("_plasma_graphicObject").value<QQuickItem *>();
         //invalid applet?
         if (!appletGraphicObject) {
             blockSignals(false);
             return applet;
         }
         if (geom.width() > 0 && geom.height() > 0) {
             appletGraphicObject->setSize(geom.size());
         }
 
         blockSignals(false);
 
         emit appletAdded(appletGraphicObject, geom.x(), geom.y());
         emit appletsChanged();
     } else {
         blockSignals(false);
     }
     return applet;
 }
 
 void ContainmentInterface::setAppletArgs(Plasma::Applet *applet, const QString &mimetype, const QString &data)
 {
     if (!applet) {
         return;
     }
 
     AppletInterface *appletInterface = applet->property("_plasma_graphicObject").value<AppletInterface *>();
     if (appletInterface) {
         emit appletInterface->externalData(mimetype, data);
     }
 }
 
 QObject *ContainmentInterface::containmentAt(int x, int y)
 {
     QObject *desktop = nullptr;
     foreach (Plasma::Containment *c, m_containment->corona()->containments()) {
         ContainmentInterface *contInterface = c->property("_plasma_graphicObject").value<ContainmentInterface *>();
 
         if (contInterface && contInterface->isVisible()) {
             QWindow *w = contInterface->window();
             if (w && w->geometry().contains(QPoint(window()->x(), window()->y()) + QPoint(x, y))) {
                 if (c->containmentType() == Plasma::Types::CustomEmbeddedContainment) {
                     continue;
                 }
                 if (c->containmentType() == Plasma::Types::DesktopContainment) {
                     desktop = contInterface;
                 } else {
                     return contInterface;
                 }
             }
         }
     }
     return desktop;
 }
 
 void ContainmentInterface::addApplet(AppletInterface *applet, int x, int y)
 {
     if (!applet || applet->applet()->containment() == m_containment) {
         return;
     }
 
     blockSignals(true);
     m_containment->addApplet(applet->applet());
     blockSignals(false);
     emit appletAdded(applet, x, y);
 }
 
 QPointF ContainmentInterface::mapFromApplet(AppletInterface *applet, int x, int y)
 {
     if (!applet->window() || !window()) {
         return QPointF();
     }
 
     //x,y in absolute screen coordinates of current view
     QPointF pos = applet->mapToScene(QPointF(x, y));
     pos = QPointF(pos + applet->window()->geometry().topLeft());
     //return the coordinate in the relative view's coords
     return pos - window()->geometry().topLeft();
 }
 
 QPointF ContainmentInterface::mapToApplet(AppletInterface *applet, int x, int y)
 {
     if (!applet->window() || !window()) {
         return QPointF();
     }
 
     //x,y in absolute screen coordinates of current view
     QPointF pos(x, y);
     pos = QPointF(pos + window()->geometry().topLeft());
     //the coordinate in the relative view's coords
     pos = pos - applet->window()->geometry().topLeft();
     //make it relative to applet coords
     return pos - applet->mapToScene(QPointF(0, 0));
 }
 
 QPointF ContainmentInterface::adjustToAvailableScreenRegion(int x, int y, int w, int h) const
 {
     QRegion reg;
     int screenId = screen();
     if (screenId > -1 && m_containment->corona()) {
         reg = m_containment->corona()->availableScreenRegion(screenId);
     }
 
     if (!reg.isEmpty()) {
         //make it relative
         QRect geometry = m_containment->corona()->screenGeometry(screenId);
         reg.translate(- geometry.topLeft());
     } else {
         reg = QRect(0, 0, width(), height());
     }
 
     const QRect rect(qBound(reg.boundingRect().left(), x, reg.boundingRect().right() + 1 - w),
                      qBound(reg.boundingRect().top(), y, reg.boundingRect().bottom() + 1 - h), w, h);
     const QRectF ar = availableScreenRect();
     QRect tempRect(rect);
 
     // in the case we are in the topleft quadrant
     // * see if the passed rect is completely in the region, if yes, return
     // * otherwise, try to move it horizontally to the screenrect x
     // * if now fits, return
     // * if fail, move vertically
     // * as last resort, move horizontally and vertically
 
     // top left corner
     if (rect.center().x() <= ar.center().x() && rect.center().y() <= ar.center().y()) {
         //QRegion::contains doesn't do what it would suggest, so do reg.intersected(rect) != rect instead
         if (reg.intersected(rect) != rect) {
             tempRect = QRect(qMax(rect.left(), (int)ar.left()), rect.top(), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(rect.left(), qMax(rect.top(), (int)ar.top()), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(qMax(rect.left(), (int)ar.left()), qMax(rect.top(), (int)ar.top()), w, h);
             return tempRect.topLeft();
         } else {
             return rect.topLeft();
         }
 
     //bottom left corner
     } else if (rect.center().x() <= ar.center().x() && rect.center().y() > ar.center().y()) {
         if (reg.intersected(rect) != rect) {
             tempRect = QRect(qMax(rect.left(), (int)ar.left()), rect.top(), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(rect.left(), qMin(rect.top(), (int)(ar.bottom() + 1 - h)), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(qMax(rect.left(), (int)ar.left()), qMin(rect.top(), (int)(ar.bottom() + 1 - h)), w, h);
             return tempRect.topLeft();
         } else {
             return rect.topLeft();
         }
 
     //top right corner
     } else if (rect.center().x() > ar.center().x() && rect.center().y() <= ar.center().y()) {
         if (reg.intersected(rect) != rect) {
             tempRect = QRect(qMin(rect.left(), (int)(ar.right() + 1 - w)), rect.top(), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(rect.left(), qMax(rect.top(), (int)ar.top()), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(qMin(rect.left(), (int)(ar.right() + 1 - w)), qMax(rect.top(), (int)ar.top()), w, h);
             return tempRect.topLeft();
         } else {
             return rect.topLeft();
         }
 
     //bottom right corner
     } else if (rect.center().x() > ar.center().x() && rect.center().y() > ar.center().y()) {
         if (reg.intersected(rect) != rect) {
             tempRect = QRect(qMin(rect.left(), (int)(ar.right() + 1 - w)), rect.top(), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(rect.left(), qMin(rect.top(), (int)(ar.bottom() + 1 - h)), w, h);
             if (reg.intersected(tempRect) == tempRect) {
                 return tempRect.topLeft();
             }
 
             tempRect = QRect(qMin(rect.left(), (int)(ar.right() + 1 - w)), qMin(rect.top(), (int)(ar.bottom() + 1 - h)), w, h);
             return tempRect.topLeft();
         } else {
             return rect.topLeft();
         }
     }
 
     return rect.topLeft();
 }
 
 bool ContainmentInterface::isEditMode() const
 {
     return m_editMode;
 }
 
 void ContainmentInterface::setEditMode(bool edit)
 {
     if (edit == m_editMode) {
         return;
     }
 
     if (m_containment->immutability() != Plasma::Types::Mutable) {
         return;
     }
 
     m_editMode = edit;
     emit editModeChanged();
 }
 
 void ContainmentInterface::processMimeData(QObject *mimeDataProxy, int x, int y, KIO::DropJob *dropJob)
 {
     QMimeData* mime = qobject_cast<QMimeData*>(mimeDataProxy);
     if (mime) {
         processMimeData(mime, x, y, dropJob);
     } else {
         processMimeData(mimeDataProxy->property("mimeData").value<QMimeData*>(), x, y, dropJob);
     }
 }
 
 void ContainmentInterface::processMimeData(QMimeData *mimeData, int x, int y, KIO::DropJob *dropJob)
 {
     if (!mimeData) {
         return;
     }
 
     //const QMimeData *mimeData = data;
 
     qDebug() << "Arrived mimeData" << mimeData->urls() << mimeData->formats() << "at" << x << ", " << y;
 
     // Catch drops from a Task Manager and convert to usable URL.
     if (!mimeData->hasUrls() && mimeData->hasFormat(QStringLiteral("text/x-orgkdeplasmataskmanager_taskurl"))) {
         QList<QUrl> urls = {QUrl(QString::fromUtf8(mimeData->data(QStringLiteral("text/x-orgkdeplasmataskmanager_taskurl"))))};
         mimeData->setUrls(urls);
     }
 
     if (mimeData->hasFormat(QStringLiteral("text/x-plasmoidservicename"))) {
         QString data = QString::fromUtf8( mimeData->data(QStringLiteral("text/x-plasmoidservicename")) );
         const QStringList appletNames = data.split(QLatin1Char('\n'), QString::SkipEmptyParts);
         foreach (const QString &appletName, appletNames) {
             qDebug() << "adding" << appletName;
 
             metaObject()->invokeMethod(this, "createApplet", Qt::QueuedConnection, Q_ARG(QString, appletName), Q_ARG(QVariantList, QVariantList()), Q_ARG(QRectF, QRectF(x, y, -1, -1)));
         }
     } else if (mimeData->hasUrls()) {
         //TODO: collect the mimetypes of available script engines and offer
         //      to create widgets out of the matching URLs, if any
         const QList<QUrl> urls = KUrlMimeData::urlsFromMimeData(mimeData);
         foreach (const QUrl &url, urls) {
-
-#ifndef PLASMA_NO_KIO
             QMimeDatabase db;
             const QMimeType &mime = db.mimeTypeForUrl(url);
             QString mimeName = mime.name();
             QVariantList args;
             args << url.url();
             qDebug() << "can decode" << mimeName << args;
 
             // It may be a directory or a file, let's stat
             KIO::JobFlags flags = KIO::HideProgressInfo;
             KIO::MimetypeJob *job = KIO::mimetype(url, flags);
             m_dropPoints[job] = QPoint(x, y);
 
             QObject::connect(job, SIGNAL(result(KJob*)), this, SLOT(dropJobResult(KJob*)));
             QObject::connect(job, SIGNAL(mimetype(KIO::Job*,QString)),
                              this, SLOT(mimeTypeRetrieved(KIO::Job*,QString)));
 
             if (dropJob) {
                 m_dropJobs[job] = dropJob;
             } else {
                 QMenu *choices = new QMenu(i18n("Content dropped"));
                 if (choices->winId()) {
                     choices->windowHandle()->setTransientParent(window());
                 }
                 choices->addAction(QIcon::fromTheme(QStringLiteral("process-working")), i18n("Fetching file type..."));
                 choices->popup(window() ? window()->mapToGlobal(QPoint(x, y)) : QPoint(x, y));
 
                 m_dropMenus[job] = choices;
             }
-#endif
         }
 
     } else {
         QStringList formats = mimeData->formats();
         QHash<QString, KPluginMetaData> seenPlugins;
         QHash<QString, QString> pluginFormats;
 
         foreach (const QString &format, formats) {
             const auto plugins = Plasma::PluginLoader::self()->listAppletMetaDataForMimeType(format);
 
             foreach (const auto &plugin, plugins) {
                 if (seenPlugins.contains(plugin.pluginId())) {
                     continue;
                 }
 
                 seenPlugins.insert(plugin.pluginId(), plugin);
                 pluginFormats.insert(plugin.pluginId(), format);
             }
         }
         //qDebug() << "Mimetype ..." << formats << seenPlugins.keys() << pluginFormats.values();
 
         QString selectedPlugin;
 
         if (seenPlugins.isEmpty()) {
             // do nothing
         //directly create if only one offer only if the conteinment didn't pass an existing plugin
         } else if (seenPlugins.count() == 1) {
             selectedPlugin = seenPlugins.constBegin().key();
             Plasma::Applet *applet = createApplet(selectedPlugin, QVariantList(), QRect(x, y, -1, -1));
             setAppletArgs(applet, pluginFormats[selectedPlugin], QString::fromUtf8(mimeData->data(pluginFormats[selectedPlugin])));
         } else {
             QMenu *choices = nullptr;
             if (!dropJob) {
                 choices = new QMenu();
                 if (choices->winId()) {
                     choices->windowHandle()->setTransientParent(window());
                 }
             }
             QList<QAction *> extraActions;
             QHash<QAction *, QString> actionsToPlugins;
             foreach (const auto &info, seenPlugins) {
                 QAction *action;
                 if (!info.iconName().isEmpty()) {
                     action = new QAction(QIcon::fromTheme(info.iconName()), info.name(), nullptr);
                 } else {
                     action = new QAction(info.name(), nullptr);
                 }
                 extraActions << action;
                 if (choices) {
                     choices->addAction(action);
                 }
                 action->setData(info.pluginId());
                 connect(action, &QAction::triggered, this, [this, x, y, mimeData, action]() {
                     const QString selectedPlugin = action->data().toString();
                     Plasma::Applet *applet = createApplet(selectedPlugin, QVariantList(), QRect(x, y, -1, -1));
                     setAppletArgs(applet, selectedPlugin, QString::fromUtf8(mimeData->data(selectedPlugin)));
                 });
 
                 actionsToPlugins.insert(action, info.pluginId());
             }
 
             //if the menu was created by ourselves, delete it
             if (choices) {
                 QAction *choice = choices->exec(window() ? window()->mapToGlobal(QPoint(x, y)) : QPoint(x, y));
 
                 delete choices;
             } else {
                 Q_ASSERT(dropJob);
                 dropJob->setApplicationActions(extraActions);
             }
         }
     }
 }
 
 void ContainmentInterface::clearDataForMimeJob(KIO::Job *job)
 {
-#ifndef PLASMA_NO_KIO
     QObject::disconnect(job, nullptr, this, nullptr);
     m_dropPoints.remove(job);
     QMenu *choices = m_dropMenus.take(job);
     m_dropJobs.remove(job);
     job->kill();
-#endif // PLASMA_NO_KIO
 }
 
 void ContainmentInterface::dropJobResult(KJob *job)
 {
-#ifndef PLASMA_NO_KIO
     if (job->error()) {
         qDebug() << "ERROR" << job->error() << ' ' << job->errorString();
     }
-#endif // PLASMA_NO_KIO
 }
 
 void ContainmentInterface::mimeTypeRetrieved(KIO::Job *job, const QString &mimetype)
 {
-#ifndef PLASMA_NO_KIO
     qDebug() << "Mimetype Job returns." << mimetype;
 
     KIO::TransferJob *tjob = dynamic_cast<KIO::TransferJob *>(job);
     if (!tjob) {
         qDebug() << "job should be a TransferJob, but isn't";
         clearDataForMimeJob(job);
         return;
     }
     QList<KPluginMetaData> appletList = Plasma::PluginLoader::self()->listAppletMetaDataForUrl(tjob->url());
     if (mimetype.isEmpty() && appletList.isEmpty()) {
         clearDataForMimeJob(job);
         qDebug() << "No applets found matching the url (" << tjob->url() << ") or the mimetype (" << mimetype << ")";
         return;
     } else {
 
         QPoint posi; // will be overwritten with the event's position
         if (m_dropPoints.contains(tjob)) {
             posi = m_dropPoints.value(tjob);
             qDebug() << "Received a suitable dropEvent at" << posi;
         } else {
             qDebug() << "Bailing out. Cannot find associated dropEvent related to the TransferJob";
             clearDataForMimeJob(job);
             return;
         }
 
         QMenu *choices = m_dropMenus.value(tjob);
         QList<QAction *> dropActions;
         KIO::DropJob *dropJob = m_dropJobs.value(tjob);
 
         if (!choices && !dropJob) {
             qDebug() << "Bailing out. No QMenu or drop job found for this job.";
             clearDataForMimeJob(job);
             return;
         }
 
         qDebug() << "Creating menu for:" << mimetype  << posi;
 
         appletList << Plasma::PluginLoader::self()->listAppletMetaDataForMimeType(mimetype);
 
         QList<KPluginMetaData> wallpaperList;
 
         if (m_containment->containmentType() != Plasma::Types::PanelContainment
             && m_containment->containmentType() != Plasma::Types::CustomPanelContainment) {
 
             if (m_wallpaperInterface && m_wallpaperInterface->supportsMimetype(mimetype)) {
                 wallpaperList << m_wallpaperInterface->kPackage().metadata();
             } else {
                 wallpaperList = WallpaperInterface::listWallpaperMetadataForMimetype(mimetype);
             }
         }
 
         const bool isPlasmaPackage = (mimetype == QLatin1String("application/x-plasma"));
 
         if (!appletList.isEmpty() || !wallpaperList.isEmpty() || isPlasmaPackage) {
             QAction *installPlasmaPackageAction = nullptr;
             if (isPlasmaPackage) {
                 if (choices) {
                     choices->addSection(i18n("Plasma Package"));
                     installPlasmaPackageAction = choices->addAction(QIcon::fromTheme(QStringLiteral("application-x-plasma")), i18n("Install"));
                 } else {
                     QAction *action = new QAction(i18n("Plasma Package"), nullptr);
                     action->setSeparator(true);
                     dropActions << action;
 
                     installPlasmaPackageAction = new QAction(QIcon::fromTheme(QStringLiteral("application-x-plasma")), i18n("Install"), nullptr);
                     Q_ASSERT(dropJob);
                     dropActions << installPlasmaPackageAction;
                     dropJob->setApplicationActions(dropActions);
                 }
                 const QString &packagePath = tjob->url().toLocalFile();
                 connect(installPlasmaPackageAction, &QAction::triggered, this, [this, posi, packagePath]() {
                     using namespace KPackage;
                     PackageStructure *structure = PackageLoader::self()->loadPackageStructure(QStringLiteral("Plasma/Applet"));
                     Package package(structure);
 
                     KJob *installJob = package.update(packagePath);
                     connect(installJob, &KJob::result, this, [this, packagePath, structure, posi](KJob *job) {
                         auto fail = [job](const QString &text) {
                             KNotification::event(QStringLiteral("plasmoidInstallationFailed"), i18n("Package Installation Failed"),
                                                  text, QStringLiteral("dialog-error"), nullptr, KNotification::CloseOnTimeout, QStringLiteral("plasma_workspace"));
                         };
 
                         // if the applet is already installed, just add it to the containment
                         if (job->error() != KJob::NoError
                             && job->error() != Package::PackageAlreadyInstalledError
                             && job->error() != Package::NewerVersionAlreadyInstalledError) {
                             fail(job->errorText());
                             return;
                         }
 
                         using namespace KPackage;
                         Package package(structure);
                         // TODO how can I get the path of the actual package?
 
                         package.setPath(packagePath);
 
                         // TODO how can I get the plugin id? Package::metadata() is deprecated
                         if (!package.isValid() || !package.metadata().isValid()) {
                             fail(i18n("The package you just dropped is invalid."));
                             return;
                         }
 
                         createApplet(package.metadata().pluginId(), QVariantList(), QRect(posi, QSize(-1,-1)));
                     });
                 });
             }
 
             if (choices) {
                 choices->addSection(i18n("Widgets"));
             } else {
                 QAction *action = new QAction(i18n("Widgets"), nullptr);
                 action->setSeparator(true);
                 dropActions << action;
             }
             foreach (const auto &info, appletList) {
                 const QString actionText = i18nc("Add widget", "Add %1", info.name());
                 QAction *action = new QAction(actionText, nullptr);
                 if (!info.iconName().isEmpty()) {
                     action->setIcon(QIcon::fromTheme(info.iconName()));
                 }
                 if (choices) {
                     choices->addAction(action);
                 }
                 dropActions << action;
                 action->setData(info.pluginId());
                 const QUrl url = tjob->url();
                 connect(action, &QAction::triggered, this, [this, action, posi, mimetype, url]() {
                     Plasma::Applet *applet = createApplet(action->data().toString(), QVariantList(), QRect(posi, QSize(-1,-1)));
                     setAppletArgs(applet, mimetype, url.toString());
                 });
             }
             {
                 QAction *action = new QAction(i18nc("Add icon widget", "Add Icon"), nullptr);
                 if (choices) {
                     choices->addAction(action);
                 }
                 dropActions << action;
                 action->setData(QStringLiteral("org.kde.plasma.icon"));
                 const QUrl url = tjob->url();
                 connect(action, &QAction::triggered, this, [this, action, posi, mimetype, url](){
                     Plasma::Applet *applet = createApplet(action->data().toString(), QVariantList(), QRect(posi, QSize(-1,-1)));
                     setAppletArgs(applet, mimetype, url.toString());
                 });
             }
 
             QHash<QAction *, QString> actionsToWallpapers;
             if (!wallpaperList.isEmpty())  {
                 if (choices) {
                     choices->addSection(i18n("Wallpaper"));
                 } else {
                     QAction *action = new QAction(i18n("Wallpaper"), nullptr);
                     action->setSeparator(true);
                     dropActions << action;
                 }
 
                 QMap<QString, KPluginMetaData> sorted;
                 foreach (const auto &info, appletList) {
                     sorted.insert(info.name(), info);
                 }
 
                 foreach (const KPluginMetaData &info, wallpaperList) {
                     const QString actionText = i18nc("Set wallpaper", "Set %1", info.name());
                     QAction *action = new QAction(actionText, nullptr);
                     if (!info.iconName().isEmpty()) {
                         action->setIcon(QIcon::fromTheme(info.iconName()));
                     }
 
                     if (choices) {
                         choices->addAction(action);
                     }
                     dropActions << action;
                     actionsToWallpapers.insert(action, info.pluginId());
                     const QUrl url = tjob->url();
                     connect(action, &QAction::triggered, this, [this, url]() {
                         //set wallpapery stuff
                         if (m_wallpaperInterface && url.isValid()) {
                             m_wallpaperInterface->setUrl(url);
                         }
                     });
                 }
             }
 
         } else {
             //case in which we created the menu ourselves, just the "fetching type entry, directly create the icon applet
             if (choices) {
                 Plasma::Applet *applet = createApplet(QStringLiteral("org.kde.plasma.icon"), QVariantList(), QRect(posi, QSize(-1,-1)));
                 setAppletArgs(applet, mimetype, tjob->url().toString());
             } else {
                 QAction *action;
                 if (choices) {
                     choices->addSection(i18n("Widgets"));
                     action = choices->addAction(i18nc("Add icon widget", "Add Icon"));
                 } else {
                     QAction *sep = new QAction(i18n("Widgets"), nullptr);
                     sep->setSeparator(true);
                     dropActions << sep;
                     // we can at least create an icon as a link to the URL
                     action = new QAction(i18nc("Add icon widget", "Add Icon"), nullptr);
                     dropActions << action;
                 }
 
                 const QUrl url = tjob->url();
                 connect(action, &QAction::triggered, this, [this, posi, mimetype, url](){
                     Plasma::Applet *applet = createApplet(QStringLiteral("org.kde.plasma.icon"), QVariantList(), QRect(posi, QSize(-1,-1)));
                     setAppletArgs(applet, mimetype, url.toString());
                 });
             }
         }
 
         if (choices) {
             // HACK If the QMenu becomes empty at any point after the "determining mimetype"
             // popup was shown, it self-destructs, does not matter if we call clear() or remove
             // the action manually, hence we remove the aforementioned item after we populated the menu
             choices->removeAction(choices->actions().at(0));
             choices->exec();
         } else {
             dropJob->setApplicationActions(dropActions);
         }
 
         clearDataForMimeJob(tjob);
     }
-#endif // PLASMA_NO_KIO
 }
 
 void ContainmentInterface::appletAddedForward(Plasma::Applet *applet)
 {
     if (!applet) {
         return;
     }
 
     AppletInterface *appletGraphicObject = applet->property("_plasma_graphicObject").value<AppletInterface *>();
     AppletInterface *contGraphicObject = m_containment->property("_plasma_graphicObject").value<AppletInterface *>();
 
 //     qDebug() << "Applet added on containment:" << m_containment->title() << contGraphicObject
 //              << "Applet: " << applet << applet->title() << appletGraphicObject;
 
     //applets can not have a graphic object if they don't have a script engine loaded
     //this can happen if they were loaded with an invalid metadata
     if (!appletGraphicObject) {
         return;
     }
 
     if (contGraphicObject) {
         appletGraphicObject->setProperty("visible", false);
         appletGraphicObject->setProperty("parent", QVariant::fromValue(contGraphicObject));
     }
 
     m_appletInterfaces << appletGraphicObject;
     connect(appletGraphicObject, &QObject::destroyed, this,
             [this](QObject *obj) {
                 m_appletInterfaces.removeAll(obj);
             });
     emit appletAdded(appletGraphicObject, appletGraphicObject->m_positionBeforeRemoval.x(), appletGraphicObject->m_positionBeforeRemoval.y());
     emit appletsChanged();
 }
 
 void ContainmentInterface::appletRemovedForward(Plasma::Applet *applet)
 {
     AppletInterface *appletGraphicObject = applet->property("_plasma_graphicObject").value<AppletInterface *>();
     if (appletGraphicObject) {
         m_appletInterfaces.removeAll(appletGraphicObject);
         appletGraphicObject->m_positionBeforeRemoval = appletGraphicObject->mapToItem(this, QPointF());
     }
     emit appletRemoved(appletGraphicObject);
     emit appletsChanged();
 }
 
 void ContainmentInterface::loadWallpaper()
 {
     if (m_containment->containmentType() != Plasma::Types::DesktopContainment &&
             m_containment->containmentType() != Plasma::Types::CustomContainment) {
         return;
     }
 
     if (!m_containment->wallpaper().isEmpty()) {
         delete m_wallpaperInterface;
 
         m_wallpaperInterface = new WallpaperInterface(this);
         m_wallpaperInterface->setZ(-1000);
         //Qml seems happier if the parent gets set in this way
         m_wallpaperInterface->setProperty("parent", QVariant::fromValue(this));
 
         //set anchors
         QQmlExpression expr(qmlObject()->engine()->rootContext(), m_wallpaperInterface, QStringLiteral("parent"));
         QQmlProperty prop(m_wallpaperInterface, QStringLiteral("anchors.fill"));
         prop.write(expr.evaluate());
 
         m_containment->setProperty("wallpaperGraphicsObject", QVariant::fromValue(m_wallpaperInterface));
     } else {
         if (m_wallpaperInterface) {
             m_wallpaperInterface->deleteLater();
             m_wallpaperInterface = nullptr;
         }
     }
 }
 
 QString ContainmentInterface::activity() const
 {
     return m_containment->activity();
 }
 
 QString ContainmentInterface::activityName() const
 {
     if (!m_activityInfo) {
         return QString();
     }
     return m_activityInfo->name();
 }
 
 QList<QObject *> ContainmentInterface::actions() const
 {
     //FIXME: giving directly a QList<QAction*> crashes
 
     QStringList actionOrder;
     actionOrder << QStringLiteral("add widgets") << QStringLiteral("manage activities") << QStringLiteral("remove") << QStringLiteral("lock widgets") << QStringLiteral("run associated application") << QStringLiteral("configure");
     QHash<QString, QAction *> orderedActions;
     //use a multimap to sort by action type
     QMultiMap<int, QObject *> actions;
     int i = 0;
     foreach (QAction *a, m_containment->actions()->actions()) {
         if (!actionOrder.contains(a->objectName())) {
             //FIXME QML visualizations don't support menus for now, *and* there is no way to
             //distinguish them on QML side
             if (!a->menu()) {
                 actions.insert(a->data().toInt()*100 + i, a);
                 ++i;
             }
         } else {
             orderedActions[a->objectName()] = a;
         }
     }
 
     i = 0;
     foreach (QAction *a, m_containment->corona()->actions()->actions()) {
         if (a->objectName() == QStringLiteral("lock widgets") || a->menu()) {
             //It is up to the Containment to decide if the user is allowed or not
             //to lock/unluck the widgets, so corona should not add one when there is none
             //(user is not allow) and it shouldn't add another one when there is already
             //one
             continue;
         }
 
         if (!actionOrder.contains(a->objectName())) {
             actions.insert(a->data().toInt()*100 + i, a);
         } else {
             orderedActions[a->objectName()] = a;
         }
         ++i;
     }
     QList<QObject *> actionList = actions.values();
 
     foreach (const QString &name, actionOrder) {
         QAction *a = orderedActions.value(name);
         if (a && !a->menu()) {
             actionList << a;
         }
         ++i;
     }
 
     return actionList;
 }
 
 //PROTECTED--------------------
 
 void ContainmentInterface::mouseReleaseEvent(QMouseEvent *event)
 {
     event->setAccepted(m_containment->containmentActions().contains(Plasma::ContainmentActions::eventToString(event)));
 }
 
 void ContainmentInterface::mousePressEvent(QMouseEvent *event)
 
 {
     //even if the menu is executed synchronously, other events may be processed
     //by the qml incubator when plasma is loading, so we need to guard there
     if (m_contextMenu) {
         m_contextMenu.data()->close();
         return;
     }
 
     const QString trigger = Plasma::ContainmentActions::eventToString(event);
     Plasma::ContainmentActions *plugin = m_containment->containmentActions().value(trigger);
 
     if (!plugin || plugin->contextualActions().isEmpty()) {
         event->setAccepted(false);
         return;
     }
 
     //the plugin can be a single action or a context menu
     //Don't have an action list? execute as single action
     //and set the event position as action data
     if (plugin->contextualActions().length() == 1) {
         QAction *action = plugin->contextualActions().at(0);
         action->setData(event->pos());
         action->trigger();
         event->accept();
         return;
     }
 
     //FIXME: very inefficient appletAt() implementation
     Plasma::Applet *applet = nullptr;
     foreach (QObject *appletObject, m_appletInterfaces) {
         if (AppletInterface *ai = qobject_cast<AppletInterface *>(appletObject)) {
             if (ai->isVisible() && ai->contains(ai->mapFromItem(this, event->posF()))) {
                 applet = ai->applet();
                 break;
             } else {
                 ai = nullptr;
             }
         }
     }
     //qDebug() << "Invoking menu for applet" << applet;
 
     QMenu *desktopMenu = new QMenu;
 
     //this is a workaround where Qt now creates the menu widget
     //in .exec before oxygen can polish it and set the following attribute
     desktopMenu->setAttribute(Qt::WA_TranslucentBackground);
     //end workaround
 
     if (desktopMenu->winId()) {
         desktopMenu->windowHandle()->setTransientParent(window());
     }
     desktopMenu->setAttribute(Qt::WA_DeleteOnClose);
 
     m_contextMenu = desktopMenu;
 
     emit m_containment->contextualActionsAboutToShow();
 
     if (applet) {
         emit applet->contextualActionsAboutToShow();
         addAppletActions(desktopMenu, applet, event);
     } else {
         addContainmentActions(desktopMenu, event);
     }
 
     //this is a workaround where Qt will fail to realize a mouse has been released
 
     // this happens if a window which does not accept focus spawns a new window that takes focus and X grab
     // whilst the mouse is depressed
     // https://bugreports.qt.io/browse/QTBUG-59044
     // this causes the next click to go missing
 
     //by releasing manually we avoid that situation
     auto ungrabMouseHack = [this]() {
         if (window() && window()->mouseGrabberItem()) {
             window()->mouseGrabberItem()->ungrabMouse();
         }
     };
 
     //pre 5.8.0 QQuickWindow code is "item->grabMouse(); sendEvent(item, mouseEvent)"
     //post 5.8.0 QQuickWindow code is sendEvent(item, mouseEvent); item->grabMouse()
     if (QVersionNumber::fromString(QLatin1String(qVersion())) > QVersionNumber(5, 8, 0)) {
         QTimer::singleShot(0, this, ungrabMouseHack);
     }
     else {
         ungrabMouseHack();
     }
     //end workaround
 
     QPoint pos = event->globalPos();
     if (window() && m_containment->containmentType() == Plasma::Types::PanelContainment) {
         desktopMenu->adjustSize();
 
         if (QScreen *screen = window()->screen()) {
             const QRect geo = screen->availableGeometry();
 
             pos = QPoint(qBound(geo.left(), pos.x(), geo.right() + 1 - desktopMenu->width()),
                          qBound(geo.top(), pos.y(), geo.bottom() + 1 - desktopMenu->height()));
         }
     }
 
     if (desktopMenu->isEmpty()) {
         delete desktopMenu;
         event->accept();
         return;
     }
 
     // Bug 344205 keep panel visible while menu is open
     const auto oldStatus = m_containment->status();
     m_containment->setStatus(Plasma::Types::RequiresAttentionStatus);
 
     connect(desktopMenu, &QMenu::aboutToHide, m_containment, [this, oldStatus] {
         m_containment->setStatus(oldStatus);
     });
 
     KAcceleratorManager::manage(desktopMenu);
 
     desktopMenu->popup(pos);
     event->setAccepted(true);
 }
 
 void ContainmentInterface::wheelEvent(QWheelEvent *event)
 {
     const QString trigger = Plasma::ContainmentActions::eventToString(event);
     Plasma::ContainmentActions *plugin = m_containment->containmentActions().value(trigger);
 
     if (!plugin) {
         event->setAccepted(false);
         return;
     }
 
     m_wheelDelta += event->delta();
 
     // Angle delta 120 for common "one click"
     // See: http://qt-project.org/doc/qt-5/qml-qtquick-wheelevent.html#angleDelta-prop
     while (m_wheelDelta >= 120) {
         m_wheelDelta -= 120;
         plugin->performPreviousAction();
     }
     while (m_wheelDelta <= -120) {
         m_wheelDelta += 120;
         plugin->performNextAction();
     }
 }
 
 void ContainmentInterface::keyPressEvent(QKeyEvent *event)
 {
     if (event->key() == Qt::Key_Menu) {
         QMouseEvent me(QEvent::MouseButtonRelease, QPoint(), Qt::RightButton, Qt::RightButton, event->modifiers());
         mousePressEvent(&me);
         event->accept();
     }
 
     AppletInterface::keyPressEvent(event);
 }
 
 void ContainmentInterface::addAppletActions(QMenu *desktopMenu, Plasma::Applet *applet, QEvent *event)
 {
     foreach (QAction *action, applet->contextualActions()) {
         if (action) {
             desktopMenu->addAction(action);
         }
     }
 
     if (!applet->failedToLaunch()) {
         QAction *runAssociatedApplication = applet->actions()->action(QStringLiteral("run associated application"));
         if (runAssociatedApplication && runAssociatedApplication->isEnabled()) {
             desktopMenu->addAction(runAssociatedApplication);
         }
 
         QAction *configureApplet = applet->actions()->action(QStringLiteral("configure"));
         if (configureApplet && configureApplet->isEnabled()) {
             desktopMenu->addAction(configureApplet);
         }
         QAction *appletAlternatives = applet->actions()->action(QStringLiteral("alternatives"));
         if (appletAlternatives && appletAlternatives->isEnabled()) {
             desktopMenu->addAction(appletAlternatives);
         }
     }
 
     QMenu *containmentMenu = new QMenu(i18nc("%1 is the name of the containment", "%1 Options", m_containment->title()), desktopMenu);
     if (m_containment->containmentType() != Plasma::Types::DesktopContainment) {
         addContainmentActions(containmentMenu, event);
     }
 
     if (!containmentMenu->isEmpty()) {
         int enabled = 0;
         //count number of real actions
         QListIterator<QAction *> actionsIt(containmentMenu->actions());
         while (enabled < 3 && actionsIt.hasNext()) {
             QAction *action = actionsIt.next();
             if (action->isVisible() && !action->isSeparator()) {
                 ++enabled;
             }
         }
 
         if (enabled) {
             //if there is only one, don't create a submenu
             if (enabled < 2) {
                 foreach (QAction *action, containmentMenu->actions()) {
                     if (action->isVisible() && !action->isSeparator()) {
                         desktopMenu->addAction(action);
                     }
                 }
             } else {
                 desktopMenu->addMenu(containmentMenu);
             }
         }
     }
 
     if (m_containment->immutability() == Plasma::Types::Mutable &&
         (m_containment->containmentType() != Plasma::Types::PanelContainment || m_containment->isUserConfiguring())) {
         QAction *closeApplet = applet->actions()->action(QStringLiteral("remove"));
         //qDebug() << "checking for removal" << closeApplet;
         if (closeApplet) {
             if (!desktopMenu->isEmpty()) {
                 desktopMenu->addSeparator();
             }
 
             //qDebug() << "adding close action" << closeApplet->isEnabled() << closeApplet->isVisible();
             desktopMenu->addAction(closeApplet);
         }
     }
 }
 
 void ContainmentInterface::addContainmentActions(QMenu *desktopMenu, QEvent *event)
 {
     if (m_containment->corona()->immutability() != Plasma::Types::Mutable &&
             !KAuthorized::authorizeKAction(QStringLiteral("plasma/containment_actions"))) {
         //qDebug() << "immutability";
         return;
     }
 
     //this is what ContainmentPrivate::prepareContainmentActions was
     const QString trigger = Plasma::ContainmentActions::eventToString(event);
     Plasma::ContainmentActions *plugin = m_containment->containmentActions().value(trigger);
 
     if (!plugin) {
         return;
     }
 
     if (plugin->containment() != m_containment) {
         plugin->setContainment(m_containment);
 
         // now configure it
         KConfigGroup cfg(m_containment->corona()->config(), "ActionPlugins");
         cfg = KConfigGroup(&cfg, QString::number(m_containment->containmentType()));
         KConfigGroup pluginConfig = KConfigGroup(&cfg, trigger);
         plugin->restore(pluginConfig);
     }
 
     QList<QAction *> actions = plugin->contextualActions();
 
     if (actions.isEmpty()) {
         //it probably didn't bother implementing the function. give the user a chance to set
         //a better plugin.  note that if the user sets no-plugin this won't happen...
         if ((m_containment->containmentType() != Plasma::Types::PanelContainment &&
                 m_containment->containmentType() != Plasma::Types::CustomPanelContainment) &&
                 m_containment->actions()->action(QStringLiteral("configure"))) {
             desktopMenu->addAction(m_containment->actions()->action(QStringLiteral("configure")));
         }
     } else {
         desktopMenu->addActions(actions);
     }
 
     return;
 }
 
 #include "moc_containmentinterface.cpp"