diff --git a/app/lattecorona.cpp b/app/lattecorona.cpp
index 68e6c800..63abddb0 100644
--- a/app/lattecorona.cpp
+++ b/app/lattecorona.cpp
@@ -1,985 +1,985 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmaibox.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 "lattecorona.h"
 
 // local
 #include "alternativeshelper.h"
 #include "importer.h"
 #include "lattedockadaptor.h"
 #include "launcherssignals.h"
 #include "layoutmanager.h"
 #include "screenpool.h"
 #include "shortcuts/globalshortcuts.h"
 #include "package/lattepackage.h"
 #include "plasma/extended/screenpool.h"
 #include "plasma/extended/theme.h"
 #include "settings/universalsettings.h"
 #include "view/view.h"
 #include "wm/abstractwindowinterface.h"
 #include "wm/waylandinterface.h"
 #include "wm/xwindowinterface.h"
 
 // Qt
 #include <QAction>
 #include <QApplication>
 #include <QScreen>
 #include <QDBusConnection>
 #include <QDebug>
 #include <QDesktopWidget>
 #include <QFile>
 #include <QFontDatabase>
 #include <QQmlContext>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Corona>
 #include <Plasma/Containment>
 #include <PlasmaQuick/ConfigView>
 
 // KDE
 #include <KActionCollection>
 #include <KPluginMetaData>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPackage/Package>
 #include <KPackage/PackageLoader>
 #include <KAboutData>
 #include <KActivities/Consumer>
 #include <KDeclarative/QmlObject>
 #include <KWindowSystem>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 
 namespace Latte {
 
 Corona::Corona(bool defaultLayoutOnStartup, QString layoutNameOnStartUp, int userSetMemoryUsage, QObject *parent)
     : Plasma::Corona(parent),
       m_defaultLayoutOnStartup(defaultLayoutOnStartup),
       m_userSetMemoryUsage(userSetMemoryUsage),
       m_layoutNameOnStartUp(layoutNameOnStartUp),
       m_activityConsumer(new KActivities::Consumer(this)),
       m_screenPool(new ScreenPool(KSharedConfig::openConfig(), this)),
-      m_globalShortcuts(new GlobalShortcuts(this)),
       m_universalSettings(new UniversalSettings(KSharedConfig::openConfig(), this)),
+      m_globalShortcuts(new GlobalShortcuts(this)),
       m_plasmaScreenPool(new PlasmaExtended::ScreenPool(this)),
       m_themeExtended(new PlasmaExtended::Theme(KSharedConfig::openConfig(), this)),
       m_layoutManager(new LayoutManager(this))
 {
     //! create the window manager
 
     if (KWindowSystem::isPlatformWayland()) {
         m_wm = new WaylandInterface(this);
     } else {
         m_wm = new XWindowInterface(this);
     }
 
     setupWaylandIntegration();
 
     KPackage::Package package(new Latte::Package(this));
 
     m_screenPool->load();
 
     if (!package.isValid()) {
         qWarning() << staticMetaObject.className()
                    << "the package" << package.metadata().rawData() << "is invalid!";
         return;
     } else {
         qDebug() << staticMetaObject.className()
                  << "the package" << package.metadata().rawData() << "is valid!";
     }
 
     setKPackage(package);
     //! universal settings / extendedtheme must be loaded after the package has been set
     m_universalSettings->load();
     m_themeExtended->load();
 
     qmlRegisterTypes();
 
     if (m_activityConsumer && (m_activityConsumer->serviceStatus() == KActivities::Consumer::Running)) {
         load();
     }
 
     connect(m_activityConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
 
     m_viewsScreenSyncTimer.setSingleShot(true);
     m_viewsScreenSyncTimer.setInterval(m_universalSettings->screenTrackerInterval());
     connect(&m_viewsScreenSyncTimer, &QTimer::timeout, this, &Corona::syncLatteViewsToScreens);
     connect(m_universalSettings, &UniversalSettings::screenTrackerIntervalChanged, this, [this]() {
         m_viewsScreenSyncTimer.setInterval(m_universalSettings->screenTrackerInterval());
     });
 
     //! Dbus adaptor initialization
     new LatteDockAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Latte"), this);
 }
 
 Corona::~Corona()
 {
     //! BEGIN: Give the time to slide-out views when closing
     m_layoutManager->hideAllViews();
 
     //! Don't delay the destruction under wayland in any case
     //! because it creates a crash with kwin effects
     //! https://bugs.kde.org/show_bug.cgi?id=392890
     if (!KWindowSystem::isPlatformWayland()) {
         QTimer::singleShot(400, [this]() {
             m_quitTimedEnded = true;
         });
 
         while (!m_quitTimedEnded) {
             QGuiApplication::processEvents(QEventLoop::AllEvents, 50);
         }
     }
 
     //! END: slide-out views when closing
 
     m_viewsScreenSyncTimer.stop();
 
     if (m_layoutManager->memoryUsage() == Types::SingleLayout) {
         cleanConfig();
     }
 
     qDebug() << "Latte Corona - unload: containments ...";
 
     m_layoutManager->unload();
 
     m_wm->deleteLater();
     m_globalShortcuts->deleteLater();
     m_layoutManager->deleteLater();
     m_screenPool->deleteLater();
     m_universalSettings->deleteLater();
     m_plasmaScreenPool->deleteLater();
     m_themeExtended->deleteLater();
 
     disconnect(m_activityConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
     delete m_activityConsumer;
 
     qDebug() << "Latte Corona - deleted...";
 }
 
 void Corona::load()
 {
     if (m_activityConsumer && (m_activityConsumer->serviceStatus() == KActivities::Consumer::Running) && m_activitiesStarting) {
         disconnect(m_activityConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
         m_layoutManager->load();
 
         m_activitiesStarting = false;
 
         connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &Corona::primaryOutputChanged, Qt::UniqueConnection);
         connect(QApplication::desktop(), &QDesktopWidget::screenCountChanged, this, &Corona::screenCountChanged);
 
         connect(m_screenPool, &ScreenPool::primaryPoolChanged, this, &Corona::screenCountChanged);
 
         QString assignedLayout = m_layoutManager->shouldSwitchToLayout(m_activityConsumer->currentActivity());
 
         QString loadLayoutName = "";
 
         if (!m_defaultLayoutOnStartup && m_layoutNameOnStartUp.isEmpty()) {
             if (!assignedLayout.isEmpty() && assignedLayout != m_universalSettings->currentLayoutName()) {
                 loadLayoutName = assignedLayout;
             } else {
                 loadLayoutName = m_universalSettings->currentLayoutName();
             }
 
             if (!m_layoutManager->layoutExists(loadLayoutName)) {
                 loadLayoutName = m_layoutManager->defaultLayoutName();
                 m_layoutManager->importDefaultLayout(false);
             }
         } else if (m_defaultLayoutOnStartup) {
             loadLayoutName = m_layoutManager->importer()->uniqueLayoutName(m_layoutManager->defaultLayoutName());
             m_layoutManager->importDefaultLayout(true);
         } else {
             loadLayoutName = m_layoutNameOnStartUp;
         }
 
         if (m_userSetMemoryUsage != -1 && !KWindowSystem::isPlatformWayland()) {
             Types::LayoutsMemoryUsage usage = static_cast<Types::LayoutsMemoryUsage>(m_userSetMemoryUsage);
 
             m_universalSettings->setLayoutsMemoryUsage(usage);
         }
 
         if (KWindowSystem::isPlatformWayland()) {
             m_universalSettings->setLayoutsMemoryUsage(Types::SingleLayout);
         }
 
         m_layoutManager->loadLayoutOnStartup(loadLayoutName);
 
 
         //! load screens signals such screenGeometryChanged in order to support
         //! plasmoid.screenGeometry properly
         for (QScreen *screen : qGuiApp->screens()) {
             addOutput(screen);
         }
 
         connect(qGuiApp, &QGuiApplication::screenAdded, this, &Corona::addOutput, Qt::UniqueConnection);
     }
 }
 
 void Corona::unload()
 {
     qDebug() << "unload: removing containments...";
 
     while (!containments().isEmpty()) {
         //deleting a containment will remove it from the list due to QObject::destroyed connect in Corona
         //this form doesn't crash, while qDeleteAll(containments()) does
         delete containments().first();
     }
 }
 
 void Corona::setupWaylandIntegration()
 {
     if (!KWindowSystem::isPlatformWayland()) {
         return;
     }
 
     using namespace KWayland::Client;
 
     auto connection = ConnectionThread::fromApplication(this);
 
     if (!connection) {
         return;
     }
 
     Registry *registry{new Registry(this)};
     registry->create(connection);
 
     connect(registry, &Registry::plasmaShellAnnounced, this
     , [this, registry](quint32 name, quint32 version) {
         m_waylandCorona = registry->createPlasmaShell(name, version, this);
     });
 
     QObject::connect(registry, &KWayland::Client::Registry::plasmaWindowManagementAnnounced,
     [this, registry](quint32 name, quint32 version) {
         KWayland::Client::PlasmaWindowManagement *pwm = registry->createPlasmaWindowManagement(name, version, this);
 
         WaylandInterface *wI = qobject_cast<WaylandInterface *>(m_wm);
 
         if (wI) {
             wI->initWindowManagement(pwm);
         }
     });
 
     registry->setup();
     connection->roundtrip();
 }
 
 KWayland::Client::PlasmaShell *Corona::waylandCoronaInterface() const
 {
     return m_waylandCorona;
 }
 
 void Corona::cleanConfig()
 {
     auto containmentsEntries = config()->group("Containments");
     bool changed = false;
 
     foreach (auto cId, containmentsEntries.groupList()) {
         if (!containmentExists(cId.toUInt())) {
             //cleanup obsolete containments
             containmentsEntries.group(cId).deleteGroup();
             changed = true;
             qDebug() << "obsolete containment configuration deleted:" << cId;
         } else {
             //cleanup obsolete applets of running containments
             auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
             foreach (auto appletId, appletsEntries.groupList()) {
                 if (!appletExists(cId.toUInt(), appletId.toUInt())) {
                     appletsEntries.group(appletId).deleteGroup();
                     changed = true;
                     qDebug() << "obsolete applet configuration deleted:" << appletId;
                 }
             }
         }
     }
 
     if (changed) {
         config()->sync();
         qDebug() << "configuration file cleaned...";
     }
 }
 
 bool Corona::containmentExists(uint id) const
 {
     foreach (auto containment, containments()) {
         if (id == containment->id()) {
             return true;
         }
     }
 
     return false;
 }
 
 bool Corona::appletExists(uint containmentId, uint appletId) const
 {
     Plasma::Containment *containment = nullptr;
 
     foreach (auto cont, containments()) {
         if (containmentId == cont->id()) {
             containment = cont;
             break;
         }
     }
 
     if (!containment) {
         return false;
     }
 
     foreach (auto applet, containment->applets()) {
         if (applet->id() == appletId) {
             return true;
         }
     }
 
     return false;
 }
 
 KActivities::Consumer *Corona::activitiesConsumer() const
 {
     return m_activityConsumer;
 }
 
 GlobalShortcuts *Corona::globalShortcuts() const
 {
     return m_globalShortcuts;
 }
 
 ScreenPool *Corona::screenPool() const
 {
     return m_screenPool;
 }
 
 UniversalSettings *Corona::universalSettings() const
 {
     return m_universalSettings;
 }
 
 LayoutManager *Corona::layoutManager() const
 {
     return m_layoutManager;
 }
 
 AbstractWindowInterface *Corona::wm() const
 {
     return m_wm;
 }
 
 PlasmaExtended::ScreenPool *Corona::plasmaScreenPool() const
 {
     return m_plasmaScreenPool;
 }
 
 PlasmaExtended::Theme *Corona::themeExtended() const
 {
     return m_themeExtended;
 }
 
 int Corona::numScreens() const
 {
     return qGuiApp->screens().count();
 }
 
 QRect Corona::screenGeometry(int id) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     QString screenName;
 
     if (m_screenPool->knownIds().contains(id))
         screenName = m_screenPool->connector(id);
 
     foreach (auto scr, screens) {
         if (scr->name() == screenName) {
             screen = scr;
             break;
         }
     }
 
     return screen->geometry();
 }
 
 QRegion Corona::availableScreenRegion(int id) const
 {
     return availableScreenRegionWithCriteria(id);
 }
 
 QRegion Corona::availableScreenRegionWithCriteria(int id, QString forLayout) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     QString screenName;
 
     if (m_screenPool->knownIds().contains(id))
         screenName = m_screenPool->connector(id);
 
     foreach (auto scr, screens) {
         if (scr->name() == screenName) {
             screen = scr;
             break;
         }
     }
 
     if (!screen)
         return QRegion();
 
     QHash<const Plasma::Containment *, Latte::View *> *views;
 
     if (forLayout.isEmpty()) {
         Layout *currentLayout = m_layoutManager->currentLayout();
         views = currentLayout ? currentLayout->latteViews() : nullptr;
     } else {
         Layout *activeLayout = m_layoutManager->activeLayout(forLayout);
         views = activeLayout ? activeLayout->latteViews() : nullptr;
     }
 
     QRegion available(screen->geometry());
 
     if (views) {
         for (const auto *view : *views) {
             if (view && view->containment() && view->screen() == screen
                 && view->visibility() && (view->visibility()->mode() != Latte::Types::AutoHide)) {
                 int realThickness = view->normalThickness() - view->effects()->innerShadow();
 
                 // Usually availableScreenRect is used by the desktop,
                 // but Latte don't have desktop, then here just
                 // need calculate available space for top and bottom location,
                 // because the left and right are those who dodge others views
                 switch (view->location()) {
                     case Plasma::Types::TopEdge:
                         if (view->behaveAsPlasmaPanel()) {
                             available -= view->geometry();
                         } else {
                             QRect realGeometry;
                             int realWidth = view->maxLength() * view->width();
 
                             switch (view->alignment()) {
                                 case Latte::Types::Left:
                                     realGeometry = QRect(view->x(), view->y(),
                                                          realWidth, realThickness);
                                     break;
 
                                 case Latte::Types::Center:
                                 case Latte::Types::Justify:
                                     realGeometry = QRect(qMax(view->geometry().x(), view->geometry().center().x() - realWidth / 2), view->y(),
                                                          realWidth, realThickness);
                                     break;
 
                                 case Latte::Types::Right:
                                     realGeometry = QRect(view->geometry().right() - realWidth + 1, view->y(),
                                                          realWidth, realThickness);
                                     break;
                             }
 
                             available -= realGeometry;
                         }
 
                         break;
 
                     case Plasma::Types::BottomEdge:
                         if (view->behaveAsPlasmaPanel()) {
                             available -= view->geometry();
                         } else {
                             QRect realGeometry;
                             int realWidth = view->maxLength() * view->width();
                             int realY = view->geometry().bottom() - realThickness + 1;
 
                             switch (view->alignment()) {
                                 case Latte::Types::Left:
                                     realGeometry = QRect(view->x(), realY,
                                                          realWidth, realThickness);
                                     break;
 
                                 case Latte::Types::Center:
                                 case Latte::Types::Justify:
                                     realGeometry = QRect(qMax(view->geometry().x(), view->geometry().center().x() - realWidth / 2),
                                                          realY, realWidth, realThickness);
                                     break;
 
                                 case Latte::Types::Right:
                                     realGeometry = QRect(view->geometry().right() - realWidth + 1, realY,
                                                          realWidth, realThickness);
                                     break;
                             }
 
                             available -= realGeometry;
                         }
 
                         break;
 
                     default:
                         //! bypass clang warnings
                         break;
                 }
             }
         }
     }
 
     /*qDebug() << "::::: FREE AREAS :::::";
 
     for (int i = 0; i < available.rectCount(); ++i) {
         qDebug() << available.rects().at(i);
     }
 
     qDebug() << "::::: END OF FREE AREAS :::::";*/
 
     return available;
 }
 
 QRect Corona::availableScreenRect(int id) const
 {
     return availableScreenRectWithCriteria(id);
 }
 
 QRect Corona::availableScreenRectWithCriteria(int id, QList<Types::Visibility> modes, QList<Plasma::Types::Location> edges) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     if (m_screenPool->knownIds().contains(id)) {
         QString scrName = m_screenPool->connector(id);
 
         foreach (auto scr, screens) {
             if (scr->name() == scrName) {
                 screen = scr;
                 break;
             }
         }
     }
 
     if (!screen)
         return {};
 
     bool allModes = modes.isEmpty();
 
     bool allEdges = edges.isEmpty();
 
     auto available = screen->geometry();
 
     Layout *currentLayout = m_layoutManager->currentLayout();
     QHash<const Plasma::Containment *, Latte::View *> *views;
 
     if (currentLayout) {
         views = currentLayout->latteViews();
     }
 
     if (views) {
         for (const auto *view : *views) {
             if (view && view->containment() && view->screen() == screen
                 && ((allEdges || edges.contains(view->location()))
                     && (allModes || (view->visibility() && modes.contains(view->visibility()->mode()))))) {
 
                 auto dockRect = view->absGeometry();
 
                 // Usually availableScreenRect is used by the desktop,
                 // but Latte don't have desktop, then here just
                 // need calculate available space for top and bottom location,
                 // because the left and right are those who dodge others docks
                 switch (view->location()) {
                     case Plasma::Types::TopEdge:
                         available.setTop(dockRect.bottom() + 1);
                         break;
 
                     case Plasma::Types::BottomEdge:
                         available.setBottom(dockRect.top() - 1);
                         break;
 
                     case Plasma::Types::LeftEdge:
                         available.setLeft(dockRect.right() + 1);
 
                         break;
 
                     case Plasma::Types::RightEdge:
                         available.setRight(dockRect.left() - 1);
 
                         break;
 
                     default:
                         //! bypass clang warnings
                         break;
                 }
             }
         }
     }
 
     return available;
 }
 
 void Corona::addOutput(QScreen *screen)
 {
     Q_ASSERT(screen);
 
     int id = m_screenPool->id(screen->name());
 
     if (id == -1) {
         int newId = m_screenPool->firstAvailableId();
         m_screenPool->insertScreenMapping(newId, screen->name());
     }
 
     connect(screen, &QScreen::geometryChanged, this, [ = ]() {
         const int id = m_screenPool->id(screen->name());
 
         if (id >= 0) {
             emit screenGeometryChanged(id);
             emit availableScreenRegionChanged();
             emit availableScreenRectChanged();
         }
     });
 
     emit availableScreenRectChanged();
     emit screenAdded(m_screenPool->id(screen->name()));
 }
 
 void Corona::primaryOutputChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 void Corona::screenRemoved(QScreen *screen)
 {
     Q_ASSERT(screen);
 }
 
 void Corona::screenCountChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 //! the central functions that updates loading/unloading latteviews
 //! concerning screen changed (for multi-screen setups mainly)
 void Corona::syncLatteViewsToScreens()
 {
     m_layoutManager->syncLatteViewsToScreens();
 }
 
 int Corona::primaryScreenId() const
 {
     return m_screenPool->id(qGuiApp->primaryScreen()->name());
 }
 
 void Corona::closeApplication()
 {
     //! this code must be called asynchronously because it is called
     //! also from qml (Settings window).
     QTimer::singleShot(5, [this]() {
         m_layoutManager->hideLatteSettingsDialog();
         m_layoutManager->hideAllViews();
     });
 
     //! give the time for the views to hide themselves
     QTimer::singleShot(500, [this]() {
         qGuiApp->quit();
     });
 }
 
 void Corona::aboutApplication()
 {
     if (aboutDialog) {
         aboutDialog->hide();
         aboutDialog->deleteLater();
     }
 
     aboutDialog = new KAboutApplicationDialog(KAboutData::applicationData());
     connect(aboutDialog.data(), &QDialog::finished, aboutDialog.data(), &QObject::deleteLater);
     m_wm->skipTaskBar(*aboutDialog);
     m_wm->setKeepAbove(*aboutDialog, true);
 
     aboutDialog->show();
 }
 
 int Corona::screenForContainment(const Plasma::Containment *containment) const
 {
     //FIXME: indexOf is not a proper way to support multi-screen
     // as for environment to environment the indexes change
     // also there is the following issue triggered
     // from latteView adaptToScreen()
     //
     // in a multi-screen environment that
     // primary screen is not set to 0 it was
     // created an endless showing loop at
     // startup (catch-up race) between
     // screen:0 and primaryScreen
 
     //case in which this containment is child of an applet, hello systray :)
 
     if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
         if (Plasma::Containment *cont = parentApplet->containment()) {
             return screenForContainment(cont);
         } else {
             return -1;
         }
     }
 
     Layout *currentLayout = m_layoutManager->currentLayout();
     QHash<const Plasma::Containment *, Latte::View *> *views;
 
     if (currentLayout) {
         views = currentLayout->latteViews();
     }
 
     //if the panel views already exist, base upon them
 
     Latte::View *view = views ? views->value(containment) : nullptr;
 
     if (view && view->screen()) {
         return m_screenPool->id(view->screen()->name());
     }
 
     //Failed? fallback on lastScreen()
     //lastScreen() is the correct screen for panels
     //It is also correct for desktops *that have the correct activity()*
     //a containment with lastScreen() == 0 but another activity,
     //won't be associated to a screen
     //     qDebug() << "ShellCorona screenForContainment: " << containment << " Last screen is " << containment->lastScreen();
 
     for (auto screen : qGuiApp->screens()) {
         // containment->lastScreen() == m_screenPool->id(screen->name()) to check if the lastScreen refers to a screen that exists/it's known
         if (containment->lastScreen() == m_screenPool->id(screen->name()) &&
             (containment->activity() == m_activityConsumer->currentActivity() ||
              containment->containmentType() == Plasma::Types::PanelContainment || containment->containmentType() == Plasma::Types::CustomPanelContainment)) {
             return containment->lastScreen();
         }
     }
 
     return -1;
 }
 
 void Corona::showAlternativesForApplet(Plasma::Applet *applet)
 {
     const QString alternativesQML = kPackage().filePath("appletalternativesui");
 
     if (alternativesQML.isEmpty()) {
         return;
     }
 
     Layout *currentLayout = m_layoutManager->currentLayout();
     QHash<const Plasma::Containment *, Latte::View *> *views;
 
     if (currentLayout) {
         views = currentLayout->latteViews();
     }
 
     Latte::View *latteView = (*views)[applet->containment()];
 
     KDeclarative::QmlObject *qmlObj{nullptr};
 
     if (latteView) {
         latteView->setAlternativesIsShown(true);
         qmlObj = new KDeclarative::QmlObject(latteView);
     } else {
         qmlObj = new KDeclarative::QmlObject(this);
     }
 
     qmlObj->setInitializationDelayed(true);
     qmlObj->setSource(QUrl::fromLocalFile(alternativesQML));
 
     AlternativesHelper *helper = new AlternativesHelper(applet, qmlObj);
     qmlObj->rootContext()->setContextProperty(QStringLiteral("alternativesHelper"), helper);
 
     m_alternativesObjects << qmlObj;
     qmlObj->completeInitialization();
 
     //! Alternative dialog signals
     connect(helper, &QObject::destroyed, this, [latteView]() {
         latteView->setAlternativesIsShown(false);
     });
 
     connect(qmlObj->rootObject(), SIGNAL(visibleChanged(bool)),
             this, SLOT(alternativesVisibilityChanged(bool)));
 
     connect(applet, &Plasma::Applet::destroyedChanged, this, [this, qmlObj](bool destroyed) {
         if (!destroyed) {
             return;
         }
 
         QMutableListIterator<KDeclarative::QmlObject *> it(m_alternativesObjects);
 
         while (it.hasNext()) {
             KDeclarative::QmlObject *obj = it.next();
 
             if (obj == qmlObj) {
                 it.remove();
                 obj->deleteLater();
             }
         }
     });
 }
 
 void Corona::alternativesVisibilityChanged(bool visible)
 {
     if (visible) {
         return;
     }
 
     QObject *root = sender();
 
     QMutableListIterator<KDeclarative::QmlObject *> it(m_alternativesObjects);
 
     while (it.hasNext()) {
         KDeclarative::QmlObject *obj = it.next();
 
         if (obj->rootObject() == root) {
             it.remove();
             obj->deleteLater();
         }
     }
 }
 
 void Corona::loadDefaultLayout()
 {
     qDebug() << "loading default layout";
     //! Setting mutable for create a containment
     setImmutability(Plasma::Types::Mutable);
     QVariantList args;
     auto defaultContainment = createContainmentDelayed("org.kde.latte.containment", args);
     defaultContainment->setContainmentType(Plasma::Types::PanelContainment);
     defaultContainment->init();
 
     if (!defaultContainment || !defaultContainment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto config = defaultContainment->config();
     defaultContainment->restore(config);
 
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                  Types::TopEdge, Types::RightEdge};
 
     Layout *currentLayout = m_layoutManager->activeLayout(m_layoutManager->currentLayoutName());
 
     if (currentLayout) {
         edges = currentLayout->freeEdges(defaultContainment->screen());
     }
 
     if ((edges.count() > 0)) {
         defaultContainment->setLocation(edges.at(0));
     } else {
         defaultContainment->setLocation(Plasma::Types::BottomEdge);
     }
 
     if (m_layoutManager->memoryUsage() == Latte::Types::MultipleLayouts) {
         config.writeEntry("layoutId", m_layoutManager->currentLayoutName());
     }
 
     defaultContainment->updateConstraints(Plasma::Types::StartupCompletedConstraint);
 
     defaultContainment->save(config);
     requestConfigSync();
 
     defaultContainment->flushPendingConstraintsEvents();
     emit containmentAdded(defaultContainment);
     emit containmentCreated(defaultContainment);
 
     defaultContainment->createApplet(QStringLiteral("org.kde.latte.plasmoid"));
     defaultContainment->createApplet(QStringLiteral("org.kde.plasma.analogclock"));
 }
 
 QStringList Corona::containmentsIds()
 {
     QStringList ids;
 
     foreach (auto containment, containments()) {
         ids << QString::number(containment->id());
     }
 
     return ids;
 }
 
 QStringList Corona::appletsIds()
 {
     QStringList ids;
 
     foreach (auto containment, containments()) {
         auto applets = containment->config().group("Applets");
         ids << applets.groupList();
     }
 
     return ids;
 }
 
 //! Activate launcher menu through dbus interface
 void Corona::activateLauncherMenu()
 {
     m_globalShortcuts->activateLauncherMenu();
 }
 
 void Corona::windowColorScheme(QString windowIdAndScheme)
 {
     int firstSlash = windowIdAndScheme.indexOf("-");
     QString windowIdStr = windowIdAndScheme.mid(0, firstSlash);
     QString schemeStr = windowIdAndScheme.mid(firstSlash + 1);
 
     m_wm->setColorSchemeForWindow(windowIdStr, schemeStr);
 }
 
 //! update badge for specific view item
 void Corona::updateDockItemBadge(QString identifier, QString value)
 {
     m_globalShortcuts->updateViewItemBadge(identifier, value);
 }
 
 
 void Corona::switchToLayout(QString layout)
 {
     m_layoutManager->switchToLayout(layout);
 }
 
 void Corona::showSettingsWindow(int page)
 {
     Types::LatteConfigPage p = Types::LayoutPage;
 
     if (page >= Types::LayoutPage && page <= Types::PreferencesPage) {
         p = static_cast<Types::LatteConfigPage>(page);
     }
 
     m_layoutManager->showLatteSettingsDialog(p);
 }
 
 QStringList Corona::contextMenuData()
 {
     QStringList data;
 
     data << QString::number((int)m_layoutManager->memoryUsage());
     data << m_layoutManager->currentLayoutName();
 
     foreach (auto layoutName, m_layoutManager->menuLayouts()) {
         if (m_layoutManager->activeLayout(layoutName)) {
             data << QString("1," + layoutName);
         } else {
             data << QString("0," + layoutName);
         }
     }
 
     return data;
 }
 
 inline void Corona::qmlRegisterTypes() const
 {
     qmlRegisterType<QScreen>();
 }
 
 }
diff --git a/app/lattecorona.h b/app/lattecorona.h
index 2bc065ec..93d0e562 100644
--- a/app/lattecorona.h
+++ b/app/lattecorona.h
@@ -1,197 +1,197 @@
 /*
 *  Copyright 2016  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 LATTECORONA_H
 #define LATTECORONA_H
 
 // local
 #include "plasma/quick/configview.h"
 #include "../liblatte2/types.h"
 
 // Qt
 #include <QObject>
 #include <QTimer>
 
 // Plasma
 #include <Plasma/Corona>
 
 // KDE
 #include <KAboutApplicationDialog>
 
 namespace KDeclarative {
 class QmlObject;
 }
 
 namespace Plasma {
 class Corona;
 class Containment;
 class Types;
 }
 
 namespace PlasmaQuick {
 class ConfigView;
 }
 
 namespace KActivities {
 class Consumer;
 }
 
 namespace KWayland {
 namespace Client {
 class PlasmaShell;
 }
 }
 
 namespace Latte {
 class AbstractWindowInterface;
 class ScreenPool;
 class GlobalShortcuts;
 class UniversalSettings;
 class LayoutManager;
 class LaunchersSignals;
 namespace PlasmaExtended{
 class ScreenPool;
 class Theme;
 }
 }
 
 namespace Latte {
 
 class Corona : public Plasma::Corona
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.LatteDock")
 
 public:
     Corona(bool defaultLayoutOnStartup = false,
                QString layoutNameOnStartUp = QString(),
                int userSetMemoryUsage = -1,
                QObject *parent = nullptr);
     virtual ~Corona();
 
     int numScreens() const override;
     QRect screenGeometry(int id) const override;
     QRegion availableScreenRegion(int id) const override;
     QRect availableScreenRect(int id) const override;
 
     //! This is a very generic function in order to return the availableScreenRect of specific screen
     //! by calculating only the user specified visibility modes and edges. Empty QLists for both
     //! arguments mean that all choices are accepted in calculations
     QRect availableScreenRectWithCriteria(int id,
                                           QList<Types::Visibility> modes = QList<Types::Visibility>(),
                                           QList<Plasma::Types::Location> edges = QList<Plasma::Types::Location>()) const;
 
     QRegion availableScreenRegionWithCriteria(int id, QString forLayout = QString()) const;
 
     int screenForContainment(const Plasma::Containment *containment) const override;
 
     void closeApplication();
 
     AbstractWindowInterface *wm() const;
     KActivities::Consumer *activitiesConsumer() const;
     GlobalShortcuts *globalShortcuts() const;
     ScreenPool *screenPool() const;
     UniversalSettings *universalSettings() const;
     LayoutManager *layoutManager() const;
 
     PlasmaExtended::ScreenPool *plasmaScreenPool() const;
     PlasmaExtended::Theme *themeExtended() const;
 
     KWayland::Client::PlasmaShell *waylandCoronaInterface() const;
 
     //! these functions are used from context menu through containmentactions
     void switchToLayout(QString layout);
     void showSettingsWindow(int page);
     QStringList contextMenuData();
 
 public slots:
     void aboutApplication();
     void activateLauncherMenu();
     //! they are separated with a "-" character
     void windowColorScheme(QString windowIdAndScheme);
     void loadDefaultLayout() override;
     void updateDockItemBadge(QString identifier, QString value);
     void unload();
 
 signals:
     void configurationShown(PlasmaQuick::ConfigView *configView);
     void viewLocationChanged();
     void raiseViewsTemporaryChanged();
 
 private slots:
     void alternativesVisibilityChanged(bool visible);
     void showAlternativesForApplet(Plasma::Applet *applet);
     void load();
 
     void addOutput(QScreen *screen);
     void primaryOutputChanged();
     void screenRemoved(QScreen *screen);
     void screenCountChanged();
     void syncLatteViewsToScreens();
 
 private:
     void cleanConfig();
     void qmlRegisterTypes() const;
     void setupWaylandIntegration();
 
     bool appletExists(uint containmentId, uint appletId) const;
     bool containmentExists(uint id) const;
 
     int primaryScreenId() const;
 
     QStringList containmentsIds();
     QStringList appletsIds();
 
     bool m_activitiesStarting{true};
     bool m_defaultLayoutOnStartup{false}; //! this is used to enforce loading the default layout on startup
     bool m_quitTimedEnded{false}; //! this is used on destructor in order to delay it and slide-out the views
 
     //!it can be used on startup to change memory usage from command line
     int m_userSetMemoryUsage{ -1};
 
     QString m_layoutNameOnStartUp;
 
     QList<KDeclarative::QmlObject *> m_alternativesObjects;
 
     QTimer m_viewsScreenSyncTimer;
 
     KActivities::Consumer *m_activityConsumer;
     QPointer<KAboutApplicationDialog> aboutDialog;
 
     AbstractWindowInterface *m_wm{nullptr};
     ScreenPool *m_screenPool{nullptr};
-    GlobalShortcuts *m_globalShortcuts{nullptr};
     UniversalSettings *m_universalSettings{nullptr};
+    GlobalShortcuts *m_globalShortcuts{nullptr};
     LayoutManager *m_layoutManager{nullptr};
 
     PlasmaExtended::ScreenPool *m_plasmaScreenPool{nullptr};
     PlasmaExtended::Theme *m_themeExtended{nullptr};
 
     KWayland::Client::PlasmaShell *m_waylandCorona{nullptr};
 
     friend class GlobalShortcuts;
     friend class Layout;
     friend class LayoutManager;
     friend class LaunchersSignals;
 };
 
 }
 
 #endif // LATTECORONA_H
diff --git a/app/settings/settingsdialog.cpp b/app/settings/settingsdialog.cpp
index c7ef2249..68f4f012 100644
--- a/app/settings/settingsdialog.cpp
+++ b/app/settings/settingsdialog.cpp
@@ -1,1606 +1,1613 @@
 /*
  * 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 "settingsdialog.h"
 
 // local
 #include "layoutmanager.h"
 #include "importer.h"
 #include "universalsettings.h"
 #include "ui_settingsdialog.h"
 #include "../lattecorona.h"
 #include "../layout/layout.h"
 #include "../liblatte2/types.h"
 #include "../plasma/extended/theme.h"
 #include "delegates/checkboxdelegate.h"
 #include "delegates/colorcmbboxdelegate.h"
 #include "delegates/activitycmbboxdelegate.h"
 #include "delegates/layoutnamedelegate.h"
 
 // Qt
 #include <QButtonGroup>
 #include <QColorDialog>
 #include <QDesktopServices>
 #include <QDir>
 #include <QFileDialog>
 #include <QHeaderView>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QProcess>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QTemporaryDir>
 
 // KDE
 #include <KActivities/Controller>
 #include <KArchive/KTar>
 #include <KArchive/KArchiveEntry>
 #include <KArchive/KArchiveDirectory>
 #include <KLocalizedString>
 #include <KNotification>
 #include <KWindowSystem>
 #include <KNewStuff3/KNS3/DownloadDialog>
 
 namespace Latte {
 
 const int IDCOLUMN = 0;
 const int HIDDENTEXTCOLUMN = 1;
 const int COLORCOLUMN = 2;
 const int NAMECOLUMN = 3;
 const int MENUCOLUMN = 4;
 const int BORDERSCOLUMN = 5;
 const int ACTIVITYCOLUMN = 6;
 
 const int SCREENTRACKERDEFAULTVALUE = 2500;
 const int THEMEDEFAULTROUNDNESS = 0; //Breeze default value is used 0px.
 
 const QChar CheckMark{0x2714};
 
 SettingsDialog::SettingsDialog(QWidget *parent, Latte::Corona *corona)
     : QDialog(parent),
       ui(new Ui::SettingsDialog),
       m_corona(corona)
 {
     ui->setupUi(this);
 
     setAttribute(Qt::WA_DeleteOnClose, true);
     setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
     resize(m_corona->universalSettings()->layoutsWindowSize());
 
     connect(ui->buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked
             , this, &SettingsDialog::apply);
     connect(ui->buttonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked
             , this, &SettingsDialog::restoreDefaults);
 
     m_model = new QStandardItemModel(m_corona->layoutManager()->layouts().count(), 6, this);
 
     ui->layoutsView->setModel(m_model);
     ui->layoutsView->horizontalHeader()->setStretchLastSection(true);
     ui->layoutsView->verticalHeader()->setVisible(false);
 
     connect(m_corona->layoutManager(), &LayoutManager::currentLayoutNameChanged, this, &SettingsDialog::layoutsChanged);
     connect(m_corona->layoutManager(), &LayoutManager::activeLayoutsChanged, this, &SettingsDialog::layoutsChanged);
 
     QString iconsPath(m_corona->kPackage().path() + "../../plasmoids/org.kde.latte.containment/contents/icons/");
 
     //!find the available colors
     QDir layoutDir(iconsPath);
     QStringList filter;
     filter.append(QString("*print.jpg"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
     QStringList colors;
 
     foreach (auto file, files) {
         int colorEnd = file.lastIndexOf("print.jpg");
         QString color = file.remove(colorEnd, 9);
         colors.append(color);
     }
 
     ui->layoutsView->setItemDelegateForColumn(NAMECOLUMN, new LayoutNameDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(COLORCOLUMN, new ColorCmbBoxDelegate(this, iconsPath, colors));
     ui->layoutsView->setItemDelegateForColumn(MENUCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(BORDERSCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(ACTIVITYCOLUMN, new ActivityCmbBoxDelegate(this));
 
     m_inMemoryButtons = new QButtonGroup(this);
     m_inMemoryButtons->addButton(ui->singleToolBtn, Latte::Types::SingleLayout);
     m_inMemoryButtons->addButton(ui->multipleToolBtn, Latte::Types::MultipleLayouts);
     m_inMemoryButtons->setExclusive(true);
 
     if (KWindowSystem::isPlatformWayland()) {
         m_inMemoryButtons->button(Latte::Types::MultipleLayouts)->setEnabled(false);
     }
 
     m_mouseSensitivityButtons = new QButtonGroup(this);
     m_mouseSensitivityButtons->addButton(ui->lowSensitivityBtn, Latte::Types::LowSensitivity);
     m_mouseSensitivityButtons->addButton(ui->mediumSensitivityBtn, Latte::Types::MediumSensitivity);
     m_mouseSensitivityButtons->addButton(ui->highSensitivityBtn, Latte::Types::HighSensitivity);
     m_mouseSensitivityButtons->setExclusive(true);
 
     ui->screenTrackerSpinBox->setValue(m_corona->universalSettings()->screenTrackerInterval());
     ui->themeRoundnessSpinBox->setSpecialValueText(i18nc("automatic background roundness","Automatic"));
     ui->themeRoundnessSpinBox->setValue(m_corona->themeExtended()->userThemeRoundness());
 
     //! About Menu
     QMenuBar *menuBar = new QMenuBar(this);
     // QMenuBar *rightAlignedMenuBar = new QMenuBar(menuBar);
 
     layout()->setMenuBar(menuBar);
     //menuBar->setCornerWidget(rightAlignedMenuBar);
 
     QMenu *fileMenu = new QMenu(i18n("File"), menuBar);
     menuBar->addMenu(fileMenu);
 
     QMenu *helpMenu = new QMenu(i18n("Help"), menuBar);
     //rightAlignedMenuBar->addMenu(helpMenu);
     menuBar->addMenu(helpMenu);
 
     QAction *quitAction = fileMenu->addAction(i18n("Quit Latte"));
     quitAction->setIcon(QIcon::fromTheme("application-exit"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
 
     QAction *aboutAction = helpMenu->addAction(i18n("About Latte"));
     aboutAction->setIcon(QIcon::fromTheme("latte-dock"));
 
     //! RTL support for labels in preferences
     if (qApp->layoutDirection() == Qt::RightToLeft) {
         ui->behaviorLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
         ui->mouseSensetivityLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
         ui->delayLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
     }
 
     loadSettings();
 
     //! SIGNALS
 
     connect(m_model, &QStandardItemModel::itemChanged, this, &SettingsDialog::itemChanged);
     connect(ui->layoutsView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, [&]() {
         updatePerLayoutButtonsState();
         updateApplyButtonsState();
     });
 
     connect(m_inMemoryButtons, static_cast<void(QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled),
     [ = ](int id, bool checked) {
         updateApplyButtonsState();
     });
 
     connect(m_mouseSensitivityButtons, static_cast<void(QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled),
     [ = ](int id, bool checked) {
         updateApplyButtonsState();
     });
 
     connect(ui->screenTrackerSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [ = ](int i) {
         updateApplyButtonsState();
     });
 
     connect(ui->themeRoundnessSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [ = ](int i) {
         updateApplyButtonsState();
     });
 
     connect(ui->autostartChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->metaPressChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
+    connect(ui->metaPressHoldChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->infoWindowChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->tabWidget, &QTabWidget::currentChanged, this, &SettingsDialog::updateApplyButtonsState);
 
     connect(ui->noBordersForMaximizedChkBox, &QCheckBox::stateChanged, this, [&]() {
         bool noBordersForMaximized = ui->noBordersForMaximizedChkBox->isChecked();
 
         if (noBordersForMaximized) {
             ui->layoutsView->setColumnHidden(BORDERSCOLUMN, false);
         } else {
             ui->layoutsView->setColumnHidden(BORDERSCOLUMN, true);
         }
 
         updateApplyButtonsState();
     });
 
     connect(aboutAction, &QAction::triggered, m_corona, &Latte::Corona::aboutApplication);
     connect(quitAction, &QAction::triggered, m_corona, &Latte::Corona::closeApplication);
 
     //! update all layouts view when runningActivities changed. This way we update immediately
     //! the running Activities in Activities checkboxes which are shown as bold
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged,
     this, [&]() {
         ui->layoutsView->update();
     });
 
     blockDeleteOnActivityStopped();
 }
 
 SettingsDialog::~SettingsDialog()
 {
     qDebug() << Q_FUNC_INFO;
 
     qDeleteAll(m_layouts);
 
     if (m_model) {
         delete m_model;
     }
 
     if (m_corona && m_corona->universalSettings()) {
         m_corona->universalSettings()->setLayoutsWindowSize(size());
 
         QStringList columnWidths;
         columnWidths << QString::number(ui->layoutsView->columnWidth(COLORCOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(NAMECOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(MENUCOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(BORDERSCOLUMN));
         m_corona->universalSettings()->setLayoutsColumnWidths(columnWidths);
     }
 
     m_inMemoryButtons->deleteLater();
     m_mouseSensitivityButtons->deleteLater();
 
     foreach (auto tempDir, m_tempDirectories) {
         QDir tDir(tempDir);
 
         if (tDir.exists() && tempDir.startsWith("/tmp/")) {
             tDir.removeRecursively();
         }
     }
 }
 
 void SettingsDialog::blockDeleteOnActivityStopped()
 {
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged,
     this, [&]() {
         m_blockDeleteOnReject = true;
         m_activityClosedTimer.start();
     });
 
     m_activityClosedTimer.setSingleShot(true);
     m_activityClosedTimer.setInterval(500);
     connect(&m_activityClosedTimer, &QTimer::timeout, this, [&]() {
         m_blockDeleteOnReject = false;
     });
 }
 
 QStringList SettingsDialog::activities()
 {
     return m_corona->layoutManager()->activities();
 }
 
 QStringList SettingsDialog::availableActivities()
 {
     return m_availableActivities;
 }
 
 void SettingsDialog::setCurrentPage(Types::LatteConfigPage page)
 {
     if (page == Types::LayoutPage) {
         ui->tabWidget->setCurrentIndex(0);
     } else if (page == Types::PreferencesPage) {
         ui->tabWidget->setCurrentIndex(1);
     }
 }
 
 void SettingsDialog::on_newButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     //! find Default preset path
     foreach (auto preset, m_corona->layoutManager()->presetsPaths()) {
         QString presetName = Layout::layoutName(preset);
 
         if (presetName == "Default") {
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = uniqueLayoutName(i18n(prset_str));
 
             addLayoutForFile(preset, presetName, true, false);
             break;
         }
     }
 }
 
 void SettingsDialog::on_copyButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     //! Update original layout before copying if this layout is active
     if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         QString lName = (m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole)).toString();
 
         if (Importer::layoutExists(lName)) {
             Layout *layout = m_corona->layoutManager()->activeLayout(lName);
 
             if (layout && layout->isOriginalLayout()) {
                 layout->syncToLayoutFile();
             }
         }
     }
 
     QString tempDir = uniqueTempDirectory();
 
     QString id = m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
     QString color = m_model->data(m_model->index(row, COLORCOLUMN), Qt::BackgroundRole).toString();
     QString textColor = m_model->data(m_model->index(row, COLORCOLUMN), Qt::UserRole).toString();
     QString layoutName = uniqueLayoutName(m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString());
     bool menu = m_model->data(m_model->index(row, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
     bool disabledBorders = m_model->data(m_model->index(row, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
 
     QString copiedId = tempDir + "/" + layoutName + ".layout.latte";
     QFile(id).copy(copiedId);
 
     QFileInfo newFileInfo(copiedId);
 
     if (newFileInfo.exists() && !newFileInfo.isWritable()) {
         QFile(copiedId).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 
     Layout *settings = new Layout(this, copiedId);
     m_layouts[copiedId] = settings;
 
     insertLayoutInfoAtRow(row + 1, copiedId, color, textColor, layoutName, menu, disabledBorders, QStringList(), false);
 
     ui->layoutsView->selectRow(row + 1);
 }
 
 void SettingsDialog::on_downloadButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     KNS3::DownloadDialog dialog(QStringLiteral("latte-layouts.knsrc"), this);
     dialog.resize(m_corona->universalSettings()->downloadWindowSize());
     dialog.exec();
 
     bool layoutAdded{false};
 
     if (!dialog.changedEntries().isEmpty() || !dialog.installedEntries().isEmpty()) {
         foreach (auto entry, dialog.installedEntries()) {
             foreach (auto entryFile, entry.installedFiles()) {
                 Importer::LatteFileVersion version = Importer::fileVersion(entryFile);
 
                 if (version == Importer::LayoutVersion2) {
                     layoutAdded = true;
                     addLayoutForFile(entryFile);
                     break;
                 }
             }
         }
     }
 
     m_corona->universalSettings()->setDownloadWindowSize(dialog.size());
 
     if (layoutAdded) {
         apply();
     }
 }
 
 void SettingsDialog::on_removeButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     QString layoutName = m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString();
 
     if (m_corona->layoutManager()->activeLayout(layoutName)) {
         return;
     }
 
     m_model->removeRow(row);
 
     updateApplyButtonsState();
 
     row = qMax(row - 1, 0);
 
     ui->layoutsView->selectRow(row);
 }
 
 void SettingsDialog::on_lockedButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     bool lockedModel = m_model->data(m_model->index(row, NAMECOLUMN), Qt::UserRole).toBool();
 
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(!lockedModel), Qt::UserRole);
 
     updatePerLayoutButtonsState();
     updateApplyButtonsState();
 }
 
 void SettingsDialog::on_importButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
 
     QFileDialog *fileDialog = new QFileDialog(this, i18nc("import layout/configuration", "Import Layout/Configuration")
             , QDir::homePath()
             , QStringLiteral("layout.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog->setDefaultSuffix("layout.latte");
 
     QStringList filters;
     filters << QString(i18nc("import latte layout", "Latte Dock Layout file v0.2") + "(*.layout.latte)")
             << QString(i18nc("import latte layouts/configuration", "Latte Dock Full Configuration file (v0.1, v0.2)") + "(*.latterc)");
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished
             , fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected
     , this, [&](const QString & file) {
         Importer::LatteFileVersion version = Importer::fileVersion(file);
         qDebug() << "VERSION :::: " << version;
 
         if (version == Importer::LayoutVersion2) {
             addLayoutForFile(file);
         } else if (version == Importer::ConfigVersion1) {
             auto msg = new QMessageBox(this);
             msg->setIcon(QMessageBox::Warning);
             msg->setWindowTitle(i18n("Import: Configuration file version v0.1"));
             msg->setText(
                 i18n("You are going to import an old version <b>v0.1</b> configuration file.<br><b>Be careful</b>, importing the entire configuration <b>will erase all</b> your current configuration!!!<br><br> <i>Alternative, you can <b>import safely</b> from this file<br><b>only the contained layouts...</b></i>"));
             msg->setStandardButtons(QMessageBox::Cancel);
 
             QPushButton *fullBtn = new QPushButton(msg);
             QPushButton *layoutsBtn = new QPushButton(msg);
             fullBtn->setText(i18nc("import full configuration", "Full Configuration"));
             fullBtn->setIcon(QIcon::fromTheme("settings"));
             layoutsBtn->setText(i18nc("import only the layouts", "Only Layouts"));
             layoutsBtn->setIcon(QIcon::fromTheme("user-identity"));
 
             msg->addButton(fullBtn, QMessageBox::AcceptRole);
             msg->addButton(layoutsBtn, QMessageBox::AcceptRole);
 
             msg->setDefaultButton(layoutsBtn);
 
             connect(msg, &QMessageBox::finished, msg, &QMessageBox::deleteLater);
 
             msg->open();
 
             connect(layoutsBtn, &QPushButton::clicked
             , this, [ &, file](bool check) {
                 importLayoutsFromV1ConfigFile(file);
             });
 
             connect(fullBtn, &QPushButton::clicked
             , this, [ &, file](bool check) {
                 //!NOTE: Restart latte for import the new configuration
                 QProcess::startDetached(qGuiApp->applicationFilePath() + " --import-full \"" + file + "\"");
                 qGuiApp->exit();
             });
         } else if (version == Importer::ConfigVersion2) {
             auto msg = new QMessageBox(this);
             msg->setIcon(QMessageBox::Warning);
             msg->setWindowTitle(i18n("Import: Configuration file version v0.2"));
             msg->setText(
                 i18n("You are going to import a <b>v0.2</b> configuration file.<br><b>Be careful</b>, importing <b>will erase all</b> your current configuration!!!<br><br><i>Would you like to proceed?</i>"));
             msg->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
             msg->setDefaultButton(QMessageBox::No);
 
             connect(msg, &QMessageBox::finished, this, [ &, msg, file](int result) {
                 if (result == QMessageBox::Yes) {
                     //!NOTE: Restart latte for import the new configuration
                     msg->deleteLater();
                     QProcess::startDetached(qGuiApp->applicationFilePath() + " --import-full \"" + file + "\"");
                     qGuiApp->exit();
                 }
             });
 
             msg->open();
         }
     });
 
     fileDialog->open();
 }
 
 bool SettingsDialog::importLayoutsFromV1ConfigFile(QString file)
 {
     KTar archive(file, QStringLiteral("application/x-tar"));
     archive.open(QIODevice::ReadOnly);
 
     //! if the file isnt a tar archive
     if (archive.isOpen()) {
         QDir tempDir{uniqueTempDirectory()};
 
         const auto archiveRootDir = archive.directory();
 
         foreach (auto &name, archiveRootDir->entries()) {
             auto fileEntry = archiveRootDir->file(name);
             fileEntry->copyTo(tempDir.absolutePath());
         }
 
         QString name = Importer::nameOfConfigFile(file);
 
         QString applets(tempDir.absolutePath() + "/" + "lattedock-appletsrc");
 
         if (QFile(applets).exists()) {
             if (m_corona->layoutManager()->importer()->importOldLayout(applets, name, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + name + ".layout.latte", name, false);
             }
 
             QString alternativeName = name + "-" + i18nc("layout", "Alternative");
 
             if (m_corona->layoutManager()->importer()->importOldLayout(applets, alternativeName, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + alternativeName + ".layout.latte", alternativeName, false);
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 void SettingsDialog::on_exportButton_clicked()
 {
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     QString layoutExported = m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
 
     //! Update ALL active original layouts before exporting,
     //! this is needed because the export method can export also the full configuration
     qDebug() << Q_FUNC_INFO;
 
     m_corona->layoutManager()->syncActiveLayoutsToOriginalFiles();
 
     QFileDialog *fileDialog = new QFileDialog(this, i18nc("export layout/configuration", "Export Layout/Configuration")
             , QDir::homePath(), QStringLiteral("layout.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptSave);
     fileDialog->setDefaultSuffix("layout.latte");
 
     QStringList filters;
     QString filter1(i18nc("export layout", "Latte Dock Layout file v0.2") + "(*.layout.latte)");
     QString filter2(i18nc("export full configuration", "Latte Dock Full Configuration file v0.2") + "(*.latterc)");
 
     filters << filter1
             << filter2;
 
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished
             , fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected
     , this, [ &, layoutExported](const QString & file) {
         auto showNotificationError = []() {
             auto notification = new KNotification("export-fail", KNotification::CloseOnTimeout);
             notification->setText(i18nc("export layout", "Failed to export layout"));
             notification->sendEvent();
         };
 
         if (QFile::exists(file) && !QFile::remove(file)) {
             showNotificationError();
             return;
         }
 
         if (file.endsWith(".layout.latte")) {
             if (!QFile(layoutExported).copy(file)) {
                 showNotificationError();
                 return;
             }
 
             QFileInfo newFileInfo(file);
 
             if (newFileInfo.exists() && !newFileInfo.isWritable()) {
                 QFile(file).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
             }
 
             Layout layoutS(this, file);
             layoutS.setActivities(QStringList());
             layoutS.clearLastUsedActivity();
 
             //NOTE: The pointer is automatically deleted when the event is closed
             auto notification = new KNotification("export-done", KNotification::CloseOnTimeout);
             notification->setActions({i18nc("export layout", "Open location")});
             notification->setText(i18nc("export layout", "Layout exported successfully"));
 
             connect(notification, &KNotification::action1Activated
             , this, [file]() {
                 QDesktopServices::openUrl({QFileInfo(file).canonicalPath()});
             });
 
             notification->sendEvent();
         } else if (file.endsWith(".latterc")) {
             auto showNotificationError = []() {
                 auto notification = new KNotification("export-fail", KNotification::CloseOnTimeout);
                 notification->setText(i18nc("import/export config", "Failed to export configuration"));
                 notification->sendEvent();
             };
 
             if (m_corona->layoutManager()->importer()->exportFullConfiguration(file)) {
 
                 auto notification = new KNotification("export-done", KNotification::CloseOnTimeout);
                 notification->setActions({i18nc("import/export config", "Open location")});
                 notification->setText(i18nc("import/export config", "Full Configuration exported successfully"));
 
                 connect(notification, &KNotification::action1Activated
                 , this, [file]() {
                     QDesktopServices::openUrl({QFileInfo(file).canonicalPath()});
                 });
 
                 notification->sendEvent();
             } else {
                 showNotificationError();
             }
         }
     });
 
 
     fileDialog->open();
 }
 
 void SettingsDialog::requestImagesDialog(int row)
 {
     QStringList mimeTypeFilters;
     mimeTypeFilters << "image/jpeg" // will show "JPEG image (*.jpeg *.jpg)
                     << "image/png";  // will show "PNG image (*.png)"
 
     QFileDialog dialog(this);
     dialog.setMimeTypeFilters(mimeTypeFilters);
 
     QString background = m_model->data(m_model->index(row, COLORCOLUMN), Qt::BackgroundRole).toString();
 
     if (background.startsWith("/") && QFileInfo(background).exists()) {
         dialog.setDirectory(QFileInfo(background).absolutePath());
         dialog.selectFile(background);
     }
 
     if (dialog.exec()) {
         QStringList files = dialog.selectedFiles();
 
         if (files.count() > 0) {
             m_model->setData(m_model->index(row, COLORCOLUMN), files[0], Qt::BackgroundRole);
         }
     }
 }
 
 void SettingsDialog::requestColorsDialog(int row)
 {
     QColorDialog dialog(this);
     QString textColor = m_model->data(m_model->index(row, COLORCOLUMN), Qt::UserRole).toString();
     dialog.setCurrentColor(QColor(textColor));
 
     if (dialog.exec()) {
         qDebug() << dialog.selectedColor().name();
         m_model->setData(m_model->index(row, COLORCOLUMN), dialog.selectedColor().name(), Qt::UserRole);
     }
 }
 
 
 void SettingsDialog::accept()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (saveAllChanges()) {
         deleteLater();
     }
 }
 
 void SettingsDialog::reject()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (!m_blockDeleteOnReject) {
         deleteLater();
     }
 }
 
 void SettingsDialog::apply()
 {
     qDebug() << Q_FUNC_INFO;
     saveAllChanges();
 
     o_settings = currentSettings();
     o_settingsLayouts = currentLayoutsSettings();
 
     updateApplyButtonsState();
     updatePerLayoutButtonsState();
 }
 
 void SettingsDialog::restoreDefaults()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (ui->tabWidget->currentIndex() == 0) {
         //! Default layouts missing from layouts list
         foreach (auto preset, m_corona->layoutManager()->presetsPaths()) {
             QString presetName = Layout::layoutName(preset);
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = i18n(prset_str);
 
             if (!nameExistsInModel(presetName)) {
                 addLayoutForFile(preset, presetName);
             }
         }
     } else if (ui->tabWidget->currentIndex() == 1) {
         //! Defaults for general Latte settings
         ui->autostartChkBox->setChecked(true);
         ui->infoWindowChkBox->setChecked(true);
         ui->metaPressChkBox->setChecked(false);
+        ui->metaPressHoldChkBox->setChecked(true);
         ui->noBordersForMaximizedChkBox->setChecked(false);
         ui->highSensitivityBtn->setChecked(true);
         ui->screenTrackerSpinBox->setValue(SCREENTRACKERDEFAULTVALUE);
         ui->themeRoundnessSpinBox->setValue(THEMEDEFAULTROUNDNESS);
     }
 }
 
 void SettingsDialog::addLayoutForFile(QString file, QString layoutName, bool newTempDirectory, bool showNotification)
 {
     if (layoutName.isEmpty()) {
         layoutName = Layout::layoutName(file);
     }
 
     QString copiedId;
 
     if (newTempDirectory) {
         QString tempDir = uniqueTempDirectory();
         copiedId = tempDir + "/" + layoutName + ".layout.latte";
         QFile(file).copy(copiedId);
     } else {
         copiedId = file;
     }
 
     QFileInfo newFileInfo(copiedId);
 
     if (newFileInfo.exists() && !newFileInfo.isWritable()) {
         QFile(copiedId).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 
     if (m_layouts.contains(copiedId)) {
         Layout *oldSettings = m_layouts.take(copiedId);
         delete oldSettings;
     }
 
     Layout *settings = new Layout(this, copiedId);
     m_layouts[copiedId] = settings;
 
     QString id = copiedId;
     QString color = settings->color();
     QString textColor = settings->textColor();
     QString background = settings->background();
     bool menu = settings->showInMenu();
     bool disabledBorders = settings->disableBordersForMaximizedWindows();
     bool locked = !settings->isWritable();
 
     layoutName = uniqueLayoutName(layoutName);
 
     int row = ascendingRowFor(layoutName);
 
     if (background.isEmpty()) {
         insertLayoutInfoAtRow(row, copiedId, color, QString(), layoutName, menu, disabledBorders, QStringList(), locked);
     } else {
         insertLayoutInfoAtRow(row, copiedId, background, textColor, layoutName, menu, disabledBorders, QStringList(), locked);
     }
 
     ui->layoutsView->selectRow(row);
 
     if (showNotification) {
         //NOTE: The pointer is automatically deleted when the event is closed
         auto notification = new KNotification("import-done", KNotification::CloseOnTimeout);
         notification->setText(i18nc("import-done", "Layout: <b>%0</b> imported successfully<br>").arg(layoutName));
         notification->sendEvent();
     }
 }
 
 void SettingsDialog::loadSettings()
 {
     m_initLayoutPaths.clear();
     m_model->clear();
 
     int i = 0;
     QStringList brokenLayouts;
 
     if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         m_corona->layoutManager()->syncActiveLayoutsToOriginalFiles();
     }
 
     foreach (auto layout, m_corona->layoutManager()->layouts()) {
         QString layoutPath = QDir::homePath() + "/.config/latte/" + layout + ".layout.latte";
         m_initLayoutPaths.append(layoutPath);
 
         Layout *layoutSets = new Layout(this, layoutPath);
         m_layouts[layoutPath] = layoutSets;
 
         QString background = layoutSets->background();
 
         if (background.isEmpty()) {
             insertLayoutInfoAtRow(i, layoutPath, layoutSets->color(), QString(), layoutSets->name(),
                                   layoutSets->showInMenu(), layoutSets->disableBordersForMaximizedWindows(),
                                   layoutSets->activities(), !layoutSets->isWritable());
         } else {
             insertLayoutInfoAtRow(i, layoutPath, background, layoutSets->textColor(), layoutSets->name(),
                                   layoutSets->showInMenu(), layoutSets->disableBordersForMaximizedWindows(),
                                   layoutSets->activities(), !layoutSets->isWritable());
         }
 
         qDebug() << "counter:" << i << " total:" << m_model->rowCount();
 
         i++;
 
         if (layoutSets->name() == m_corona->layoutManager()->currentLayoutName()) {
             ui->layoutsView->selectRow(i - 1);
         }
 
         Layout *activeLayout = m_corona->layoutManager()->activeLayout(layoutSets->name());
 
         if ((activeLayout && activeLayout->layoutIsBroken()) || (!activeLayout && layoutSets->layoutIsBroken())) {
             brokenLayouts.append(layoutSets->name());
         }
     }
 
 
     //! Check Multiple Layouts Integrity
     /*if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         m_corona->layoutManager()->syncActiveLayoutsToOriginalFiles();
 
         QString multipleLayoutPath = QDir::homePath() + "/.config/latte/" + Layout::MultipleLayoutsName + ".layout.latte";
         Layout multipleHiddenLayouts(this, multipleLayoutPath, "Multiple Layouts File");
 
         if (multipleHiddenLayouts.layoutIsBroken()) {
             qDebug() << "Integrity Error ::: Multiple Layouts Hidden file is broken!!!!";
             brokenLayouts.append(multipleHiddenLayouts.name());
         }
     }*/
 
 
     recalculateAvailableActivities();
 
     m_model->setHorizontalHeaderItem(IDCOLUMN, new QStandardItem(QString("#path")));
     m_model->setHorizontalHeaderItem(COLORCOLUMN, new QStandardItem(QString(i18nc("column for layout background", "Background"))));
     m_model->setHorizontalHeaderItem(NAMECOLUMN, new QStandardItem(QString(i18nc("column for layout name", "Name"))));
     m_model->setHorizontalHeaderItem(MENUCOLUMN, new QStandardItem(QString(i18nc("column for layout to show in menu", "In Menu"))));
     m_model->setHorizontalHeaderItem(BORDERSCOLUMN, new QStandardItem(QString(i18nc("column for layout to hide borders for maximized windows", "Borderless"))));
     m_model->setHorizontalHeaderItem(ACTIVITYCOLUMN, new QStandardItem(QString(i18nc("column for layout to show which activities is assigned to", "Activities"))));
 
     //! this line should be commented for debugging layouts window functionality
     ui->layoutsView->setColumnHidden(IDCOLUMN, true);
     ui->layoutsView->setColumnHidden(HIDDENTEXTCOLUMN, true);
 
     if (m_corona->universalSettings()->canDisableBorders()) {
         ui->layoutsView->setColumnHidden(BORDERSCOLUMN, false);
     } else {
         ui->layoutsView->setColumnHidden(BORDERSCOLUMN, true);
     }
 
     ui->layoutsView->resizeColumnsToContents();
 
     QStringList columnWidths = m_corona->universalSettings()->layoutsColumnWidths();
 
     if (!columnWidths.isEmpty() && columnWidths.count() == 4) {
         ui->layoutsView->setColumnWidth(COLORCOLUMN, columnWidths[0].toInt());
         ui->layoutsView->setColumnWidth(NAMECOLUMN, columnWidths[1].toInt());
         ui->layoutsView->setColumnWidth(MENUCOLUMN, columnWidths[2].toInt());
         ui->layoutsView->setColumnWidth(BORDERSCOLUMN, columnWidths[3].toInt());
     }
 
     if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout) {
         ui->singleToolBtn->setChecked(true);
     } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         ui->multipleToolBtn->setChecked(true);
     }
 
     updatePerLayoutButtonsState();
 
     ui->autostartChkBox->setChecked(m_corona->universalSettings()->autostart());
     ui->infoWindowChkBox->setChecked(m_corona->universalSettings()->showInfoWindow());
     ui->metaPressChkBox->setChecked(m_corona->universalSettings()->metaForwardedToLatte());
+    ui->metaPressHoldChkBox->setChecked(m_corona->universalSettings()->metaPressAndHoldEnabled());
     ui->noBordersForMaximizedChkBox->setChecked(m_corona->universalSettings()->canDisableBorders());
 
     if (m_corona->universalSettings()->mouseSensitivity() == Types::LowSensitivity) {
         ui->lowSensitivityBtn->setChecked(true);
     } else if (m_corona->universalSettings()->mouseSensitivity() == Types::MediumSensitivity) {
         ui->mediumSensitivityBtn->setChecked(true);
     } else if (m_corona->universalSettings()->mouseSensitivity() == Types::HighSensitivity) {
         ui->highSensitivityBtn->setChecked(true);
     }
 
     o_settings = currentSettings();
     o_settingsLayouts = currentLayoutsSettings();
     updateApplyButtonsState();
 
     //! there are broken layouts and the user must be informed!
     if (brokenLayouts.count() > 0) {
         auto msg = new QMessageBox(this);
         msg->setIcon(QMessageBox::Warning);
         msg->setWindowTitle(i18n("Layout Warning"));
         msg->setText(i18n("The layout(s) <b>%0</b> have <i>broken configuration</i>!!! Please <b>remove them</b> to improve the system stability...").arg(brokenLayouts.join(",")));
         msg->setStandardButtons(QMessageBox::Ok);
 
         msg->open();
     }
 }
 
 QList<int> SettingsDialog::currentSettings()
 {
     QList<int> settings;
     settings << m_inMemoryButtons->checkedId();
     settings << (int)ui->autostartChkBox->isChecked();
     settings << (int)ui->infoWindowChkBox->isChecked();
     settings << (int)ui->metaPressChkBox->isChecked();
+    settings << (int)ui->metaPressHoldChkBox->isChecked();
     settings << (int)ui->noBordersForMaximizedChkBox->isChecked();
     settings << m_mouseSensitivityButtons->checkedId();
     settings << ui->screenTrackerSpinBox->value();
     settings << ui->themeRoundnessSpinBox->value();
     settings << m_model->rowCount();
 
     return settings;
 }
 
 QStringList SettingsDialog::currentLayoutsSettings()
 {
     QStringList layoutSettings;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString color = m_model->data(m_model->index(i, COLORCOLUMN), Qt::BackgroundRole).toString();
         QString textColor = m_model->data(m_model->index(i, COLORCOLUMN), Qt::UserRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         bool borders = m_model->data(m_model->index(i, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         QStringList lActivities = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         layoutSettings << id;
         layoutSettings << color;
         layoutSettings << textColor;
         layoutSettings << name;
         layoutSettings << QString::number((int)locked);
         layoutSettings << QString::number((int)menu);
         layoutSettings << QString::number((int)borders);
         layoutSettings << lActivities;
     }
 
     return layoutSettings;
 }
 
 
 void SettingsDialog::insertLayoutInfoAtRow(int row, QString path, QString color, QString textColor, QString name, bool menu,
         bool disabledBorders, QStringList activities, bool locked)
 {
     QStandardItem *pathItem = new QStandardItem(path);
 
     QStandardItem *hiddenTextItem = new QStandardItem();
 
     QStandardItem *colorItem = new QStandardItem();
     colorItem->setSelectable(false);
 
     QStandardItem *nameItem = new QStandardItem(name);
     nameItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *menuItem = new QStandardItem();
     menuItem->setEditable(false);
     menuItem->setSelectable(true);
     menuItem->setText(menu ? CheckMark : QString());
     menuItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *bordersItem = new QStandardItem();
     bordersItem->setEditable(false);
     bordersItem->setSelectable(true);
     bordersItem->setText(disabledBorders ? CheckMark : QString());
     bordersItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *activitiesItem = new QStandardItem(activities.join(","));
 
     QList<QStandardItem *> items;
 
     items.append(pathItem);
     items.append(hiddenTextItem);
     items.append(colorItem);
     items.append(nameItem);
     items.append(menuItem);
     items.append(bordersItem);
     items.append(activitiesItem);
 
     if (row > m_model->rowCount() - 1) {
         m_model->appendRow(items);
         row = m_model->rowCount() - 1;
 
         qDebug() << "append row at:" << row << " rows:" << m_model->rowCount();
     } else {
         m_model->insertRow(row, items);
         qDebug() << "insert row at:" << row << " rows:" << m_model->rowCount();
     }
 
     m_model->setData(m_model->index(row, IDCOLUMN), path, Qt::DisplayRole);
     m_model->setData(m_model->index(row, COLORCOLUMN), color, Qt::BackgroundRole);
     m_model->setData(m_model->index(row, COLORCOLUMN), textColor, Qt::UserRole);
 
     QFont font;
 
     if (m_corona->layoutManager()->activeLayout(name)) {
         font.setBold(true);
     } else {
         font.setBold(false);
     }
 
     if (path.startsWith("/tmp/")) {
         font.setItalic(true);
     } else {
         font.setItalic(false);
     }
 
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(name), Qt::DisplayRole);
     m_model->setData(m_model->index(row, NAMECOLUMN), font, Qt::FontRole);
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(locked), Qt::UserRole);
 
     m_model->setData(m_model->index(row, ACTIVITYCOLUMN), activities, Qt::UserRole);
 }
 
 
 void SettingsDialog::on_switchButton_clicked()
 {
     if (ui->buttonBox->button(QDialogButtonBox::Apply)->isEnabled()) {
         //! thus there are changes in the settings
 
         QString lName;
         QStringList lActivities;
 
         if (m_inMemoryButtons->checkedId() == Latte::Types::MultipleLayouts) {
             lName = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole).toString();
             lActivities = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), ACTIVITYCOLUMN), Qt::UserRole).toStringList();
         }
 
         apply();
 
         if (!lName.isEmpty() && !lActivities.isEmpty()) {
             //! an activities-assigned layout is chosen and at the same time we are moving
             //! to multiple layouts state
             m_corona->layoutManager()->switchToLayout(lName);
         }
     } else {
         QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
 
         if (value.isValid()) {
             m_corona->layoutManager()->switchToLayout(value.toString());
         } else {
             qDebug() << "not valid layout";
         }
     }
 
     updatePerLayoutButtonsState();
 }
 
 void SettingsDialog::on_pauseButton_clicked()
 {
     ui->pauseButton->setEnabled(false);
 
     QString id = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), IDCOLUMN), Qt::DisplayRole).toString();
     Layout *layout = m_layouts[id];
 
     if (layout) {
         m_corona->layoutManager()->pauseLayout(layout->name());
     }
 }
 
 void SettingsDialog::layoutsChanged()
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QModelIndex nameIndex = m_model->index(i, NAMECOLUMN);
         QVariant value = m_model->data(nameIndex);
 
         if (value.isValid()) {
             QString name = value.toString();
             QFont font;
 
             if (m_corona->layoutManager()->currentLayoutName() == name) {
                 font.setBold(true);
                 // ui->layoutsView->selectRow(i);
             } else {
                 Layout *layout = m_corona->layoutManager()->activeLayout(name);
 
                 if (layout && (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts)) {
                     font.setBold(true);
                 } else {
                     font.setBold(false);
                 }
             }
 
             m_model->setData(nameIndex, font, Qt::FontRole);
         }
     }
 }
 
 void SettingsDialog::itemChanged(QStandardItem *item)
 {
     updatePerLayoutButtonsState();
 
     if (item->column() == ACTIVITYCOLUMN) {
         //! recalculate the available activities
         recalculateAvailableActivities();
     } else if (item->column() == NAMECOLUMN) {
         int currentRow = ui->layoutsView->currentIndex().row();
 
         QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
         QFont font = qvariant_cast<QFont>(m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::FontRole));
 
         if (m_layouts[id]->name() != name) {
             font.setItalic(true);
             m_model->setData(m_model->index(currentRow, NAMECOLUMN), font, Qt::FontRole);
         } else {
             font.setItalic(false);
             m_model->setData(m_model->index(currentRow, NAMECOLUMN), font, Qt::FontRole);
         }
     }
 
     updateApplyButtonsState();
 }
 
 void SettingsDialog::updateApplyButtonsState()
 {
     bool changed{false};
 
     //! Ok, Apply Buttons
     if ((o_settings != currentSettings())
         || (o_settingsLayouts != currentLayoutsSettings())) {
         changed = true;
     }
 
     if (changed) {
         ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
         ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
     } else {
         ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
         ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
     }
 
     //! RestoreDefaults Button
     if (ui->tabWidget->currentIndex() == 0) {
         //! Check Default layouts missing from layouts list
 
         bool layoutMissing{false};
 
         foreach (auto preset, m_corona->layoutManager()->presetsPaths()) {
             QString presetName = Layout::layoutName(preset);
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = i18n(prset_str);
 
             if (!nameExistsInModel(presetName)) {
                 layoutMissing = true;
                 break;
             }
         }
 
         if (layoutMissing) {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(true);
         } else {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
         }
     } else if (ui->tabWidget->currentIndex() == 1) {
         //! Defaults for general Latte settings
 
         if (!ui->autostartChkBox->isChecked()
             || ui->metaPressChkBox->isChecked()
+            || !ui->metaPressHoldChkBox->isChecked()
             || !ui->infoWindowChkBox->isChecked()
             || ui->noBordersForMaximizedChkBox->isChecked()
             || !ui->highSensitivityBtn->isChecked()
             || ui->screenTrackerSpinBox->value() != SCREENTRACKERDEFAULTVALUE
             || ui->themeRoundnessSpinBox->value() != THEMEDEFAULTROUNDNESS) {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(true);
         } else {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
         }
     }
 }
 
 void SettingsDialog::updatePerLayoutButtonsState()
 {
     int currentRow = ui->layoutsView->currentIndex().row();
 
     QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
     QString nameInModel = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
     QString originalName = m_layouts.contains(id) ? m_layouts[id]->name() : "";
     bool lockedInModel = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::UserRole).toBool();
 
     //! Switch Button
     if (id.startsWith("/tmp/") || originalName != nameInModel) {
         ui->switchButton->setEnabled(false);
     } else {
         ui->switchButton->setEnabled(true);
     }
 
     //! Pause Button
     if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout) {
         ui->pauseButton->setVisible(false);
     } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         ui->pauseButton->setVisible(true);
 
         QStringList lActivities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         Layout *layout = m_layouts[id];
 
         if (!lActivities.isEmpty() && layout && m_corona->layoutManager()->activeLayout(layout->name())) {
             ui->pauseButton->setEnabled(true);
         } else {
             ui->pauseButton->setEnabled(false);
         }
     }
 
     //! Remove Layout Button
     if (originalName != nameInModel
         || (originalName == m_corona->layoutManager()->currentLayoutName())
         || (m_corona->layoutManager()->activeLayout(originalName))
         || lockedInModel) {
         ui->removeButton->setEnabled(false);
     } else {
         ui->removeButton->setEnabled(true);
     }
 
     if (lockedInModel) {
         ui->lockedButton->setChecked(true);
     } else {
         ui->lockedButton->setChecked(false);
     }
 }
 
 void SettingsDialog::recalculateAvailableActivities()
 {
     QStringList tempActivities = m_corona->layoutManager()->activities();
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QStringList assigned = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         foreach (auto activity, assigned) {
             if (tempActivities.contains(activity)) {
                 tempActivities.removeAll(activity);
             }
         }
     }
 
     m_availableActivities = tempActivities;
 }
 
 bool SettingsDialog::dataAreAccepted()
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString layout1 = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         for (int j = i + 1; j < m_model->rowCount(); ++j) {
             QString temp = m_model->data(m_model->index(j, NAMECOLUMN), Qt::DisplayRole).toString();
 
             //!same layout name exists again
             if (layout1 == temp) {
                 auto msg = new QMessageBox(this);
                 msg->setIcon(QMessageBox::Warning);
                 msg->setWindowTitle(i18n("Layout Warning"));
                 msg->setText(i18n("There are layouts with the same name, that is not permitted!!! Please update these names to re-apply the changes..."));
                 msg->setStandardButtons(QMessageBox::Ok);
 
                 connect(msg, &QMessageBox::finished, this, [ &, i, j](int result) {
                     QItemSelectionModel::SelectionFlags flags = QItemSelectionModel::ClearAndSelect;
                     QModelIndex indexBase = m_model->index(i, NAMECOLUMN);
                     ui->layoutsView->selectionModel()->select(indexBase, flags);
 
                     QModelIndex indexOccurence = m_model->index(j, NAMECOLUMN);
                     ui->layoutsView->edit(indexOccurence);
                 });
 
 
                 msg->open();
 
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool SettingsDialog::saveAllChanges()
 {
     if (!dataAreAccepted()) {
         return false;
     }
 
     //! Update universal settings
     Latte::Types::MouseSensitivity sensitivity = static_cast<Latte::Types::MouseSensitivity>(m_mouseSensitivityButtons->checkedId());
     bool autostart = ui->autostartChkBox->isChecked();
-    bool forwardMeta = ui->metaPressChkBox->isChecked();
+    bool forwardMetaPress = ui->metaPressChkBox->isChecked();
+    bool metaPressAndHold = ui->metaPressHoldChkBox->isChecked();
     bool showInfoWindow = ui->infoWindowChkBox->isChecked();
     bool noBordersForMaximized = ui->noBordersForMaximizedChkBox->isChecked();
 
     m_corona->universalSettings()->setMouseSensitivity(sensitivity);
     m_corona->universalSettings()->setAutostart(autostart);
-    m_corona->universalSettings()->forwardMetaToLatte(forwardMeta);
+    m_corona->universalSettings()->forwardMetaToLatte(forwardMetaPress);
+    m_corona->universalSettings()->setMetaPressAndHoldEnabled(metaPressAndHold);
     m_corona->universalSettings()->setShowInfoWindow(showInfoWindow);
     m_corona->universalSettings()->setCanDisableBorders(noBordersForMaximized);
     m_corona->universalSettings()->setScreenTrackerInterval(ui->screenTrackerSpinBox->value());
 
     m_corona->themeExtended()->setUserThemeRoundness(ui->themeRoundnessSpinBox->value());
 
     //! Update Layouts
     QStringList knownActivities = activities();
 
     QTemporaryDir layoutTempDir;
 
     qDebug() << "Temporary Directory ::: " << layoutTempDir.path();
 
     QStringList fromRenamePaths;
     QStringList toRenamePaths;
     QStringList toRenameNames;
 
     QString switchToLayout;
 
     QHash<QString, Layout *> activeLayoutsToRename;
 
     //! remove layouts that have been removed from the user
     foreach (auto initLayout, m_initLayoutPaths) {
         if (!idExistsInModel(initLayout)) {
             QFile(initLayout).remove();
 
             if (m_layouts.contains(initLayout)) {
                 Layout *removedLayout = m_layouts.take(initLayout);
                 delete removedLayout;
             }
         }
     }
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString color = m_model->data(m_model->index(i, COLORCOLUMN), Qt::BackgroundRole).toString();
         QString textColor = m_model->data(m_model->index(i, COLORCOLUMN), Qt::UserRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         bool disabledBorders = m_model->data(m_model->index(i, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         QStringList lActivities = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         QStringList cleanedActivities;
 
         //!update only activities that are valid
         foreach (auto activity, lActivities) {
             if (knownActivities.contains(activity)) {
                 cleanedActivities.append(activity);
             }
         }
 
         //qDebug() << i << ". " << id << " - " << color << " - " << name << " - " << menu << " - " << lActivities;
         Layout *activeLayout = m_corona->layoutManager()->activeLayout(m_layouts[id]->name());
 
         Layout *layout = activeLayout ? activeLayout : m_layouts[id];
 
         //! unlock read-only layout
         if (!layout->isWritable()) {
             layout->unlock();
         }
 
         if (color.startsWith("/")) {
             //it is image file in such case
             if (color != layout->background()) {
                 layout->setBackground(color);
             }
 
             if (layout->textColor() != textColor) {
                 layout->setTextColor(textColor);
             }
         } else {
             if (color != layout->color()) {
                 layout->setColor(color);
                 layout->setBackground(QString());
                 layout->setTextColor(QString());
             }
         }
 
         if (layout->showInMenu() != menu) {
             layout->setShowInMenu(menu);
         }
 
         if (layout->disableBordersForMaximizedWindows() != disabledBorders) {
             layout->setDisableBordersForMaximizedWindows(disabledBorders);
         }
 
         if (layout->activities() != cleanedActivities) {
             layout->setActivities(cleanedActivities);
         }
 
         //! If the layout name changed OR the layout path is a temporary one
         if (layout->name() != name || (id.startsWith("/tmp/"))) {
             //! If the layout is Active in MultipleLayouts
             if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts && activeLayout) {
                 qDebug() << " Active Layout Should Be Renamed From : " << layout->name() << " TO :: " << name;
                 activeLayoutsToRename[name] = layout;
             }
 
             QString tempFile = layoutTempDir.path() + "/" + QString(layout->name() + ".layout.latte");
             qDebug() << "new temp file ::: " << tempFile;
 
             if ((m_corona->layoutManager()->memoryUsage() == Types::SingleLayout) && (layout->name() == m_corona->layoutManager()->currentLayoutName())) {
                 switchToLayout = name;
             }
 
             layout = m_layouts.take(id);
             delete layout;
 
             QFile(id).rename(tempFile);
 
             fromRenamePaths.append(id);
             toRenamePaths.append(tempFile);
             toRenameNames.append(name);
         }
     }
 
     //! this is necessary in case two layouts have to swap names
     //! so we copy first the layouts in a temp directory and afterwards all
     //! together we move them in the official layout directory
     for (int i = 0; i < toRenamePaths.count(); ++i) {
         QString newFile = QDir::homePath() + "/.config/latte/" + toRenameNames[i] + ".layout.latte";
         QFile(toRenamePaths[i]).rename(newFile);
 
         Layout *nLayout = new Layout(this, newFile);
         m_layouts[newFile] = nLayout;
 
         for (int j = 0; j < m_model->rowCount(); ++j) {
             QString tId = m_model->data(m_model->index(j, IDCOLUMN), Qt::DisplayRole).toString();
 
             if (tId == fromRenamePaths[i]) {
                 m_model->setData(m_model->index(j, IDCOLUMN), newFile, Qt::DisplayRole);
                 m_initLayoutPaths.append(newFile);
 
                 QFont font = qvariant_cast<QFont>(m_model->data(m_model->index(j, NAMECOLUMN), Qt::FontRole));
 
                 font.setItalic(false);
                 m_model->setData(m_model->index(j, NAMECOLUMN), font, Qt::FontRole);
             }
         }
     }
 
     QString orphanedLayout;
 
     if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         foreach (auto newLayoutName, activeLayoutsToRename.keys()) {
             qDebug() << " Active Layout Is Renamed From : " << activeLayoutsToRename[newLayoutName]->name() << " TO :: " << newLayoutName;
             Layout *layout = activeLayoutsToRename[newLayoutName];
             layout->renameLayout(newLayoutName);
 
             //! that means it is an active layout for orphaned Activities
             if (layout->activities().isEmpty()) {
                 orphanedLayout = newLayoutName;
             }
         }
     }
 
     //! lock layouts in the end when the user has chosen it
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
 
         Layout *activeLayout = m_corona->layoutManager()->activeLayout(m_layouts[id]->name());
         Layout *layout = activeLayout ? activeLayout : m_layouts[id];
 
         if (layout && locked && layout->isWritable()) {
             layout->lock();
         }
     }
 
     m_corona->layoutManager()->loadLayouts();
 
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
 
     if (m_corona->layoutManager()->memoryUsage() != inMemoryOption) {
         Types::LayoutsMemoryUsage previousMemoryUsage = m_corona->layoutManager()->memoryUsage();
         m_corona->layoutManager()->setMemoryUsage(inMemoryOption);
 
         QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
         QString layoutName = value.toString();
 
         m_corona->layoutManager()->switchToLayout(layoutName, previousMemoryUsage);
     } else {
         if (!switchToLayout.isEmpty()) {
             m_corona->layoutManager()->switchToLayout(switchToLayout);
         } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
             m_corona->layoutManager()->syncMultipleLayoutsToActivities(orphanedLayout);
         }
     }
 
     return true;
 }
 
 bool SettingsDialog::idExistsInModel(QString id)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowId = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
 
         if (rowId == id) {
             return true;
         }
     }
 
     return false;
 }
 
 bool SettingsDialog::nameExistsInModel(QString name)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName == name) {
             return true;
         }
     }
 
     return false;
 }
 
 int SettingsDialog::ascendingRowFor(QString name)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName.toUpper() > name.toUpper()) {
             return i;
         }
     }
 
     return m_model->rowCount();
 }
 
 QString SettingsDialog::uniqueTempDirectory()
 {
     QTemporaryDir tempDir;
     tempDir.setAutoRemove(false);
     m_tempDirectories.append(tempDir.path());
 
     return tempDir.path();
 }
 
 QString SettingsDialog::uniqueLayoutName(QString name)
 {
     int pos_ = name.lastIndexOf(QRegExp(QString("[-][0-9]+")));
 
     if (nameExistsInModel(name) && pos_ > 0) {
         name = name.left(pos_);
     }
 
     int i = 2;
 
     QString namePart = name;
 
     while (nameExistsInModel(name)) {
         name = namePart + "-" + QString::number(i);
         i++;
     }
 
     return name;
 }
 
 }//end of namespace
 
diff --git a/app/settings/universalsettings.cpp b/app/settings/universalsettings.cpp
index 72eb6232..9bc35be0 100644
--- a/app/settings/universalsettings.cpp
+++ b/app/settings/universalsettings.cpp
@@ -1,425 +1,447 @@
 /*
 *  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"
 
 // local
 #include "layoutmanager.h"
 
 // Qt
 #include <QDebug>
 #include <QDir>
 #include <QProcess>
 #include <QtDBus>
 
 // KDE
 #include <KActivities/Consumer>
 
 #define KWINMETAFORWARDTOLATTESTRING "org.kde.lattedock,/Latte,org.kde.LatteDock,activateLauncherMenu"
 #define KWINMETAFORWARDTOPLASMASTRING "org.kde.plasmashell,/PlasmaShell,org.kde.PlasmaShell,activateLauncherMenu"
 
 namespace Latte {
 
 UniversalSettings::UniversalSettings(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_config(config),
       m_universalGroup(KConfigGroup(config, QStringLiteral("UniversalSettings")))
 {
     m_corona = qobject_cast<Latte::Corona *>(parent);
 
     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::metaPressAndHoldEnabledChanged, 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::versionChanged, this, &UniversalSettings::saveConfig);
 }
 
 UniversalSettings::~UniversalSettings()
 {
     saveConfig();
     cleanupSettings();
 }
 
 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();
+
+    //! this is needed to inform globalshortcuts to update its modifiers tracking
+    emit metaPressAndHoldEnabledChanged();
 }
 
 bool UniversalSettings::showInfoWindow() const
 {
     return m_showInfoWindow;
 }
 
 void UniversalSettings::setShowInfoWindow(bool show)
 {
     if (m_showInfoWindow == show) {
         return;
     }
 
     m_showInfoWindow = show;
     emit showInfoWindowChanged();
 }
 
 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 haven't added the flag "OnlyShowIn=KDE;" into the autostart file
         //! because I fall onto a Plasma 5.8 case that this flag
         //! didn't 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();
 }
 
 bool UniversalSettings::metaForwardedToLatte() const
 {
     return kwin_metaForwardedToLatte();
 }
 
 void UniversalSettings::forwardMetaToLatte(bool forward)
 {
     kwin_forwardMetaToLatte(forward);
 }
 
 bool UniversalSettings::kwin_metaForwardedToLatte() const
 {
     QProcess process;
     process.start("kreadconfig5 --file kwinrc --group ModifierOnlyShortcuts --key Meta");
     process.waitForFinished();
     QString output(process.readAllStandardOutput());
 
     output = output.remove("\n");
 
     return (output == KWINMETAFORWARDTOLATTESTRING);
 }
 
 void UniversalSettings::kwin_forwardMetaToLatte(bool forward)
 {
     if (kwin_metaForwardedToLatte() == forward) {
         return;
     }
 
     QProcess process;
     QStringList parameters;
     parameters << "--file" << "kwinrc" << "--group" << "ModifierOnlyShortcuts" << "--key" << "Meta";
 
     if (forward) {
         parameters << KWINMETAFORWARDTOLATTESTRING;
     } else {
         parameters << KWINMETAFORWARDTOPLASMASTRING;
     }
 
     process.start("kwriteconfig5", parameters);
     process.waitForFinished();
 
     QDBusInterface iface("org.kde.KWin", "/KWin", "", QDBusConnection::sessionBus());
 
     if (iface.isValid()) {
         iface.call("reconfigure");
     }
 }
 
+bool UniversalSettings::metaPressAndHoldEnabled() const
+{
+    return m_metaPressAndHoldEnabled;
+}
+
+void UniversalSettings::setMetaPressAndHoldEnabled(bool enabled)
+{
+    if (m_metaPressAndHoldEnabled == enabled) {
+        return;
+    }
+
+    m_metaPressAndHoldEnabled = enabled;
+
+    emit metaPressAndHoldEnabledChanged();
+}
+
 Types::LayoutsMemoryUsage UniversalSettings::layoutsMemoryUsage() const
 {
     return m_memoryUsage;
 }
 
 void UniversalSettings::setLayoutsMemoryUsage(Types::LayoutsMemoryUsage layoutsMemoryUsage)
 {
     if (m_memoryUsage == layoutsMemoryUsage) {
         return;
     }
 
     m_memoryUsage = layoutsMemoryUsage;
     emit layoutsMemoryUsageChanged();
 }
 
 Types::MouseSensitivity UniversalSettings::mouseSensitivity() const
 {
     return m_mouseSensitivity;
 }
 
 void UniversalSettings::setMouseSensitivity(Types::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_metaPressAndHoldEnabled = m_universalGroup.readEntry("metaPressAndHoldEnabled", true);
     m_screenTrackerInterval = m_universalGroup.readEntry("screenTrackerInterval", 2500);
     m_showInfoWindow = m_universalGroup.readEntry("showInfoWindow", true);
     m_memoryUsage = static_cast<Types::LayoutsMemoryUsage>(m_universalGroup.readEntry("memoryUsage", (int)Types::SingleLayout));
     m_mouseSensitivity = static_cast<Types::MouseSensitivity>(m_universalGroup.readEntry("mouseSensitivity", (int)Types::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("metaPressAndHoldEnabled", m_metaPressAndHoldEnabled);
     m_universalGroup.writeEntry("screenTrackerInterval", m_screenTrackerInterval);
     m_universalGroup.writeEntry("showInfoWindow", m_showInfoWindow);
     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()
 {
     return m_corona->kPackage().filePath("splitter");
 }
 
 QString UniversalSettings::trademarkIconPath()
 {
     return m_corona->kPackage().filePath("trademark");
 }
 
 QQmlListProperty<QScreen> UniversalSettings::screens()
 {
     return QQmlListProperty<QScreen>(this, nullptr, &countScreens, &atScreens);
 }
 
 int UniversalSettings::countScreens(QQmlListProperty<QScreen> *property)
 {
     Q_UNUSED(property)
     return qGuiApp->screens().count();
 }
 
 QScreen *UniversalSettings::atScreens(QQmlListProperty<QScreen> *property, int index)
 {
     Q_UNUSED(property)
     return qGuiApp->screens().at(index);
 }
 
 }
diff --git a/app/settings/universalsettings.h b/app/settings/universalsettings.h
index 30a5b171..55afb3c7 100644
--- a/app/settings/universalsettings.h
+++ b/app/settings/universalsettings.h
@@ -1,172 +1,177 @@
 /*
 *  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
 
 // local
 #include "../lattecorona.h"
 #include "../liblatte2/types.h"
 
 // Qt
 #include <QObject>
 #include <QAbstractItemModel>
 #include <QHash>
 #include <QPointer>
 #include <QQmlListProperty>
 #include <QScreen>
 
 // KDE
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 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)
 
     Q_PROPERTY(QString currentLayoutName READ currentLayoutName WRITE setCurrentLayoutName NOTIFY currentLayoutNameChanged)
 
     Q_PROPERTY(QStringList launchers READ launchers WRITE setLaunchers NOTIFY launchersChanged)
 
     Q_PROPERTY(Latte::Types::MouseSensitivity mouseSensitivity READ mouseSensitivity WRITE setMouseSensitivity NOTIFY mouseSensitivityChanged)
 
     Q_PROPERTY(QQmlListProperty<QScreen> screens READ screens)
 
 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 metaForwardedToLatte() const;
     void forwardMetaToLatte(bool forward);
 
+    bool metaPressAndHoldEnabled() const;
+    void setMetaPressAndHoldEnabled(bool enabled);
+
     bool showInfoWindow() const;
     void setShowInfoWindow(bool show);
 
     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);
 
     Types::MouseSensitivity mouseSensitivity() const;
     void setMouseSensitivity(Types::MouseSensitivity sensitivity);
 
     QQmlListProperty<QScreen> screens();
     static int countScreens(QQmlListProperty<QScreen> *property); //! is needed by screens()
     static QScreen *atScreens(QQmlListProperty<QScreen> *property, int index); //! is needed by screens()
 
 public slots:
     Q_INVOKABLE QString splitterIconPath();
     Q_INVOKABLE QString trademarkIconPath();
 
 signals:
     void autostartChanged();
     void canDisableBordersChanged();
     void currentLayoutNameChanged();
     void downloadWindowSizeChanged();
     void lastNonAssignedLayoutNameChanged();
     void layoutsColumnWidthsChanged();
     void layoutsWindowSizeChanged();
     void launchersChanged();
     void layoutsMemoryUsageChanged();
+    void metaPressAndHoldEnabledChanged();
     void mouseSensitivityChanged();
     void screenTrackerIntervalChanged();
     void showInfoWindowChanged();
     void versionChanged();
 
 private slots:
     void loadConfig();
     void saveConfig();
 
 private:
     void cleanupSettings();
 
     bool kwin_metaForwardedToLatte() const;
     void kwin_forwardMetaToLatte(bool forward);
 
     Types::LayoutsMemoryUsage layoutsMemoryUsage() const;
     void setLayoutsMemoryUsage(Types::LayoutsMemoryUsage layoutsMemoryUsage);
 
 private:
     bool m_canDisableBorders{false};
+    bool m_metaPressAndHoldEnabled{true};
     bool m_showInfoWindow{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;
 
     Types::LayoutsMemoryUsage m_memoryUsage;
     Types::MouseSensitivity m_mouseSensitivity{Types::HighSensitivity};
 
     QPointer<Latte::Corona> m_corona;
 
     KConfigGroup m_universalGroup;
     KSharedConfig::Ptr m_config;
 
     friend class LayoutManager;
     friend class Latte::Corona;
 };
 
 }
 
 #endif //UNIVERSALSETTINGS_H
diff --git a/app/shortcuts/globalshortcuts.cpp b/app/shortcuts/globalshortcuts.cpp
index ae7fdb18..4d494a8f 100644
--- a/app/shortcuts/globalshortcuts.cpp
+++ b/app/shortcuts/globalshortcuts.cpp
@@ -1,796 +1,806 @@
 /*
 *  Copyright 2016  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 "globalshortcuts.h"
 
 // local
 #include "modifiertracker.h"
 #include "shortcutstracker.h"
 #include "../lattecorona.h"
 #include "../layoutmanager.h"
 #include "../layout/layout.h"
 #include "../settings/universalsettings.h"
 #include "../view/view.h"
 
 // C++
 #include <array>
 
 // Qt
 #include <QAction>
 #include <QDebug>
 #include <QQuickItem>
 #include <QMetaMethod>
 #include <QX11Info>
 
 // KDE
 #include <KActionCollection>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPluginMetaData>
 
 // Plasma
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 
 namespace Latte {
 
 const int APPLETEXECUTIONDELAY = 400;
 
 GlobalShortcuts::GlobalShortcuts(QObject *parent)
     : QObject(parent)
 {
     m_corona = qobject_cast<Latte::Corona *>(parent);
     m_modifierTracker = new ShortcutsPart::ModifierTracker(this);
     m_shortcutsTracker = new ShortcutsPart::ShortcutsTracker(this);
 
     if (m_corona) {
         init();
     }
 
     m_hideViewsTimer.setSingleShot(true);
 
     if (QX11Info::isPlatformX11()) {
         //in X11 the timer is a poller that checks to see if the modifier keys
         //from user global shortcut have been released
         m_hideViewsTimer.setInterval(300);
     } else {
         //on wayland in acting just as simple timer that hides the view afterwards
         m_hideViewsTimer.setInterval(2500);
     }
 
     connect(&m_hideViewsTimer, &QTimer::timeout, this, &GlobalShortcuts::hideViewsTimerSlot);
 }
 
 GlobalShortcuts::~GlobalShortcuts()
 {
     if (m_modifierTracker) {
         m_modifierTracker->deleteLater();
     }
 
     if (m_shortcutsTracker) {
         m_shortcutsTracker->deleteLater();
     }
 }
 
 void GlobalShortcuts::init()
 {
     KActionCollection *generalActions = new KActionCollection(m_corona);
 
     //show-hide the main view in the primary screen
     QAction *showAction = generalActions->addAction(QStringLiteral("show latte view"));
     showAction->setText(i18n("Show Latte View"));
     showAction->setShortcut(QKeySequence(Qt::META + '`'));
     KGlobalAccel::setGlobalShortcut(showAction, QKeySequence(Qt::META + '`'));
     connect(showAction, &QAction::triggered, this, [this]() {
         showViews();
     });
 
     //show-cycle between Latte settings windows
     QAction *settingsAction = generalActions->addAction(QStringLiteral("show view settings"));
     settingsAction->setText(i18n("Show Latte View Settings"));
     KGlobalAccel::setGlobalShortcut(settingsAction, QKeySequence(Qt::META + Qt::Key_A));
     connect(settingsAction, &QAction::triggered, this, [this] {
         m_modifierTracker->cancelMetaPressed();
         showSettings();
     });
 
     //show the layouts editor
     QAction *layoutsAction = generalActions->addAction(QStringLiteral("show layout settings"));
     layoutsAction->setText(i18n("Show Layout Settings"));
     layoutsAction->setShortcut(QKeySequence(Qt::META + Qt::Key_W));
     KGlobalAccel::setGlobalShortcut(layoutsAction, QKeySequence(Qt::META + Qt::Key_W));
     connect(layoutsAction, &QAction::triggered, this, [this]() {
         m_modifierTracker->cancelMetaPressed();
         m_corona->layoutManager()->showLatteSettingsDialog(Types::LayoutPage);
     });
 
     //show the latter universal settings
     QAction *universalSettingsAction = generalActions->addAction(QStringLiteral("show latte universal settings"));
     universalSettingsAction->setText(i18n("Show Latte Settings"));
     universalSettingsAction->setShortcut(QKeySequence(Qt::META + Qt::Key_E));
     KGlobalAccel::setGlobalShortcut(universalSettingsAction, QKeySequence(Qt::META + Qt::Key_E));
     connect(universalSettingsAction, &QAction::triggered, this, [this]() {
         m_modifierTracker->cancelMetaPressed();
         m_corona->layoutManager()->showLatteSettingsDialog(Types::PreferencesPage);
     });
 
     KActionCollection *taskbarActions = new KActionCollection(m_corona);
 
     //activate actions [1-9]
     for (int i = 1; i < 10; ++i) {
         const int entryNumber = i;
         const Qt::Key key = static_cast<Qt::Key>(Qt::Key_0 + i);
 
         QAction *action = taskbarActions->addAction(QStringLiteral("activate entry %1").arg(QString::number(entryNumber)));
         action->setText(i18n("Activate Entry %1", entryNumber));
         action->setShortcut(QKeySequence(Qt::META + key));
         KGlobalAccel::setGlobalShortcut(action, QKeySequence(Qt::META + key));
         connect(action, &QAction::triggered, this, [this, i] {
             // qDebug() << "meta action...";
             m_modifierTracker->cancelMetaPressed();
             activateEntry(i, static_cast<Qt::Key>(Qt::META));
         });
     }
 
     //! Array that is used to register correctly actions for task index>=10 and <19
     std::array<Qt::Key, 10> keysAboveTen{  Qt::Key_0,  Qt::Key_Z,  Qt::Key_X, Qt::Key_C, Qt::Key_V, Qt::Key_B, Qt::Key_N, Qt::Key_M, Qt::Key_Comma, Qt::Key_Period };
 
     //activate actions [10-19]
     for (int i = 10; i < 20; ++i) {
         QAction *action = taskbarActions->addAction(QStringLiteral("activate entry %1").arg(QString::number(i)));
         action->setText(i18n("Activate Entry %1", i));
         action->setShortcut(QKeySequence(Qt::META + keysAboveTen[i - 10]));
         KGlobalAccel::setGlobalShortcut(action, QKeySequence(Qt::META + keysAboveTen[i - 10]));
         connect(action, &QAction::triggered, this, [this, i] {
             m_modifierTracker->cancelMetaPressed();
             activateEntry(i, static_cast<Qt::Key>(Qt::META));
         });
     }
 
     //new instance actions [1-9]
     for (int i = 1; i < 10; ++i) {
         const int entryNumber = i;
         const Qt::Key key = static_cast<Qt::Key>(Qt::Key_0 + i);
 
         QAction *action = taskbarActions->addAction(QStringLiteral("new instance for entry %1").arg(QString::number(entryNumber)));
         action->setText(i18n("New Instance for Entry %1", entryNumber));
         KGlobalAccel::setGlobalShortcut(action, QKeySequence(Qt::META + Qt::CTRL + key));
         connect(action, &QAction::triggered, this, [this, i] {
             // qDebug() << "meta + ctrl + action...";
             m_modifierTracker->cancelMetaPressed();
             activateEntry(i, static_cast<Qt::Key>(Qt::CTRL));
         });
     }
 
     //new instance actions [10-19]
     for (int i = 10; i < 20; ++i) {
         QAction *action = taskbarActions->addAction(QStringLiteral("new instance for entry %1").arg(QString::number(i)));
         action->setText(i18n("New Instance for Entry %1", i));
         KGlobalAccel::setGlobalShortcut(action, QKeySequence(Qt::META + Qt::CTRL + keysAboveTen[i - 10]));
         connect(action, &QAction::triggered, this, [this, i] {
             m_modifierTracker->cancelMetaPressed();
             activateEntry(i, static_cast<Qt::Key>(Qt::CTRL));
         });
     }
 
     m_singleMetaAction = new QAction(this);
     m_singleMetaAction->setShortcut(QKeySequence(Qt::META));
 
+    connect(m_corona->universalSettings(), &UniversalSettings::metaPressAndHoldEnabledChanged , this, [&]() {
+        if (!m_corona->universalSettings()->metaPressAndHoldEnabled()) {
+            m_modifierTracker->blockModifierTracking(Qt::Key_Super_L);
+            m_modifierTracker->blockModifierTracking(Qt::Key_Super_R);
+        } else {
+            m_modifierTracker->unblockModifierTracking(Qt::Key_Super_L);
+            m_modifierTracker->unblockModifierTracking(Qt::Key_Super_R);
+        }
+    });
+
     //display shortcut badges while holding Meta
     connect(m_modifierTracker, &ShortcutsPart::ModifierTracker::metaModifierPressed, this, [&]() {
         m_metaShowedViews = true;
         showViews();
     });
 }
 
 ShortcutsPart::ShortcutsTracker *GlobalShortcuts::shortcutsTracker() const
 {
     return m_shortcutsTracker;
 }
 
 //! Activate launcher menu through dbus interface
 void GlobalShortcuts::activateLauncherMenu()
 {
     if (m_metaShowedViews) {
         return;
     }
 
     QList<Latte::View *> sortedViews;
     Layout *currentLayout = m_corona->layoutManager()->currentLayout();
 
     if (currentLayout) {
         sortedViews = currentLayout->sortedLatteViews();
     }
 
     foreach (auto view, sortedViews) {
         const auto applets = view->containment()->applets();
 
         for (auto applet : applets) {
             const auto provides = applet->kPackage().metadata().value(QStringLiteral("X-Plasma-Provides"));
 
             if (provides.contains(QLatin1String("org.kde.plasma.launchermenu"))) {
                 if (view->visibility()->isHidden()) {
                     if (!m_hideViews.contains(view)) {
                         m_hideViews.append(view);
                     }
 
                     m_lastInvokedAction = m_singleMetaAction;
 
                     view->visibility()->setBlockHiding(true);
 
                     //! delay the execution in order to show first the view
                     QTimer::singleShot(APPLETEXECUTIONDELAY, [this, view, applet]() {
                         view->toggleAppletExpanded(applet->id());
                     });
 
                     m_hideViewsTimer.start();
                 } else {
                     view->toggleAppletExpanded(applet->id());
                 }
 
                 return;
             }
         }
     }
 }
 
 bool GlobalShortcuts::activatePlasmaTaskManagerEntryAtContainment(const Plasma::Containment *c, int index, Qt::Key modifier)
 {
     const auto &applets = c->applets();
 
     for (auto *applet : applets) {
         const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                 const auto &childItems = appletInterface->childItems();
 
                 if (childItems.isEmpty()) {
                     continue;
                 }
 
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 for (QQuickItem *item : childItems) {
                     if (auto *metaObject = item->metaObject()) {
                         // not using QMetaObject::invokeMethod to avoid warnings when calling
                         // this on applets that don't have it or other child items since this
                         // is pretty much trial and error.
 
                         // Also, "var" arguments are treated as QVariant in QMetaObject
                         int methodIndex = modifier == static_cast<Qt::Key>(Qt::META) ?
                                     metaObject->indexOfMethod("activateTaskAtIndex(QVariant)") :
                                     metaObject->indexOfMethod("newInstanceForTaskAtIndex(QVariant)");
 
                         int methodIndex2 = metaObject->indexOfMethod("setShowTaskShortcutBadges(QVariant)");
 
                         if (methodIndex == -1 || (methodIndex2 == -1 && meta.pluginId() == "org.kde.latte.plasmoid")) {
                             continue;
                         }
 
                         int showMethodIndex = -1;
 
                         if (!m_viewItemsCalled.contains(item)) {
                             m_viewItemsCalled.append(item);
                             m_showShortcutBadgesMethods.append(metaObject->method(methodIndex));
                             showMethodIndex = m_showShortcutBadgesMethods.count() - 1;
                         } else {
                             showMethodIndex = m_showShortcutBadgesMethods.indexOf(metaObject->method(methodIndex));
                         }
 
                         QMetaMethod method = metaObject->method(methodIndex);
 
                         if (method.invoke(item, Q_ARG(QVariant, index - 1))) {
                             if (methodIndex2 != -1) {
                                 m_showShortcutBadgesMethods[showMethodIndex].invoke(item, Q_ARG(QVariant, true));
                             }
 
                             return true;
                         }
 
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 bool GlobalShortcuts::activateLatteEntryAtContainment(const Latte::View *view, int index, Qt::Key modifier)
 {
     if (QQuickItem *containmentInterface = view->containment()->property("_plasma_graphicObject").value<QQuickItem *>()) {
         const auto &childItems = containmentInterface->childItems();
 
         for (QQuickItem *item : childItems) {
             if (auto *metaObject = item->metaObject()) {
                 // not using QMetaObject::invokeMethod to avoid warnings when calling
                 // this on applets that don't have it or other child items since this
                 // is pretty much trial and error.
 
                 // Also, "var" arguments are treated as QVariant in QMetaObject
                 int methodIndex = modifier == static_cast<Qt::Key>(Qt::META) ?
                             metaObject->indexOfMethod("activateEntryAtIndex(QVariant)") :
                             metaObject->indexOfMethod("newInstanceForEntryAtIndex(QVariant)");
 
                 int methodIndex2 = metaObject->indexOfMethod("setShowAppletShortcutBadges(QVariant,QVariant,QVariant,QVariant)");
 
                 if (methodIndex == -1 || (methodIndex2 == -1)) {
                     continue;
                 }
 
                 int appLauncher = m_corona->universalSettings()->metaForwardedToLatte() ?
                             applicationLauncherId(view->containment()) : -1;
 
                 int showMethodIndex = -1;
 
                 if (!m_viewItemsCalled.contains(item)) {
                     m_viewItemsCalled.append(item);
                     m_showShortcutBadgesMethods.append(metaObject->method(methodIndex2));
                     showMethodIndex = m_showShortcutBadgesMethods.count() - 1;
                 } else {
                     showMethodIndex = m_showShortcutBadgesMethods.indexOf(metaObject->method(methodIndex2));
                 }
 
                 QMetaMethod method = metaObject->method(methodIndex);
 
                 if (view->visibility()->isHidden()) {
                     //! delay the execution in order to show first the view
                     QTimer::singleShot(APPLETEXECUTIONDELAY, [this, item, method, index]() {
                         method.invoke(item, Q_ARG(QVariant, index));
                     });
 
                     return true;
                 } else {
                     if (method.invoke(item, Q_ARG(QVariant, index))) {
                         return true;
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 
 //! Activate task manager entry
 void GlobalShortcuts::activateEntry(int index, Qt::Key modifier)
 {
     m_lastInvokedAction = dynamic_cast<QAction *>(sender());
 
     QList<Latte::View *> sortedViews;
     Layout *currentLayout = m_corona->layoutManager()->currentLayout();
 
     if (currentLayout) {
         sortedViews = currentLayout->sortedLatteViews();
     }
 
     foreach (auto view, sortedViews) {
         if (view->managedLayout()->preferredForShortcutsTouched() && !view->isPreferredForShortcuts()) {
             continue;
         }
 
         if ((!view->latteTasksPresent() && view->tasksPresent() &&
              activatePlasmaTaskManagerEntryAtContainment(view->containment(), index, modifier))
                 || activateLatteEntryAtContainment(view, index, modifier)) {
 
             if (!m_hideViews.contains(view)) {
                 m_hideViews.append(view);
             }
 
             view->visibility()->setBlockHiding(true);
             m_hideViewsTimer.start();
             return;
         }
     }
 
 }
 
 //! update badge for specific view item
 void GlobalShortcuts::updateViewItemBadge(QString identifier, QString value)
 {
     //qDebug() << "DBUS CALL ::: " << identifier << " - " << value;
     auto updateBadgeForTaskInContainment = [this](const Plasma::Containment * c, QString identifier, QString value) {
         const auto &applets = c->applets();
 
         for (auto *applet : applets) {
             KPluginMetaData meta = applet->kPackage().metadata();
 
             if (meta.pluginId() == "org.kde.latte.plasmoid") {
 
                 if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                     const auto &childItems = appletInterface->childItems();
 
                     if (childItems.isEmpty()) {
                         continue;
                     }
 
                     for (QQuickItem *item : childItems) {
                         if (auto *metaObject = item->metaObject()) {
                             // not using QMetaObject::invokeMethod to avoid warnings when calling
                             // this on applets that don't have it or other child items since this
                             // is pretty much trial and error.
                             // Also, "var" arguments are treated as QVariant in QMetaObject
 
                             int methodIndex = metaObject->indexOfMethod("updateBadge(QVariant,QVariant)");
 
                             if (methodIndex == -1) {
                                 continue;
                             }
 
                             QMetaMethod method = metaObject->method(methodIndex);
 
                             if (method.invoke(item, Q_ARG(QVariant, identifier), Q_ARG(QVariant, value))) {
                                 return true;
                             }
                         }
                     }
                 }
             }
         }
 
         return false;
     };
 
     QHash<const Plasma::Containment *, Latte::View *> *views;
     Layout *currentLayout = m_corona->layoutManager()->currentLayout();
 
     if (currentLayout) {
         views = currentLayout->latteViews();
     }
 
     // update badges in all Latte Tasks plasmoids
     for (auto it = views->constBegin(), end = views->constEnd(); it != end; ++it) {
         updateBadgeForTaskInContainment(it.key(), identifier, value);
     }
 }
 
 bool GlobalShortcuts::isCapableToShowShortcutBadges(Latte::View *view)
 {
     if (!view->latteTasksPresent() && view->tasksPresent()) {
         return false;
     }
 
     const Plasma::Containment *c = view->containment();
 
     if (QQuickItem *containmentInterface = c->property("_plasma_graphicObject").value<QQuickItem *>()) {
         const auto &childItems = containmentInterface->childItems();
 
         for (QQuickItem *item : childItems) {
             if (auto *metaObject = item->metaObject()) {
                 // not using QMetaObject::invokeMethod to avoid warnings when calling
                 // this on applets that don't have it or other child items since this
                 // is pretty much trial and error.
 
                 // Also, "var" arguments are treated as QVariant in QMetaObject
                 int methodIndex = metaObject->indexOfMethod("setShowAppletShortcutBadges(QVariant,QVariant,QVariant,QVariant)");
 
                 if (methodIndex == -1) {
                     continue;
                 }
 
                 return true;
             }
         }
     }
 
     return false;
 }
 
 int GlobalShortcuts::applicationLauncherId(const Plasma::Containment *c)
 {
     const auto applets = c->applets();
 
     for (auto applet : applets) {
         const auto provides = applet->kPackage().metadata().value(QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.launchermenu"))) {
             return applet->id();
         }
     }
 
     return -1;
 }
 
 void GlobalShortcuts::showViews()
 {
     m_lastInvokedAction = dynamic_cast<QAction *>(sender());
     if (!m_lastInvokedAction) {
         // when holding Meta
         m_lastInvokedAction = m_singleMetaAction;
     }
 
     auto invokeShowShortcuts = [this](const Plasma::Containment * c, const bool showLatteShortcuts, const bool showMeta) {
         if (QQuickItem *containmentInterface = c->property("_plasma_graphicObject").value<QQuickItem *>()) {
             const auto &childItems = containmentInterface->childItems();
 
             for (QQuickItem *item : childItems) {
                 if (auto *metaObject = item->metaObject()) {
                     // not using QMetaObject::invokeMethod to avoid warnings when calling
                     // this on applets that don't have it or other child items since this
                     // is pretty much trial and error.
 
                     // Also, "var" arguments are treated as QVariant in QMetaObject
                     int methodIndex = metaObject->indexOfMethod("setShowAppletShortcutBadges(QVariant,QVariant,QVariant,QVariant)");
 
                     if (methodIndex == -1) {
                         continue;
                     }
 
                     int appLauncher = m_corona->universalSettings()->metaForwardedToLatte() && showMeta ?
                                 applicationLauncherId(c) : -1;
 
                     int showMethodIndex = -1;
 
                     if (!m_viewItemsCalled.contains(item)) {
                         m_viewItemsCalled.append(item);
                         m_showShortcutBadgesMethods.append(metaObject->method(methodIndex));
                         showMethodIndex = m_showShortcutBadgesMethods.count() - 1;
                     } else {
                         showMethodIndex = m_showShortcutBadgesMethods.indexOf(metaObject->method(methodIndex));
                     }
 
                     if (m_showShortcutBadgesMethods[showMethodIndex].invoke(item,
                                                                             Q_ARG(QVariant, showLatteShortcuts),
                                                                             Q_ARG(QVariant, true),
                                                                             Q_ARG(QVariant, showMeta),
                                                                             Q_ARG(QVariant, appLauncher))) {
                         return true;
                     }
 
                 }
             }
         }
 
         return false;
     };
 
     auto invokeShowOnlyMeta = [this](const Plasma::Containment * c, const bool showLatteShortcuts) {
         if (QQuickItem *containmentInterface = c->property("_plasma_graphicObject").value<QQuickItem *>()) {
             const auto &childItems = containmentInterface->childItems();
 
             for (QQuickItem *item : childItems) {
                 if (auto *metaObject = item->metaObject()) {
                     // not using QMetaObject::invokeMethod to avoid warnings when calling
                     // this on applets that don't have it or other child items since this
                     // is pretty much trial and error.
 
                     // Also, "var" arguments are treated as QVariant in QMetaObject
                     int methodIndex = metaObject->indexOfMethod("setShowAppletShortcutBadges(QVariant,QVariant,QVariant,QVariant)");
 
                     if (methodIndex == -1) {
                         continue;
                     }
 
                     int appLauncher = m_corona->universalSettings()->metaForwardedToLatte() ?
                                 applicationLauncherId(c) : -1;
 
                     int showMethodIndex = -1;
 
                     if (!m_viewItemsCalled.contains(item)) {
                         m_viewItemsCalled.append(item);
                         m_showShortcutBadgesMethods.append(metaObject->method(methodIndex));
                         showMethodIndex = m_showShortcutBadgesMethods.count() - 1;
                     } else {
                         showMethodIndex = m_showShortcutBadgesMethods.indexOf(metaObject->method(methodIndex));
                     }
 
                     if (m_showShortcutBadgesMethods[showMethodIndex].invoke(item,
                                                                             Q_ARG(QVariant, showLatteShortcuts),
                                                                             Q_ARG(QVariant, true),
                                                                             Q_ARG(QVariant, true),
                                                                             Q_ARG(QVariant, appLauncher))) {
                         return true;
                     }
                 }
             }
         }
 
         return false;
     };
 
     QList<Latte::View *> sortedViews;
     Layout *currentLayout = m_corona->layoutManager()->currentLayout();
 
     if (currentLayout) {
         sortedViews = currentLayout->sortedLatteViews();
     }
 
     Latte::View *viewWithTasks{nullptr};
     Latte::View *viewWithMeta{nullptr};
 
     foreach (auto view, sortedViews) {
         if (!viewWithTasks && (!view->managedLayout()->preferredForShortcutsTouched() || view->isPreferredForShortcuts()) && isCapableToShowShortcutBadges(view)) {
             viewWithTasks = view;
             break;
         }
     }
 
     //! show Meta if it is not already shown for Tasks Latte View
     if (!viewWithTasks || applicationLauncherId(viewWithTasks->containment()) == -1) {
         foreach (auto view, sortedViews) {
             if (!viewWithMeta && m_corona->universalSettings()->metaForwardedToLatte() && applicationLauncherId(view->containment()) > -1) {
                 viewWithMeta = view;
                 break;
             }
         }
     }
 
     bool viewFound{false};
 
     if (!m_hideViewsTimer.isActive()) {
         m_hideViews.clear();
 
         if (viewWithTasks || viewWithMeta) {
             m_viewItemsCalled.clear();
             m_showShortcutBadgesMethods.clear();
         }
     }
 
     //! show view that contains tasks plasmoid
     if (viewWithTasks && invokeShowShortcuts(viewWithTasks->containment(), true, true)) {
         viewFound = true;
 
         if (!m_hideViewsTimer.isActive()) {
             m_hideViews.append(viewWithTasks);
             viewWithTasks->visibility()->setBlockHiding(true);
         }
     }
 
     //! show view that contains only meta
     if (viewWithMeta && viewWithMeta != viewWithTasks && invokeShowOnlyMeta(viewWithMeta->containment(), false)) {
         viewFound = true;
 
         if (!m_hideViewsTimer.isActive()) {
             m_hideViews.append(viewWithMeta);
             viewWithMeta->visibility()->setBlockHiding(true);
         }
     }
 
     //! show all the rest views that contain plasma shortcuts
     QList<Latte::View *> viewsWithShortcuts;
 
     if (currentLayout) {
         viewsWithShortcuts = currentLayout->viewsWithPlasmaShortcuts();
     }
 
     if (viewsWithShortcuts.count() > 0) {
         viewFound = true;
 
         if (!m_hideViewsTimer.isActive()) {
             foreach (auto view, viewsWithShortcuts) {
                 if (view != viewWithTasks && view != viewWithMeta) {
                     if (invokeShowShortcuts(view->containment(), false, false)) {
                         m_hideViews.append(view);
                         view->visibility()->setBlockHiding(true);
                     }
                 }
             }
         }
     }
 
     if (viewFound) {
         if (!m_hideViewsTimer.isActive()) {
             m_hideViewsTimer.start();
         } else {
             m_hideViewsTimer.stop();
             hideViewsTimerSlot();
         }
     }
 }
 
 bool GlobalShortcuts::viewsToHideAreValid()
 {
     foreach (auto view, m_hideViews) {
         if (!m_corona->layoutManager()->latteViewExists(view)) {
             return false;
         }
 
     }
 
     return true;
 }
 
 void GlobalShortcuts::showSettings()
 {
     QList<Latte::View *> sortedViews;
     Layout *currentLayout = m_corona->layoutManager()->currentLayout();
 
     if (currentLayout) {
         sortedViews = currentLayout->sortedLatteViews();
     }
 
     //! find which is the next view to show its settings
     if (sortedViews.count() > 0) {
         int openSettings = -1;
 
         //! check if there is a view with opened settings window
         for (int i = 0; i < sortedViews.size(); ++i) {
             if (sortedViews[i]->settingsWindowIsShown()) {
                 openSettings = i;
                 break;
             }
         }
 
         if (openSettings >= 0 && sortedViews.count() > 1) {
             openSettings = openSettings + 1;
 
             if (openSettings >= sortedViews.size()) {
                 openSettings = 0;
             }
 
             sortedViews[openSettings]->showSettingsWindow();
         } else {
             sortedViews[0]->showSettingsWindow();
         }
     }
 }
 
 void GlobalShortcuts::hideViewsTimerSlot()
 {
     if (!m_lastInvokedAction || m_hideViews.count() == 0) {
         return;
     }
 
     auto initParameters = [this]() {
         m_lastInvokedAction = Q_NULLPTR;
 
         if (viewsToHideAreValid()) {
             foreach (auto latteView, m_hideViews) {
                 latteView->visibility()->setBlockHiding(false);
             }
 
             if (m_viewItemsCalled.count() > 0) {
                 for (int i = 0; i < m_viewItemsCalled.count(); ++i) {
                     m_showShortcutBadgesMethods[i].invoke(m_viewItemsCalled[i],
                                                           Q_ARG(QVariant, false),
                                                           Q_ARG(QVariant, false),
                                                           Q_ARG(QVariant, false),
                                                           Q_ARG(QVariant, -1));
                 }
             }
         }
 
         m_hideViews.clear();
         m_viewItemsCalled.clear();
         m_showShortcutBadgesMethods.clear();
         m_metaShowedViews = false;
     };
 
     // qDebug() << "MEMORY ::: " << m_hideViews.count() << " _ " << m_viewItemsCalled.count() << " _ " << m_showShortcutBadgesMethods.count();
 
     if (QX11Info::isPlatformX11()) {
         if (!m_modifierTracker->sequenceModifierPressed(m_lastInvokedAction->shortcut())) {
             initParameters();
 
             return;
         } else {
             m_hideViewsTimer.start();
         }
     } else {
         // TODO: This is needs to be fixed in wayland
         initParameters();
     }
 }
 
 }
 
 #include "moc_globalshortcuts.cpp"
diff --git a/app/shortcuts/modifiertracker.cpp b/app/shortcuts/modifiertracker.cpp
index 28e6edaf..a8c0c7ee 100644
--- a/app/shortcuts/modifiertracker.cpp
+++ b/app/shortcuts/modifiertracker.cpp
@@ -1,135 +1,153 @@
 /*
 *  Copyright 2019  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/>.
 */
 
 // local
 #include "modifiertracker.h"
 
 // Qt
 #include <QDebug>
 #include <QKeySequence>
 
 namespace Latte {
 namespace ShortcutsPart {
 
 ModifierTracker::ModifierTracker(QObject *parent)
     : QObject(parent)
 {
     init();
 }
 
 ModifierTracker::~ModifierTracker()
 {
 }
 
 void ModifierTracker::init()
 {
     m_metaPressedTimer.setSingleShot(true);
     m_metaPressedTimer.setInterval(700);
 
     m_pressed[Qt::Key_Super_L] = false;
     m_pressed[Qt::Key_Control] = false;
     m_pressed[Qt::Key_Alt] = false;
     m_pressed[Qt::Key_Shift] = false;
 
     connect(&m_metaPressedTimer, &QTimer::timeout, this, &ModifierTracker::metaModifierPressed);
 
     connect(&m_modifierKeyInfo, &KModifierKeyInfo::keyPressed, this, [&](Qt::Key key, bool state) {
         Qt::Key nKey = normalizeKey(key);
         //! ignore modifiers that we do not take into account
         if (!modifierIsTracked(nKey)) {
             return;
         }
 
         m_pressed[nKey] = state;
 
         if (nKey == Qt::Key_Super_L) {
             bool singleKey{singleModifierPressed(Qt::Key_Super_L)};
             if (state && singleKey) {
                 m_metaPressedTimer.start();
             } else if (!state || !singleKey) {
                 cancelMetaPressed();
             }
         } else {
             cancelMetaPressed();
         }
 
         emit modifiersChanged();
     });
 }
 
 
 bool ModifierTracker::modifierIsTracked(Qt::Key key)
 {
-    return(key == Qt::Key_Super_L || key == Qt::Key_Super_R || key == Qt::Key_Control || key == Qt::Key_Alt || key == Qt::Key_Shift);
+    if (m_blockedModifiers.contains(key)) {
+        return false;
+    }
+
+    return (key == Qt::Key_Super_L || key == Qt::Key_Super_R || key == Qt::Key_Control || key == Qt::Key_Alt || key == Qt::Key_Shift);
+}
+
+void ModifierTracker::blockModifierTracking(Qt::Key key)
+{
+    if (!m_blockedModifiers.contains(key)) {
+        m_blockedModifiers.append(key);
+    }
+}
+
+void ModifierTracker::unblockModifierTracking(Qt::Key key)
+{
+    if (m_blockedModifiers.contains(key)) {
+        m_blockedModifiers.removeAll(key);
+    }
 }
 
 bool ModifierTracker::noModifierPressed()
 {
     foreach(Qt::Key modifier, m_pressed.keys()) {
         if ( m_pressed[modifier]) {
             return false;
         }
     }
 
     return true;
 }
 
 bool ModifierTracker::sequenceModifierPressed(const QKeySequence &seq)
 {
     if (seq.isEmpty()) {
         return false;
     }
 
     int mod = seq[seq.count() - 1] & Qt::KeyboardModifierMask;
 
     if ( ((mod & Qt::SHIFT) && m_pressed[Qt::Key_Shift])
          || ((mod & Qt::CTRL) && m_pressed[Qt::Key_Control])
          || ((mod & Qt::ALT) && m_pressed[Qt::Key_Alt])
          || ((mod & Qt::META) && m_pressed[Qt::Key_Super_L])) {
         return true;
     }
 
     return false;
 }
 
 bool ModifierTracker::singleModifierPressed(Qt::Key key)
 {
     foreach(Qt::Key modifier, m_pressed.keys()) {
         if ( (modifier != key && m_pressed[modifier])
              || (modifier == key && !m_pressed[modifier]) ) {
             return false;
         }
     }
 
     return true;
 }
 
 Qt::Key ModifierTracker::normalizeKey(Qt::Key key)
 {
     return key == Qt::Key_Super_L || key == key == Qt::Key_Super_R ? Qt::Key_Super_L : key;
 }
 
 void ModifierTracker::cancelMetaPressed()
 {
     m_metaPressedTimer.stop();
 }
 
 
 }
 }
diff --git a/app/shortcuts/modifiertracker.h b/app/shortcuts/modifiertracker.h
index c13d9c5b..f5741813 100644
--- a/app/shortcuts/modifiertracker.h
+++ b/app/shortcuts/modifiertracker.h
@@ -1,78 +1,84 @@
 /*
 *  Copyright 2019  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 MODIFIERTRACKER_H
 #define MODIFIERTRACKER_H
 
 // Qt
 #include <QHash>
 #include <QObject>
 #include <QTimer>
 
 // KDE
 #include <KModifierKeyInfo>
 
 namespace Latte {
 namespace ShortcutsPart {
 
 class ModifierTracker: public QObject {
     Q_OBJECT
 
 public:
     ModifierTracker(QObject *parent);
     ~ModifierTracker() override;
 
     //! cancel meta is pressed delayer
     void cancelMetaPressed();
 
     //! none of tracked modifiers is pressed
     bool noModifierPressed();
 
     //! at least one of the modifiers from KeySequence is pressed
     bool sequenceModifierPressed(const QKeySequence &seq);
 
     //! only <key> is pressed and no other modifier
     bool singleModifierPressed(Qt::Key key);
 
+    void blockModifierTracking(Qt::Key key);
+    void unblockModifierTracking(Qt::Key key);
+
 signals:
     void metaModifierPressed();
     void modifiersChanged();
 
 private:
     void init();
 
     //! <key> modifier is tracked for changes
     bool modifierIsTracked(Qt::Key key);
 
     //! adjust key in more general values, e.g. Super_L and Super_R both return Super_L
     Qt::Key normalizeKey(Qt::Key key);
 
 private:
     KModifierKeyInfo m_modifierKeyInfo;
     QTimer m_metaPressedTimer;
 
+    //! modifiers that the user does not want to track anymore
+    QList<Qt::Key> m_blockedModifiers;
+
     //! keep a record for modifiers
     QHash<Qt::Key, bool> m_pressed;
 
 };
 
 }
 }
 
 #endif