diff --git a/discover/DiscoverMainWindow.cpp b/discover/DiscoverMainWindow.cpp
index b4cbe68e..f8e395e1 100644
--- a/discover/DiscoverMainWindow.cpp
+++ b/discover/DiscoverMainWindow.cpp
@@ -1,408 +1,409 @@
 /*
  *   Copyright (C) 2012 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library/Lesser General Public License
  *   version 2, or (at your option) any later version, as published by the
  *   Free Software Foundation
  *
  *   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/Lesser 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 "DiscoverMainWindow.h"
 #include "PaginateModel.h"
 #include "SystemFonts.h"
 #include "UnityLauncher.h"
 #include "FeaturedModel.h"
 #include "CachedNetworkAccessManager.h"
 #include "DiscoverDeclarativePlugin.h"
 
 // Qt includes
 #include <QAction>
 #include <QDebug>
 #include <QDesktopServices>
 #include <QtQml/QQmlEngine>
 #include <QtQml/QQmlContext>
 #include <QtQml/QQmlApplicationEngine>
 #include <QtQuick/QQuickItem>
 #include <qqml.h>
 #include <QPointer>
 #include <QGuiApplication>
 #include <QSortFilterProxyModel>
 #include <QTimer>
 
 // KDE includes
 #include <KAboutApplicationDialog>
 #include <KAuthorized>
 #include <KBugReport>
 #include <KActionCollection>
 #include <KDeclarative/KDeclarative>
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KHelpMenu>
 #include <KAboutData>
 #include <KHelpMenu>
 #include <KShortcutsDialog>
 #include <KConcatenateRowsProxyModel>
 #include <KSharedConfig>
 #include <KConfigGroup>
 // #include <KSwitchLanguageDialog>
 
 // DiscoverCommon includes
 #include <resources/AbstractResource.h>
 #include <resources/ResourcesModel.h>
 #include <resources/ResourcesProxyModel.h>
 #include <Category/Category.h>
 #include <Category/CategoryModel.h>
 
 #include <functional>
 #include <cmath>
 #include <unistd.h>
 #include <resources/StoredResultsStream.h>
 #include <utils.h>
 
 DiscoverMainWindow::DiscoverMainWindow(CompactMode mode)
     : QObject()
     , m_collection(this)
     , m_engine(new QQmlApplicationEngine)
     , m_mode(mode)
     , m_networkAccessManagerFactory(new CachedNetworkAccessManagerFactory)
 {
     setObjectName(QStringLiteral("DiscoverMain"));
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(m_engine);
     kdeclarative.setupBindings();
 
     qmlRegisterType<UnityLauncher>("org.kde.discover.app", 1, 0, "UnityLauncher");
     qmlRegisterType<PaginateModel>("org.kde.discover.app", 1, 0, "PaginateModel");
     qmlRegisterType<KConcatenateRowsProxyModel>("org.kde.discover.app", 1, 0, "KConcatenateRowsProxyModel");
     qmlRegisterType<FeaturedModel>("org.kde.discover.app", 1, 0, "FeaturedModel");
     qmlRegisterType<QSortFilterProxyModel>("org.kde.discover.app", 1, 0, "QSortFilterProxyModel");
 
     qmlRegisterSingletonType<SystemFonts>("org.kde.discover.app", 1, 0, "SystemFonts", ([](QQmlEngine*, QJSEngine*) -> QObject* { return new SystemFonts; }));
     qmlRegisterSingletonType(QUrl(QStringLiteral("qrc:/qml/DiscoverSystemPalette.qml")), "org.kde.discover.app", 1, 0, "DiscoverSystemPalette");
     qmlRegisterType<QQuickView>();
     qmlRegisterType<QActionGroup>();
     qmlRegisterType<QAction>();
     qmlRegisterUncreatableType<DiscoverMainWindow>("org.kde.discover.app", 1, 0, "DiscoverMainWindow", QStringLiteral("don't do that"));
     setupActions();
 
     auto uri = "org.kde.discover";
     DiscoverDeclarativePlugin* plugin = new DiscoverDeclarativePlugin;
     plugin->setParent(this);
     plugin->initializeEngine(m_engine, uri);
     plugin->registerTypes(uri);
 
     //Here we set up a cache for the screenshots
     delete m_engine->networkAccessManagerFactory();
     m_engine->setNetworkAccessManagerFactory(m_networkAccessManagerFactory.data());
     m_engine->rootContext()->setContextProperty(QStringLiteral("app"), this);
 
     connect(m_engine, &QQmlApplicationEngine::objectCreated, this, &DiscoverMainWindow::integrateObject);
     m_engine->load(QUrl(QStringLiteral("qrc:/qml/DiscoverWindow.qml")));
 }
 
 DiscoverMainWindow::~DiscoverMainWindow()
 {
     delete m_engine;
 }
 
 bool DiscoverMainWindow::isRoot()
 {
     return ::getuid() == 0;
 }
 
 QStringList DiscoverMainWindow::modes() const
 {
     QStringList ret;
     QObject* obj = rootObject();
     for(int i = obj->metaObject()->propertyOffset(); i<obj->metaObject()->propertyCount(); i++) {
         QMetaProperty p = obj->metaObject()->property(i);
         QByteArray compName = p.name();
         if(compName.startsWith("top") && compName.endsWith("Comp")) {
             ret += QString::fromLatin1(compName.mid(3, compName.length()-7));
         }
     }
     return ret;
 }
 
 void DiscoverMainWindow::openMode(const QString& _mode)
 {
     if(!modes().contains(_mode))
         qWarning() << "unknown mode" << _mode;
 
     QString mode = _mode;
     mode[0] = mode[0].toUpper();
 
     QObject* obj = rootObject();
     const QByteArray propertyName = "top"+mode.toLatin1()+"Comp";
     const QVariant modeComp = obj->property(propertyName.constData());
     if (!modeComp.isValid())
         qWarning() << "couldn't open mode" << _mode;
     else
         obj->setProperty("currentTopLevel", modeComp);
 }
 
 void DiscoverMainWindow::openMimeType(const QString& mime)
 {
     emit listMimeInternal(mime);
 }
 
 void DiscoverMainWindow::openCategory(const QString& category)
 {
     rootObject()->setProperty("defaultStartup", false);
     auto action = new OneTimeAction(
         [this, category]() {
             Category* cat = CategoryModel::global()->findCategoryByName(category);
             if (cat) {
                 emit listCategoryInternal(cat);
             } else {
                 showPassiveNotification(i18n("Could not find category '%1'", category));
                 rootObject()->setProperty("defaultStartup", false);
             }
         }
         , this);
 
     if (ResourcesModel::global()->backends().isEmpty()) {
         connect(ResourcesModel::global(), &ResourcesModel::backendsChanged, action, &OneTimeAction::trigger);
     } else {
         action->trigger();
     }
 }
 
 void DiscoverMainWindow::openLocalPackage(const QUrl& localfile)
 {
     if (!QFile::exists(localfile.toLocalFile())) {
 //         showPassiveNotification(i18n("Trying to open unexisting file '%1'", localfile.toString()));
         qWarning() << "Trying to open unexisting file" << localfile;
         return;
     }
     rootObject()->setProperty("defaultStartup", false);
     auto action = new OneTimeAction(
         [this, localfile]() {
             auto res = ResourcesModel::global()->resourceForFile(localfile);
             qDebug() << "all initialized..." << res;
             if (res) {
                 emit openApplicationInternal(res);
             } else {
                 rootObject()->setProperty("defaultStartup", true);
                 showPassiveNotification(i18n("Couldn't open %1", localfile.toDisplayString()));
             }
         }
         , this);
 
     if (ResourcesModel::global()->backends().isEmpty()) {
         connect(ResourcesModel::global(), &ResourcesModel::backendsChanged, action, &OneTimeAction::trigger);
     } else {
         action->trigger();
     }
 }
 
 void DiscoverMainWindow::openApplication(const QUrl& url)
 {
     Q_ASSERT(!url.isEmpty());
     Q_EMIT openUrl(url);
 }
 
 void DiscoverMainWindow::integrateObject(QObject* object)
 {
     if (!object) {
         qWarning() << "Errors when loading the GUI";
         QTimer::singleShot(0, QCoreApplication::instance(), [](){
             QCoreApplication::instance()->exit(1);
         });
         return;
     }
 
     Q_ASSERT(object == rootObject());
 
     KConfigGroup window(KSharedConfig::openConfig(), "Window");
     if (window.hasKey("geometry"))
         rootObject()->setGeometry(window.readEntry("geometry", QRect()));
     if (window.hasKey("visibility")) {
         QWindow::Visibility visibility(QWindow::Visibility(window.readEntry<int>("visibility", QWindow::Windowed)));
         rootObject()->setVisibility(qMax(visibility, QQuickView::AutomaticVisibility));
     }
 
     object->installEventFilter(this);
+    connect(object, &QObject::destroyed, qGuiApp, &QCoreApplication::quit);
 }
 
 bool DiscoverMainWindow::eventFilter(QObject * object, QEvent * event)
 {
     if (object!=rootObject())
         return false;
 
     if (event->type() == QEvent::Close) {
         if (ResourcesModel::global()->isBusy()) {
             qWarning() << "not closing because there's still pending tasks";
             Q_EMIT preventedClose();
             return true;
         }
 
         KConfigGroup window(KSharedConfig::openConfig(), "Window");
         window.writeEntry("geometry", rootObject()->geometry());
         window.writeEntry<int>("visibility", rootObject()->visibility());
     }
     return false;
 }
 
 void DiscoverMainWindow::setupActions()
 {
     QAction *quitAction = KStandardAction::quit(QCoreApplication::instance(), &QCoreApplication::quit, actionCollection());
     actionCollection()->addAction(QStringLiteral("file_quit"), quitAction);
 
     if (KAuthorized::authorizeAction(QStringLiteral("help_contents"))) {
         auto mHandBookAction = KStandardAction::helpContents(this, &DiscoverMainWindow::appHelpActivated, this);
         actionCollection()->addAction(mHandBookAction->objectName(), mHandBookAction);
     }
 
     if (KAuthorized::authorizeAction(QStringLiteral("help_report_bug")) && !KAboutData::applicationData().bugAddress().isEmpty()) {
         auto mReportBugAction = KStandardAction::reportBug(this, &DiscoverMainWindow::reportBug, this);
         actionCollection()->addAction(mReportBugAction->objectName(), mReportBugAction);
     }
 
     if (KAuthorized::authorizeAction(QStringLiteral("switch_application_language"))) {
 //         if (KLocalizedString::availableApplicationTranslations().count() > 1) {
             auto mSwitchApplicationLanguageAction = KStandardAction::create(KStandardAction::SwitchApplicationLanguage, this, &DiscoverMainWindow::switchApplicationLanguage, this);
             actionCollection()->addAction(mSwitchApplicationLanguageAction->objectName(), mSwitchApplicationLanguageAction);
 //         }
     }
 
     if (KAuthorized::authorizeAction(QStringLiteral("help_about_app"))) {
         auto mAboutAppAction = KStandardAction::aboutApp(this, &DiscoverMainWindow::aboutApplication, this);
         actionCollection()->addAction(mAboutAppAction->objectName(), mAboutAppAction);
     }
     auto mKeyBindignsAction = KStandardAction::keyBindings(this, &DiscoverMainWindow::configureShortcuts, this);
     actionCollection()->addAction(mKeyBindignsAction->objectName(), mKeyBindignsAction);
 }
 
 QAction * DiscoverMainWindow::action(const QString& name)
 {
     return actionCollection()->action(name);
 }
 
 QString DiscoverMainWindow::iconName(const QIcon& icon)
 {
     return icon.name();
 }
 
 void DiscoverMainWindow::appHelpActivated()
 {
     QDesktopServices::openUrl(QUrl(QStringLiteral("help:/")));
 }
 
 void DiscoverMainWindow::aboutApplication()
 {
     static QPointer<QDialog> dialog;
     if (!dialog) {
         dialog = new KAboutApplicationDialog(KAboutData::applicationData(), nullptr);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
     }
     dialog->show();
 }
 
 void DiscoverMainWindow::reportBug()
 {
     static QPointer<QDialog> dialog;
     if (!dialog) {
         dialog = new KBugReport(KAboutData::applicationData(), nullptr);
         dialog->setAttribute(Qt::WA_DeleteOnClose);
     }
     dialog->show();
 }
 
 void DiscoverMainWindow::switchApplicationLanguage()
 {
 //     auto langDialog = new KSwitchLanguageDialog(nullptr);
 //     connect(langDialog, SIGNAL(finished(int)), this, SLOT(dialogFinished()));
 //     langDialog->show();
 }
 
 void DiscoverMainWindow::configureShortcuts()
 {
     KShortcutsDialog dlg(KShortcutsEditor::AllActions, KShortcutsEditor::LetterShortcutsAllowed, nullptr);
     dlg.setModal(true);
     dlg.addCollection(actionCollection());
     qDebug() << "saving shortcuts..." << dlg.configure(/*bSaveSettings*/);
 }
 
 void DiscoverMainWindow::setCompactMode(DiscoverMainWindow::CompactMode mode)
 {
     if (m_mode != mode) {
         m_mode = mode;
         Q_EMIT compactModeChanged(m_mode);
     }
 }
 
 class DiscoverTestExecutor : public QObject
 {
 public:
     DiscoverTestExecutor(QObject* rootObject, QQmlEngine* engine, const QUrl &url)
         : QObject(engine)
     {
         connect(engine, &QQmlEngine::quit, this, &DiscoverTestExecutor::finish, Qt::QueuedConnection);
 
         QQmlComponent* component = new QQmlComponent(engine, url, engine);
         m_testObject = component->create(engine->rootContext());
 
         if (!m_testObject) {
             qWarning() << "error loading test" << url << m_testObject << component->errors();
             Q_ASSERT(false);
         }
 
         m_testObject->setProperty("appRoot", QVariant::fromValue<QObject*>(rootObject));
         connect(engine, &QQmlEngine::warnings, this, &DiscoverTestExecutor::processWarnings);
     }
 
     void processWarnings(const QList<QQmlError> &warnings) {
         foreach(const QQmlError &warning, warnings) {
             if (warning.url().path().endsWith(QLatin1String("DiscoverTest.qml"))) {
                 qWarning() << "Test failed!" << warnings;
                 qGuiApp->exit(1);
             }
         }
         m_warnings << warnings;
     }
 
     void finish() {
         //The CI doesn't seem to have icons, remove when it's not an issue anymore
         m_warnings.erase(std::remove_if(m_warnings.begin(), m_warnings.end(), [](const QQmlError& err) -> bool {
             return err.description().contains(QLatin1String("QML Image: Failed to get image from provider: image://icon/"));
         }));
 
         if (m_warnings.isEmpty())
             qDebug() << "cool no warnings!";
         else
             qDebug() << "test finished succesfully despite" << m_warnings;
         qGuiApp->exit(m_warnings.count());
     }
 
 private:
     QObject* m_testObject;
     QList<QQmlError> m_warnings;
 };
 
 void DiscoverMainWindow::loadTest(const QUrl& url)
 {
     new DiscoverTestExecutor(rootObject(), engine(), url);
 }
 
 QWindow* DiscoverMainWindow::rootObject() const
 {
     return qobject_cast<QWindow*>(m_engine->rootObjects().at(0));
 }
 
 void DiscoverMainWindow::showPassiveNotification(const QString& msg)
 {
     QTimer::singleShot(100, this, [this, msg](){
         QMetaObject::invokeMethod(rootObject(), "showPassiveNotification", Qt::QueuedConnection, Q_ARG(QVariant, msg), Q_ARG(QVariant, {}), Q_ARG(QVariant, {}), Q_ARG(QVariant, {}));
     });
 }
diff --git a/discover/main.cpp b/discover/main.cpp
index 6f41f918..5ad63209 100644
--- a/discover/main.cpp
+++ b/discover/main.cpp
@@ -1,152 +1,155 @@
 /*
  *   Copyright (C) 2012 Aleix Pol Gonzalez <aleixpol@blue-systems.com>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library/Lesser General Public License
  *   version 2, or (at your option) any later version, as published by the
  *   Free Software Foundation
  *
  *   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/Lesser 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.
  */
 
 // #define QT_QML_DEBUG
 
 #include <QApplication>
 #include <KAboutData>
 #include <KCrash>
 #include <KDBusService>
 #include <KLocalizedString>
 #include <QCommandLineParser>
 #include <qwindow.h>
 #include "DiscoverMainWindow.h"
 #include <DiscoverBackendsFactory.h>
 #include "DiscoverVersion.h"
 #include <QTextStream>
 #include <QStandardPaths>
 
 typedef QHash<QString, DiscoverMainWindow::CompactMode> StringCompactMode;
 Q_GLOBAL_STATIC_WITH_ARGS(StringCompactMode, s_decodeCompactMode, (StringCompactMode {
     { QLatin1String("auto"), DiscoverMainWindow::Auto },
     { QLatin1String("compact"), DiscoverMainWindow::Compact },
     { QLatin1String("full"), DiscoverMainWindow::Full }
 }))
 
 QCommandLineParser* createParser()
 {
     QCommandLineParser* parser = new QCommandLineParser;
     parser->addOption(QCommandLineOption(QStringLiteral("application"), i18n("Directly open the specified application by its package name."), QStringLiteral("name")));
     parser->addOption(QCommandLineOption(QStringLiteral("mime"), i18n("Open with a program that can deal with the given mimetype."), QStringLiteral("name")));
     parser->addOption(QCommandLineOption(QStringLiteral("category"), i18n("Display a list of entries with a category."), QStringLiteral("name")));
     parser->addOption(QCommandLineOption(QStringLiteral("mode"), i18n("Open Discover in a said mode. Modes correspond to the toolbar buttons."), QStringLiteral("name")));
     parser->addOption(QCommandLineOption(QStringLiteral("listmodes"), i18n("List all the available modes.")));
     parser->addOption(QCommandLineOption(QStringLiteral("compact"), i18n("Compact Mode (auto/compact/full)."), QStringLiteral("mode"), QStringLiteral("auto")));
     parser->addOption(QCommandLineOption(QStringLiteral("local-filename"), i18n("Local package file to install"), QStringLiteral("package")));
     parser->addOption(QCommandLineOption(QStringLiteral("listbackends"), i18n("List all the available backends.")));
     parser->addOption(QCommandLineOption(QStringLiteral("test"), QStringLiteral("Test file"), QStringLiteral("file.qml")));
     parser->addPositionalArgument(QStringLiteral("urls"), i18n("Supports appstream: url scheme"));
     DiscoverBackendsFactory::setupCommandLine(parser);
     KAboutData::applicationData().setupCommandLine(parser);
     parser->addHelpOption();
     parser->addVersionOption();
     return parser;
 }
 
 void processArgs(QCommandLineParser* parser, DiscoverMainWindow* mainWindow)
 {
     if(parser->isSet(QStringLiteral("application")))
         mainWindow->openApplication(QUrl(parser->value(QStringLiteral("application"))));
     else if(parser->isSet(QStringLiteral("mime")))
         mainWindow->openMimeType(parser->value(QStringLiteral("mime")));
     else if(parser->isSet(QStringLiteral("category")))
         mainWindow->openCategory(parser->value(QStringLiteral("category")));
 
     if(parser->isSet(QStringLiteral("mode")))
         mainWindow->openMode(parser->value(QStringLiteral("mode")));
 
     if(parser->isSet(QStringLiteral("local-filename")))
         mainWindow->openLocalPackage(QUrl::fromUserInput(parser->value(QStringLiteral("local-filename")), {}, QUrl::AssumeLocalFile));
 
     foreach(const QString &arg, parser->positionalArguments()) {
         const QUrl url = QUrl::fromUserInput(arg, {}, QUrl::AssumeLocalFile);
         if (url.isLocalFile())
             mainWindow->openLocalPackage(url);
         else
             mainWindow->openApplication(url);
     }
 }
 
 int main(int argc, char** argv)
 {
     QApplication app(argc, argv);
     app.setWindowIcon(QIcon::fromTheme(QStringLiteral("plasmadiscover")));
     app.setAttribute(Qt::AA_DontCreateNativeWidgetSiblings);
     app.setAttribute(Qt::AA_UseHighDpiPixmaps, true);
     KCrash::initialize();
     KLocalizedString::setApplicationDomain("plasma-discover");
     KAboutData about(QStringLiteral("discover"), i18n("Discover"), version, i18n("An application explorer"),
                      KAboutLicense::GPL, i18n("© 2010-2016 Plasma Development Team"));
     about.addAuthor(i18n("Aleix Pol Gonzalez"), QString(), QStringLiteral("aleixpol@blue-systems.com"));
     about.addAuthor(i18n("Jonathan Thomas"), QString(), QStringLiteral("echidnaman@kubuntu.org"));
     about.setProductName("discover/discover");
     KAboutData::setApplicationData(about);
 
     DiscoverMainWindow *mainWindow = nullptr;
     {
         QScopedPointer<QCommandLineParser> parser(createParser());
         parser->process(app);
         about.processCommandLine(parser.data());
         DiscoverBackendsFactory::processCommandLine(parser.data(), parser->isSet(QStringLiteral("test")));
 
         if(parser->isSet(QStringLiteral("listbackends"))) {
             QTextStream(stdout) << i18n("Available backends:\n");
             DiscoverBackendsFactory f;
             foreach(const QString& name, f.allBackendNames(false, true))
                 QTextStream(stdout) << " * " << name << '\n';
             return 0;
         }
 
         if (parser->isSet(QStringLiteral("test"))) {
             QStandardPaths::setTestModeEnabled(true);
         }
 
         KDBusService* service = new KDBusService(KDBusService::Unique, &app);
 
         mainWindow = new DiscoverMainWindow(s_decodeCompactMode->value(parser->value(QStringLiteral("compact")), DiscoverMainWindow::Full));
         QObject::connect(&app, &QCoreApplication::aboutToQuit, mainWindow, &DiscoverMainWindow::deleteLater);
         QObject::connect(service, &KDBusService::activateRequested, mainWindow, [mainWindow](const QStringList &arguments, const QString &/*workingDirectory*/){
+            if (!mainWindow->rootObject())
+                QCoreApplication::instance()->quit();
+
             mainWindow->rootObject()->raise();
             if (arguments.isEmpty())
                 return;
             QScopedPointer<QCommandLineParser> parser(createParser());
             parser->parse(arguments);
             processArgs(parser.data(), mainWindow);
         });
 
         processArgs(parser.data(), mainWindow);
 
         if(parser->isSet(QStringLiteral("listmodes"))) {
             QTextStream(stdout) << i18n("Available modes:\n");
             foreach(const QString& mode, mainWindow->modes())
                 QTextStream(stdout) << " * " << mode << '\n';
             delete mainWindow;
             return 0;
         }
 
         if (parser->isSet(QStringLiteral("test"))) {
             const QUrl testFile = QUrl::fromUserInput(parser->value(QStringLiteral("test")), {}, QUrl::AssumeLocalFile);
             Q_ASSERT(!testFile.isEmpty() && testFile.isLocalFile());
 
             mainWindow->loadTest(testFile);
         }
     }
 
     return app.exec();
 }