diff --git a/app/universalsettings.cpp b/app/universalsettings.cpp
index 34348611..77db43ee 100644
--- a/app/universalsettings.cpp
+++ b/app/universalsettings.cpp
@@ -1,425 +1,453 @@
 /*
 *  Copyright 2017  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "universalsettings.h"
 #include "dockcorona.h"
 
 #include "sortedactivitiesmodel.h"
 
 #include <QDir>
+#include <QAction>
 
+#include <KGlobalAccel>
 #include <KActivities/Consumer>
 
+#define GLOBALSHORTCUTSCONFIG "kglobalshortcutsrc"
+
 namespace Latte {
 
 UniversalSettings::UniversalSettings(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_config(config),
       m_universalGroup(KConfigGroup(config, QStringLiteral("UniversalSettings")))
 {
+    const QString globalShortcutsFilePath = QDir::homePath() + "/.config/" + GLOBALSHORTCUTSCONFIG;
+    m_shortcutsConfigPtr = KSharedConfig::openConfig(globalShortcutsFilePath);
+
     connect(this, &UniversalSettings::canDisableBordersChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::currentLayoutNameChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::downloadWindowSizeChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::lastNonAssignedLayoutNameChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::launchersChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsColumnWidthsChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsMemoryUsageChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsWindowSizeChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::mouseSensitivityChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::screenTrackerIntervalChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::showInfoWindowChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::unifiedGlobalShortcutsChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::versionChanged, this, &UniversalSettings::saveConfig);
 }
 
 UniversalSettings::~UniversalSettings()
 {
     saveConfig();
     cleanupSettings();
 
     if (m_runningActivitiesModel) {
         m_runningActivitiesModel->deleteLater();
     }
 }
 
+void UniversalSettings::clearAllAppletShortcuts()
+{
+    KConfigGroup latteGroup = KConfigGroup(m_shortcutsConfigPtr, "lattedock");
+
+    foreach(auto key, latteGroup.keyList()) {
+        if (key.startsWith("activate widget ")) {
+            QAction *appletAction = new QAction(this);
+
+            appletAction->setText(QString("Activate ") + key);
+            appletAction->setObjectName(key);
+            appletAction->setShortcut(QKeySequence());
+            KGlobalAccel::setGlobalShortcut(appletAction, QKeySequence());
+            KGlobalAccel::self()->removeAllShortcuts(appletAction);
+
+            appletAction->deleteLater();
+        }
+    }
+}
+
 void UniversalSettings::load()
 {
     //! check if user has set the autostart option
     bool autostartUserSet = m_universalGroup.readEntry("userConfiguredAutostart", false);
 
     if (!autostartUserSet && !autostart()) {
         setAutostart(true);
     }
 
     //! load configuration
     loadConfig();
+
+    clearAllAppletShortcuts();
 }
 
 bool UniversalSettings::showInfoWindow() const
 {
     return m_showInfoWindow;
 }
 
 void UniversalSettings::setShowInfoWindow(bool show)
 {
     if (m_showInfoWindow == show) {
         return;
     }
 
     m_showInfoWindow = show;
     emit showInfoWindowChanged();
 }
 
 bool UniversalSettings::unifiedGlobalShortcuts() const
 {
     return m_unifiedGlobalShortcuts;
 }
 
 void UniversalSettings::setUnifiedGlobalShortcuts(bool unified)
 {
     if (m_unifiedGlobalShortcuts == unified) {
         return;
     }
 
     m_unifiedGlobalShortcuts = unified;
     emit unifiedGlobalShortcutsChanged();
 }
 
 int UniversalSettings::version() const
 {
     return m_version;
 }
 
 void UniversalSettings::setVersion(int ver)
 {
     if (m_version == ver) {
         return;
     }
 
     m_version = ver;
 
     emit versionChanged();
 }
 
 int UniversalSettings::screenTrackerInterval() const
 {
     return m_screenTrackerInterval;
 }
 
 void UniversalSettings::setScreenTrackerInterval(int duration)
 {
     if (m_screenTrackerInterval == duration) {
         return;
     }
 
     m_screenTrackerInterval = duration;
     emit screenTrackerIntervalChanged();
 }
 
 QString UniversalSettings::currentLayoutName() const
 {
     return m_currentLayoutName;
 }
 
 void UniversalSettings::setCurrentLayoutName(QString layoutName)
 {
     if (m_currentLayoutName == layoutName) {
         return;
     }
 
     m_currentLayoutName = layoutName;
     emit currentLayoutNameChanged();
 }
 
 QString UniversalSettings::lastNonAssignedLayoutName() const
 {
     return m_lastNonAssignedLayoutName;
 }
 
 void UniversalSettings::setLastNonAssignedLayoutName(QString layoutName)
 {
     if (m_lastNonAssignedLayoutName == layoutName) {
         return;
     }
 
     m_lastNonAssignedLayoutName = layoutName;
     emit lastNonAssignedLayoutNameChanged();
 }
 
 QSize UniversalSettings::downloadWindowSize() const
 {
     return m_downloadWindowSize;
 }
 
 void UniversalSettings::setDownloadWindowSize(QSize size)
 {
     if (m_downloadWindowSize == size) {
         return;
     }
 
     m_downloadWindowSize = size;
     emit downloadWindowSizeChanged();
 }
 
 
 QSize UniversalSettings::layoutsWindowSize() const
 {
     return m_layoutsWindowSize;
 }
 
 void UniversalSettings::setLayoutsWindowSize(QSize size)
 {
     if (m_layoutsWindowSize == size) {
         return;
     }
 
     m_layoutsWindowSize = size;
     emit layoutsWindowSizeChanged();
 }
 
 QStringList UniversalSettings::layoutsColumnWidths() const
 {
     return m_layoutsColumnWidths;
 }
 
 void UniversalSettings::setLayoutsColumnWidths(QStringList widths)
 {
     if (m_layoutsColumnWidths == widths) {
         return;
     }
 
     m_layoutsColumnWidths = widths;
     emit layoutsColumnWidthsChanged();
 }
 
 QStringList UniversalSettings::launchers() const
 {
     return m_launchers;
 }
 
 void UniversalSettings::setLaunchers(QStringList launcherList)
 {
     if (m_launchers == launcherList) {
         return;
     }
 
     m_launchers = launcherList;
     emit launchersChanged();
 }
 
 
 bool UniversalSettings::autostart() const
 {
     QFile autostartFile(QDir::homePath() + "/.config/autostart/org.kde.latte-dock.desktop");
     return autostartFile.exists();
 }
 
 void UniversalSettings::setAutostart(bool state)
 {
     //! remove old autostart file
     QFile oldAutostartFile(QDir::homePath() + "/.config/autostart/latte-dock.desktop");
 
     if (oldAutostartFile.exists()) {
         oldAutostartFile.remove();
     }
 
     //! end of removal of old autostart file
 
     QFile autostartFile(QDir::homePath() + "/.config/autostart/org.kde.latte-dock.desktop");
     QFile metaFile("/usr/share/applications/org.kde.latte-dock.desktop");
 
     if (!state && autostartFile.exists()) {
         //! the first time that the user disables the autostart, this is recorded
         //! and from now own it will not be recreated it in the beginning
         if (!m_universalGroup.readEntry("userConfiguredAutostart", false)) {
             m_universalGroup.writeEntry("userConfiguredAutostart", true);
         }
 
         autostartFile.remove();
         emit autostartChanged();
     } else if (state && metaFile.exists()) {
         //! check if autostart folder exists and create otherwise
         QDir autostartDir(QDir::homePath() + "/.config/autostart");
         if (!autostartDir.exists()) {
             QDir configDir(QDir::homePath() + "/.config");
             configDir.mkdir("autostart");
         }
 
         metaFile.copy(autostartFile.fileName());
         //! I havent added the flag "OnlyShowIn=KDE;" into the autostart file
         //! because I fall onto a Plasma 5.8 case that this flag
         //! didnt let the plasma desktop to start
         emit autostartChanged();
     }
 }
 
 bool UniversalSettings::canDisableBorders() const
 {
     return m_canDisableBorders;
 }
 
 void UniversalSettings::setCanDisableBorders(bool enable)
 {
     if (m_canDisableBorders == enable) {
         return;
     }
 
     m_canDisableBorders = enable;
     emit canDisableBordersChanged();
 }
 
 Dock::LayoutsMemoryUsage UniversalSettings::layoutsMemoryUsage() const
 {
     return m_memoryUsage;
 }
 
 void UniversalSettings::setLayoutsMemoryUsage(Dock::LayoutsMemoryUsage layoutsMemoryUsage)
 {
     if (m_memoryUsage == layoutsMemoryUsage) {
         return;
     }
 
     m_memoryUsage = layoutsMemoryUsage;
     emit layoutsMemoryUsageChanged();
 }
 
 Dock::MouseSensitivity UniversalSettings::mouseSensitivity() const
 {
     return m_mouseSensitivity;
 }
 
 void UniversalSettings::setMouseSensitivity(Dock::MouseSensitivity sensitivity)
 {
     if (m_mouseSensitivity == sensitivity) {
         return;
     }
 
     m_mouseSensitivity = sensitivity;
     emit mouseSensitivityChanged();
 }
 
 void UniversalSettings::loadConfig()
 {
     m_version = m_universalGroup.readEntry("version", 1);
     m_canDisableBorders = m_universalGroup.readEntry("canDisableBorders", false);
     m_currentLayoutName = m_universalGroup.readEntry("currentLayout", QString());
     m_downloadWindowSize = m_universalGroup.readEntry("downloadWindowSize", QSize(800, 550));
     m_lastNonAssignedLayoutName = m_universalGroup.readEntry("lastNonAssignedLayout", QString());
     m_layoutsWindowSize = m_universalGroup.readEntry("layoutsWindowSize", QSize(700, 450));
     m_layoutsColumnWidths = m_universalGroup.readEntry("layoutsColumnWidths", QStringList());
     m_launchers = m_universalGroup.readEntry("launchers", QStringList());
     m_screenTrackerInterval = m_universalGroup.readEntry("screenTrackerInterval", 2500);
     m_showInfoWindow = m_universalGroup.readEntry("showInfoWindow", true);
     m_unifiedGlobalShortcuts = m_universalGroup.readEntry("unifiedGlobalShortcuts", true);
     m_memoryUsage = static_cast<Dock::LayoutsMemoryUsage>(m_universalGroup.readEntry("memoryUsage", (int)Dock::SingleLayout));
     m_mouseSensitivity = static_cast<Dock::MouseSensitivity>(m_universalGroup.readEntry("mouseSensitivity", (int)Dock::HighSensitivity));
 }
 
 void UniversalSettings::saveConfig()
 {
     m_universalGroup.writeEntry("version", m_version);
     m_universalGroup.writeEntry("canDisableBorders", m_canDisableBorders);
     m_universalGroup.writeEntry("currentLayout", m_currentLayoutName);
     m_universalGroup.writeEntry("downloadWindowSize", m_downloadWindowSize);
     m_universalGroup.writeEntry("lastNonAssignedLayout", m_lastNonAssignedLayoutName);
     m_universalGroup.writeEntry("layoutsWindowSize", m_layoutsWindowSize);
     m_universalGroup.writeEntry("layoutsColumnWidths", m_layoutsColumnWidths);
     m_universalGroup.writeEntry("launchers", m_launchers);
     m_universalGroup.writeEntry("screenTrackerInterval", m_screenTrackerInterval);
     m_universalGroup.writeEntry("showInfoWindow", m_showInfoWindow);
     m_universalGroup.writeEntry("unifiedGlobalShortcuts", m_unifiedGlobalShortcuts);
     m_universalGroup.writeEntry("memoryUsage", (int)m_memoryUsage);
     m_universalGroup.writeEntry("mouseSensitivity", (int)m_mouseSensitivity);
 
     m_universalGroup.sync();
 }
 
 void UniversalSettings::cleanupSettings()
 {
     KConfigGroup containments = KConfigGroup(m_config, QStringLiteral("Containments"));
     containments.deleteGroup();
 
     containments.sync();
 }
 
 QString UniversalSettings::splitterIconPath()
 {
     auto *dockCorona = qobject_cast<DockCorona *>(parent());
 
     if (dockCorona) {
         return dockCorona->kPackage().filePath("splitter");
     }
 
     return "";
 }
 
 QString UniversalSettings::trademarkIconPath()
 {
     auto *dockCorona = qobject_cast<DockCorona *>(parent());
 
     if (dockCorona) {
         return dockCorona->kPackage().filePath("trademark");
     }
 
     return "";
 }
 
 QAbstractItemModel *UniversalSettings::runningActivitiesModel() const
 {
     return m_runningActivitiesModel;
 }
 
 void UniversalSettings::setRunningActivitiesModel(SortedActivitiesModel *model)
 {
     if (m_runningActivitiesModel == model) {
         return;
     }
 
     if (m_runningActivitiesModel) {
         m_runningActivitiesModel->deleteLater();
     }
 
     m_runningActivitiesModel = model;
 
     emit runningActivitiesModelChanged();
 }
 
 void UniversalSettings::enableActivitiesModel()
 {
     if (!m_runningActivitiesModel) {
         setRunningActivitiesModel(new SortedActivitiesModel({KActivities::Info::Running, KActivities::Info::Stopping}, this));
     }
 }
 
 void UniversalSettings::disableActivitiesModel()
 {
     if (m_runningActivitiesModel) {
         setRunningActivitiesModel(nullptr);
     }
 }
 
 float UniversalSettings::luminasFromFile(QString imageFile, int edge)
 {
     enableActivitiesModel();
 
     return m_runningActivitiesModel->luminasFromFile(imageFile, edge);
 }
 
 }
diff --git a/app/universalsettings.h b/app/universalsettings.h
index 5110eb3b..84f26218 100644
--- a/app/universalsettings.h
+++ b/app/universalsettings.h
@@ -1,173 +1,176 @@
 /*
 *  Copyright 2017  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef UNIVERSALSETTINGS_H
 #define UNIVERSALSETTINGS_H
 
 #include <QObject>
 #include <QAbstractItemModel>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include "../liblattedock/dock.h"
 
 class SortedActivitiesModel;
 
 namespace Latte {
 
 class LayoutManager;
 
 //! This class holds all the settings that are universally available
 //! independent of layouts
 class UniversalSettings : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool autostart READ autostart WRITE setAutostart NOTIFY autostartChanged)
     Q_PROPERTY(bool showInfoWindow READ showInfoWindow WRITE setShowInfoWindow NOTIFY showInfoWindowChanged)
     //! some v0.7 users wanted the previous global shortcuts behavior that applets werent taken
     //! into account. By default unification will take place but the user will be able to change
     //! this from latte global settings
     Q_PROPERTY(bool unifiedGlobalShortcuts READ unifiedGlobalShortcuts NOTIFY unifiedGlobalShortcutsChanged)
 
     Q_PROPERTY(QString currentLayoutName READ currentLayoutName WRITE setCurrentLayoutName NOTIFY currentLayoutNameChanged)
 
     Q_PROPERTY(QStringList launchers READ launchers WRITE setLaunchers NOTIFY launchersChanged)
 
     Q_PROPERTY(Latte::Dock::MouseSensitivity mouseSensitivity READ mouseSensitivity WRITE setMouseSensitivity NOTIFY mouseSensitivityChanged)
 
     Q_PROPERTY(QAbstractItemModel *runningActivitiesModel  READ runningActivitiesModel NOTIFY runningActivitiesModelChanged)
 public:
     UniversalSettings(KSharedConfig::Ptr config, QObject *parent = nullptr);
     ~UniversalSettings() override;
 
     void load();
 
     bool autostart() const;
     void setAutostart(bool state);
 
     bool canDisableBorders() const;
     void setCanDisableBorders(bool enable);
 
     bool showInfoWindow() const;
     void setShowInfoWindow(bool show);
 
     bool unifiedGlobalShortcuts() const;
 
     int version() const;
     void setVersion(int ver);
 
     int screenTrackerInterval() const;
     void setScreenTrackerInterval(int duration);
 
     QString currentLayoutName() const;
     void setCurrentLayoutName(QString layoutName);
 
     QString lastNonAssignedLayoutName() const;
     void setLastNonAssignedLayoutName(QString layoutName);
 
     QSize downloadWindowSize() const;
     void setDownloadWindowSize(QSize size);
 
     QSize layoutsWindowSize() const;
     void setLayoutsWindowSize(QSize size);
 
     QStringList layoutsColumnWidths() const;
     void setLayoutsColumnWidths(QStringList widths);
 
     QStringList launchers() const;
     void setLaunchers(QStringList launcherList);
 
     Dock::MouseSensitivity mouseSensitivity() const;
     void setMouseSensitivity(Dock::MouseSensitivity sensitivity);
 
     QAbstractItemModel *runningActivitiesModel() const;
     void setRunningActivitiesModel(SortedActivitiesModel *model);
     void enableActivitiesModel();
     void disableActivitiesModel();
 
+    void clearAllAppletShortcuts();
+
 public slots:
     Q_INVOKABLE QString splitterIconPath();
     Q_INVOKABLE QString trademarkIconPath();
 
     Q_INVOKABLE float luminasFromFile(QString imageFile, int edge);
 
 signals:
     void autostartChanged();
     void canDisableBordersChanged();
     void currentLayoutNameChanged();
     void downloadWindowSizeChanged();
     void lastNonAssignedLayoutNameChanged();
     void layoutsColumnWidthsChanged();
     void layoutsWindowSizeChanged();
     void launchersChanged();
     void layoutsMemoryUsageChanged();
     void mouseSensitivityChanged();
     void runningActivitiesModelChanged();
     void screenTrackerIntervalChanged();
     void showInfoWindowChanged();
     void unifiedGlobalShortcutsChanged();
     void versionChanged();
 
 private slots:
     void loadConfig();
     void saveConfig();
 
 private:
     void cleanupSettings();
 
     void setUnifiedGlobalShortcuts(bool unified);
 
     Dock::LayoutsMemoryUsage layoutsMemoryUsage() const;
     void setLayoutsMemoryUsage(Dock::LayoutsMemoryUsage layoutsMemoryUsage);
 
 private:
     bool m_canDisableBorders{false};
     bool m_showInfoWindow{true};
     bool m_unifiedGlobalShortcuts{true};
 
     //when there isnt a version it is an old universal file
     int m_version{1};
 
     int m_screenTrackerInterval{2500};
 
     QString m_currentLayoutName;
     QString m_lastNonAssignedLayoutName;
     QSize m_downloadWindowSize{800, 550};
     QSize m_layoutsWindowSize{700, 450};
 
     QStringList m_layoutsColumnWidths;
     QStringList m_launchers;
 
     Dock::LayoutsMemoryUsage m_memoryUsage;
     Dock::MouseSensitivity m_mouseSensitivity{Dock::HighSensitivity};
 
     KConfigGroup m_universalGroup;
     KSharedConfig::Ptr m_config;
+    KSharedConfig::Ptr m_shortcutsConfigPtr;
 
     SortedActivitiesModel *m_runningActivitiesModel{nullptr};
 
     friend class LayoutManager;
     friend class DockCorona;
 };
 
 }
 
 #endif //UNIVERSALSETTINGS_H