diff --git a/CMakeLists.txt b/CMakeLists.txt
index 93d7f1200..4221b536d 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,184 +1,185 @@
 cmake_minimum_required(VERSION 3.0)
 
 project(plasma-desktop)
 
 set(PROJECT_VERSION "5.17.80")
 set(PROJECT_VERSION_MAJOR 5)
 
 set(QT_MIN_VERSION "5.11.0")
 set(KF5_MIN_VERSION "5.62.0")
 
 find_package(ECM ${KF5_MIN_VERSION} REQUIRED NO_MODULE)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH} ${ECM_KDE_MODULE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(ECMInstallIcons)
 include(ECMMarkAsTest)
 include(ECMMarkNonGuiExecutable)
 include(ECMOptionalAddSubdirectory)
 include(ECMQtDeclareLoggingCategory)
 include(FeatureSummary)
 include(CheckIncludeFiles)
 
 find_package(Qt5 ${QT_MIN_VERSION} CONFIG REQUIRED COMPONENTS
     Quick
     QuickWidgets
     DBus
     Widgets
     X11Extras
     Svg
     Concurrent
 )
 
 find_package(KF5 ${KF5_MIN_VERSION} REQUIRED COMPONENTS
     Auth
     Plasma
     PlasmaQuick
     DocTools
     I18n
     KCMUtils
     NewStuff
+    NewStuffQuick
     KDELibs4Support
     Notifications
     NotifyConfig
     Attica
     Wallet
     Runner
     GlobalAccel
     Declarative
     DBusAddons
     Activities
     ActivitiesStats
     Config
 )
 
 find_package(KF5Kirigami2 ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5Kirigami2 PROPERTIES
     DESCRIPTION "A QtQuick based components set"
     PURPOSE "Required at runtime by many KCMs"
     TYPE RUNTIME
 )
 
 find_package(KF5QQC2DeskopStyle ${KF5_MIN_VERSION} CONFIG)
 set_package_properties(KF5QQC2DeskopStyle PROPERTIES
     DESCRIPTION "QtQuickControls 2 style that uses QWidget's QStyle for painting"
     PURPOSE "Required at runtime by many KCMs"
     TYPE RUNTIME
 )
 
 find_package(LibKWorkspace ${PROJECT_VERSION} CONFIG REQUIRED)
 find_package(LibNotificationManager ${PROJECT_VERSION} CONFIG REQUIRED)
 find_package(LibTaskManager ${PROJECT_VERSION} CONFIG REQUIRED)
 find_package(LibColorCorrect ${PROJECT_VERSION} CONFIG REQUIRED)
 find_package(KWinDBusInterface CONFIG REQUIRED)
 find_package(ScreenSaverDBusInterface CONFIG REQUIRED)
 find_package(KRunnerAppDBusInterface CONFIG REQUIRED)
 find_package(KSMServerDBusInterface CONFIG REQUIRED)
 find_package(KF5ItemModels CONFIG REQUIRED)
 find_package(KF5Emoticons CONFIG REQUIRED)
 
 find_package(KF5Baloo 5.15)
 set_package_properties(KF5Baloo PROPERTIES DESCRIPTION "File Searching"
                        TYPE RECOMMENDED
                        PURPOSE "Needed to build the File Search KCM"
                       )
 
 find_package(Fontconfig)
 set_package_properties(Fontconfig PROPERTIES DESCRIPTION "Font access configuration library"
                        URL "https://www.freedesktop.org/wiki/Software/fontconfig"
                        TYPE OPTIONAL
                        PURPOSE "Needed to build font configuration and installation tools"
                       )
 
 find_package(X11)
 set_package_properties(X11 PROPERTIES DESCRIPTION "X11 libraries"
                         URL "https://www.x.org"
                         TYPE REQUIRED
                         PURPOSE "Required for building the X11 based workspace"
                       )
 if(X11_FOUND)
   set(HAVE_X11 1)
 endif()
 
 find_package(UDev)
 set_package_properties(UDev PROPERTIES DESCRIPTION "UDev library"
                         URL "http://www.kernel.org/pub/linux/utils/kernel/hotplug/udev.html"
                         TYPE OPTIONAL
                         PURPOSE "Required for device discovery in keyboard daemon"
                       )
 
 find_package(XCB
     REQUIRED COMPONENTS
         XCB SHM IMAGE
     OPTIONAL_COMPONENTS
         XKB XINPUT
 )
 
 set_package_properties(XCB PROPERTIES TYPE REQUIRED)
 add_feature_info("XCB-XKB" XCB_XKB_FOUND "Required for building kcm/keyboard")
 add_feature_info("libxft" X11_Xft_FOUND "X FreeType interface library required for font installation")
 
 find_package(Evdev)
 set_package_properties(Evdev PROPERTIES TYPE OPTIONAL)
 add_feature_info("Evdev" EVDEV_FOUND "Evdev driver headers needed for mouse KCM")
 
 find_package(Synaptics)
 set_package_properties(Synaptics PROPERTIES TYPE OPTIONAL)
 add_feature_info("Synaptics" SYNAPTICS_FOUND "Synaptics libraries needed for touchpad KCM")
 
 find_package(XorgLibinput)
 set_package_properties(XorgLibinput PROPERTIES TYPE OPTIONAL)
 add_feature_info("XorgLibinput" XORGLIBINPUT_FOUND "Libinput driver headers needed for mouse and touchpad KCM")
 
 if(XORGLIBINPUT_FOUND)
   set(HAVE_XORGLIBINPUT 1)
 endif()
 
 include(ConfigureChecks.cmake)
 
 find_package(Breeze ${PROJECT_VERSION} CONFIG)
 set_package_properties(Breeze PROPERTIES
                        TYPE OPTIONAL
                        PURPOSE "For setting the default window decoration plugin")
 if(${Breeze_FOUND})
     if(${BREEZE_WITH_KDECORATION})
         set(HAVE_BREEZE_DECO true)
     else()
         set(HAVE_BREEZE_DECO FALSE)
     endif()
 else()
     set(HAVE_BREEZE_DECO FALSE)
 endif()
 
 include_directories("${CMAKE_CURRENT_BINARY_DIR}")
 
 configure_file(config-workspace.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-workspace.h)
 configure_file(config-unix.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-unix.h )
 configure_file(config-X11.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-X11.h)
 configure_file(config-runtime.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-runtime.h)
 
 plasma_install_package(desktoppackage org.kde.plasma.desktop shells shell)
 
 add_definitions(-DQT_NO_URL_CAST_FROM_STRING)
 
 add_subdirectory(layout-templates)
 
 add_subdirectory(doc)
 add_subdirectory(runners)
 add_subdirectory(containments)
 add_subdirectory(toolboxes)
 add_subdirectory(applets)
 add_subdirectory(dataengines)
 add_subdirectory(kcms)
 add_subdirectory(knetattach)
 add_subdirectory(attica-kde)
 add_subdirectory(imports/activitymanager/)
 add_subdirectory(solid-device-automounter)
 if(X11_Xkb_FOUND AND XCB_XKB_FOUND)
     add_subdirectory(kaccess)
 endif()
 install(FILES org.kde.plasmashell.metainfo.xml DESTINATION ${KDE_INSTALL_METAINFODIR})
 
 feature_summary(WHAT ALL INCLUDE_QUIET_PACKAGES FATAL_ON_MISSING_REQUIRED_PACKAGES)
diff --git a/kcms/lookandfeel/CMakeLists.txt b/kcms/lookandfeel/CMakeLists.txt
index 0b92538c0..6d4f904ee 100644
--- a/kcms/lookandfeel/CMakeLists.txt
+++ b/kcms/lookandfeel/CMakeLists.txt
@@ -1,108 +1,107 @@
 # KI18N Translation Domain for this library
 add_definitions(-DTRANSLATION_DOMAIN=\"kcm_lookandfeel\")
 
 configure_file (config-kcm.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kcm.h )
 
 
 set(kcm_lookandfeel_SRCS
   kcmmain.cpp
   kcm.cpp
   ../krdb/krdb.cpp
   ../cursortheme/xcursor/cursortheme.cpp
   ../cursortheme/xcursor/xcursortheme.cpp
 )
 
 set(klauncher_xml ${KINIT_DBUS_INTERFACES_DIR}/kf5_org.kde.KLauncher.xml)
 qt5_add_dbus_interface(kcm_lookandfeel_SRCS ${klauncher_xml} klauncher_iface)
 
 add_library(kcm_lookandfeel MODULE ${kcm_lookandfeel_SRCS})
 
 target_link_libraries(kcm_lookandfeel
   KF5::KIOWidgets
   KF5::CoreAddons
   KF5::GuiAddons
   KF5::KCMUtils
   KF5::I18n
   KF5::Plasma
   KF5::PlasmaQuick
   KF5::KDELibs4Support
   KF5::Declarative
   KF5::QuickAddons
-  KF5::NewStuff
 
   Qt5::DBus
   Qt5::Widgets
   Qt5::QuickWidgets
   ${X11_LIBRARIES}
 )
 
 if(X11_FOUND)
     target_link_libraries(kcm_lookandfeel Qt5::X11Extras)
 endif()
 if (X11_Xcursor_FOUND)
    target_link_libraries(kcm_lookandfeel ${X11_Xcursor_LIB})
 endif ()
 if (X11_Xfixes_FOUND)
    target_link_libraries(kcm_lookandfeel ${X11_Xfixes_LIB})
 endif ()
 
 kcoreaddons_desktop_to_json(kcm_lookandfeel "kcm_lookandfeel.desktop" SERVICE_TYPES kcmodule.desktop)
 
 #this desktop file is installed only for retrocompatibility with sycoca
 install(FILES kcm_lookandfeel.desktop DESTINATION ${KDE_INSTALL_KSERVICES5DIR})
 install(TARGETS kcm_lookandfeel DESTINATION ${KDE_INSTALL_PLUGINDIR}/kcms)
 install(FILES lookandfeel.knsrc DESTINATION ${KDE_INSTALL_KNSRCDIR})
 
 if(BUILD_TESTING)
    find_package(Qt5Test ${QT_MIN_VERSION} CONFIG REQUIRED)
    add_subdirectory(autotests)
 endif()
 
 kpackage_install_package(package kcm_lookandfeel kcms)
 
 ###### Command line tool
 
 set(lookandfeeltool_SRCS
     lnftool.cpp
     # TODO: load kcm plugin instead of using code copy
     kcm.cpp
     ../krdb/krdb.cpp
     ../cursortheme/xcursor/cursortheme.cpp
     ../cursortheme/xcursor/xcursortheme.cpp
 )
 
 qt5_add_dbus_interface(lookandfeeltool_SRCS ${klauncher_xml} klauncher_iface)
 
 add_executable(lookandfeeltool ${lookandfeeltool_SRCS})
 
 target_link_libraries(lookandfeeltool
   KF5::KIOWidgets
   KF5::CoreAddons
   KF5::KCMUtils
   KF5::I18n
   #TODO:kpackage
   KF5::Plasma
   KF5::PlasmaQuick
   KF5::KDELibs4Support
   KF5::Declarative
   KF5::QuickAddons
   KF5::NewStuff
 
   Qt5::DBus
   Qt5::Widgets
   Qt5::QuickWidgets
   ${X11_LIBRARIES}
 )
 
 if(X11_FOUND)
     target_link_libraries(lookandfeeltool Qt5::X11Extras)
 endif()
 if (X11_Xcursor_FOUND)
    target_link_libraries(lookandfeeltool ${X11_Xcursor_LIB})
 endif ()
 if (X11_Xfixes_FOUND)
    target_link_libraries(lookandfeeltool ${X11_Xfixes_LIB})
 endif ()
 
 install( TARGETS lookandfeeltool ${KDE_INSTALL_TARGETS_DEFAULT_ARGS} )
 
diff --git a/kcms/lookandfeel/kcm.cpp b/kcms/lookandfeel/kcm.cpp
index 1aa4bf951..721016534 100644
--- a/kcms/lookandfeel/kcm.cpp
+++ b/kcms/lookandfeel/kcm.cpp
@@ -1,739 +1,727 @@
 /* This file is part of the KDE Project
    Copyright (c) 2014 Marco Martin <mart@kde.org>
    Copyright (c) 2014 Vishesh Handa <me@vhanda.in>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "kcm.h"
 #include "../krdb/krdb.h"
 #include "../cursortheme/xcursor/xcursortheme.h"
 #include "config-kcm.h"
 #include "config-workspace.h"
 #include <klauncher_iface.h>
 
 #include <KAboutData>
 #include <KSharedConfig>
 #include <KGlobalSettings>
 #include <KIconLoader>
 #include <KAutostart>
 #include <KRun>
 #include <KService>
 
 #include <QDebug>
 #include <QQuickItem>
 #include <QQuickWindow>
 #include <QStandardPaths>
 #include <QProcess>
 #include <QStandardItemModel>
 #include <QX11Info>
 
 #include <KLocalizedString>
 #include <KPackage/PackageLoader>
 
 #include <X11/Xlib.h>
 #include <X11/Xcursor/Xcursor.h>
 
 #ifdef HAVE_XFIXES
 #  include <X11/extensions/Xfixes.h>
 #endif
 
 KCMLookandFeel::KCMLookandFeel(QObject* parent, const QVariantList& args)
     : KQuickAddons::ConfigModule(parent, args)
     , m_config(QStringLiteral("kdeglobals"))
     , m_configGroup(m_config.group("KDE"))
     , m_applyColors(true)
     , m_applyWidgetStyle(true)
     , m_applyIcons(true)
     , m_applyPlasmaTheme(true)
     , m_applyCursors(true)
     , m_applyWindowSwitcher(true)
     , m_applyDesktopSwitcher(true)
     , m_resetDefaultLayout(false)
     , m_applyWindowDecoration(true)
 {
     qmlRegisterType<QStandardItemModel>();
     qmlRegisterType<KCMLookandFeel>();
     KAboutData* about = new KAboutData(QStringLiteral("kcm_lookandfeel"), i18n("Global Theme"),
                                        QStringLiteral("0.1"), QString(), KAboutLicense::LGPL);
     about->addAuthor(i18n("Marco Martin"), QString(), QStringLiteral("mart@kde.org"));
     setAboutData(about);
     setButtons(Apply | Default);
 
     m_model = new QStandardItemModel(this);
     QHash<int, QByteArray> roles = m_model->roleNames();
     roles[PluginNameRole] = "pluginName";
     roles[DescriptionRole] = "description";
     roles[ScreenshotRole] = "screenshot";
     roles[FullScreenPreviewRole] = "fullScreenPreview";
     roles[HasSplashRole] = "hasSplash";
     roles[HasLockScreenRole] = "hasLockScreen";
     roles[HasRunCommandRole] = "hasRunCommand";
     roles[HasLogoutRole] = "hasLogout";
 
     roles[HasColorsRole] = "hasColors";
     roles[HasWidgetStyleRole] = "hasWidgetStyle";
     roles[HasIconsRole] = "hasIcons";
     roles[HasPlasmaThemeRole] = "hasPlasmaTheme";
     roles[HasCursorsRole] = "hasCursors";
     roles[HasWindowSwitcherRole] = "hasWindowSwitcher";
     roles[HasDesktopSwitcherRole] = "hasDesktopSwitcher";
     m_model->setItemRoleNames(roles);
     loadModel();
 }
 
 KCMLookandFeel::~KCMLookandFeel()
 {
 }
 
-void KCMLookandFeel::getNewStuff(QQuickItem *ctx)
+void KCMLookandFeel::reloadModel()
 {
-    if (!m_newStuffDialog) {
-        m_newStuffDialog = new KNS3::DownloadDialog( QLatin1String("lookandfeel.knsrc") );
-        m_newStuffDialog.data()->setWindowTitle(i18n("Download New Global Themes"));
-        m_newStuffDialog->setWindowModality(Qt::WindowModal);
-        m_newStuffDialog->winId(); // so it creates the windowHandle();
-        connect(m_newStuffDialog.data(), &KNS3::DownloadDialog::accepted, this,  &KCMLookandFeel::loadModel);
-    }
-
-    if (ctx && ctx->window()) {
-        m_newStuffDialog->windowHandle()->setTransientParent(ctx->window());
-    }
-
-    m_newStuffDialog.data()->show();
+    loadModel();
 }
 
 QStandardItemModel *KCMLookandFeel::lookAndFeelModel() const
 {
     return m_model;
 }
 
 QString KCMLookandFeel::selectedPlugin() const
 {
     return m_selectedPlugin;
 }
 
 void KCMLookandFeel::setSelectedPlugin(const QString &plugin)
 {
     if (m_selectedPlugin == plugin) {
         return;
     }
 
     const bool firstTime = m_selectedPlugin.isNull();
     m_selectedPlugin = plugin;
     emit selectedPluginChanged();
     emit selectedPluginIndexChanged();
 
     if (!firstTime) {
         setNeedsSave(true);
     }
 }
 
 int KCMLookandFeel::selectedPluginIndex() const
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         if (m_model->data(m_model->index(i, 0), PluginNameRole).toString() == m_selectedPlugin) {
             return i;
         }
     }
     return -1;
 }
 
 QList<KPackage::Package> KCMLookandFeel::availablePackages(const QStringList &components)
 {
     QList<KPackage::Package> packages;
     QStringList paths;
     const QStringList dataPaths = QStandardPaths::standardLocations(QStandardPaths::GenericDataLocation);
 
     paths.reserve(dataPaths.count());
     for (const QString &path : dataPaths) {
         QDir dir(path + QStringLiteral("/plasma/look-and-feel"));
         paths << dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot);
     }
 
     for (const QString &path : paths) {
         KPackage::Package pkg = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LookAndFeel"));
         pkg.setPath(path);
         pkg.setFallbackPackage(KPackage::Package());
         if (components.isEmpty()) {
             packages << pkg;
         } else {
             for (const auto &component : components) {
                 if (!pkg.filePath(component.toUtf8()).isEmpty()) {
                     packages << pkg;
                     break;
                 }
             }
         }
     }
 
     return packages;
 }
 
 void KCMLookandFeel::loadModel()
 {
     m_model->clear();
 
     const QList<KPackage::Package> pkgs = availablePackages({"defaults", "layouts"});
     for (const KPackage::Package &pkg : pkgs) {
         if (!pkg.metadata().isValid()) {
             continue;
         }
         QStandardItem* row = new QStandardItem(pkg.metadata().name());
         row->setData(pkg.metadata().pluginId(), PluginNameRole);
         row->setData(pkg.metadata().description(), DescriptionRole);
         row->setData(pkg.filePath("preview"), ScreenshotRole);
         row->setData(pkg.filePath("fullscreenpreview"), FullScreenPreviewRole);
 
         //What the package provides
         row->setData(!pkg.filePath("splashmainscript").isEmpty(), HasSplashRole);
         row->setData(!pkg.filePath("lockscreenmainscript").isEmpty(), HasLockScreenRole);
         row->setData(!pkg.filePath("runcommandmainscript").isEmpty(), HasRunCommandRole);
         row->setData(!pkg.filePath("logoutmainscript").isEmpty(), HasLogoutRole);
 
         if (!pkg.filePath("defaults").isEmpty()) {
             KSharedConfigPtr conf = KSharedConfig::openConfig(pkg.filePath("defaults"));
             KConfigGroup cg(conf, "kdeglobals");
             cg = KConfigGroup(&cg, "General");
             bool hasColors = !cg.readEntry("ColorScheme", QString()).isEmpty();
             if (!hasColors) {
                 hasColors = !pkg.filePath("colors").isEmpty();
             }
             row->setData(hasColors, HasColorsRole);
             cg = KConfigGroup(&cg, "KDE");
             row->setData(!cg.readEntry("widgetStyle", QString()).isEmpty(), HasWidgetStyleRole);
             cg = KConfigGroup(conf, "kdeglobals");
             cg = KConfigGroup(&cg, "Icons");
             row->setData(!cg.readEntry("Theme", QString()).isEmpty(), HasIconsRole);
 
             cg = KConfigGroup(conf, "kdeglobals");
             cg = KConfigGroup(&cg, "Theme");
             row->setData(!cg.readEntry("name", QString()).isEmpty(), HasPlasmaThemeRole);
 
             cg = KConfigGroup(conf, "kcminputrc");
             cg = KConfigGroup(&cg, "Mouse");
             row->setData(!cg.readEntry("cursorTheme", QString()).isEmpty(), HasCursorsRole);
 
             cg = KConfigGroup(conf, "kwinrc");
             cg = KConfigGroup(&cg, "WindowSwitcher");
             row->setData(!cg.readEntry("LayoutName", QString()).isEmpty(), HasWindowSwitcherRole);
 
             cg = KConfigGroup(conf, "kwinrc");
             cg = KConfigGroup(&cg, "DesktopSwitcher");
             row->setData(!cg.readEntry("LayoutName", QString()).isEmpty(), HasDesktopSwitcherRole);
         }
 
         m_model->appendRow(row);
     }
     m_model->sort(0 /*column*/);
     emit selectedPluginIndexChanged();
 }
 
 void KCMLookandFeel::load()
 {
     m_package = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LookAndFeel"));
     KConfigGroup cg(KSharedConfig::openConfig(QStringLiteral("kdeglobals")), "KDE");
     const QString packageName = cg.readEntry("LookAndFeelPackage", QString());
     if (!packageName.isEmpty()) {
         m_package.setPath(packageName);
     }
 
     if (!m_package.metadata().isValid()) {
         return;
     }
 
     setSelectedPlugin(m_package.metadata().pluginId());
 
     setNeedsSave(false);
 }
 
 
 void KCMLookandFeel::save()
 {
     KPackage::Package package = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LookAndFeel"));
     package.setPath(m_selectedPlugin);
 
     if (!package.isValid()) {
         return;
     }
 
     m_configGroup.writeEntry("LookAndFeelPackage", m_selectedPlugin);
 
     if (m_resetDefaultLayout) {
         QDBusMessage message = QDBusMessage::createMethodCall(QStringLiteral("org.kde.plasmashell"), QStringLiteral("/PlasmaShell"),
                                                    QStringLiteral("org.kde.PlasmaShell"), QStringLiteral("loadLookAndFeelDefaultLayout"));
 
         QList<QVariant> args;
         args << m_selectedPlugin;
         message.setArguments(args);
 
         QDBusConnection::sessionBus().call(message, QDBus::NoBlock);
     }
 
     if (!package.filePath("defaults").isEmpty()) {
         KSharedConfigPtr conf = KSharedConfig::openConfig(package.filePath("defaults"));
         KConfigGroup cg(conf, "kdeglobals");
         cg = KConfigGroup(&cg, "KDE");
         if (m_applyWidgetStyle) {
             setWidgetStyle(cg.readEntry("widgetStyle", QString()));
         }
 
         if (m_applyColors) {
             QString colorsFile = package.filePath("colors");
             KConfigGroup cg(conf, "kdeglobals");
             cg = KConfigGroup(&cg, "General");
             QString colorScheme = cg.readEntry("ColorScheme", QString());
 
             if (!colorsFile.isEmpty()) {
                 if (!colorScheme.isEmpty()) {
                     setColors(colorScheme, colorsFile);
                 } else {
                     setColors(package.metadata().name(), colorsFile);
                 }
             } else if (!colorScheme.isEmpty()) {
                 colorScheme.remove(QLatin1Char('\'')); // So Foo's does not become FooS
                 QRegExp fixer(QStringLiteral("[\\W,.-]+(.?)"));
                 int offset;
                 while ((offset = fixer.indexIn(colorScheme)) >= 0) {
                     colorScheme.replace(offset, fixer.matchedLength(), fixer.cap(1).toUpper());
                 }
                 colorScheme.replace(0, 1, colorScheme.at(0).toUpper());
 
                 //NOTE: why this loop trough all the scheme files?
                 //the scheme theme name is an heuristic, there is no plugin metadata whatsoever.
                 //is based on the file name stripped from weird characters or the
                 //eventual id- prefix store.kde.org puts, so we can just find a
                 //theme that ends as the specified name
                 bool schemeFound = false;
                 const QStringList schemeDirs = QStandardPaths::locateAll(QStandardPaths::GenericDataLocation, QStringLiteral("color-schemes"), QStandardPaths::LocateDirectory);
                 for (const QString &dir : schemeDirs) {
                     const QStringList fileNames = QDir(dir).entryList(QStringList()<<QStringLiteral("*.colors"));
                     for (const QString &file : fileNames) {
                         if (file.endsWith(colorScheme + QStringLiteral(".colors"))) {
                             setColors(colorScheme, dir + QLatin1Char('/') + file);
                             schemeFound = true;
                             break;
                         }
                     }
                     if (schemeFound) {
                         break;
                     }
                 }
             }
         }
 
         if (m_applyIcons) {
             cg = KConfigGroup(conf, "kdeglobals");
             cg = KConfigGroup(&cg, "Icons");
             setIcons(cg.readEntry("Theme", QString()));
         }
 
         if (m_applyPlasmaTheme) {
             cg = KConfigGroup(conf, "plasmarc");
             cg = KConfigGroup(&cg, "Theme");
             setPlasmaTheme(cg.readEntry("name", QString()));
         }
 
         if (m_applyCursors) {
             cg = KConfigGroup(conf, "kcminputrc");
             cg = KConfigGroup(&cg, "Mouse");
             setCursorTheme(cg.readEntry("cursorTheme", QString()));
         }
 
         if (m_applyWindowSwitcher) {
             cg = KConfigGroup(conf, "kwinrc");
             cg = KConfigGroup(&cg, "WindowSwitcher");
             setWindowSwitcher(cg.readEntry("LayoutName", QString()));
         }
 
         if (m_applyDesktopSwitcher) {
             cg = KConfigGroup(conf, "kwinrc");
             cg = KConfigGroup(&cg, "DesktopSwitcher");
             setDesktopSwitcher(cg.readEntry("LayoutName", QString()));
         }
 
         if (m_applyWindowDecoration) {
             cg = KConfigGroup(conf, "kwinrc");
             cg = KConfigGroup(&cg, "org.kde.kdecoration2");
 #ifdef HAVE_BREEZE_DECO
             setWindowDecoration(cg.readEntry("library", QStringLiteral(BREEZE_KDECORATION_PLUGIN_ID)), cg.readEntry("theme", QString()));
 #else
             setWindowDecoration(cg.readEntry("library", QStringLiteral("org.kde.kwin.aurorae")), cg.readEntry("theme", QString()));
 #endif
         }
 
         // Reload KWin if something changed, but only once.
         if (m_applyWindowSwitcher || m_applyDesktopSwitcher || m_applyWindowDecoration) {
             QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/KWin"),
                                                     QStringLiteral("org.kde.KWin"),
                                                     QStringLiteral("reloadConfig"));
             QDBusConnection::sessionBus().send(message);
         }
 
         //autostart
         if (m_resetDefaultLayout) {
             //remove all the old package to autostart
             {
                 KSharedConfigPtr oldConf = KSharedConfig::openConfig(m_package.filePath("defaults"));
                 cg = KConfigGroup(oldConf, QStringLiteral("Autostart"));
                 const QStringList autostartServices = cg.readEntry("Services", QStringList());
 
                 if (qEnvironmentVariableIsSet("KDE_FULL_SESSION")) {
                     for (const QString &serviceFile : autostartServices) {
                         KService service(serviceFile + QStringLiteral(".desktop"));
                         KAutostart as(serviceFile);
                         as.setAutostarts(false);
                         //FIXME: quite ugly way to stop things, and what about non KDE things?
                         QProcess::startDetached(QStringLiteral("kquitapp5"), {QStringLiteral("--service"), service.property(QStringLiteral("X-DBUS-ServiceName")).toString()});
                     }
                 }
             }
             //Set all the stuff in the new lnf to autostart
             {
                 cg = KConfigGroup(conf, QStringLiteral("Autostart"));
                 const QStringList autostartServices = cg.readEntry("Services", QStringList());
 
                 for (const QString &serviceFile : autostartServices) {
                     KService service(serviceFile + QStringLiteral(".desktop"));
                     KAutostart as(serviceFile);
                     as.setCommand(service.exec());
                     as.setAutostarts(true);
                     if (qEnvironmentVariableIsSet("KDE_FULL_SESSION")) {
                         KRun::runApplication(service, {}, nullptr);
                     }
                 }
             }
         }
     }
 
     //TODO: option to enable/disable apply? they don't seem required by UI design
     setSplashScreen(m_selectedPlugin);
     setLockScreen(m_selectedPlugin);
 
     m_configGroup.sync();
     m_package.setPath(m_selectedPlugin);
     runRdb(KRdbExportQtColors | KRdbExportGtkTheme | KRdbExportColors | KRdbExportQtSettings | KRdbExportXftSettings);
 }
 
 void KCMLookandFeel::defaults()
 {
     if (!m_package.metadata().isValid()) {
         return;
     }
 
     setSelectedPlugin(m_package.metadata().pluginId());
 }
 
 void KCMLookandFeel::setWidgetStyle(const QString &style)
 {
     if (style.isEmpty()) {
         return;
     }
 
     m_configGroup.writeEntry("widgetStyle", style);
     m_configGroup.sync();
     //FIXME: changing style on the fly breaks QQuickWidgets
     KGlobalSettings::self()->emitChange(KGlobalSettings::StyleChanged);
 }
 
 void KCMLookandFeel::setColors(const QString &scheme, const QString &colorFile)
 {
     if (scheme.isEmpty() && colorFile.isEmpty()) {
         return;
     }
 
     KSharedConfigPtr conf = KSharedConfig::openConfig(colorFile, KSharedConfig::CascadeConfig);
     foreach (const QString &grp, conf->groupList()) {
         KConfigGroup cg(conf, grp);
         KConfigGroup cg2(&m_config, grp);
         cg.copyTo(&cg2);
     }
 
     KConfigGroup configGroup(&m_config, "General");
     configGroup.writeEntry("ColorScheme", scheme);
 
     configGroup.sync();
     KGlobalSettings::self()->emitChange(KGlobalSettings::PaletteChanged);
 }
 
 void KCMLookandFeel::setIcons(const QString &theme)
 {
     if (theme.isEmpty()) {
         return;
     }
 
     KConfigGroup cg(&m_config, "Icons");
     cg.writeEntry("Theme", theme);
     cg.sync();
 
     for (int i=0; i < KIconLoader::LastGroup; i++) {
         KIconLoader::emitChange(KIconLoader::Group(i));
     }
 }
 
 void KCMLookandFeel::setPlasmaTheme(const QString &theme)
 {
     if (theme.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("plasmarc"));
     KConfigGroup cg(&config, "Theme");
     cg.writeEntry("name", theme);
     cg.sync();
 }
 
 void KCMLookandFeel::setCursorTheme(const QString themeName)
 {
     //TODO: use pieces of cursor kcm when moved to plasma-desktop
     if (themeName.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("kcminputrc"));
     KConfigGroup cg(&config, "Mouse");
     cg.writeEntry("cursorTheme", themeName);
     cg.sync();
 
     // Require the Xcursor version that shipped with X11R6.9 or greater, since
     // in previous versions the Xfixes code wasn't enabled due to a bug in the
     // build system (freedesktop bug #975).
 #if HAVE_XFIXES && XFIXES_MAJOR >= 2 && XCURSOR_LIB_VERSION >= 10105
     const int cursorSize = cg.readEntry("cursorSize", 0);
 
     QDir themeDir = cursorThemeDir(themeName, 0);
 
     if (!themeDir.exists()) {
         return;
     }
 
     XCursorTheme theme(themeDir);
 
     if (!CursorTheme::haveXfixes()) {
         return;
     }
 
     // Set up the proper launch environment for newly started apps
     OrgKdeKLauncherInterface klauncher(QStringLiteral("org.kde.klauncher5"),
                                        QStringLiteral("/KLauncher"),
                                        QDBusConnection::sessionBus());
     klauncher.setLaunchEnv(QStringLiteral("XCURSOR_THEME"), themeName);
 
     // Update the Xcursor X resources
     runRdb(0);
 
     // Notify all applications that the cursor theme has changed
     KGlobalSettings::self()->emitChange(KGlobalSettings::CursorChanged);
 
     // Reload the standard cursors
     QStringList names;
 
     // Qt cursors
     names << QStringLiteral("left_ptr")       << QStringLiteral("up_arrow")      << QStringLiteral("cross")      << QStringLiteral("wait")
           << QStringLiteral("left_ptr_watch") << QStringLiteral("ibeam")         << QStringLiteral("size_ver")   << QStringLiteral("size_hor")
           << QStringLiteral("size_bdiag")     << QStringLiteral("size_fdiag")    << QStringLiteral("size_all")   << QStringLiteral("split_v")
           << QStringLiteral("split_h")        << QStringLiteral("pointing_hand") << QStringLiteral("openhand")
           << QStringLiteral("closedhand")     << QStringLiteral("forbidden")     << QStringLiteral("whats_this") << QStringLiteral("copy") << QStringLiteral("move") << QStringLiteral("link");
 
     // X core cursors
     names << QStringLiteral("X_cursor")            << QStringLiteral("right_ptr")           << QStringLiteral("hand1")
           << QStringLiteral("hand2")               << QStringLiteral("watch")               << QStringLiteral("xterm")
           << QStringLiteral("crosshair")           << QStringLiteral("left_ptr_watch")      << QStringLiteral("center_ptr")
           << QStringLiteral("sb_h_double_arrow")   << QStringLiteral("sb_v_double_arrow")   << QStringLiteral("fleur")
           << QStringLiteral("top_left_corner")     << QStringLiteral("top_side")            << QStringLiteral("top_right_corner")
           << QStringLiteral("right_side")          << QStringLiteral("bottom_right_corner") << QStringLiteral("bottom_side")
           << QStringLiteral("bottom_left_corner")  << QStringLiteral("left_side")           << QStringLiteral("question_arrow")
           << QStringLiteral("pirate");
 
     foreach (const QString &name, names) {
         XFixesChangeCursorByName(QX11Info::display(), theme.loadCursor(name, cursorSize), QFile::encodeName(name));
     }
 
 #else
     KMessageBox::information(this,
                                  i18n("You have to restart the Plasma session for these changes to take effect."),
                                  i18n("Cursor Settings Changed"), "CursorSettingsChanged");
 #endif
 }
 
 QDir KCMLookandFeel::cursorThemeDir(const QString &theme, const int depth)
 {
     // Prevent infinite recursion
     if (depth > 10) {
         return QDir();
     }
 
     // Search each icon theme directory for 'theme'
     foreach (const QString &baseDir, cursorSearchPaths()) {
         QDir dir(baseDir);
         if (!dir.exists() || !dir.cd(theme)) {
             continue;
         }
 
         // If there's a cursors subdir, we'll assume this is a cursor theme
         if (dir.exists(QStringLiteral("cursors"))) {
             return dir;
         }
 
         // If the theme doesn't have an index.theme file, it can't inherit any themes.
         if (!dir.exists(QStringLiteral("index.theme"))) {
             continue;
         }
 
         // Open the index.theme file, so we can get the list of inherited themes
         KConfig config(dir.path() + QStringLiteral("/index.theme"), KConfig::NoGlobals);
         KConfigGroup cg(&config, "Icon Theme");
 
         // Recurse through the list of inherited themes, to check if one of them
         // is a cursor theme.
         QStringList inherits = cg.readEntry("Inherits", QStringList());
         foreach (const QString &inherit, inherits) {
             // Avoid possible DoS
             if (inherit == theme) {
                 continue;
             }
 
             if (cursorThemeDir(inherit, depth + 1).exists()) {
                 return dir;
             }
         }
     }
 
     return QDir();
 }
 
 const QStringList KCMLookandFeel::cursorSearchPaths()
 {
     if (!m_cursorSearchPaths.isEmpty())
         return m_cursorSearchPaths;
 
 #if XCURSOR_LIB_MAJOR == 1 && XCURSOR_LIB_MINOR < 1
     // These are the default paths Xcursor will scan for cursor themes
     QString path("~/.icons:/usr/share/icons:/usr/share/pixmaps:/usr/X11R6/lib/X11/icons");
 
     // If XCURSOR_PATH is set, use that instead of the default path
     char *xcursorPath = std::getenv("XCURSOR_PATH");
     if (xcursorPath)
         path = xcursorPath;
 #else
     // Get the search path from Xcursor
     QString path = XcursorLibraryPath();
 #endif
 
     // Separate the paths
     m_cursorSearchPaths = path.split(QLatin1Char(':'), QString::SkipEmptyParts);
 
     // Remove duplicates
     QMutableStringListIterator i(m_cursorSearchPaths);
     while (i.hasNext())
     {
         const QString path = i.next();
         QMutableStringListIterator j(i);
         while (j.hasNext())
             if (j.next() == path)
                 j.remove();
     }
 
     // Expand all occurrences of ~/ to the home dir
     m_cursorSearchPaths.replaceInStrings(QRegExp(QStringLiteral("^~\\/")), QDir::home().path() + QLatin1Char('/'));
     return m_cursorSearchPaths;
 }
 
 void KCMLookandFeel::setSplashScreen(const QString &theme)
 {
     if (theme.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("ksplashrc"));
     KConfigGroup cg(&config, "KSplash");
     cg.writeEntry("Theme", theme);
     //TODO: a way to set none as spash in the l&f
     cg.writeEntry("Engine", "KSplashQML");
     cg.sync();
 }
 
 void KCMLookandFeel::setLockScreen(const QString &theme)
 {
     if (theme.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("kscreenlockerrc"));
     KConfigGroup cg(&config, "Greeter");
     cg.writeEntry("Theme", theme);
     cg.sync();
 }
 
 void KCMLookandFeel::setWindowSwitcher(const QString &theme)
 {
     if (theme.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("kwinrc"));
     KConfigGroup cg(&config, "TabBox");
     cg.writeEntry("LayoutName", theme);
     cg.sync();
 }
 
 void KCMLookandFeel::setDesktopSwitcher(const QString &theme)
 {
     if (theme.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("kwinrc"));
     KConfigGroup cg(&config, "TabBox");
     cg.writeEntry("DesktopLayout", theme);
     cg.writeEntry("DesktopListLayout", theme);
     cg.sync();
 }
 
 void KCMLookandFeel::setWindowDecoration(const QString &library, const QString &theme)
 {
     if (library.isEmpty()) {
         return;
     }
 
     KConfig config(QStringLiteral("kwinrc"));
     KConfigGroup cg(&config, "org.kde.kdecoration2");
     cg.writeEntry("library", library);
     cg.writeEntry("theme", theme);
     
     cg.sync();
     // Reload KWin.
     QDBusMessage message = QDBusMessage::createSignal(QStringLiteral("/KWin"),
                                                       QStringLiteral("org.kde.KWin"),
                                                       QStringLiteral("reloadConfig"));
     QDBusConnection::sessionBus().send(message);
 }
 
 void KCMLookandFeel::setResetDefaultLayout(bool reset)
 {
     if (m_resetDefaultLayout == reset) {
         return;
     }
     m_resetDefaultLayout = reset;
     emit resetDefaultLayoutChanged();
     if (reset) {
         setNeedsSave(true);
     }
 }
 
 bool KCMLookandFeel::resetDefaultLayout() const
 {
     return m_resetDefaultLayout;
 }
diff --git a/kcms/lookandfeel/kcm.h b/kcms/lookandfeel/kcm.h
index 0275bb7d1..b9848b57b 100644
--- a/kcms/lookandfeel/kcm.h
+++ b/kcms/lookandfeel/kcm.h
@@ -1,126 +1,123 @@
 /*
    Copyright (c) 2014 Marco Martin <mart@kde.org>
    Copyright (c) 2014 Vishesh Handa <me@vhanda.in>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #ifndef _KCM_SEARCH_H
 #define _KCM_SEARCH_H
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <QDir>
 
-#include <KNewStuff3/KNS3/DownloadDialog>
-
 #include <KPackage/Package>
 #include <KQuickAddons/ConfigModule>
 
 class QQuickItem;
 class QStandardItemModel;
 
 class KCMLookandFeel : public KQuickAddons::ConfigModule
 {
     Q_OBJECT
     Q_PROPERTY(QStandardItemModel *lookAndFeelModel READ lookAndFeelModel CONSTANT)
     Q_PROPERTY(QString selectedPlugin READ selectedPlugin WRITE setSelectedPlugin NOTIFY selectedPluginChanged)
     Q_PROPERTY(int selectedPluginIndex READ selectedPluginIndex NOTIFY selectedPluginIndexChanged)
     Q_PROPERTY(bool resetDefaultLayout READ resetDefaultLayout WRITE setResetDefaultLayout NOTIFY resetDefaultLayoutChanged)
 
 public:
     enum Roles {
         PluginNameRole = Qt::UserRole +1,
         ScreenshotRole,
         FullScreenPreviewRole,
         DescriptionRole,
         HasSplashRole,
         HasLockScreenRole,
         HasRunCommandRole,
         HasLogoutRole,
         HasColorsRole,
         HasWidgetStyleRole,
         HasIconsRole,
         HasPlasmaThemeRole,
         HasCursorsRole,
         HasWindowSwitcherRole,
         HasDesktopSwitcherRole
     };
 
     KCMLookandFeel(QObject* parent, const QVariantList& args);
     ~KCMLookandFeel() override;
 
     //List only packages which provide at least one of the components
     QList<KPackage::Package> availablePackages(const QStringList &components);
 
     QStandardItemModel *lookAndFeelModel() const;
 
     QString selectedPlugin() const;
     void setSelectedPlugin(const QString &plugin);
 
     int selectedPluginIndex() const;
 
     bool resetDefaultLayout() const;
     void setResetDefaultLayout(bool reset);
 
     //Setters of the various theme pieces
     void setWidgetStyle(const QString &style);
     void setColors(const QString &scheme, const QString &colorFile);
     void setIcons(const QString &theme);
     void setPlasmaTheme(const QString &theme);
     void setCursorTheme(const QString theme);
     void setSplashScreen(const QString &theme);
     void setLockScreen(const QString &theme);
     void setWindowSwitcher(const QString &theme);
     void setDesktopSwitcher(const QString &theme);
     void setWindowDecoration(const QString &library, const QString &theme);
 
-    Q_INVOKABLE void getNewStuff(QQuickItem *ctx);
+    Q_INVOKABLE void reloadModel();
 
 public Q_SLOTS:
     void load() override;
     void save() override;
     void defaults() override;
 
 Q_SIGNALS:
     void selectedPluginChanged();
     void selectedPluginIndexChanged();
     void resetDefaultLayoutChanged();
 
 private:
     void loadModel();
     QDir cursorThemeDir(const QString &theme, const int depth);
     const QStringList cursorSearchPaths();
     QStandardItemModel *m_model;
     KPackage::Package m_package;
     QString m_selectedPlugin;
     QStringList m_cursorSearchPaths;
-    QPointer<KNS3::DownloadDialog> m_newStuffDialog;
 
     KConfig m_config;
     KConfigGroup m_configGroup;
 
     bool m_applyColors : 1;
     bool m_applyWidgetStyle : 1;
     bool m_applyIcons : 1;
     bool m_applyPlasmaTheme : 1;
     bool m_applyCursors : 1;
     bool m_applyWindowSwitcher : 1;
     bool m_applyDesktopSwitcher : 1;
     bool m_resetDefaultLayout : 1;
     bool m_applyWindowDecoration : 1;
 };
 
 #endif
diff --git a/kcms/lookandfeel/package/contents/ui/main.qml b/kcms/lookandfeel/package/contents/ui/main.qml
index 20e3868a5..daa838601 100644
--- a/kcms/lookandfeel/package/contents/ui/main.qml
+++ b/kcms/lookandfeel/package/contents/ui/main.qml
@@ -1,120 +1,121 @@
 /*
    Copyright (c) 2018 Marco Martin <mart@kde.org>
 
    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Library General Public
    License version 2 as published by the Free Software Foundation.
 
    This library 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
    Library General Public License for more details.
 
    You should have received a copy of the GNU Library General Public License
    along with this library; see the file COPYING.LIB.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 import QtQuick 2.6
 import QtQuick.Layouts 1.1
 import QtQuick.Window 2.2
 import QtQuick.Controls 2.3 as QtControls
 import org.kde.kirigami 2.4 as Kirigami
+import org.kde.newstuff 1.62 as NewStuff
 import org.kde.kconfig 1.0 // for KAuthorized
 import org.kde.kcm 1.1 as KCM
 
 KCM.GridViewKCM {
     KCM.ConfigModule.quickHelp: i18n("This module lets you choose the global look and feel.")
 
     view.model: kcm.lookAndFeelModel
     view.currentIndex: kcm.selectedPluginIndex
     view.delegate: KCM.GridDelegate {
         id: delegate
 
         text: model.display
         toolTip: model.description
 
         thumbnailAvailable: model.screenshot
         thumbnail: Image {
             anchors.fill: parent
             source: model.screenshot || ""
             sourceSize: Qt.size(delegate.GridView.view.cellWidth * Screen.devicePixelRatio,
                                 delegate.GridView.view.cellHeight * Screen.devicePixelRatio)
         }
         actions: [
             Kirigami.Action {
                 visible: model.fullScreenPreview !== ""
                 iconName: "view-preview"
                 tooltip: i18n("Preview Theme")
                 onTriggered: {
                     previewWindow.url = model.fullScreenPreview;
                     previewWindow.showFullScreen();
                 }
             }
         ]
         onClicked: {
             kcm.selectedPlugin = model.pluginName;
             view.forceActiveFocus();
             resetCheckbox.checked = false;
         }
     }
 
     footer: ColumnLayout {
         Kirigami.InlineMessage {
             Layout.fillWidth: true
             type: Kirigami.MessageType.Warning
             text: i18n("Your desktop layout will be lost and reset to the default layout provided by the selected theme.")
             visible: resetCheckbox.checked
         }
 
         RowLayout {
             Layout.fillWidth: true
 
             QtControls.CheckBox {
                 id: resetCheckbox
                 checked: kcm.resetDefaultLayout
                 text: i18n("Use desktop layout from theme")
                 onCheckedChanged: kcm.resetDefaultLayout = checked;
             }
             Item {
                 Layout.fillWidth: true
             }
-            QtControls.Button {
-                text: i18n("Get New Global Themes...")
-                icon.name: "get-hot-new-stuff"
-                onClicked: kcm.getNewStuff(this);
-                visible: KAuthorized.authorize("ghns")
+            NewStuff.Button {
+                downloadNewWhat: i18n("Global Themes")
+                configFile: "lookandfeel.knsrc"
+                viewMode: NewStuff.Page.ViewMode.Preview
+                onChangedEntriesChanged: kcm.reloadModel();
             }
         }
     }
 
     Window {
         id: previewWindow
         property alias url: previewImage.source
         color: Qt.rgba(0, 0, 0, 0.7)
         MouseArea {
             anchors.fill: parent
             Image {
                 id: previewImage
                 anchors.centerIn: parent
                 fillMode: Image.PreserveAspectFit
                 width: Math.min(parent.width, sourceSize.width)
                 height: Math.min(parent.height, sourceSize.height)
             }
             onClicked: previewWindow.close()
             QtControls.ToolButton {
                 anchors {
                     top: parent.top
                     right: parent.right
                 }
                 icon.name: "window-close"
                 onClicked: previewWindow.close()
             }
             Shortcut {
                 onActivated: previewWindow.close()
                 sequence: "Esc"
             }
         }
     }
 }