diff --git a/app/layout/layout.cpp b/app/layout/layout.cpp
index 90595cd0..b9c9188a 100644
--- a/app/layout/layout.cpp
+++ b/app/layout/layout.cpp
@@ -1,1958 +1,1976 @@
 /*
 *  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 "layout.h"
 
 // local
 #include "shortcuts.h"
 #include "../importer.h"
 #include "../lattecorona.h"
 #include "../layoutmanager.h"
 #include "../screenpool.h"
 #include "../settings/universalsettings.h"
 #include "../shortcuts/globalshortcuts.h"
 #include "../shortcuts/shortcutstracker.h"
 #include "../view/positioner.h"
 #include "../view/view.h"
 
 // Qt
 #include <QDir>
 #include <QFile>
 #include <QtDBus/QtDBus>
 
 // KDE
 #include <KSharedConfig>
 #include <KActivities/Consumer>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 
 namespace Latte {
 
 const QString Layout::MultipleLayoutsName = ".multiple-layouts_hidden";
 
 Layout::Layout(QObject *parent, QString layoutFile, QString assignedName)
     : QObject(parent)
 {
     qDebug() << "Layout file to create object: " << layoutFile << " with name: " << assignedName;
 
     if (QFile(layoutFile).exists()) {
         if (assignedName.isEmpty()) {
             assignedName =  layoutName(layoutFile);
         }
 
         //!this order is important because setFile initializes also the m_layoutGroup
         setFile(layoutFile);
         setName(assignedName);
         loadConfig();
         init();
     }
 }
 
 Layout::~Layout()
 {
     if (m_shortcuts) {
         m_shortcuts->deleteLater();
     }
 
     if (!m_layoutFile.isEmpty()) {
         m_layoutGroup.sync();
     }
 }
 
 void Layout::syncToLayoutFile(bool removeLayoutId)
 {
     if (!m_corona || !isWritable()) {
         return;
     }
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(m_layoutFile);
 
     KConfigGroup oldContainments = KConfigGroup(filePtr, "Containments");
     oldContainments.deleteGroup();
     oldContainments.sync();
 
     qDebug() << " LAYOUT :: " << m_layoutName << " is syncing its original file.";
 
     foreach (auto containment, m_containments) {
         if (removeLayoutId) {
             containment->config().writeEntry("layoutId", "");
         }
 
         KConfigGroup newGroup = oldContainments.group(QString::number(containment->id()));
         containment->config().copyTo(&newGroup);
 
         if (!removeLayoutId) {
             newGroup.writeEntry("layoutId", "");
             newGroup.sync();
         }
     }
 
     oldContainments.sync();
 }
 
 void Layout::unloadContainments()
 {
     if (!m_corona) {
         return;
     }
 
     //!disconnect signals in order to avoid crashes when the layout is unloading
     disconnect(this, &Layout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRectChanged);
     disconnect(this, &Layout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRegionChanged);
 
     qDebug() << "Layout - " + name() + " unload: containments ... size ::: " << m_containments.size()
              << " ,latteViews in memory ::: " << m_latteViews.size()
              << " ,hidden latteViews in memory :::  " << m_waitingLatteViews.size();
 
     foreach (auto view, m_latteViews) {
         view->disconnectSensitiveSignals();
     }
 
     foreach (auto view, m_waitingLatteViews) {
         view->disconnectSensitiveSignals();
     }
 
     m_unloadedContainmentsIds.clear();
 
     QList<Plasma::Containment *> systrays;
 
     //!identify systrays and unload them first
     foreach (auto containment, m_containments) {
         if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
             systrays.append(containment);
         }
     }
 
     while (!systrays.isEmpty()) {
         Plasma::Containment *systray = systrays.at(0);
         m_unloadedContainmentsIds << QString::number(systray->id());
         systrays.removeFirst();
         m_containments.removeAll(systray);
         delete systray;
     }
 
     while (!m_containments.isEmpty()) {
         Plasma::Containment *containment = m_containments.at(0);
         m_unloadedContainmentsIds << QString::number(containment->id());
         m_containments.removeFirst();
         delete containment;
     }
 }
 
 void Layout::unloadLatteViews()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "Layout - " + name() + " unload: latteViews ... size: " << m_latteViews.size();
 
     qDeleteAll(m_latteViews);
     qDeleteAll(m_waitingLatteViews);
     m_latteViews.clear();
     m_waitingLatteViews.clear();
 }
 
 void Layout::init()
 {
     connect(this, &Layout::activitiesChanged, this, &Layout::saveConfig);
     connect(this, &Layout::backgroundChanged, this, &Layout::saveConfig);
     connect(this, &Layout::versionChanged, this, &Layout::saveConfig);
     connect(this, &Layout::colorChanged, this, &Layout::textColorChanged);
     connect(this, &Layout::disableBordersForMaximizedWindowsChanged, this, &Layout::saveConfig);
     connect(this, &Layout::showInMenuChanged, this, &Layout::saveConfig);
     connect(this, &Layout::textColorChanged, this, &Layout::saveConfig);
     connect(this, &Layout::launchersChanged, this, &Layout::saveConfig);
     connect(this, &Layout::lastUsedActivityChanged, this, &Layout::saveConfig);
+    connect(this, &Layout::preferredForShortcutsTouchedChanged, this, &Layout::saveConfig);
 }
 
 void Layout::initToCorona(Latte::Corona *corona)
 {
     if (m_corona) {
         return;
     }
 
     m_corona = corona;
 
     if (!m_shortcuts) {
         m_shortcuts = new LayoutPart::Shortcuts(this);
     }
 
     foreach (auto containment, m_corona->containments()) {
         if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout) {
             addContainment(containment);
         } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
             QString layoutId = containment->config().readEntry("layoutId", QString());
 
             if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
                 addContainment(containment);
             }
         }
     }
 
     qDebug() << "Layout ::::: " << name() << " added containments ::: " << m_containments.size();
 
     connect(m_corona->universalSettings(), &UniversalSettings::canDisableBordersChanged, this, [&]() {
         if (m_corona->universalSettings()->canDisableBorders()) {
             kwin_setDisabledMaximizedBorders(disableBordersForMaximizedWindows());
         } else {
             kwin_setDisabledMaximizedBorders(false);
         }
     });
 
 
     if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout && m_corona->universalSettings()->canDisableBorders()) {
         kwin_setDisabledMaximizedBorders(disableBordersForMaximizedWindows());
     } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         connect(m_corona->layoutManager(), &LayoutManager::currentLayoutNameChanged, this, [&]() {
             if (m_corona->universalSettings()->canDisableBorders()
                 && m_corona->layoutManager()->currentLayoutName() == name()) {
                 kwin_setDisabledMaximizedBorders(disableBordersForMaximizedWindows());
             }
         });
     }
 
     if (m_layoutName != MultipleLayoutsName) {
         updateLastUsedActivity();
     }
 
     connect(m_corona, &Plasma::Corona::containmentAdded, this, &Layout::addContainment);
 
     connect(m_corona->m_activityConsumer, &KActivities::Consumer::currentActivityChanged,
             this, &Layout::updateLastUsedActivity);
 
     //!connect signals after adding the containment
     connect(this, &Layout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRectChanged);
     connect(this, &Layout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRegionChanged);
 
     emit viewsCountChanged();
 }
 
 int Layout::version() const
 {
     return m_version;
 }
 
 void Layout::setVersion(int ver)
 {
     if (m_version == ver) {
         return;
     }
 
     m_version = ver;
 
     emit versionChanged();
 }
 
 bool Layout::blockAutomaticLatteViewCreation() const
 {
     return m_blockAutomaticLatteViewCreation;
 }
 
 void Layout::setBlockAutomaticLatteViewCreation(bool block)
 {
     if (m_blockAutomaticLatteViewCreation == block) {
         return;
     }
 
     m_blockAutomaticLatteViewCreation = block;
 }
 
 bool Layout::disableBordersForMaximizedWindows() const
 {
     return m_disableBordersForMaximizedWindows;
 }
 
 void Layout::setDisableBordersForMaximizedWindows(bool disable)
 {
     if (m_disableBordersForMaximizedWindows == disable) {
         return;
     }
 
     m_disableBordersForMaximizedWindows = disable;
     kwin_setDisabledMaximizedBorders(disable);
 
     emit disableBordersForMaximizedWindowsChanged();
 }
 
 bool Layout::kwin_disabledMaximizedBorders() const
 {
     //! Identify Plasma Desktop version
     QProcess process;
     process.start("kreadconfig5 --file kwinrc --group Windows --key BorderlessMaximizedWindows");
     process.waitForFinished();
     QString output(process.readAllStandardOutput());
 
     output = output.remove("\n");
 
     return (output == "true");
 }
 
 void Layout::kwin_setDisabledMaximizedBorders(bool disable)
 {
     if (kwin_disabledMaximizedBorders() == disable) {
         return;
     }
 
     QString disableText = disable ? "true" : "false";
 
     QProcess process;
     QString commandStr = "kwriteconfig5 --file kwinrc --group Windows --key BorderlessMaximizedWindows --type bool " + disableText;
     process.start(commandStr);
     process.waitForFinished();
 
     QDBusInterface iface("org.kde.KWin", "/KWin", "", QDBusConnection::sessionBus());
 
     if (iface.isValid()) {
         iface.call("reconfigure");
     }
 
 }
 
 bool Layout::showInMenu() const
 {
     return m_showInMenu;
 }
 
 void Layout::setShowInMenu(bool show)
 {
     if (m_showInMenu == show) {
         return;
     }
 
     m_showInMenu = show;
     emit showInMenuChanged();
 }
 
 bool Layout::isWritable() const
 {
     QFileInfo layoutFileInfo(m_layoutFile);
 
     if (layoutFileInfo.exists() && !layoutFileInfo.isWritable()) {
         return false;
     } else {
         return true;
     }
 }
 
 void Layout::lock()
 {
     QFileInfo layoutFileInfo(m_layoutFile);
 
     if (layoutFileInfo.exists() && layoutFileInfo.isWritable()) {
         QFile(m_layoutFile).setPermissions(QFileDevice::ReadUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 }
 
 void Layout::unlock()
 {
     QFileInfo layoutFileInfo(m_layoutFile);
 
     if (layoutFileInfo.exists() && !layoutFileInfo.isWritable()) {
         QFile(m_layoutFile).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 }
 
 QString Layout::background() const
 {
     return m_background;
 }
 
 void Layout::setBackground(QString path)
 {
     if (path == m_background) {
         return;
     }
 
     if (!path.isEmpty() && !QFileInfo(path).exists()) {
         return;
     }
 
     m_background = path;
 
     //! initialize the text color also
     if (path.isEmpty()) {
         setTextColor(QString());
     }
 
     emit backgroundChanged();
 }
 
 QString Layout::name() const
 {
     return m_layoutName;
 }
 
 void Layout::setName(QString name)
 {
     if (m_layoutName == name) {
         return;
     }
 
     qDebug() << "Layout name:" << name;
 
     m_layoutName = name;
 
     emit nameChanged();
 }
 
 void Layout::renameLayout(QString newName)
 {
     if (m_layoutFile != Importer::layoutFilePath(newName)) {
         setFile(Importer::layoutFilePath(newName));
     }
 
     if (m_layoutName != newName) {
         setName(newName);
     }
 
     //! thus this is a linked file
     if (m_corona) {
         foreach (auto containment, m_containments) {
             containment->config().writeEntry("layoutId", m_layoutName);
         }
     }
 }
 
 QString Layout::color() const
 {
     return m_color;
 }
 
 void Layout::setColor(QString color)
 {
     if (m_color == color) {
         return;
     }
 
     m_color = color;
     emit colorChanged();
 }
 
 QString Layout::textColor() const
 {
     //! the user is in default layout theme
     if (m_background.isEmpty()) {
         if (m_color == "blue") {
             return "#D7E3FF";
         } else if (m_color == "brown") {
             return "#F1DECB";
         } else if (m_color == "darkgrey") {
             return "#ECECEC";
         } else if (m_color == "gold") {
             return "#7C3636";
         } else if (m_color == "green") {
             return "#4D7549";
         } else if (m_color == "lightskyblue") {
             return "#0C2A43";
         } else if (m_color == "orange") {
             return "#6F3902";
         } else if (m_color == "pink") {
             return "#743C46";
         } else if (m_color == "purple") {
             return "#ECD9FF";
         }  else if (m_color == "red") {
             return "#F3E4E4";
         }  else if (m_color == "wheat") {
             return "#6A4E25";
         }  else {
             return "#FCFCFC";
         }
     }
 
     return "#" + m_textColor;
 }
 
 void Layout::setTextColor(QString color)
 {
     //! remove # if someone is trying to set it this way
     if (color.startsWith("#")) {
         color.remove(0, 1);
     }
 
     if (m_textColor == color) {
         return;
     }
 
     m_textColor = color;
     emit textColorChanged();
 }
 
 QString Layout::file() const
 {
     return m_layoutFile;
 }
 
 void Layout::setFile(QString file)
 {
     if (m_layoutFile == file) {
         return;
     }
 
     qDebug() << "Layout file:" << file;
 
     m_layoutFile = file;
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(m_layoutFile);
     m_layoutGroup = KConfigGroup(filePtr, "LayoutSettings");
 
     emit fileChanged();
 }
 
 QStringList Layout::launchers() const
 {
     return m_launchers;
 }
 
 void Layout::setLaunchers(QStringList launcherList)
 {
     if (m_launchers == launcherList)
         return;
 
     m_launchers = launcherList;
 
     emit launchersChanged();
 }
 
 QStringList Layout::activities() const
 {
     return m_activities;
 }
 
 void Layout::setActivities(QStringList activities)
 {
     if (m_activities == activities) {
         return;
     }
 
     m_activities = activities;
 
     emit activitiesChanged();
 }
 
+bool Layout::preferredForShortcutsTouched() const
+{
+    return m_preferredForShortcutsTouched;
+}
+
+void Layout::setPreferredForShortcutsTouched(bool touched)
+{
+    if (m_preferredForShortcutsTouched == touched) {
+        return;
+    }
+
+    m_preferredForShortcutsTouched = touched;
+    emit preferredForShortcutsTouchedChanged();
+}
+
 QStringList Layout::unloadedContainmentsIds()
 {
     return m_unloadedContainmentsIds;
 }
 
 bool Layout::isActiveLayout() const
 {
     if (!m_corona) {
         return false;
     }
 
     Layout *activeLayout = m_corona->layoutManager()->activeLayout(m_layoutName);
 
     if (activeLayout) {
         return true;
     } else {
         return false;
     }
 }
 
 bool Layout::isOriginalLayout() const
 {
     return m_layoutName != MultipleLayoutsName;
 }
 
 bool Layout::appletGroupIsValid(KConfigGroup appletGroup) const
 {
     return !( appletGroup.keyList().count() == 0
               && appletGroup.groupList().count() == 1
               && appletGroup.groupList().at(0) == "Configuration"
               && appletGroup.group("Configuration").keyList().count() == 1
               && appletGroup.group("Configuration").hasKey("PreloadWeight") );
 }
 
 bool Layout::layoutIsBroken() const
 {
     if (m_layoutFile.isEmpty() || !QFile(m_layoutFile).exists()) {
         return false;
     }
 
     QStringList ids;
     QStringList conts;
     QStringList applets;
 
     KSharedConfigPtr lFile = KSharedConfig::openConfig(m_layoutFile);
 
 
     if (!m_corona) {
         KConfigGroup containmentsEntries = KConfigGroup(lFile, "Containments");
         ids << containmentsEntries.groupList();
         conts << ids;
 
         foreach (auto cId, containmentsEntries.groupList()) {
             auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
             QStringList validAppletIds;
             bool updated{false};
 
             foreach (auto appletId, appletsEntries.groupList()) {
                 KConfigGroup appletGroup = appletsEntries.group(appletId);
 
                 if (appletGroupIsValid(appletGroup)) {
                     validAppletIds << appletId;
                 } else {
                     updated = true;
                     //! heal layout file by removing applet config records that are not used any more
                     qDebug() << "Layout: " << name() << " removing deprecated applet : " << appletId;
                     appletsEntries.deleteGroup(appletId);
                 }
             }
 
             if (updated) {
                 appletsEntries.sync();
             }
 
             ids << validAppletIds;
             applets << validAppletIds;
         }
     } else {
         foreach (auto containment, m_containments) {
             ids << QString::number(containment->id());
             conts << QString::number(containment->id());
 
             foreach (auto applet, containment->applets()) {
                 ids << QString::number(applet->id());
                 applets << QString::number(applet->id());
             }
         }
     }
 
     QSet<QString> idsSet = QSet<QString>::fromList(ids);
 
     /* a different way to count duplicates
     QMap<QString, int> countOfStrings;
 
     for (int i = 0; i < ids.count(); i++) {
         countOfStrings[ids[i]]++;
     }*/
 
     if (idsSet.count() != ids.count()) {
         qDebug() << "   ----   ERROR - BROKEN LAYOUT :: " << m_layoutName << " ----";
 
         if (!m_corona) {
             qDebug() << "   --- file : " << m_layoutFile;
         } else {
             if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
                 qDebug() << "   --- in multiple layouts hidden file : " << Importer::layoutFilePath(Layout::MultipleLayoutsName);
             } else {
                 qDebug() << "   --- in layout file : " << m_layoutFile;
             }
         }
 
         qDebug() << "Containments :: " << conts;
         qDebug() << "Applets :: " << applets;
 
         foreach (QString c, conts) {
             if (applets.contains(c)) {
                 qDebug() << "Error: Same applet and containment id found ::: " << c;
             }
         }
 
         for (int i = 0; i < ids.count(); ++i) {
             for (int j = i + 1; j < ids.count(); ++j) {
                 if (ids[i] == ids[j]) {
                     qDebug() << "Error: Applets with same id ::: " << ids[i];
                 }
             }
         }
 
         qDebug() << "  -- - -- - -- - -- - - -- - - - - -- - - - - ";
 
         if (!m_corona) {
             KConfigGroup containmentsEntries = KConfigGroup(lFile, "Containments");
 
             foreach (auto cId, containmentsEntries.groupList()) {
                 auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
                 qDebug() << " CONTAINMENT : " << cId << " APPLETS : " << appletsEntries.groupList();
             }
         } else {
             foreach (auto containment, m_containments) {
                 QStringList appletsIds;
 
                 foreach (auto applet, containment->applets()) {
                     appletsIds << QString::number(applet->id());
                 }
 
                 qDebug() << " CONTAINMENT : " << containment->id() << " APPLETS : " << appletsIds.join(",");
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 QString Layout::layoutName(const QString &fileName)
 {
     int lastSlash = fileName.lastIndexOf("/");
     QString tempLayoutFile = fileName;
     QString layoutName = tempLayoutFile.remove(0, lastSlash + 1);
 
     int ext = layoutName.lastIndexOf(".layout.latte");
     layoutName = layoutName.remove(ext, 13);
 
     return layoutName;
 }
 
 void Layout::loadConfig()
 {
     m_version = m_layoutGroup.readEntry("version", 2);
     m_color = m_layoutGroup.readEntry("color", QString("blue"));
     m_disableBordersForMaximizedWindows = m_layoutGroup.readEntry("disableBordersForMaximizedWindows", false);
     m_showInMenu = m_layoutGroup.readEntry("showInMenu", false);
     m_textColor = m_layoutGroup.readEntry("textColor", QString("fcfcfc"));
     m_activities = m_layoutGroup.readEntry("activities", QStringList());
     m_launchers = m_layoutGroup.readEntry("launchers", QStringList());
     m_lastUsedActivity = m_layoutGroup.readEntry("lastUsedActivity", QString());
+    m_preferredForShortcutsTouched = m_layoutGroup.readEntry("preferredForShortcutsTouched", false);
 
     QString back = m_layoutGroup.readEntry("background", "");
 
     if (!back.isEmpty()) {
         if (QFileInfo(back).exists()) {
             m_background = back;
         } else {
             m_layoutGroup.writeEntry("background", QString());
         }
     }
 
     emit activitiesChanged();
 }
 
 void Layout::saveConfig()
 {
     qDebug() << "layout is saving... for layout:" << m_layoutName;
     m_layoutGroup.writeEntry("version", m_version);
     m_layoutGroup.writeEntry("showInMenu", m_showInMenu);
     m_layoutGroup.writeEntry("color", m_color);
     m_layoutGroup.writeEntry("disableBordersForMaximizedWindows", m_disableBordersForMaximizedWindows);
     m_layoutGroup.writeEntry("launchers", m_launchers);
     m_layoutGroup.writeEntry("background", m_background);
     m_layoutGroup.writeEntry("activities", m_activities);
     m_layoutGroup.writeEntry("lastUsedActivity", m_lastUsedActivity);
     m_layoutGroup.writeEntry("textColor", m_textColor);
+    m_layoutGroup.writeEntry("preferredForShortcutsTouched", m_preferredForShortcutsTouched);
 
     m_layoutGroup.sync();
 }
 
 //! Containments Actions
 
 void Layout::addContainment(Plasma::Containment *containment)
 {
     if (!containment || m_containments.contains(containment)) {
         return;
     }
 
     bool containmentInLayout{false};
 
     if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout) {
         m_containments.append(containment);
         containmentInLayout = true;
     } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         QString layoutId = containment->config().readEntry("layoutId", QString());
 
         if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
             m_containments.append(containment);
             containmentInLayout = true;
         }
     }
 
     if (containmentInLayout) {
         if (!blockAutomaticLatteViewCreation()) {
             addView(containment);
         } else {
             qDebug() << "delaying LatteView creation for containment :: " << containment->id();
         }
 
         connect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
     }
 }
 
 QHash<const Plasma::Containment *, Latte::View *> *Layout::latteViews()
 {
     return &m_latteViews;
 }
 
 QList<Plasma::Containment *> *Layout::containments()
 {
     return &m_containments;
 }
 
 QList<Latte::View *> Layout::viewsWithPlasmaShortcuts()
 {
     QList<Latte::View *> views;
 
     if (!m_corona) {
         return views;
     }
 
     QList<int> appletsWithShortcuts = m_corona->globalShortcuts()->shortcutsTracker()->appletsWithPlasmaShortcuts();
 
     foreach(auto appletId, appletsWithShortcuts) {
         foreach(auto view, m_latteViews) {
             bool found{false};
             foreach(auto applet, view->containment()->applets()) {
                 if (appletId == applet->id()) {
                     if (!views.contains(view)) {
                         views.append(view);
                         found = true;
                         break;
                     }
                 }
             }
 
             if (found) {
                 break;
             }
         }
     }
 
     return views;
 }
 
 const QStringList Layout::appliedActivities()
 {
     if (!m_corona) {
         return {};
     }
 
     if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout) {
         return {"0"};
     } else if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         if (m_activities.isEmpty()) {
             return m_corona->layoutManager()->orphanedActivities();
         } else {
             return m_activities;
         }
     } else {
         return {"0"};
     }
 }
 
 QString Layout::lastUsedActivity()
 {
     return m_lastUsedActivity;
 }
 
 void Layout::clearLastUsedActivity()
 {
     m_lastUsedActivity = "";
     emit lastUsedActivityChanged();
 }
 
 void Layout::updateLastUsedActivity()
 {
     if (!m_corona) {
         return;
     }
 
     if (!m_lastUsedActivity.isEmpty() && !m_corona->layoutManager()->activities().contains(m_lastUsedActivity)) {
         clearLastUsedActivity();
     }
 
     QString currentId = m_corona->activitiesConsumer()->currentActivity();
 
     QStringList appliedActivitiesIds = appliedActivities();
 
     if (m_lastUsedActivity != currentId
         && (appliedActivitiesIds.contains(currentId)
             || m_corona->layoutManager()->memoryUsage() == Types::SingleLayout)) {
         m_lastUsedActivity = currentId;
 
         emit lastUsedActivityChanged();
     }
 }
 
 void Layout::destroyedChanged(bool destroyed)
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "dock containment destroyed changed!!!!";
     Plasma::Containment *sender = qobject_cast<Plasma::Containment *>(QObject::sender());
 
     if (!sender) {
         return;
     }
 
     if (destroyed) {
         m_waitingLatteViews[sender] = m_latteViews.take(static_cast<Plasma::Containment *>(sender));
     } else {
         m_latteViews[sender] = m_waitingLatteViews.take(static_cast<Plasma::Containment *>(sender));
     }
 
     emit viewsCountChanged();
 }
 
 void Layout::containmentDestroyed(QObject *cont)
 {
     if (!m_corona) {
         return;
     }
 
     Plasma::Containment *containment = static_cast<Plasma::Containment *>(cont);
 
     if (containment) {
         int containmentIndex = m_containments.indexOf(containment);
 
         if (containmentIndex >= 0) {
             m_containments.removeAt(containmentIndex);
         }
 
         qDebug() << "Layout " << name() << " :: containment destroyed!!!!";
         auto view = m_latteViews.take(containment);
 
         if (!view) {
             view = m_waitingLatteViews.take(containment);
         }
 
         if (view) {
             view->disconnectSensitiveSignals();
 
             view->deleteLater();
 
             emit viewsCountChanged();
         }
     }
 }
 
 void Layout::addView(Plasma::Containment *containment, bool forceOnPrimary, int explicitScreen)
 {
     qDebug() << "Layout :::: " << m_layoutName << " ::: addView was called... m_containments :: " << m_containments.size();
 
     if (!containment || !m_corona || !containment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     qDebug() << "step 1...";
 
     if (!isLatteContainment(containment))
         return;
 
     qDebug() << "step 2...";
 
     for (auto *dock : m_latteViews) {
         if (dock->containment() == containment)
             return;
     }
 
     qDebug() << "step 3...";
 
     QScreen *nextScreen{qGuiApp->primaryScreen()};
 
     bool onPrimary = containment->config().readEntry("onPrimary", true);
     int id = containment->screen();
 
     if (id == -1 && explicitScreen == -1) {
         id = containment->lastScreen();
     }
 
     if (explicitScreen > -1) {
         id = explicitScreen;
     }
 
     qDebug() << "add dock - containment id: " << containment->id() << " ,screen : " << id << " - " << m_corona->screenPool()->connector(id)
              << " ,onprimary:" << onPrimary << " - " << qGuiApp->primaryScreen()->name() << " ,forceOnPrimary:" << forceOnPrimary;
 
     if (id >= 0 && !onPrimary && !forceOnPrimary) {
         QString connector = m_corona->screenPool()->connector(id);
         qDebug() << "add dock - connector : " << connector;
         bool found{false};
 
         foreach (auto scr, qGuiApp->screens()) {
             if (scr && scr->name() == connector) {
                 found = true;
                 nextScreen = scr;
                 break;
             }
         }
 
         if (!found) {
             qDebug() << "reject : adding explicit dock, screen not available ! : " << connector;
             return;
         }
 
         //! explicit dock can not be added at explicit screen when that screen is the same with
         //! primary screen and that edge is already occupied by a primary dock
         if (nextScreen == qGuiApp->primaryScreen() && primaryDockOccupyEdge(containment->location())) {
             qDebug() << "reject : adding explicit dock, primary dock occupies edge at screen ! : " << connector;
             return;
         }
     }
 
     if (id >= 0 && onPrimary) {
         QString connector = m_corona->screenPool()->connector(id);
         qDebug() << "add dock - connector : " << connector;
 
         foreach (auto view, m_latteViews) {
             auto testContainment = view->containment();
 
             int testScreenId = testContainment->screen();
 
             if (testScreenId == -1) {
                 testScreenId = testContainment->lastScreen();
             }
 
             bool testOnPrimary = testContainment->config().readEntry("onPrimary", true);
             Plasma::Types::Location testLocation = static_cast<Plasma::Types::Location>((int)testContainment->config().readEntry("location", (int)Plasma::Types::BottomEdge));
 
             if (!testOnPrimary && m_corona->screenPool()->primaryScreenId() == testScreenId && testLocation == containment->location()) {
                 qDebug() << "Rejected explicit latteView and removing it in order add an onPrimary with higher priority at screen: " << connector;
                 auto viewToDelete = m_latteViews.take(testContainment);
                 viewToDelete->disconnectSensitiveSignals();
                 viewToDelete->deleteLater();
             }
         }
     }
 
     /* old behavior to not add primary docks on explicit one
         else if (onPrimary) {
         if (explicitDockOccupyEdge(m_corona->screenPool()->primaryScreenId(), containment->location())) {
             qDebug() << "CORONA ::: adding dock rejected, the edge is occupied by explicit dock ! : " <<  containment->location();
             //we must check that an onPrimary dock should never catch up the same edge on
             //the same screen with an explicit dock
             return;
         }
     }*/
 
     qDebug() << "Adding dock for container...";
     qDebug() << "onPrimary: " << onPrimary << "screen!!! :" << nextScreen->name();
 
     //! it is used to set the correct flag during the creation
     //! of the window... This of course is also used during
     //! recreations of the window between different visibility modes
     auto mode = static_cast<Types::Visibility>(containment->config().readEntry("visibility", static_cast<int>(Types::DodgeActive)));
     bool byPassWM{false};
 
     if (mode == Types::AlwaysVisible || mode == Types::WindowsGoBelow) {
         byPassWM = false;
     } else {
         byPassWM = containment->config().readEntry("byPassWM", false);
     }
 
     auto latteView = new Latte::View(m_corona, nextScreen, byPassWM);
 
     latteView->init();
     latteView->setContainment(containment);
     latteView->setManagedLayout(this);
 
     //! force this special dock case to become primary
     //! even though it isnt
     if (forceOnPrimary) {
         qDebug() << "Enforcing onPrimary:true as requested for LatteView...";
         latteView->setOnPrimary(true);
     }
 
     //  connect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
     connect(containment, &Plasma::Applet::destroyedChanged, this, &Layout::destroyedChanged);
     connect(containment, &Plasma::Applet::locationChanged, m_corona, &Latte::Corona::viewLocationChanged);
     connect(containment, &Plasma::Containment::appletAlternativesRequested
             , m_corona, &Latte::Corona::showAlternativesForApplet, Qt::QueuedConnection);
 
     if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         connect(containment, &Plasma::Containment::appletCreated, this, &Layout::appletCreated);
     }
 
     //! Qt 5.9 creates a crash for this in wayland, that is why the check is used
     //! but on the other hand we need this for copy to work correctly and show
     //! the copied dock under X11
     //if (!KWindowSystem::isPlatformWayland()) {
     latteView->show();
     //}
 
     m_latteViews[containment] = latteView;
 
     emit viewsCountChanged();
 }
 
 void Layout::addNewView()
 {
     if (!m_corona) {
         return;
     }
 
     m_corona->loadDefaultLayout();
 }
 
 void Layout::copyView(Plasma::Containment *containment)
 {
     if (!containment || !m_corona)
         return;
 
     qDebug() << "copying containment layout";
     //! Setting mutable for create a containment
     m_corona->setImmutability(Plasma::Types::Mutable);
 
     QString temp1File = QDir::homePath() + "/.config/lattedock.copy1.bak";
 
     //! WE NEED A WAY TO COPY A CONTAINMENT!!!!
     QFile copyFile(temp1File);
 
     if (copyFile.exists())
         copyFile.remove();
 
 
     KSharedConfigPtr newFile = KSharedConfig::openConfig(temp1File);
     KConfigGroup copied_conts = KConfigGroup(newFile, "Containments");
     KConfigGroup copied_c1 = KConfigGroup(&copied_conts, QString::number(containment->id()));
     KConfigGroup copied_systray;
 
     // toCopyContainmentIds << QString::number(containment->id());
     //  toCopyAppletIds << containment->config().group("Applets").groupList();
     containment->config().copyTo(&copied_c1);
 
     //!investigate if there is a systray in the containment to copy also
     int systrayId = -1;
     QString systrayAppletId;
     auto applets = containment->config().group("Applets");
 
     foreach (auto applet, applets.groupList()) {
         KConfigGroup appletSettings = applets.group(applet).group("Configuration");
 
         int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
         if (tSysId != -1) {
             systrayId = tSysId;
             systrayAppletId = applet;
             qDebug() << "systray was found in the containment... ::: " << tSysId;
             break;
         }
     }
 
     if (systrayId != -1) {
         Plasma::Containment *systray{nullptr};
 
         foreach (auto containment, m_corona->containments()) {
             if (containment->id() == systrayId) {
                 systray = containment;
                 break;
             }
         }
 
         if (systray) {
             copied_systray = KConfigGroup(&copied_conts, QString::number(systray->id()));
             //  toCopyContainmentIds << QString::number(systray->id());
             //  toCopyAppletIds << systray->config().group("Applets").groupList();
             systray->config().copyTo(&copied_systray);
         }
     }
 
     //! end of systray specific code
 
     //! update ids to unique ones
     QString temp2File = newUniqueIdsLayoutFromFile(temp1File);
 
 
     //! Don't create LatteView when the containment is created because we must update
     //! its screen settings first
     setBlockAutomaticLatteViewCreation(true);
     //! Finally import the configuration
     QList<Plasma::Containment *> importedDocks = importLayoutFile(temp2File);
 
     Plasma::Containment *newContainment{nullptr};
 
     if (importedDocks.size() == 1) {
         newContainment = importedDocks[0];
     }
 
     if (!newContainment || !newContainment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto config = newContainment->config();
 
     //in multi-screen environment the copied dock is moved to alternative screens first
     const auto screens = qGuiApp->screens();
     auto dock = m_latteViews[containment];
 
     bool setOnExplicitScreen = false;
 
     int dockScrId = -1;
     int copyScrId = -1;
 
     if (dock) {
         dockScrId = dock->positioner()->currentScreenId();
         qDebug() << "COPY DOCK SCREEN ::: " << dockScrId;
 
         if (dockScrId != -1 && screens.count() > 1) {
             foreach (auto scr, screens) {
                 copyScrId = m_corona->screenPool()->id(scr->name());
 
                 //the screen must exist and not be the same with the original dock
                 if (copyScrId > -1 && copyScrId != dockScrId) {
                     QList<Plasma::Types::Location> fEdges = freeEdges(copyScrId);
 
                     if (fEdges.contains((Plasma::Types::Location)containment->location())) {
                         ///set this containment to an explicit screen
                         config.writeEntry("onPrimary", false);
                         config.writeEntry("lastScreen", copyScrId);
                         newContainment->setLocation(containment->location());
 
                         qDebug() << "COPY DOCK SCREEN NEW SCREEN ::: " << copyScrId;
 
                         setOnExplicitScreen = true;
                         break;
                     }
                 }
             }
         }
     }
 
     if (!setOnExplicitScreen) {
         QList<Plasma::Types::Location> edges = freeEdges(newContainment->screen());
 
         if (edges.count() > 0) {
             newContainment->setLocation(edges.at(0));
         } else {
             newContainment->setLocation(Plasma::Types::BottomEdge);
         }
 
         config.writeEntry("onPrimary", false);
         config.writeEntry("lastScreen", dockScrId);
     }
 
     newContainment->config().sync();
 
     if (setOnExplicitScreen && copyScrId > -1) {
         qDebug() << "Copy Dock in explicit screen ::: " << copyScrId;
         addView(newContainment, false, copyScrId);
         newContainment->reactToScreenChange();
     } else {
         qDebug() << "Copy Dock in current screen...";
         addView(newContainment, false, dockScrId);
     }
 
     setBlockAutomaticLatteViewCreation(false);
 }
 
 void Layout::appletCreated(Plasma::Applet *applet)
 {
     //! In Multiple Layout the orphaned systrays must be assigned to layouts
     //! when the user adds them
     KConfigGroup appletSettings = applet->containment()->config().group("Applets").group(QString::number(applet->id())).group("Configuration");
 
     int systrayId = appletSettings.readEntry("SystrayContainmentId", -1);
 
     if (systrayId != -1) {
         uint sId = (uint)systrayId;
 
         foreach (auto containment, m_corona->containments()) {
             if (containment->id() == sId) {
                 containment->config().writeEntry("layoutId", m_layoutName);
             }
 
             addContainment(containment);
         }
     }
 }
 
 void Layout::importToCorona()
 {
     if (!m_corona) {
         return;
     }
 
     //! Setting mutable for create a containment
     m_corona->setImmutability(Plasma::Types::Mutable);
 
     QString temp1FilePath = QDir::homePath() + "/.config/lattedock.copy1.bak";
     //! we need to copy first the layout file because the kde cache
     //! may not have yet been updated (KSharedConfigPtr)
     //! this way we make sure at the latest changes stored in the layout file
     //! will be also available when changing to Multiple Layouts
     QString tempLayoutFilePath = QDir::homePath() + "/.config/lattedock.layout.bak";
 
     //! WE NEED A WAY TO COPY A CONTAINMENT!!!!
     QFile tempLayoutFile(tempLayoutFilePath);
     QFile copyFile(temp1FilePath);
     QFile layoutOriginalFile(m_layoutFile);
 
     if (tempLayoutFile.exists()) {
         tempLayoutFile.remove();
     }
 
     if (copyFile.exists())
         copyFile.remove();
 
     layoutOriginalFile.copy(tempLayoutFilePath);
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(tempLayoutFilePath);
     KSharedConfigPtr newFile = KSharedConfig::openConfig(temp1FilePath);
     KConfigGroup copyGroup = KConfigGroup(newFile, "Containments");
     KConfigGroup current_containments = KConfigGroup(filePtr, "Containments");
 
     current_containments.copyTo(&copyGroup);
 
     copyGroup.sync();
 
     //! update ids to unique ones
     QString temp2File = newUniqueIdsLayoutFromFile(temp1FilePath);
 
 
     //! Finally import the configuration
     importLayoutFile(temp2File);
 }
 
 QString Layout::availableId(QStringList all, QStringList assigned, int base)
 {
     bool found = false;
 
     int i = base;
 
     while (!found && i < 32000) {
         QString iStr = QString::number(i);
 
         if (!all.contains(iStr) && !assigned.contains(iStr)) {
             return iStr;
         }
 
         i++;
     }
 
     return QString("");
 }
 
 QString Layout::newUniqueIdsLayoutFromFile(QString file)
 {
     if (!m_corona) {
         return QString();
     }
 
     QString tempFile = QDir::homePath() + "/.config/lattedock.copy2.bak";
 
     QFile copyFile(tempFile);
 
     if (copyFile.exists())
         copyFile.remove();
 
     //! BEGIN updating the ids in the temp file
     QStringList allIds;
     allIds << m_corona->containmentsIds();
     allIds << m_corona->appletsIds();
 
     QStringList toInvestigateContainmentIds;
     QStringList toInvestigateAppletIds;
     QStringList toInvestigateSystrayContIds;
 
     //! first is the systray containment id
     QHash<QString, QString> systrayParentContainmentIds;
     QHash<QString, QString> systrayAppletIds;
 
     //qDebug() << "Ids:" << allIds;
 
     //qDebug() << "to copy containments: " << toCopyContainmentIds;
     //qDebug() << "to copy applets: " << toCopyAppletIds;
 
     QStringList assignedIds;
     QHash<QString, QString> assigned;
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(file);
     KConfigGroup investigate_conts = KConfigGroup(filePtr, "Containments");
     //KConfigGroup copied_c1 = KConfigGroup(&copied_conts, QString::number(containment->id()));
 
     //! Record the containment and applet ids
     foreach (auto cId, investigate_conts.groupList()) {
         toInvestigateContainmentIds << cId;
         auto appletsEntries = investigate_conts.group(cId).group("Applets");
         toInvestigateAppletIds << appletsEntries.groupList();
 
         //! investigate for systrays
         foreach (auto appletId, appletsEntries.groupList()) {
             KConfigGroup appletSettings = appletsEntries.group(appletId).group("Configuration");
 
             int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
             //! It is a systray !!!
             if (tSysId != -1) {
                 QString tSysIdStr = QString::number(tSysId);
                 toInvestigateSystrayContIds << tSysIdStr;
                 systrayParentContainmentIds[tSysIdStr] = cId;
                 systrayAppletIds[tSysIdStr] = appletId;
                 qDebug() << "systray was found in the containment...";
             }
         }
     }
 
     //! Reassign containment and applet ids to unique ones
     foreach (auto contId, toInvestigateContainmentIds) {
         QString newId = availableId(allIds, assignedIds, 12);
 
         assignedIds << newId;
         assigned[contId] = newId;
     }
 
     foreach (auto appId, toInvestigateAppletIds) {
         QString newId = availableId(allIds, assignedIds, 40);
 
         assignedIds << newId;
         assigned[appId] = newId;
     }
 
     qDebug() << "ALL CORONA IDS ::: " << allIds;
     qDebug() << "FULL ASSIGNMENTS ::: " << assigned;
 
     foreach (auto cId, toInvestigateContainmentIds) {
         QString value = assigned[cId];
 
         if (assigned.contains(value)) {
             QString value2 = assigned[value];
 
             if (cId != assigned[cId] && !value2.isEmpty() && cId == value2) {
                 qDebug() << "PROBLEM APPEARED !!!! FOR :::: " << cId << " .. fixed ..";
                 assigned[cId] = cId;
                 assigned[value] = value;
             }
         }
     }
 
     foreach (auto aId, toInvestigateAppletIds) {
         QString value = assigned[aId];
 
         if (assigned.contains(value)) {
             QString value2 = assigned[value];
 
             if (aId != assigned[aId] && !value2.isEmpty() && aId == value2) {
                 qDebug() << "PROBLEM APPEARED !!!! FOR :::: " << aId << " .. fixed ..";
                 assigned[aId] = aId;
                 assigned[value] = value;
             }
         }
     }
 
     qDebug() << "FIXED FULL ASSIGNMENTS ::: " << assigned;
 
     //! update applet ids in their containment order and in MultipleLayouts update also the layoutId
     foreach (auto cId, investigate_conts.groupList()) {
         //! Update options that contain applet ids
         //! (appletOrder) and (lockedZoomApplets) and (userBlocksColorizingApplets)
         QStringList options;
         options << "appletOrder" << "lockedZoomApplets" << "userBlocksColorizingApplets";
 
         foreach (auto settingStr, options) {
             QString order1 = investigate_conts.group(cId).group("General").readEntry(settingStr, QString());
 
             if (!order1.isEmpty()) {
                 QStringList order1Ids = order1.split(";");
                 QStringList fixedOrder1Ids;
 
                 for (int i = 0; i < order1Ids.count(); ++i) {
                     fixedOrder1Ids.append(assigned[order1Ids[i]]);
                 }
 
                 QString fixedOrder1 = fixedOrder1Ids.join(";");
                 investigate_conts.group(cId).group("General").writeEntry(settingStr, fixedOrder1);
             }
         }
 
         if (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
             investigate_conts.group(cId).writeEntry("layoutId", m_layoutName);
         }
     }
 
     //! must update also the systray id in its applet
     foreach (auto systrayId, toInvestigateSystrayContIds) {
         KConfigGroup systrayParentContainment = investigate_conts.group(systrayParentContainmentIds[systrayId]);
         systrayParentContainment.group("Applets").group(systrayAppletIds[systrayId]).group("Configuration").writeEntry("SystrayContainmentId", assigned[systrayId]);
         systrayParentContainment.sync();
     }
 
     investigate_conts.sync();
 
     //! Copy To Temp 2 File And Update Correctly The Ids
     KSharedConfigPtr file2Ptr = KSharedConfig::openConfig(tempFile);
     KConfigGroup fixedNewContainmets = KConfigGroup(file2Ptr, "Containments");
 
     foreach (auto contId, investigate_conts.groupList()) {
         QString pluginId = investigate_conts.group(contId).readEntry("plugin", "");
 
         if (pluginId != "org.kde.desktopcontainment") { //!don't add ghost containments
             KConfigGroup newContainmentGroup = fixedNewContainmets.group(assigned[contId]);
             investigate_conts.group(contId).copyTo(&newContainmentGroup);
 
             newContainmentGroup.group("Applets").deleteGroup();
 
             foreach (auto appId, investigate_conts.group(contId).group("Applets").groupList()) {
                 KConfigGroup appletGroup = investigate_conts.group(contId).group("Applets").group(appId);
                 KConfigGroup newAppletGroup = fixedNewContainmets.group(assigned[contId]).group("Applets").group(assigned[appId]);
                 appletGroup.copyTo(&newAppletGroup);
             }
         }
     }
 
     fixedNewContainmets.sync();
 
     return tempFile;
 }
 
 QList<Plasma::Containment *> Layout::importLayoutFile(QString file)
 {
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(file);
     auto newContainments = m_corona->importLayout(KConfigGroup(filePtr, ""));
 
     ///Find latte and systray containments
     qDebug() << " imported containments ::: " << newContainments.length();
 
     QList<Plasma::Containment *> importedDocks;
     //QList<Plasma::Containment *> systrays;
 
     foreach (auto containment, newContainments) {
         if (isLatteContainment(containment)) {
             qDebug() << "new latte containment id: " << containment->id();
             importedDocks << containment;
         }
     }
 
     ///after systrays were found we must update in latte the relevant ids
     /*if (!systrays.isEmpty()) {
         foreach (auto systray, systrays) {
             qDebug() << "systray found with id : " << systray->id();
             Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(systray->parent());
 
             if (parentApplet) {
                 KConfigGroup appletSettings = parentApplet->config().group("Configuration");
 
                 if (appletSettings.hasKey("SystrayContainmentId")) {
                     qDebug() << "!!! updating systray id to : " << systray->id();
                     appletSettings.writeEntry("SystrayContainmentId", systray->id());
                 }
             }
         }
     }*/
 
     return importedDocks;
 }
 
 void Layout::recreateView(Plasma::Containment *containment)
 {
     if (!m_corona) {
         return;
     }
 
     //! give the time to config window to close itself first and then recreate the dock
     //! step:1 remove the latteview
     QTimer::singleShot(350, [this, containment]() {
         auto view = m_latteViews.take(containment);
 
         if (view) {
             qDebug() << "recreate - step 1: removing dock for containment:" << containment->id();
 
             //! step:2 add the new latteview
             connect(view, &QObject::destroyed, this, [this, containment]() {
                 QTimer::singleShot(250, this, [this, containment]() {
                     if (!m_latteViews.contains(containment)) {
                         qDebug() << "recreate - step 2: adding dock for containment:" << containment->id();
                         addView(containment);
                     }
                 });
             });
 
             view->deleteLater();
         }
     });
 }
 
 //! the central functions that updates loading/unloading latteviews
 //! concerning screen changed (for multi-screen setups mainly)
 void Layout::syncLatteViewsToScreens()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "start of, syncLatteViewsToScreens ....";
     qDebug() << "LAYOUT ::: " << name();
     qDebug() << "screen count changed -+-+ " << qGuiApp->screens().size();
 
     QHash<QString, QList<Plasma::Types::Location>> futureDocksLocations;
     QList<uint> futureShownViews;
     QString prmScreenName = qGuiApp->primaryScreen()->name();
 
     //! first step: primary docks must be placed in primary screen free edges
     foreach (auto containment, m_containments) {
         if (isLatteContainment(containment)) {
             int screenId = containment->screen();
 
             if (screenId == -1) {
                 screenId = containment->lastScreen();
             }
 
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             Plasma::Types::Location location = static_cast<Plasma::Types::Location>((int)containment->config().readEntry("location", (int)Plasma::Types::BottomEdge));
 
             if (onPrimary && !futureDocksLocations[prmScreenName].contains(location)) {
                 futureDocksLocations[prmScreenName].append(location);
                 futureShownViews.append(containment->id());
             }
         }
     }
 
     //! second step: explicit docks must be placed in their screens if the screen edge is free
     foreach (auto containment, m_containments) {
         if (isLatteContainment(containment)) {
             int screenId = containment->screen();
 
             if (screenId == -1) {
                 screenId = containment->lastScreen();
             }
 
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             Plasma::Types::Location location = static_cast<Plasma::Types::Location>((int)containment->config().readEntry("location", (int)Plasma::Types::BottomEdge));
 
             if (!onPrimary) {
                 QString expScreenName = m_corona->screenPool()->connector(screenId);
 
                 if (m_corona->screenPool()->screenExists(screenId) && !futureDocksLocations[expScreenName].contains(location)) {
                     futureDocksLocations[expScreenName].append(location);
                     futureShownViews.append(containment->id());
                 }
             }
         }
     }
 
     qDebug() << "PRIMARY SCREEN :: " << prmScreenName;
     qDebug() << "LATTEVIEWS MUST BE PRESENT AT :: " << futureDocksLocations;
     qDebug() << "FUTURESHOWNVIEWS MUST BE :: " << futureShownViews;
 
     //! add views
     foreach (auto containment, m_containments) {
         int screenId = containment->screen();
 
         if (screenId == -1) {
             screenId = containment->lastScreen();
         }
 
         if (!latteViewExists(containment) && futureShownViews.contains(containment->id())) {
             qDebug() << "syncLatteViewsToScreens: view must be added... for containment:" << containment->id() << " at screen:" << m_corona->screenPool()->connector(screenId);
             addView(containment);
         }
     }
 
     //! remove views
     foreach (auto view, m_latteViews) {
         if (view->containment() && !futureShownViews.contains(view->containment()->id())) {
             qDebug() << "syncLatteViewsToScreens: view must be deleted... for containment:" << view->containment()->id() << " at screen:" << view->positioner()->currentScreenName();
             auto viewToDelete = m_latteViews.take(view->containment());
             viewToDelete->disconnectSensitiveSignals();
             viewToDelete->deleteLater();
         }
     }
 
     //! reconsider views
     foreach (auto view, m_latteViews) {
         if (view->containment() && futureShownViews.contains(view->containment()->id())) {
             //! if the dock will not be deleted its a very good point to reconsider
             //! if the screen in which is running is the correct one
             view->reconsiderScreen();
         }
     }
 
     qDebug() << "end of, syncLatteViewsToScreens ....";
 }
 
 void Layout::assignToLayout(Latte::View *latteView, QList<Plasma::Containment *> containments)
 {
     if (!m_corona) {
         return;
     }
 
     if (latteView) {
         m_latteViews[latteView->containment()] = latteView;
         m_containments << containments;
 
         foreach (auto containment, containments) {
             containment->config().writeEntry("layoutId", name());
 
             connect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
             connect(containment, &Plasma::Applet::destroyedChanged, this, &Layout::destroyedChanged);
             connect(containment, &Plasma::Containment::appletCreated, this, &Layout::appletCreated);
         }
 
         latteView->setManagedLayout(this);
 
         emit viewsCountChanged();
     }
 
     //! sync the original layout file for integrity
     if (m_corona && m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         syncToLayoutFile(false);
     }
 }
 
 QList<Plasma::Containment *> Layout::unassignFromLayout(Latte::View *latteView)
 {
     QList<Plasma::Containment *> containments;
 
     if (!m_corona) {
         return containments;
     }
 
     containments << latteView->containment();
 
     foreach (auto containment, m_containments) {
         Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent());
 
         //! add systrays from that latteView
         if (parentApplet && parentApplet->containment() && parentApplet->containment() == latteView->containment()) {
             containments << containment;
             disconnect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
             disconnect(containment, &Plasma::Applet::destroyedChanged, this, &Layout::destroyedChanged);
             disconnect(containment, &Plasma::Containment::appletCreated, this, &Layout::appletCreated);
         }
     }
 
     foreach (auto containment, containments) {
         m_containments.removeAll(containment);
     }
 
     if (containments.size() > 0) {
         m_latteViews.remove(latteView->containment());
     }
 
     //! sync the original layout file for integrity
     if (m_corona && m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         syncToLayoutFile(false);
     }
 
     return containments;
 }
 
 bool Layout::latteViewExists(Plasma::Containment *containment)
 {
     if (!m_corona) {
         return false;
     }
 
     return m_latteViews.keys().contains(containment);
 }
 
 QList<Plasma::Types::Location> Layout::availableEdgesForView(QScreen *scr, Latte::View *forView) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                  Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     foreach (auto view, m_latteViews) {
         //! make sure that availabe edges takes into account only views that should be excluded,
         //! this is why the forView should not be excluded
         if (view && view != forView && view->positioner()->currentScreenName() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 QList<int> Layout::qmlFreeEdges(int screen) const
 {
     if (!m_corona) {
         const QList<int> emptyEdges;
         return emptyEdges;
     }
 
     const auto edges = freeEdges(screen);
     QList<int> edgesInt;
 
     foreach (Plasma::Types::Location edge, edges) {
         edgesInt.append(static_cast<int>(edge));
     }
 
     return edgesInt;
 }
 
 QList<Plasma::Types::Location> Layout::freeEdges(QScreen *scr) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                  Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     foreach (auto view, m_latteViews) {
         if (view && view->positioner()->currentScreenName() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 QList<Plasma::Types::Location> Layout::freeEdges(int screen) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                  Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     QScreen *scr = m_corona->screenPool()->screenForId(screen);
 
     foreach (auto view, m_latteViews) {
         if (view && scr && view->positioner()->currentScreenName() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 bool Layout::explicitDockOccupyEdge(int screen, Plasma::Types::Location location) const
 {
     if (!m_corona) {
         return false;
     }
 
     foreach (auto containment, m_containments) {
         if (isLatteContainment(containment)) {
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             int id = containment->lastScreen();
             Plasma::Types::Location contLocation = containment->location();
 
             if (!onPrimary && id == screen && contLocation == location) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool Layout::primaryDockOccupyEdge(Plasma::Types::Location location) const
 {
     if (!m_corona) {
         return false;
     }
 
     foreach (auto containment, m_containments) {
         if (isLatteContainment(containment)) {
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             Plasma::Types::Location contLocation = containment->location();
 
             if (onPrimary && contLocation == location) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool Layout::isLatteContainment(Plasma::Containment *containment) const
 {
     if (!containment) {
         return false;
     }
 
     if (containment->pluginMetaData().pluginId() == "org.kde.latte.containment") {
         return true;
     }
 
     return false;
 }
 
 int Layout::viewsWithTasks() const
 {
     if (!m_corona) {
         return 0;
     }
 
     int result = 0;
 
     foreach (auto view, m_latteViews) {
         if (view->tasksPresent()) {
             result++;
         }
     }
 
     return result;
 }
 
 int Layout::viewsCount(int screen) const
 {
     if (!m_corona) {
         return 0;
     }
 
     QScreen *scr = m_corona->screenPool()->screenForId(screen);
 
     int docks{0};
 
     foreach (auto view, m_latteViews) {
         if (view && view->screen() == scr && !view->containment()->destroyed()) {
             ++docks;
         }
     }
 
     return docks;
 }
 
 int Layout::viewsCount(QScreen *screen) const
 {
     if (!m_corona) {
         return 0;
     }
 
     int docks{0};
 
     foreach (auto view, m_latteViews) {
         if (view && view->screen() == screen && !view->containment()->destroyed()) {
             ++docks;
         }
     }
 
     return docks;
 }
 
 int Layout::viewsCount() const
 {
     if (!m_corona) {
         return 0;
     }
 
     int docks{0};
 
     foreach (auto view, m_latteViews) {
         if (view && view->containment() && !view->containment()->destroyed()) {
             ++docks;
         }
     }
 
     return docks;
 }
 
 }
diff --git a/app/layout/layout.h b/app/layout/layout.h
index 02438bf3..89fa6646 100644
--- a/app/layout/layout.h
+++ b/app/layout/layout.h
@@ -1,264 +1,271 @@
 /*
 *  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 LAYOUT_H
 #define LAYOUT_H
 
 // Qt
 #include <QObject>
 #include <QPointer>
 #include <QScreen>
 
 // KDE
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 // Plasma
 #include <Plasma>
 
 namespace Plasma {
 class Applet;
 class Containment;
 class Types;
 }
 
 namespace Latte {
 class Corona;
 class View;
 namespace LayoutPart {
 class Shortcuts;
 }
 }
 
 namespace Latte {
 
 //! This class is responsible to hold the settings for a specific layout.
 //! It also updates always the relevant layout configuration concerning
 //! its general settings (no the containments)
 class Layout : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool showInMenu READ showInMenu WRITE setShowInMenu NOTIFY showInMenuChanged)
 
     Q_PROPERTY(int viewsCount READ viewsCount NOTIFY viewsCountChanged)
 
     Q_PROPERTY(QString background READ background NOTIFY backgroundChanged)
     Q_PROPERTY(QString color READ color WRITE setColor NOTIFY colorChanged)
     Q_PROPERTY(QString lastUsedActivity READ lastUsedActivity NOTIFY lastUsedActivityChanged)
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
     Q_PROPERTY(QString textColor READ textColor NOTIFY textColorChanged)
     Q_PROPERTY(QStringList launchers READ launchers WRITE setLaunchers NOTIFY launchersChanged)
     Q_PROPERTY(QStringList activities READ activities WRITE setActivities NOTIFY activitiesChanged)
 
+    Q_PROPERTY(bool preferredForShortcutsTouched READ preferredForShortcutsTouched WRITE setPreferredForShortcutsTouched NOTIFY preferredForShortcutsTouchedChanged)
+
 public:
     Layout(QObject *parent, QString layoutFile, QString layoutName = QString());
     ~Layout() override;
 
     static const QString MultipleLayoutsName;
 
     void initToCorona(Latte::Corona *corona);
     void syncToLayoutFile(bool removeLayoutId = false);
     void unloadContainments();
     void unloadLatteViews();
 
     bool disableBordersForMaximizedWindows() const;
     void setDisableBordersForMaximizedWindows(bool disable);
 
     bool showInMenu() const;
     void setShowInMenu(bool show);
 
     bool layoutIsBroken() const;
 
     //!this layout is loaded and running
     bool isActiveLayout() const;
     //!it is original layout compared to pseudo-layouts that are combinations of multiple-original layouts
     bool isOriginalLayout() const;
 
     bool isWritable() const;
 
     bool latteViewExists(Plasma::Containment *containment);
 
     int version() const;
     void setVersion(int ver);
 
     QString background() const;
     void setBackground(QString path);
 
     QString color() const;
     void setColor(QString color);
 
     QString lastUsedActivity();
     void clearLastUsedActivity(); //!e.g. when we export a layout
 
     QString name() const;
     QString file() const;
 
     QString textColor() const;
     void setTextColor(QString color);
 
     QStringList activities() const;
     void setActivities(QStringList activities);
 
     QStringList launchers() const;
     void setLaunchers(QStringList launcherList);
 
     static QString layoutName(const QString &fileName);
 
     void renameLayout(QString newName);
 
     QStringList unloadedContainmentsIds();
 
     //! this function needs the layout to have first set the corona through initToCorona() function
     void addView(Plasma::Containment *containment, bool forceOnPrimary = false, int explicitScreen = -1);
     void copyView(Plasma::Containment *containment);
     void recreateView(Plasma::Containment *containment);
 
     void syncLatteViewsToScreens();
     void importToCorona();
 
     const QStringList appliedActivities();
 
     QList<Plasma::Containment *> *containments();
     QList<Latte::View *> viewsWithPlasmaShortcuts();
     QHash<const Plasma::Containment *, Latte::View *> *latteViews();
 
     //! Bind this latteView and its relevant containments(including systrays)
     //! to this layout. It is used for moving a Latte::View from layout to layout)
     void assignToLayout(Latte::View *latteView, QList<Plasma::Containment *> containments);
 
     //! Unassign that latteView from this layout (this is used for moving a latteView
     //! from layout to layout) and returns all the containments relevant to
     //! that latteView
     QList<Plasma::Containment *> unassignFromLayout(Latte::View *latteView);
 
     //! Available edges for specific view in that screen
     QList<Plasma::Types::Location> availableEdgesForView(QScreen *scr, Latte::View *forView) const;
 
     //! All free edges in that screen
     QList<Plasma::Types::Location> freeEdges(QScreen *scr) const;
     QList<Plasma::Types::Location> freeEdges(int screen) const;
 
     //! make it only read-only
     void lock();
     //! make it writable which it should be the default
     void unlock();
 
     int viewsCount(int screen) const;
     int viewsCount(QScreen *screen) const;
     int viewsCount() const;
 
+    bool preferredForShortcutsTouched() const;
+    void setPreferredForShortcutsTouched(bool touched);
+
 public slots:
     Q_INVOKABLE int viewsWithTasks() const;
 
     //change <Plasma::Types::Location> to <int> types
     Q_INVOKABLE QList<int> qmlFreeEdges(int screen) const;
 
     Q_INVOKABLE void addNewView();
 
 signals:
     void activitiesChanged();
     void backgroundChanged();
     void colorChanged();
     void disableBordersForMaximizedWindowsChanged();
     void fileChanged();
     void lastUsedActivityChanged();
     void launchersChanged();
     void nameChanged();
     void versionChanged();
     void showInMenuChanged();
     void textColorChanged();
     void viewsCountChanged();
 
     //! used from LatteView(s) in order to exist only one each time that has the highest priority
     //! to use the global shortcuts activations
     void preferredViewForShortcutsChanged(Latte::View *view);
+    void preferredForShortcutsTouchedChanged();
 
 private slots:
     void loadConfig();
     void saveConfig();
 
     void addContainment(Plasma::Containment *containment);
     void appletCreated(Plasma::Applet *applet);
     void destroyedChanged(bool destroyed);
     void containmentDestroyed(QObject *cont);
     void updateLastUsedActivity();
 
 private:
     void importLocalLayout(QString file);
     void init();
     void setName(QString name);
     void setFile(QString file);
 
     //! It can be used in order for LatteViews to not be created automatically when
     //! their corresponding containments are created e.g. copyView functionality
     bool blockAutomaticLatteViewCreation() const;
     void setBlockAutomaticLatteViewCreation(bool block);
 
     bool explicitDockOccupyEdge(int screen, Plasma::Types::Location location) const;
     bool primaryDockOccupyEdge(Plasma::Types::Location location) const;
 
     //! Check if a containment is a latte dock/panel
     bool isLatteContainment(Plasma::Containment *containment) const;
     //! Check if an applet config group is valid or belongs to removed applet
     bool appletGroupIsValid(KConfigGroup appletGroup) const;
 
     bool kwin_disabledMaximizedBorders() const;
     void kwin_setDisabledMaximizedBorders(bool disable);
 
     QString availableId(QStringList all, QStringList assigned, int base);
     //! provides a new file path based the provided file. The new file
     //! has updated ids for containments and applets based on the corona
     //! loaded ones
     QString newUniqueIdsLayoutFromFile(QString file);
     //! imports a layout file and returns the containments for the docks
     QList<Plasma::Containment *> importLayoutFile(QString file);
 
 private:
     bool m_blockAutomaticLatteViewCreation{false};
     bool m_disableBordersForMaximizedWindows{false};
     bool m_showInMenu{false};
     //if version doesn't exist it is and old layout file
     int m_version{2};
 
     QString m_background;
     QString m_color;
     QString m_lastUsedActivity; //the last used activity for this layout
     QString m_layoutFile;
     QString m_layoutName;
     QString m_textColor;
     QStringList m_activities;
     QStringList m_launchers;
+    bool m_preferredForShortcutsTouched{false};
 
     QStringList m_unloadedContainmentsIds;
 
     Latte::Corona *m_corona{nullptr};
     QPointer<Latte::LayoutPart::Shortcuts> m_shortcuts;
 
     KConfigGroup m_layoutGroup;
 
     QList<Plasma::Containment *> m_containments;
 
     QHash<const Plasma::Containment *, Latte::View *> m_latteViews;
     QHash<const Plasma::Containment *, Latte::View *> m_waitingLatteViews;
 };
 
 }
 
 #endif // LAYOUT_H
diff --git a/app/shortcuts/globalshortcuts.cpp b/app/shortcuts/globalshortcuts.cpp
index 39c36b14..a778eb2f 100644
--- a/app/shortcuts/globalshortcuts.cpp
+++ b/app/shortcuts/globalshortcuts.cpp
@@ -1,887 +1,897 @@
 /*
 *  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 "../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));
 
     //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 = sortedViewsList(m_corona->layoutManager()->currentLatteViews());
 
     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 = sortedViewsList(m_corona->layoutManager()->currentLatteViews());
 
     foreach (auto view, sortedViews) {
-        if (!view->isPreferredForShortcuts()) {
+        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 =  m_corona->layoutManager()->currentLatteViews();
 
     // 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 = sortedViewsList(m_corona->layoutManager()->currentLatteViews());
 
     Latte::View *viewWithTasks{nullptr};
     Latte::View *viewWithMeta{nullptr};
 
     foreach (auto view, sortedViews) {
-        if (!viewWithTasks && view->isPreferredForShortcuts() && isCapableToShowShortcutBadges(view)) {
+        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 = m_corona->layoutManager()->currentViewsWithPlasmaShortcuts();
 
     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;
 }
 
 bool GlobalShortcuts::viewAtLowerScreenPriority(Latte::View *test, Latte::View *base)
 {
     if (!base || ! test) {
         return true;
     }
 
     if (base->screen() == test->screen()) {
         return false;
     } else if (base->screen() != qGuiApp->primaryScreen() && test->screen() == qGuiApp->primaryScreen()) {
         return false;
     } else if (base->screen() == qGuiApp->primaryScreen() && test->screen() != qGuiApp->primaryScreen()) {
         return true;
     } else {
         int basePriority = -1;
         int testPriority = -1;
 
         for (int i = 0; i < qGuiApp->screens().count(); ++i) {
             if (base->screen() == qGuiApp->screens()[i]) {
                 basePriority = i;
             }
 
             if (test->screen() == qGuiApp->screens()[i]) {
                 testPriority = i;
             }
         }
 
         if (testPriority <= basePriority) {
             return true;
         } else {
             return false;
         }
 
     }
 
     qDebug() << "viewAtLowerScreenPriority : shouldn't had reached here...";
     return false;
 }
 
 bool GlobalShortcuts::viewAtLowerEdgePriority(Latte::View *test, Latte::View *base)
 {
     if (!base || ! test) {
         return true;
     }
 
     QList<Plasma::Types::Location> edges{Plasma::Types::RightEdge, Plasma::Types::TopEdge,
                 Plasma::Types::LeftEdge, Plasma::Types::BottomEdge};
 
     int testPriority = -1;
     int basePriority = -1;
 
     for (int i = 0; i < edges.count(); ++i) {
         if (edges[i] == base->location()) {
             basePriority = i;
         }
 
         if (edges[i] == test->location()) {
             testPriority = i;
         }
     }
 
     if (testPriority < basePriority)
         return true;
     else
         return false;
 }
 
 
 QList<Latte::View *> GlobalShortcuts::sortedViewsList(QHash<const Plasma::Containment *, Latte::View *> *views)
 {
     QList<Latte::View *> sortedViews;
 
     //! create views list to be sorted out
     for (auto it = views->constBegin(), end = views->constEnd(); it != end; ++it) {
         sortedViews.append(it.value());
     }
 
     qDebug() << " -------- ";
 
     for (int i = 0; i < sortedViews.count(); ++i) {
         qDebug() << i << ". " << sortedViews[i]->screen()->name() << " - " << sortedViews[i]->location();
     }
 
     //! sort the views based on screens and edges priorities
     //! views on primary screen have higher priority and
     //! for views in the same screen the priority goes to
     //! Bottom,Left,Top,Right
     for (int i = 0; i < sortedViews.size(); ++i) {
         for (int j = 0; j < sortedViews.size() - i - 1; ++j) {
             if (viewAtLowerScreenPriority(sortedViews[j], sortedViews[j + 1])
                     || (sortedViews[j]->screen() == sortedViews[j + 1]->screen()
                         && viewAtLowerEdgePriority(sortedViews[j], sortedViews[j + 1]))) {
                 Latte::View *temp = sortedViews[j + 1];
                 sortedViews[j + 1] = sortedViews[j];
                 sortedViews[j] = temp;
             }
         }
     }
 
     Latte::View *highestPriorityView{nullptr};
 
     for (int i = 0; i < sortedViews.size(); ++i) {
         if (sortedViews[i]->isPreferredForShortcuts()) {
             highestPriorityView = sortedViews[i];
             sortedViews.removeAt(i);
             break;
         }
     }
 
     if (highestPriorityView) {
         sortedViews.prepend(highestPriorityView);
     }
 
     qDebug() << " -------- sorted -----";
 
     for (int i = 0; i < sortedViews.count(); ++i) {
         qDebug() << i << ". " << sortedViews[i]->isPreferredForShortcuts() << " - " << sortedViews[i]->screen()->name() << " - " << sortedViews[i]->location();
     }
 
     return sortedViews;
 }
 
+Latte::View *GlobalShortcuts::highestPriorityView()
+{
+    QList<Latte::View *> views = sortedViewsList(m_corona->layoutManager()->currentLatteViews());
+
+    if (views.count() > 0) {
+        return views[0];
+    }
+    return nullptr;
+}
+
 void GlobalShortcuts::showSettings()
 {
     QList<Latte::View *> views = sortedViewsList(m_corona->layoutManager()->currentLatteViews());
 
     //! find which is the next view to show its settings
     if (views.count() > 0) {
         int openSettings = -1;
 
         //! check if there is a view with opened settings window
         for (int i = 0; i < views.size(); ++i) {
             if (views[i]->settingsWindowIsShown()) {
                 openSettings = i;
                 break;
             }
         }
 
         if (openSettings >= 0 && views.count() > 1) {
             openSettings = openSettings + 1;
 
             if (openSettings >= views.size()) {
                 openSettings = 0;
             }
 
             views[openSettings]->showSettingsWindow();
         } else {
             views[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/globalshortcuts.h b/app/shortcuts/globalshortcuts.h
index b3183d64..7b8426d1 100644
--- a/app/shortcuts/globalshortcuts.h
+++ b/app/shortcuts/globalshortcuts.h
@@ -1,110 +1,111 @@
 /*
 *  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 GLOBALSHORTCUTS_H
 #define GLOBALSHORTCUTS_H
 
 // local
 #include "../liblatte2/types.h"
 
 // Qt
 #include <QMetaMethod>
 #include <QQuickItem>
 #include <QPointer>
 #include <QTimer>
 
 // KDE
 #include <kmodifierkeyinfo.h>
 
 namespace Plasma {
 class Containment;
 }
 
 namespace Latte {
 class Corona;
 class View;
 namespace ShortcutsPart{
 class ModifierTracker;
 class ShortcutsTracker;
 }
 }
 
 namespace Latte {
 
 class GlobalShortcuts : public QObject
 {
     Q_OBJECT
 
 public:
     GlobalShortcuts(QObject *parent = nullptr);
     ~GlobalShortcuts() override;
 
     void activateLauncherMenu();
     void updateViewItemBadge(QString identifier, QString value);
 
     ShortcutsPart::ShortcutsTracker *shortcutsTracker() const;
 
+    Latte::View *highestPriorityView();
+
 signals:
     void modifiersChanged();
 
 private slots:
     void hideViewsTimerSlot();
 
 private:
     void init();
     void initModifiers();
     void activateEntry(int index, Qt::Key modifier);
     void showViews();
     void showSettings();
 
     bool activateLatteEntryAtContainment(const Latte::View *view, int index, Qt::Key modifier);
     bool activatePlasmaTaskManagerEntryAtContainment(const Plasma::Containment *c, int index, Qt::Key modifier);
     bool viewAtLowerEdgePriority(Latte::View *test, Latte::View *base);
     bool viewAtLowerScreenPriority(Latte::View *test, Latte::View *base);
     bool viewsToHideAreValid();
     bool isCapableToShowShortcutBadges(Latte::View *view);
 
     int applicationLauncherId(const Plasma::Containment *c);
-
     QList<Latte::View *> sortedViewsList(QHash<const Plasma::Containment *, Latte::View *> *views);
 
 private:
     bool m_metaShowedViews{false};
 
     //! last action that was trigerred from the user
     QAction *m_lastInvokedAction;
     //! it is used for code compatibility reasons in order to replicate a single Meta action
     QAction *m_singleMetaAction;
 
     //! delayer for hiding the shown latte views
     QTimer m_hideViewsTimer;
     QList<Latte::View *> m_hideViews;
 
     QList<QQuickItem *> m_viewItemsCalled;
     QList<QMetaMethod> m_showShortcutBadgesMethods;
 
     QPointer<ShortcutsPart::ModifierTracker> m_modifierTracker;
     QPointer<ShortcutsPart::ShortcutsTracker> m_shortcutsTracker;
     QPointer<Latte::Corona> m_corona;
 };
 
 }
 
 #endif // GLOBALSHORTCUTS_H
diff --git a/app/view/view.cpp b/app/view/view.cpp
index 329f604a..858c5e56 100644
--- a/app/view/view.cpp
+++ b/app/view/view.cpp
@@ -1,1076 +1,1085 @@
 /*
 *  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 "view.h"
 
 // local
 #include "contextmenu.h"
 #include "effects.h"
 #include "positioner.h"
 #include "visibilitymanager.h"
 #include "settings/primaryconfigview.h"
 #include "../lattecorona.h"
 #include "../layoutmanager.h"
 #include "../layout/layout.h"
 #include "../plasma/extended/theme.h"
 #include "../screenpool.h"
 #include "../settings/universalsettings.h"
 #include "../shortcuts/globalshortcuts.h"
 #include "../shortcuts/shortcutstracker.h"
 #include "../../liblatte2/extras.h"
 
 // Qt
 #include <QAction>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QQmlProperty>
 #include <QQuickItem>
 #include <QMenu>
 
 // KDe
 #include <KActionCollection>
 #include <KActivities/Consumer>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Containment>
 #include <Plasma/ContainmentActions>
 #include <PlasmaQuick/AppletQuickItem>
 
 namespace Latte {
 
 //! both alwaysVisible and byPassWM are passed through corona because
 //! during the view window creation containment hasn't been set, but these variables
 //! are needed in order for window flags to be set correctly
 View::View(Plasma::Corona *corona, QScreen *targetScreen, bool byPassWM)
     : PlasmaQuick::ContainmentView(corona),
       m_contextMenu(new ViewPart::ContextMenu(this)),
       m_effects(new ViewPart::Effects(this)),
       m_positioner(new ViewPart::Positioner(this)) //needs to be created after Effects because it catches some of its signals
 {
     setTitle(corona->kPackage().metadata().name());
     setIcon(qGuiApp->windowIcon());
     setResizeMode(QuickViewSharedEngine::SizeRootObjectToView);
     setColor(QColor(Qt::transparent));
     setClearBeforeRendering(true);
 
     const auto flags = Qt::FramelessWindowHint
                        | Qt::WindowStaysOnTopHint
                        | Qt::NoDropShadowWindowHint
                        | Qt::WindowDoesNotAcceptFocus;
 
     if (byPassWM) {
         setFlags(flags | Qt::BypassWindowManagerHint);
     } else {
         setFlags(flags);
     }
 
     KWindowSystem::setOnAllDesktops(winId(), true);
 
     if (targetScreen)
         m_positioner->setScreenToFollow(targetScreen);
     else
         m_positioner->setScreenToFollow(qGuiApp->primaryScreen());
 
     connect(this, &View::containmentChanged
     , this, [ &, byPassWM]() {
         qDebug() << "dock view c++ containment changed 1...";
 
         if (!this->containment())
             return;
 
         qDebug() << "dock view c++ containment changed 2...";
 
         //! First load default values from file
         restoreConfig();
 
         //! Afterwards override that values in case during creation something different is needed
         setByPassWM(byPassWM);
 
         //! Check the screen assigned to this dock
         reconsiderScreen();
 
         if (!m_visibility) {
             m_visibility = new ViewPart::VisibilityManager(this);
 
             connect(m_visibility, &ViewPart::VisibilityManager::isHiddenChanged, this, [&]() {
                 if (m_visibility->isHidden()) {
                     deactivateApplets();
                 }
             });
         }
 
         connect(this->containment(), SIGNAL(statusChanged(Plasma::Types::ItemStatus)), SLOT(statusChanged(Plasma::Types::ItemStatus)));
     }, Qt::DirectConnection);
 
     auto *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
 
     if (latteCorona) {
         connect(latteCorona, &Latte::Corona::viewLocationChanged, this, &View::dockLocationChanged);
     }
 }
 
 View::~View()
 {
     m_inDelete = true;
 
     disconnect(corona(), &Plasma::Corona::availableScreenRectChanged, this, &View::availableScreenRectChanged);
     disconnect(containment(), SIGNAL(statusChanged(Plasma::Types::ItemStatus)), this, SLOT(statusChanged(Plasma::Types::ItemStatus)));
 
     qDebug() << "dock view deleting...";
     rootContext()->setContextProperty(QStringLiteral("dock"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("layoutManager"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("themeExtended"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("universalSettings"), nullptr);
 
     //! this disconnect does not free up connections correctly when
     //! latteView is deleted. A crash for this example is the following:
     //! switch to Alternative Session and disable compositing,
     //! the signal creating the crash was probably from deleted
     //! windows.
     //! this->disconnect();
 
     if (m_configView) {
         m_configView->setVisible(false);//hide();
     }
 
     if (m_contextMenu) {
         delete m_contextMenu;
     }
 
     //needs to be deleted before Effects because it catches some of its signals
     if (m_positioner) {
         delete m_positioner;
     }
 
     if (m_effects) {
         delete m_effects;
     }
 
     if (m_visibility)
         delete m_visibility;
 }
 
 void View::init()
 {
     connect(this, &QQuickWindow::xChanged, this, &View::xChanged);
     connect(this, &QQuickWindow::xChanged, this, &View::updateAbsDockGeometry);
     connect(this, &QQuickWindow::yChanged, this, &View::yChanged);
     connect(this, &QQuickWindow::yChanged, this, &View::updateAbsDockGeometry);
     connect(this, &QQuickWindow::widthChanged, this, &View::widthChanged);
     connect(this, &QQuickWindow::widthChanged, this, &View::updateAbsDockGeometry);
     connect(this, &QQuickWindow::heightChanged, this, &View::heightChanged);
     connect(this, &QQuickWindow::heightChanged, this, &View::updateAbsDockGeometry);
 
     connect(corona(), &Plasma::Corona::availableScreenRectChanged, this, &View::availableScreenRectChanged);
 
     connect(this, &View::byPassWMChanged, this, &View::saveConfig);
     connect(this, &View::onPrimaryChanged, this, &View::saveConfig);
     connect(this, &View::isPreferredForShortcutsChanged, this, &View::saveConfig);
 
     connect(this, SIGNAL(normalThicknessChanged()), corona(), SIGNAL(availableScreenRectChanged()));
 
     connect(m_positioner, &ViewPart::Positioner::onHideWindowsForSlidingOut, this, &View::hideWindowsForSlidingOut);
     connect(m_positioner, &ViewPart::Positioner::screenGeometryChanged, this, &View::screenGeometryChanged);
     connect(m_contextMenu, &ViewPart::ContextMenu::menuChanged, this, &View::contextMenuIsShownChanged);
 
     ///!!!!!
     rootContext()->setContextProperty(QStringLiteral("latteView"), this);
 
     auto *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
 
     if (latteCorona) {
         rootContext()->setContextProperty(QStringLiteral("layoutManager"), latteCorona->layoutManager());
         rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), latteCorona->globalShortcuts()->shortcutsTracker());
         rootContext()->setContextProperty(QStringLiteral("themeExtended"), latteCorona->themeExtended());
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), latteCorona->universalSettings());
     }
 
     setSource(corona()->kPackage().filePath("lattedockui"));
     // setVisible(true);
     m_positioner->syncGeometry();
 
     if (!KWindowSystem::isPlatformWayland()) {
         setVisible(true);
     }
 
     qDebug() << "SOURCE:" << source();
 }
 
 bool View::inDelete() const
 {
     return m_inDelete;
 }
 
 void View::disconnectSensitiveSignals()
 {
     disconnect(corona(), &Plasma::Corona::availableScreenRectChanged, this, &View::availableScreenRectChanged);
     setManagedLayout(nullptr);
 
     if (visibility()) {
         visibility()->setEnabledDynamicBackground(false);
     }
 }
 
 void View::availableScreenRectChanged()
 {
     if (m_inDelete)
         return;
 
     if (formFactor() == Plasma::Types::Vertical) {
         m_positioner->syncGeometry();
     }
 }
 
 void View::setupWaylandIntegration()
 {
     if (m_shellSurface)
         return;
 
     if (Latte::Corona *c = qobject_cast<Latte::Corona *>(corona())) {
         using namespace KWayland::Client;
         PlasmaShell *interface {c->waylandCoronaInterface()};
 
         if (!interface)
             return;
 
         Surface *s{Surface::fromWindow(this)};
 
         if (!s)
             return;
 
         m_shellSurface = interface->createSurface(s, this);
         qDebug() << "WAYLAND dock window surface was created...";
 
         m_shellSurface->setSkipTaskbar(true);
         m_shellSurface->setRole(PlasmaShellSurface::Role::Panel);
         m_shellSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::WindowsGoBelow);
     }
 }
 
 KWayland::Client::PlasmaShellSurface *View::surface()
 {
     return m_shellSurface;
 }
 
 //! the main function which decides if this dock is at the
 //! correct screen
 void View::reconsiderScreen()
 {
     m_positioner->reconsiderScreen();
 }
 
 void View::copyView()
 {
     m_managedLayout->copyView(containment());
 }
 
 void View::removeView()
 {
     if (m_managedLayout && m_managedLayout->viewsCount() > 1) {
         QAction *removeAct = this->containment()->actions()->action(QStringLiteral("remove"));
 
         if (removeAct) {
             removeAct->trigger();
         }
     }
 }
 
 bool View::settingsWindowIsShown()
 {
     auto configView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
     return (configView != nullptr);
 }
 
 void View::showSettingsWindow()
 {
     if (!settingsWindowIsShown()) {
         emit m_visibility->mustBeShown();
         showConfigurationInterface(containment());
         applyActivitiesToWindows();
     }
 }
 
 void View::showConfigurationInterface(Plasma::Applet *applet)
 {
     if (!applet || !applet->containment())
         return;
 
     Plasma::Containment *c = qobject_cast<Plasma::Containment *>(applet);
 
     if (m_configView && c && c->isContainment() && c == this->containment()) {
         if (m_configView->isVisible()) {
             m_configView->setVisible(false);
             //m_configView->hide();
         } else {
             m_configView->setVisible(true);
             //m_configView->show();
         }
 
         return;
     } else if (m_configView) {
         if (m_configView->applet() == applet) {
             m_configView->setVisible(true);
             //m_configView->show();
             m_configView->requestActivate();
             return;
         } else {
             m_configView->setVisible(false);
             //m_configView->hide();
             m_configView->deleteLater();
         }
     }
 
     bool delayConfigView = false;
 
     if (c && containment() && c->isContainment() && c->id() == this->containment()->id()) {
         m_configView = new ViewPart::PrimaryConfigView(c, this);
         delayConfigView = true;
     } else {
         m_configView = new PlasmaQuick::ConfigView(applet);
     }
 
     m_configView.data()->init();
 
     if (!delayConfigView) {
         m_configView->setVisible(true);
         //m_configView.data()->show();
     } else {
         //add a timer for showing the configuration window the first time it is
         //created in order to give the containment's layouts the time to
         //calculate the window's height
         if (!KWindowSystem::isPlatformWayland()) {
             QTimer::singleShot(150, m_configView, SLOT(show()));
         } else {
             QTimer::singleShot(150, [this]() {
                 m_configView->setVisible(true);
             });
         }
     }
 }
 
 QRect View::localGeometry() const
 {
     return m_localGeometry;
 }
 
 void View::setLocalGeometry(const QRect &geometry)
 {
     if (m_localGeometry == geometry) {
         return;
     }
 
     m_localGeometry = geometry;
     emit localGeometryChanged();
     updateAbsDockGeometry();
 }
 
 void View::updateAbsDockGeometry(bool bypassChecks)
 {
     //! there was a -1 in height and width here. The reason of this
     //! if I remember correctly was related to multi-screen but I cant
     //! remember exactly the reason, something related to right edge in
     //! multi screen environment. BUT this was breaking the entire AlwaysVisible
     //! experience with struts. Removing them in order to restore correct
     //! behavior and keeping this comment in order to check for
     //! multi-screen breakage
     QRect absGeometry {x() + m_localGeometry.x(), y() + m_localGeometry.y()
                        , m_localGeometry.width(), m_localGeometry.height()};
 
     if (m_absGeometry == absGeometry && !bypassChecks)
         return;
 
     m_absGeometry = absGeometry;
     emit absGeometryChanged(m_absGeometry);
 
     //! this is needed in order to update correctly the screenGeometries
     if (visibility() && corona() && visibility()->mode() == Types::AlwaysVisible) {
         emit corona()->availableScreenRectChanged();
         emit corona()->availableScreenRegionChanged();
     }
 }
 
 void View::statusChanged(Plasma::Types::ItemStatus status)
 {
     if (containment()) {
         if (containment()->status() >= Plasma::Types::NeedsAttentionStatus &&
             containment()->status() != Plasma::Types::HiddenStatus) {
             setBlockHiding(true);
         } else if (!containment()->isUserConfiguring()){
             setBlockHiding(false);
         }
     }
 }
 
 bool View::alternativesIsShown() const
 {
     return m_alternativesIsShown;
 }
 
 void View::setAlternativesIsShown(bool show)
 {
     if (m_alternativesIsShown == show) {
         return;
     }
 
     m_alternativesIsShown = show;
 
     setBlockHiding(show);
     emit alternativesIsShownChanged();
 }
 
 bool View::contextMenuIsShown() const
 {
     if (!m_contextMenu) {
         return false;
     }
 
     return m_contextMenu->menu();
 }
 
 int View::currentThickness() const
 {
     if (formFactor() == Plasma::Types::Vertical) {
         return m_effects->mask().isNull() ? width() : m_effects->mask().width() - m_effects->innerShadow();
     } else {
         return m_effects->mask().isNull() ? height() : m_effects->mask().height() - m_effects->innerShadow();
     }
 }
 
 int View::normalThickness() const
 {
     return m_normalThickness;
 }
 
 void View::setNormalThickness(int thickness)
 {
     if (m_normalThickness == thickness) {
         return;
     }
 
     m_normalThickness = thickness;
     emit normalThicknessChanged();
 }
 
 bool View::byPassWM() const
 {
     return m_byPassWM;
 }
 
 void View::setByPassWM(bool bypass)
 {
     if (m_byPassWM == bypass) {
         return;
     }
 
     m_byPassWM = bypass;
     emit byPassWMChanged();
 }
 
 bool View::behaveAsPlasmaPanel() const
 {
     return m_behaveAsPlasmaPanel;
 }
 
 void View::setBehaveAsPlasmaPanel(bool behavior)
 {
     if (m_behaveAsPlasmaPanel == behavior) {
         return;
     }
 
     m_behaveAsPlasmaPanel = behavior;
 
     emit behaveAsPlasmaPanelChanged();
 }
 
 bool View::inEditMode() const
 {
     return m_inEditMode;
 }
 
 void View::setInEditMode(bool edit)
 {
     if (m_inEditMode == edit) {
         return;
     }
 
     m_inEditMode = edit;
 
     emit inEditModeChanged();
 }
 
 bool View::isPreferredForShortcuts() const
 {
     return m_isPreferredForShortcuts;
 }
 
 void View::setIsPreferredForShortcuts(bool preferred)
 {
     if (m_isPreferredForShortcuts == preferred) {
         return;
     }
 
     m_isPreferredForShortcuts = preferred;
 
     emit isPreferredForShortcutsChanged();
 
     if (m_isPreferredForShortcuts && m_managedLayout) {
         emit m_managedLayout->preferredViewForShortcutsChanged(this);
     }
 }
 
 void View::preferredViewForShortcutsChangedSlot(Latte::View *view)
 {
     if (view != this) {
         setIsPreferredForShortcuts(false);
     }
 }
 
 bool View::onPrimary() const
 {
     return m_onPrimary;
 }
 
 void View::setOnPrimary(bool flag)
 {
     if (m_onPrimary == flag) {
         return;
     }
 
     m_onPrimary = flag;
     emit onPrimaryChanged();
 }
 
 float View::maxLength() const
 {
     return m_maxLength;
 }
 
 void View::setMaxLength(float length)
 {
     if (m_maxLength == length) {
         return;
     }
 
     m_maxLength = length;
     emit maxLengthChanged();
 }
 
 int View::maxThickness() const
 {
     return m_maxThickness;
 }
 
 void View::setMaxThickness(int thickness)
 {
     if (m_maxThickness == thickness)
         return;
 
     m_maxThickness = thickness;
     emit maxThicknessChanged();
 }
 
 int View::alignment() const
 {
     return m_alignment;
 }
 
 void View::setAlignment(int alignment)
 {
     Types::Alignment align = static_cast<Types::Alignment>(alignment);
 
     if (m_alignment == alignment) {
         return;
     }
 
     m_alignment = align;
     emit alignmentChanged();
 }
 
 QRect View::absGeometry() const
 {
     return m_absGeometry;
 }
 
 QRect View::screenGeometry() const
 {
     if (this->screen()) {
         QRect geom = this->screen()->geometry();
         return geom;
     }
 
     return QRect();
 }
 
 int View::offset() const
 {
     return m_offset;
 }
 
 void View::setOffset(int offset)
 {
     if (m_offset == offset) {
         return;
     }
 
     m_offset = offset;
     emit offsetChanged();
 }
 
 int View::fontPixelSize() const
 {
     return m_fontPixelSize;
 }
 
 void View::setFontPixelSize(int size)
 {
     if (m_fontPixelSize == size) {
         return;
     }
 
     m_fontPixelSize = size;
 
     emit fontPixelSizeChanged();
 }
 
 void View::applyActivitiesToWindows()
 {
     if (m_visibility) {
         QStringList activities = m_managedLayout->appliedActivities();
         m_visibility->setWindowOnActivities(*this, activities);
 
         if (m_configView) {
             m_visibility->setWindowOnActivities(*m_configView, activities);
 
             auto configView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
             if (configView && configView->secondaryWindow()) {
                 m_visibility->setWindowOnActivities(*configView->secondaryWindow(), activities);
             }
         }
 
         if (m_visibility->supportsKWinEdges()) {
             m_visibility->applyActivitiesToHiddenWindows(activities);
         }
     }
 }
 
 Layout *View::managedLayout() const
 {
     return m_managedLayout;
 }
 
 void View::setManagedLayout(Layout *layout)
 {
     if (m_managedLayout == layout) {
         return;
     }
 
     // clear mode
     for (auto &c : connectionsManagedLayout) {
         disconnect(c);
     }
 
     m_managedLayout = layout;
 
     if (m_managedLayout) {
         //! Sometimes the activity isnt completely ready, by adding a delay
         //! we try to catch up
         QTimer::singleShot(100, [this]() {
             if (m_managedLayout && m_visibility) {
                 qDebug() << "DOCK VIEW FROM LAYOUT ::: " << m_managedLayout->name() << " - activities: " << m_managedLayout->appliedActivities();
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         connectionsManagedLayout[0] = connect(m_managedLayout, &Layout::preferredViewForShortcutsChanged, this, &View::preferredViewForShortcutsChangedSlot);
     }
 
     Latte::Corona *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
 
     if (latteCorona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
         connectionsManagedLayout[1] = connect(latteCorona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged, this, [&]() {
             if (m_managedLayout && m_visibility) {
                 qDebug() << "DOCK VIEW FROM LAYOUT (runningActivitiesChanged) ::: " << m_managedLayout->name()
                          << " - activities: " << m_managedLayout->appliedActivities();
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         connectionsManagedLayout[2] = connect(m_managedLayout, &Layout::activitiesChanged, this, [&]() {
             if (m_managedLayout) {
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         connectionsManagedLayout[3] = connect(latteCorona->layoutManager(), &LayoutManager::layoutsChanged, this, [&]() {
             if (m_managedLayout) {
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         //!IMPORTANT!!! ::: This fixes a bug when closing an Activity all docks from all Activities are
         //! disappearing! With this they reappear!!!
         connectionsManagedLayout[4] = connect(this, &QWindow::visibleChanged, this, [&]() {
             if (!isVisible() && m_managedLayout) {
                 QTimer::singleShot(100, [this]() {
                     if (m_managedLayout && containment() && !containment()->destroyed()) {
                         setVisible(true);
                         applyActivitiesToWindows();
                         emit activitiesChanged();
                     }
                 });
 
                 QTimer::singleShot(1500, [this]() {
                     if (m_managedLayout && containment() && !containment()->destroyed()) {
                         setVisible(true);
                         applyActivitiesToWindows();
                         emit activitiesChanged();
                     }
                 });
             }
         });
     }
 
     emit managedLayoutChanged();
 }
 
 void View::moveToLayout(QString layoutName)
 {
     if (!m_managedLayout) {
         return;
     }
 
     QList<Plasma::Containment *> containments = m_managedLayout->unassignFromLayout(this);
 
     Latte::Corona *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
 
     if (latteCorona && containments.size() > 0) {
         Layout *newLayout = latteCorona->layoutManager()->activeLayout(layoutName);
 
         if (newLayout) {
             newLayout->assignToLayout(this, containments);
         }
     }
 }
 
 void View::setBlockHiding(bool block)
 {
     if (!block) {
         auto *configView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
         if (m_alternativesIsShown || (configView && configView->sticker() && configView->isVisible())) {
             return;
         }
 
         if (m_visibility) {
             m_visibility->setBlockHiding(false);
         }
     } else {
         if (m_visibility) {
             m_visibility->setBlockHiding(true);
         }
     }
 }
 
 void View::hideWindowsForSlidingOut()
 {
     setBlockHiding(false);
 
     if (m_configView) {
         auto configDialog = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
         if (configDialog) {
             configDialog->hideConfigWindow();
         }
     }
 }
 
 //! remove latte tasks plasmoid
 void View::removeTasksPlasmoid()
 {
     if (!tasksPresent() || !containment()) {
         return;
     }
 
     foreach (Plasma::Applet *applet, containment()->applets()) {
         KPluginMetaData meta = applet->kPackage().metadata();
 
         if (meta.pluginId() == "org.kde.latte.plasmoid") {
             QAction *closeApplet = applet->actions()->action(QStringLiteral("remove"));
 
             if (closeApplet) {
                 closeApplet->trigger();
                 //! remove only the first found
                 return;
             }
         }
     }
 }
 
 //! check if the tasks plasmoid exist in the dock
 bool View::tasksPresent()
 {
     if (!this->containment()) {
         return false;
     }
 
     foreach (Plasma::Applet *applet, this->containment()->applets()) {
         const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             return true;
         }
     }
 
     return false;
 }
 
 
 //! check if the tasks plasmoid exist in the dock
 bool View::latteTasksPresent()
 {
     if (!this->containment()) {
         return false;
     }
 
     foreach (Plasma::Applet *applet, this->containment()->applets()) {
         KPluginMetaData metadata = applet->pluginMetaData();
 
         if (metadata.pluginId() == "org.kde.latte.plasmoid") {
             return true;
         }
     }
 
     return false;
 }
 
 
 //!check if the plasmoid with _name_ exists in the midedata
 bool View::mimeContainsPlasmoid(QMimeData *mimeData, QString name)
 {
     if (!mimeData) {
         return false;
     }
 
     if (mimeData->hasFormat(QStringLiteral("text/x-plasmoidservicename"))) {
         QString data = mimeData->data(QStringLiteral("text/x-plasmoidservicename"));
         const QStringList appletNames = data.split('\n', QString::SkipEmptyParts);
 
         foreach (const QString &appletName, appletNames) {
             if (appletName == name)
                 return true;
         }
     }
 
     return false;
 }
 
 ViewPart::Effects *View::effects() const
 {
     return m_effects;
 }
 
 ViewPart::Positioner *View::positioner() const
 {
     return m_positioner;
 }
 
 ViewPart::VisibilityManager *View::visibility() const
 {
     return m_visibility;
 }
 
 bool View::event(QEvent *e)
 {
     if (!m_inDelete) {
         emit eventTriggered(e);
 
         switch (e->type()) {
             case QEvent::Leave:
                 engine()->trimComponentCache();
                 break;
 
             case QEvent::PlatformSurface:
                 if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
                     switch (pe->surfaceEventType()) {
                         case QPlatformSurfaceEvent::SurfaceCreated:
                             setupWaylandIntegration();
 
                             if (m_shellSurface) {
                                 m_positioner->syncGeometry();
                                 m_effects->updateShadows();
                             }
 
                             break;
 
                         case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                             if (m_shellSurface) {
                                 delete m_shellSurface;
                                 m_shellSurface = nullptr;
                                 qDebug() << "WAYLAND dock window surface was deleted...";
                                 m_effects->clearShadows();
                             }
 
                             break;
                     }
                 }
 
                 break;
 
             default:
                 break;
         }
     }
 
     return ContainmentView::event(e);;
 }
 
 void View::deactivateApplets()
 {
     if (!containment()) {
         return;
     }
 
     foreach (auto applet, containment()->applets()) {
         PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (ai) {
             ai->setExpanded(false);
         }
     }
 }
 
 void View::toggleAppletExpanded(const int id)
 {
     if (!containment()) {
         return;
     }
 
     foreach (auto applet, containment()->applets()) {
         if (applet->id() == id) {
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 if (!ai->isActivationTogglesExpanded()) {
                     ai->setActivationTogglesExpanded(true);
                 }
 
                 emit applet->activated();
             }
         }
     }
 }
 
 QVariantList View::containmentActions()
 {
     QVariantList actions;
     /*if (containment()->corona()->immutability() != Plasma::Types::Mutable) {
         return actions;
     }*/
     //FIXME: the trigger string it should be better to be supported this way
     //const QString trigger = Plasma::ContainmentActions::eventToString(event);
     const QString trigger = "RightButton;NoModifier";
     Plasma::ContainmentActions *plugin = this->containment()->containmentActions().value(trigger);
 
     if (!plugin) {
         return actions;
     }
 
     if (plugin->containment() != this->containment()) {
         plugin->setContainment(this->containment());
         // now configure it
         KConfigGroup cfg(this->containment()->corona()->config(), "ActionPlugins");
         cfg = KConfigGroup(&cfg, QString::number(this->containment()->containmentType()));
         KConfigGroup pluginConfig = KConfigGroup(&cfg, trigger);
         plugin->restore(pluginConfig);
     }
 
     foreach (QAction *ac, plugin->contextualActions()) {
         actions << QVariant::fromValue<QAction *>(ac);
     }
 
     return actions;
 }
 
 void View::disableGrabItemBehavior()
 {
     setMouseGrabEnabled(false);
 }
 
 void View::restoreGrabItemBehavior()
 {
     if (mouseGrabberItem()) {
         mouseGrabberItem()->ungrabMouse();
     }
 }
 
+bool View::isHighestPriorityView() {
+    auto *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
+
+    if (latteCorona) {
+        return this == latteCorona->globalShortcuts()->highestPriorityView(); 
+    }
+    return false;
+}
+
 //!BEGIN overriding context menus behavior
 void View::mousePressEvent(QMouseEvent *event)
 {
     bool result = m_contextMenu->mousePressEvent(event);
     emit contextMenuIsShownChanged();
 
     if (result) {
         PlasmaQuick::ContainmentView::mousePressEvent(event);
     }
 }
 //!END overriding context menus behavior
 
 //!BEGIN configuration functions
 void View::saveConfig()
 {
     if (!this->containment())
         return;
 
     auto config = this->containment()->config();
     config.writeEntry("onPrimary", onPrimary());
     config.writeEntry("byPassWM", byPassWM());
     config.writeEntry("isPreferredForShortcuts", isPreferredForShortcuts());
     config.sync();
 }
 
 void View::restoreConfig()
 {
     if (!this->containment())
         return;
 
     auto config = this->containment()->config();
     m_onPrimary = config.readEntry("onPrimary", true);
     m_byPassWM = config.readEntry("byPassWM", false);
     m_isPreferredForShortcuts = config.readEntry("isPreferredForShortcuts", false);
 
     //! Send changed signals at the end in order to be sure that saveConfig
     //! wont rewrite default/invalid values
     emit onPrimaryChanged();
     emit byPassWMChanged();
 }
 //!END configuration functions
 
 }
 //!END namespace
diff --git a/app/view/view.h b/app/view/view.h
index 4b251f32..caa9f177 100644
--- a/app/view/view.h
+++ b/app/view/view.h
@@ -1,286 +1,289 @@
 /*
 *  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 VIEW_H
 #define VIEW_H
 
 // local
 #include "effects.h"
 #include "positioner.h"
 #include "visibilitymanager.h"
 #include "settings/primaryconfigview.h"
+#include "../shortcuts/globalshortcuts.h"
 #include "../layout/layout.h"
 #include "../plasma/quick/containmentview.h"
 #include "../plasma/quick/configview.h"
 #include "../../liblatte2/types.h"
 
 // C++
 #include <array>
 
 // Qt
 #include <QQuickView>
 #include <QMenu>
 #include <QMimeData>
 #include <QScreen>
 #include <QPointer>
 #include <QTimer>
 
 namespace Plasma {
 class Types;
 class Corona;
 class Containment;
 }
 
 namespace KWayland {
 namespace Client {
 class PlasmaShellSurface;
 }
 }
 
 namespace Latte {
 class Layout;
 
 namespace ViewPart {
 class ContextMenu;
 }
 }
 
 namespace Latte {
 
 class View : public PlasmaQuick::ContainmentView
 {
     Q_OBJECT
     Q_PROPERTY(bool alternativesIsShown READ alternativesIsShown NOTIFY alternativesIsShownChanged)
     Q_PROPERTY(bool behaveAsPlasmaPanel READ behaveAsPlasmaPanel WRITE setBehaveAsPlasmaPanel NOTIFY behaveAsPlasmaPanelChanged)
     Q_PROPERTY(bool byPassWM READ byPassWM WRITE setByPassWM NOTIFY byPassWMChanged)
     Q_PROPERTY(bool contextMenuIsShown READ contextMenuIsShown NOTIFY contextMenuIsShownChanged)
     //! Because Latte uses animations, changing to edit mode it may be different than
     //! when the isUserConfiguring changes value
     Q_PROPERTY(bool inEditMode READ inEditMode WRITE setInEditMode NOTIFY inEditModeChanged)
     Q_PROPERTY(bool isPreferredForShortcuts READ isPreferredForShortcuts WRITE setIsPreferredForShortcuts NOTIFY isPreferredForShortcutsChanged)
     Q_PROPERTY(bool onPrimary READ onPrimary WRITE setOnPrimary NOTIFY onPrimaryChanged)
 
     Q_PROPERTY(int alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
     Q_PROPERTY(int fontPixelSize READ fontPixelSize WRITE setFontPixelSize NOTIFY fontPixelSizeChanged)
     Q_PROPERTY(int x READ x NOTIFY xChanged)
     Q_PROPERTY(int y READ y NOTIFY yChanged)
     Q_PROPERTY(int width READ width NOTIFY widthChanged)
     Q_PROPERTY(int height READ height NOTIFY heightChanged)
     Q_PROPERTY(int maxThickness READ maxThickness WRITE setMaxThickness NOTIFY maxThicknessChanged)
     Q_PROPERTY(int normalThickness READ normalThickness WRITE setNormalThickness NOTIFY normalThicknessChanged)
     Q_PROPERTY(int offset READ offset WRITE setOffset NOTIFY offsetChanged)
 
     Q_PROPERTY(float maxLength READ maxLength WRITE setMaxLength NOTIFY maxLengthChanged)
 
     Q_PROPERTY(Latte::ViewPart::Effects *effects READ effects NOTIFY effectsChanged)
     Q_PROPERTY(Layout *managedLayout READ managedLayout WRITE setManagedLayout NOTIFY managedLayoutChanged)
     Q_PROPERTY(Latte::ViewPart::Positioner *positioner READ positioner NOTIFY positionerChanged)
     Q_PROPERTY(Latte::ViewPart::VisibilityManager *visibility READ visibility NOTIFY visibilityChanged)
 
     Q_PROPERTY(QRect absoluteGeometry READ absGeometry NOTIFY absGeometryChanged)
     Q_PROPERTY(QRect localGeometry READ localGeometry WRITE setLocalGeometry NOTIFY localGeometryChanged)
     Q_PROPERTY(QRect screenGeometry READ screenGeometry NOTIFY screenGeometryChanged)
 
 public:
     View(Plasma::Corona *corona, QScreen *targetScreen = nullptr, bool byPassWM = false);
     virtual ~View();
 
     void init();
 
     bool alternativesIsShown() const;
     void setAlternativesIsShown(bool show);
 
     bool inDelete() const;
 
     bool onPrimary() const;
     void setOnPrimary(bool flag);
 
     int currentThickness() const;
 
     bool behaveAsPlasmaPanel() const;
     void setBehaveAsPlasmaPanel(bool behavior);
 
     bool contextMenuIsShown() const;
 
     bool byPassWM() const;
     void setByPassWM(bool bypass);
 
     bool inEditMode() const;
     void setInEditMode(bool edit);
 
     bool isPreferredForShortcuts() const;
     void setIsPreferredForShortcuts(bool preferred);
 
     float maxLength() const;
     void setMaxLength(float length);
 
     int fontPixelSize() const;
     void setFontPixelSize(int size);
 
     int maxThickness() const;
     void setMaxThickness(int thickness);
 
     int normalThickness() const;
     void setNormalThickness(int thickness);
 
     int offset() const;
     void setOffset(int offset);
 
     int alignment() const;
     void setAlignment(int alignment);
 
     QRect absGeometry() const;
     QRect screenGeometry() const;
 
     QRect localGeometry() const;
     void setLocalGeometry(const QRect &geometry);
 
     bool settingsWindowIsShown();
     void showSettingsWindow();
 
     ViewPart::Effects *effects() const;
     ViewPart::Positioner *positioner() const;
     ViewPart::VisibilityManager *visibility() const;
 
     Layout *managedLayout() const;
     void setManagedLayout(Layout *layout);
 
     KWayland::Client::PlasmaShellSurface *surface();
 
     void reconsiderScreen();
 
     //! these are signals that create crashes, such a example is the availableScreenRectChanged from corona
     //! when its containment is destroyed
     void disconnectSensitiveSignals();
 
 public slots:
     Q_INVOKABLE void copyView();
     Q_INVOKABLE void removeView();
 
     Q_INVOKABLE QVariantList containmentActions();
 
     Q_INVOKABLE void deactivateApplets();
     Q_INVOKABLE void moveToLayout(QString layoutName);
     Q_INVOKABLE void removeTasksPlasmoid();
     Q_INVOKABLE void setBlockHiding(bool block);
     Q_INVOKABLE void toggleAppletExpanded(const int id);
 
     Q_INVOKABLE bool mimeContainsPlasmoid(QMimeData *mimeData, QString name);
     Q_INVOKABLE bool tasksPresent();
     Q_INVOKABLE bool latteTasksPresent();
 
     void updateAbsDockGeometry(bool bypassChecks = false);
 
     Q_INVOKABLE void disableGrabItemBehavior();
     Q_INVOKABLE void restoreGrabItemBehavior();
 
+    Q_INVOKABLE bool isHighestPriorityView();
+
 protected slots:
     void showConfigurationInterface(Plasma::Applet *applet) override;
 
 protected:
     bool event(QEvent *ev) override;
     void mousePressEvent(QMouseEvent *event) override;
 
 signals:
     void addInternalViewSplitter();
     void removeInternalViewSplitter();
     void eventTriggered(QEvent *ev);
 
     void activitiesChanged();
     void alternativesIsShownChanged();
     void alignmentChanged();
     void behaveAsPlasmaPanelChanged();
     void byPassWMChanged();
     void contextMenuIsShownChanged();
     void dockLocationChanged();
     void effectsChanged();
     void fontPixelSizeChanged();
     void widthChanged();
     void heightChanged();
     void inEditModeChanged();
     void isPreferredForShortcutsChanged();
     void localGeometryChanged();
     void managedLayoutChanged();
     void maxLengthChanged();
     void maxThicknessChanged();
     void normalThicknessChanged();
     void offsetChanged();
     void onPrimaryChanged();
     void visibilityChanged();
     void positionerChanged();
     void screenGeometryChanged();
     void xChanged();
     void yChanged();
 
     void absGeometryChanged(const QRect &geometry);
 
 private slots:
     void availableScreenRectChanged();
     void hideWindowsForSlidingOut();
     void preferredViewForShortcutsChangedSlot(Latte::View *view);
     void statusChanged(Plasma::Types::ItemStatus);
 
     void restoreConfig();
     void saveConfig();
 
 private:
     void applyActivitiesToWindows();
     void initSignalingForLocationChangeSliding();
     void setupWaylandIntegration();
     void updateAppletContainsMethod();
 
 private:
     Plasma::Containment *containmentById(uint id);
 
     bool m_alternativesIsShown{false};
     bool m_behaveAsPlasmaPanel{false};
     bool m_byPassWM{true};
     bool m_inDelete{false};
     bool m_inEditMode{false};
     bool m_isPreferredForShortcuts{false};
     bool m_onPrimary{true};
     int m_fontPixelSize{ -1};
     int m_maxThickness{24};
     int m_normalThickness{24};
     int m_offset{0};
     float m_maxLength{1};
 
     Types::Alignment m_alignment{Types::Center};
 
     QRect m_localGeometry;
     QRect m_absGeometry;
 
     Layout *m_managedLayout{nullptr};
     QPointer<PlasmaQuick::ConfigView> m_configView;
 
     QPointer<ViewPart::ContextMenu> m_contextMenu;
     QPointer<ViewPart::Effects> m_effects;
     QPointer<ViewPart::Positioner> m_positioner;
     QPointer<ViewPart::VisibilityManager> m_visibility;
 
     //! Connections to release and bound for the managed layout
     std::array<QMetaObject::Connection, 5> connectionsManagedLayout;
 
     KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
 };
 
 }
 
 #endif
diff --git a/shell/package/contents/configuration/pages/BehaviorConfig.qml b/shell/package/contents/configuration/pages/BehaviorConfig.qml
index ccb256cd..c322773f 100644
--- a/shell/package/contents/configuration/pages/BehaviorConfig.qml
+++ b/shell/package/contents/configuration/pages/BehaviorConfig.qml
@@ -1,636 +1,639 @@
 /*
 *  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/>.
 */
 
 import QtQuick 2.0
 import QtQuick.Controls 1.4
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.components 3.0 as PlasmaComponents3
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte 0.2 as Latte
 
 import "../../controls" as LatteExtraControls
 
 PlasmaComponents.Page {
     Layout.maximumWidth: content.width + content.Layout.leftMargin * 2
     Layout.maximumHeight: content.height + units.smallSpacing * 2
 
     property alias dockTypeSelection: _dockTypeSelection
 
     ColumnLayout {
         id: content
 
         width: (dialog.appliedWidth - units.smallSpacing * 2) - Layout.leftMargin * 2
         spacing: dialog.subGroupSpacing
         anchors.horizontalCenter: parent.horizontalCenter
         Layout.leftMargin: units.smallSpacing * 2
 
         //! BEGIN: Inline Dock/Panel Type, it is used only when the secondary window
         //! overlaps the main dock config window
         ColumnLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
             Layout.topMargin: units.smallSpacing
 
             visible: dialog.highLevel && viewConfig.showInlineProperties
 
             LatteExtraControls.Header {
                 text: i18n("Type")
             }
 
 
             LatteExtraControls.TypeSelection{
                 id: _dockTypeSelection
                 horizontal: true
             }
         }
         //! END: Inline Dock/Panel Type
 
         //! BEGIN: Location
         ColumnLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
             Layout.topMargin: units.smallSpacing
 
             LatteExtraControls.Header {
                 text: i18n("Location")
             }
 
             RowLayout {
                 id: screenRow
                 Layout.fillWidth: true
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.rightMargin: units.smallSpacing * 2
                 spacing: 2
                 visible: true
 
                 function updateScreens() {
                     if (universalSettings.screens.length > 1)
                         screenRow.visible = true;
                     else
                         screenRow.visible = false;
 
                     var screens = []
                     var rtlSpace = Qt.application.layoutDirection === Qt.RightToLeft ? "    " : "";
 
                     screens.push(rtlSpace + i18n("On Primary"));
 
                     //check if the screen exists, it is used in cases Latte is moving
                     //the view automatically to primaryScreen in order for the user
                     //to has always a view with tasks shown
                     var screenExists = false
                     for (var i = 0; i < universalSettings.screens.length; i++) {
                         if (universalSettings.screens[i].name === latteView.positioner.currentScreenName)
                             screenExists = true;
                     }
 
                     if (!screenExists && !latteView.onPrimary)
                         screens.push(rtlSpace + latteView.positioner.currentScreenName);
 
                     for (var i = 0; i < universalSettings.screens.length; i++) {
                         screens.push(rtlSpace + universalSettings.screens[i].name)
                     }
 
                     screenCmb.model = screens;
 
                     if (latteView.onPrimary) {
                         screenCmb.currentIndex = 0;
                     } else {
                         screenCmb.currentIndex = screenCmb.find(latteView.positioner.currentScreenName);
                     }
 
                     console.log(latteView.positioner.currentScreenName);
                 }
 
                 Connections{
                     target: viewConfig
                     onShowSignal: screenRow.updateScreens();
                 }
 
                 PlasmaComponents.Label {
                     text: i18n("Screen:")
                     Layout.alignment: Qt.AlignRight
                 }
 
                 PlasmaComponents3.ComboBox {
                     id: screenCmb
                     Layout.fillWidth: true
                     Component.onCompleted: screenRow.updateScreens();
 
                     //they are used to restore the index when the screen edge
                     //is occupied
                     property bool acceptedIndex: true
                     property int previousIndex: -1
 
                     onCurrentIndexChanged: {
                         //it is used to restore the index when the screen edge
                         //is occupied
                         if (!acceptedIndex) {
                             acceptedIndex = true;
                             currentIndex = previousIndex;
                         }
                     }
 
                     onActivated: {
                         previousIndex = currentIndex;
                         if (index === 0) {
                             var succeed = latteView.positioner.setCurrentScreen("primary");
 
                             latteView.onPrimary = true;
                             acceptedIndex = true;
                         } else if (index>0 && (index !== find(latteView.positioner.currentScreenName) || latteView.onPrimary)) {
                             console.log("current index changed!!! :"+ index);
                             console.log("screen must be changed...");
 
                             var succeed = latteView.positioner.setCurrentScreen(textAt(index));
 
                             if(succeed) {
                                 latteView.onPrimary = false;
                             } else {
                                 console.log("the edge is already occupied!!!");
                                 acceptedIndex = false;
                             }
                         }
                     }
                 }
             }
 
             RowLayout {
                 id: locationLayout
                 Layout.fillWidth: true
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.rightMargin: units.smallSpacing * 2
                 LayoutMirroring.enabled: false
                 spacing: 2
 
                 Connections{
                     target: latteView
                     onDockLocationChanged: locationLayout.lockReservedEdges();
                 }
 
                 Connections{
                     target: latteView.managedLayout
                     onViewsCountChanged: locationLayout.lockReservedEdges();
                 }
 
                 Connections{
                     target: latteView.positioner
                     onCurrentScreenChanged: locationLayout.lockReservedEdges();
                 }
 
                 Component.onCompleted: lockReservedEdges()
 
                 ExclusiveGroup {
                     id: locationGroup
                     property bool inStartup: true
 
                     onCurrentChanged: {
                         if (current.checked && !inStartup) {
                             latteView.positioner.hideDockDuringLocationChange(current.edge);
                         }
                         inStartup = false;
                     }
                 }
 
                 function lockReservedEdges() {
                     var edges = latteView.managedLayout.qmlFreeEdges(latteView.positioner.currentScreenId);
 
                     bottomEdgeBtn.edgeIsFree = (edges.indexOf(bottomEdgeBtn.edge)>=0);
                     topEdgeBtn.edgeIsFree = (edges.indexOf(topEdgeBtn.edge)>=0);
                     leftEdgeBtn.edgeIsFree = (edges.indexOf(leftEdgeBtn.edge)>=0);
                     rightEdgeBtn.edgeIsFree = (edges.indexOf(rightEdgeBtn.edge)>=0);
                 }
 
                 PlasmaComponents.Button {
                     id: bottomEdgeBtn
                     Layout.fillWidth: true
                     text: i18nc("bottom location", "Bottom")
                     iconSource: "arrow-down"
                     checked: latteView.location === edge
                     checkable: true
                     enabled: checked || edgeIsFree
                     exclusiveGroup: locationGroup
 
                     property bool edgeIsFree: true
                     readonly property int edge: PlasmaCore.Types.BottomEdge
                 }
                 PlasmaComponents.Button {
                     id: leftEdgeBtn
                     Layout.fillWidth: true
                     text: i18nc("left location", "Left")
                     iconSource: "arrow-left"
                     checked: latteView.location === edge
                     checkable: true
                     enabled: checked || edgeIsFree
                     exclusiveGroup: locationGroup
 
                     property bool edgeIsFree: true
                     readonly property int edge: PlasmaCore.Types.LeftEdge
                 }
                 PlasmaComponents.Button {
                     id: topEdgeBtn
                     Layout.fillWidth: true
                     text: i18nc("top location", "Top")
                     iconSource: "arrow-up"
                     checked: latteView.location === edge
                     checkable: true
                     enabled: checked || edgeIsFree
                     exclusiveGroup: locationGroup
 
                     property bool edgeIsFree: true
                     readonly property int edge: PlasmaCore.Types.TopEdge
                 }
                 PlasmaComponents.Button {
                     id: rightEdgeBtn
                     Layout.fillWidth: true
                     text: i18nc("right location", "Right")
                     iconSource: "arrow-right"
                     checked: latteView.location === edge
                     checkable: true
                     enabled: checked || edgeIsFree
                     exclusiveGroup: locationGroup
 
                     property bool edgeIsFree: true
                     readonly property int edge: PlasmaCore.Types.RightEdge
                 }
             }
         }
         //! END: Location
 
         //! BEGIN: Alignment
         ColumnLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
 
             LatteExtraControls.Header {
                 text: i18n("Alignment")
             }
 
             RowLayout {
                 Layout.fillWidth: true
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.rightMargin: units.smallSpacing * 2
                 LayoutMirroring.enabled: false
                 spacing: 2
 
                 property int panelPosition: plasmoid.configuration.panelPosition
 
                 onPanelPositionChanged: {
                     if (panelPosition === Latte.Types.Justify)
                         latteView.addInternalViewSplitter()
                     else
                         latteView.removeInternalViewSplitter()
                 }
 
                 Component.onCompleted: {
                     if (panelPosition === Latte.Types.Justify)
                         latteView.addInternalViewSplitter()
                     else
                         latteView.removeInternalViewSplitter()
                 }
 
                 ExclusiveGroup {
                     id: alignmentGroup
                     onCurrentChanged: {
                         if (current.checked)
                             plasmoid.configuration.panelPosition = current.position
                     }
                 }
 
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: panelIsVertical ? i18nc("top alignment", "Top") : i18nc("left alignment", "Left")
                     iconSource: panelIsVertical ? "format-align-vertical-top" : "format-justify-left"
                     checked: parent.panelPosition === position
                     checkable: true
                     exclusiveGroup: alignmentGroup
 
                     property int position: panelIsVertical ? Latte.Types.Top : Latte.Types.Left
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18nc("center alignment", "Center")
                     iconSource: panelIsVertical ? "format-align-vertical-center" : "format-justify-center"
                     checked: parent.panelPosition === position
                     checkable: true
                     exclusiveGroup: alignmentGroup
 
                     property int position: Latte.Types.Center
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: panelIsVertical ? i18nc("bottom alignment", "Bottom") : i18nc("right alignment", "Right")
                     iconSource: panelIsVertical ? "format-align-vertical-bottom" : "format-justify-right"
                     checked: parent.panelPosition === position
                     checkable: true
                     exclusiveGroup: alignmentGroup
 
                     property int position: panelIsVertical ? Latte.Types.Bottom : Latte.Types.Right
                 }
 
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18nc("justify alignment", "Justify")
                     iconSource: "format-justify-fill"
                     checked: parent.panelPosition === position
                     checkable: true
                     exclusiveGroup: alignmentGroup
 
                     property int position: Latte.Types.Justify
                 }
             }
         }
         //! END: Alignment
 
         //! BEGIN: Visibility
         ColumnLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
 
             LatteExtraControls.Header {
                 text: i18n("Visibility")
             }
 
             GridLayout {
                 width: parent.width
                 rowSpacing: 1
                 columnSpacing: 2
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.rightMargin: units.smallSpacing * 2
 
                 columns: 2
 
                 property int mode: latteView.visibility.mode
 
                 ExclusiveGroup {
                     id: visibilityGroup
                     onCurrentChanged: {
                         if (current.checked)
                             latteView.visibility.mode = current.mode
                     }
                 }
 
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18n("Always Visible")
                     checked: parent.mode === mode
                     checkable: true
                     exclusiveGroup: visibilityGroup
 
                     property int mode: Latte.Types.AlwaysVisible
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18n("Auto Hide")
                     checked: parent.mode === mode
                     checkable: true
                     exclusiveGroup: visibilityGroup
 
                     property int mode: Latte.Types.AutoHide
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18n("Dodge Active")
                     checked: parent.mode === mode
                     checkable: true
                     exclusiveGroup: visibilityGroup
 
                     property int mode: Latte.Types.DodgeActive
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18n("Dodge Maximized")
                     checked: parent.mode === mode
                     checkable: true
                     exclusiveGroup: visibilityGroup
 
                     property int mode: Latte.Types.DodgeMaximized
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18n("Dodge All Windows")
                     checked: parent.mode === mode
                     checkable: true
                     exclusiveGroup: visibilityGroup
 
                     property int mode: Latte.Types.DodgeAllWindows
                 }
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18n("Windows Go Below")
                     checked: parent.mode === mode
                     checkable: true
                     exclusiveGroup: visibilityGroup
 
                     property int mode: Latte.Types.WindowsGoBelow
                 }
             }
         }
         //! END: Visibility
 
         //! BEGIN: Delay
         ColumnLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
 
             enabled: !(latteView.visibility.mode === Latte.Types.AlwaysVisible
                        || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
 
             LatteExtraControls.Header {
                 Layout.fillWidth: true
                 text: i18n("Delay")
             }
 
             RowLayout {
                 Layout.fillWidth: false
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.rightMargin: units.smallSpacing * 2
                 Layout.alignment: Qt.AlignHCenter
 
                 spacing: 2
 
                 PlasmaComponents.Label {
                     Layout.fillWidth: false
                     Layout.rightMargin: Qt.application.layoutDirection === Qt.RightToLeft ? 0 : units.smallSpacing
                     Layout.leftMargin: Qt.application.layoutDirection === Qt.RightToLeft ? units.smallSpacing : 0
                     horizontalAlignment: Text.AlignRight
                     text: i18n("Show")
                 }
                 LatteExtraControls.TextField {
                     Layout.preferredWidth: width
                     text: latteView.visibility.timerShow
 
                     onValueChanged: {
                         latteView.visibility.timerShow = value
                     }
                 }
 
                 PlasmaComponents.Label {
                     Layout.fillWidth: false
                     Layout.leftMargin: Qt.application.layoutDirection === Qt.RightToLeft ?
                                            units.smallSpacing : units.largeSpacing
                     Layout.rightMargin: Qt.application.layoutDirection === Qt.RightToLeft ?
                                             units.largeSpacing : units.smallSpacing
                     horizontalAlignment: Text.AlignRight
                     text: i18n("Hide")
                 }
                 LatteExtraControls.TextField{
                     Layout.preferredWidth: width
                     text: latteView.visibility.timerHide
 
                     onValueChanged: {
                         latteView.visibility.timerHide = value
                     }
                 }
             }
         }
         //! END: Delay
 
         //! BEGIN: Items
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             visible: dialog.expertLevel
 
             LatteExtraControls.Header {
                 text: i18n("Items")
             }
 
             PlasmaComponents.CheckBox {
                 id: titleTooltipsChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show title tooltips on hovering")
                 checked: plasmoid.configuration.titleTooltips
 
                 onClicked: {
                     plasmoid.configuration.titleTooltips = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: mouseWheelChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Activate through mouse wheel")
                 checked: plasmoid.configuration.mouseWheelActions
                 tooltip: i18n("Enable/Disable the mouse wheel action")
                 visible: dialog.highLevel
 
                 onClicked: {
                     plasmoid.configuration.mouseWheelActions = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Activate based on position through global shortcuts")
-                checked: latteView.isPreferredForShortcuts
+                checked: latteView.isPreferredForShortcuts || (!latteView.managedLayout.preferredForShortcutsTouched && latteView.isHighestPriorityView())
                 //enabled: shortcutsEngine.basedOnPositionEnabled
 
                 tooltip: i18n("This view is used for based on position global shortcuts. Take note that only one view can have that option enabled for each layout")
 
                 onClicked: {
                     latteView.isPreferredForShortcuts = checked
+                    if (!latteView.managedLayout.preferredForShortcutsTouched) {
+                        latteView.managedLayout.preferredForShortcutsTouched = true
+                    }
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Decrease size automatically when needed")
                 checked: plasmoid.configuration.autoDecreaseIconSize
                 tooltip: i18n("Items size is decreased automatically when the contents exceed the maximum length \n\nHint: this option is disabled when plasma taskmanagers are present")
                 enabled: !(latteView.tasksPresent() && !latteView.latteTasksPresent());
 
                 onClicked: {
                     plasmoid.configuration.autoDecreaseIconSize = checked
                 }
             }
         }
         //! END: Items
 
         //! BEGIN: Adjust
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             visible: dialog.expertLevel
 
             LatteExtraControls.Header {
                 text: i18n("Environment")
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Activate KWin edge after hiding")
                 checked: latteView.visibility.enableKWinEdges
                 tooltip: i18n("After the view becomes hidden, KWin is informed to track user feedback. For example an edge visual hint is shown whenever the mouse approaches the hidden view")
 
                 onClicked: {
                     latteView.visibility.enableKWinEdges = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Can be above fullscreen windows")
                 checked: latteView.byPassWM
                 enabled: !(latteView.visibility.mode === Latte.Types.AlwaysVisible
                            || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
 
                 tooltip: i18n("BypassWindowManagerHint flag for the window. The view will be above all windows even those set as 'Always On Top'")
 
                 onCheckedChanged: {
                     latteView.byPassWM = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Raise on desktop change")
                 checked: latteView.visibility.raiseOnDesktop
                 enabled: latteView.visibility.mode !== Latte.Types.AlwaysVisible
 
                 onClicked: {
                     latteView.visibility.raiseOnDesktop = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Raise on activity change")
                 checked: latteView.visibility.raiseOnActivity
                 enabled: latteView.visibility.mode !== Latte.Types.AlwaysVisible
 
                 onClicked: {
                     latteView.visibility.raiseOnActivity = checked
                 }
             }
         }
         //! END: Adjust
 
         //! Bottom spacer
         PlasmaComponents.Label{
             id: bottomMarginSpacer
             text:" "
         }
     }
 }
diff --git a/shell/package/contents/configuration/pages/TasksConfig.qml b/shell/package/contents/configuration/pages/TasksConfig.qml
index 80c2e25d..1f67e42d 100644
--- a/shell/package/contents/configuration/pages/TasksConfig.qml
+++ b/shell/package/contents/configuration/pages/TasksConfig.qml
@@ -1,516 +1,516 @@
 /*
 *  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/>.
 */
 import QtQuick 2.7
 import QtQuick.Controls 1.4
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.components 3.0 as PlasmaComponents3
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte 0.2 as Latte
 
 import "../../controls" as LatteExtraControls
 
 PlasmaComponents.Page {
     Layout.maximumWidth: content.width + content.Layout.leftMargin * 2
     Layout.maximumHeight: content.height + units.smallSpacing * 2
 
     property bool disableAllWindowsFunctionality: plasmoid.configuration.showWindowsOnlyFromLaunchers
                                                   && plasmoid.configuration.activeIndicator === Latte.Types.NoneIndicator
 
     ColumnLayout {
         id: content
 
         width: (dialog.appliedWidth - units.smallSpacing * 2) - Layout.leftMargin * 2
         spacing: dialog.subGroupSpacing
         anchors.horizontalCenter: parent.horizontalCenter
         Layout.leftMargin: units.smallSpacing * 2
         Layout.rightMargin: units.smallSpacing * 2
 
         //! BEGIN: Tasks Appearance
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.topMargin: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             enabled: !disableAllWindowsFunctionality
 
             LatteExtraControls.Header {
                 text: i18n("Appearance")
             }
 
             PlasmaComponents.CheckBox {
                 id: threeColorsWindows
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Different color for minimized windows")
                 checked: plasmoid.configuration.threeColorsWindows
 
                 onClicked: {
                     plasmoid.configuration.threeColorsWindows = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: dotsOnActive
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show an extra dot for grouped windows when active")
                 checked: plasmoid.configuration.dotsOnActive
                 tooltip: i18n("Grouped windows show both a line and a dot when \none of them is active and the Line Active Indicator \nis enabled")
                 visible: dialog.highLevel
                 enabled: plasmoid.configuration.activeIndicatorType === Latte.Types.LineIndicator
 
                 onClicked: {
                     plasmoid.configuration.dotsOnActive = checked
                 }
             }
 
         }
         //! END: Tasks Appearance
 
         //! BEGIN: Badges
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.topMargin: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             visible: dialog.highLevel
 
             LatteExtraControls.Header {
                 text: i18n("Badges")
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Unread messages from tasks")
                 checked: plasmoid.configuration.showInfoBadge
                 tooltip: i18n("Show unread messages or information from tasks")
 
                 onClicked: {
                     plasmoid.configuration.showInfoBadge = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Progress information for tasks")
                 checked: plasmoid.configuration.showProgressBadge
                 tooltip: i18n("Show a progress animation for tasks e.g. when copying files with Dolphin")
 
                 onClicked: {
                     plasmoid.configuration.showProgressBadge = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Audio playing from tasks")
                 checked: plasmoid.configuration.showAudioBadge
                 tooltip: i18n("Show audio playing from tasks, the user is able to mute/unmute or change the volume")
 
                 onClicked: {
                     plasmoid.configuration.showAudioBadge = checked
                 }
             }
         }
         //! END: Badges
 
         //! BEGIN: Tasks Interaction
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
 
             LatteExtraControls.Header {
                 text: i18n("Interaction")
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Add launchers only in the Tasks Area")
                 checked: plasmoid.configuration.addLaunchersInTaskManager
                 tooltip: i18n("Launchers are added only in the taskmanager and not as plasma applets")
 
                 onClicked: {
                     plasmoid.configuration.addLaunchersInTaskManager = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: windowActionsChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show window actions in the context menu")
                 checked: plasmoid.configuration.showWindowActions
                 visible: dialog.highLevel
                 enabled: !disableAllWindowsFunctionality
 
                 onClicked: {
                     plasmoid.configuration.showWindowActions = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: unifyGlobalShortcutsChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Based on position shortcuts apply only for tasks")
                 checked: !plasmoid.configuration.unifiedGlobalShortcuts
                 tooltip: i18n("Based on position global shortcuts are enabled only for tasks and not for applets")
                 visible: dialog.highLevel
-                enabled: latteView.isPreferredForShortcuts
+                enabled: latteView.isPreferredForShortcuts || (!latteView.managedLayout.preferredForShortcutsTouched && latteView.isHighestPriorityView())
 
                 onClicked: {
                     plasmoid.configuration.unifiedGlobalShortcuts = !checked
                 }
             }
         }
         //! END: Tasks Interaction
 
         //! BEGIN: Tasks Filters
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
 
             LatteExtraControls.Header {
                 text: i18n("Filters")
             }
 
             PlasmaComponents.CheckBox {
                 id: showOnlyCurrentScreen
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show only tasks from the current screen")
                 checked: plasmoid.configuration.showOnlyCurrentScreen
 
                 onClicked: {
                     plasmoid.configuration.showOnlyCurrentScreen = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: showOnlyCurrentDesktop
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show only tasks from the current desktop")
                 checked: plasmoid.configuration.showOnlyCurrentDesktop
 
                 onClicked: {
                     plasmoid.configuration.showOnlyCurrentDesktop = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: showOnlyCurrentActivity
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show only tasks from the current activity")
                 checked: plasmoid.configuration.showOnlyCurrentActivity
 
                 onClicked: {
                     plasmoid.configuration.showOnlyCurrentActivity = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: showWindowsOnlyFromLaunchersChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show only tasks from launchers")
                 checked: plasmoid.configuration.showWindowsOnlyFromLaunchers
                 visible: dialog.highLevel
 
                 onClicked: {
                     plasmoid.configuration.showWindowsOnlyFromLaunchers = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: groupTasksChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Group tasks of the same application")
                 checked: plasmoid.configuration.groupTasksByDefault
                 tooltip: i18n("By default group tasks of the same application")
                 visible: dialog.highLevel
 
                 onClicked: {
                     plasmoid.configuration.groupTasksByDefault = checked
                 }
             }
         }
         //! END: Tasks Filters
 
         //! BEGIN: Launchers Group
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
 
             LatteExtraControls.Header {
                 text: i18n("Launchers")
             }
 
             RowLayout {
                 Layout.fillWidth: true
                 Layout.leftMargin: units.smallSpacing * 2
                 spacing: 2
 
                 property int group: plasmoid.configuration.launchersGroup
 
                 ExclusiveGroup {
                     id: launchersGroup
                     onCurrentChanged: {
                         if (current.checked) {
                             viewConfig.updateLaunchersForGroup(current.group);
                             plasmoid.configuration.launchersGroup = current.group;
                         }
                     }
                 }
 
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18nc("unique launchers group","Unique")
                     checked: parent.group === group
                     checkable: true
                     exclusiveGroup: launchersGroup
                     tooltip: i18n("Use a unique set of launchers for this view which is independent from any other view")
 
                     readonly property int group: Latte.Types.UniqueLaunchers
                 }
 
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18nc("layout launchers group","Layout")
                     checked: parent.group === group
                     checkable: true
                     exclusiveGroup: launchersGroup
                     tooltip: i18n("Use the current layout set of launchers for this latteView. This group provides launchers <b>synchronization</b> between different views in the <b>same layout</b>")
                     //! it is shown only when the user has activated that option manually from the text layout file
                     visible: plasmoid.configuration.launchersGroup === group
 
                     readonly property int group: Latte.Types.LayoutLaunchers
                 }
 
                 PlasmaComponents.Button {
                     Layout.fillWidth: true
                     text: i18nc("global launchers group","Global")
                     checked: parent.group === group
                     checkable: true
                     exclusiveGroup: launchersGroup
                     tooltip: i18n("Use the global set of launchers for this latteView. This group provides launchers <b>synchronization</b> between different views and between <b>different layouts</b>")
 
                     readonly property int group: Latte.Types.GlobalLaunchers
                 }
             }
         }
         //! END: Launchers Group
 
         //! BEGIN: Actions
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             visible: dialog.expertLevel
 
             LatteExtraControls.Header {
                 text: i18n("Actions")
             }
 
             GridLayout {
                 columns: 2
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.topMargin: units.smallSpacing
                 enabled: !disableAllWindowsFunctionality
 
                 PlasmaComponents.Label {
                     text: i18n("Left Click")
                 }
 
                 PlasmaComponents3.ComboBox {
                     id: leftClickAction
                     Layout.fillWidth: true
                     model: [i18nc("present windows action", "Present Windows"),
                         i18n("Cycle Through Tasks"),
                         i18n("Preview Windows")]
 
                     currentIndex: {
                         switch(plasmoid.configuration.leftClickAction) {
                         case Latte.Types.PresentWindows:
                             return 0;
                         case Latte.Types.CycleThroughTasks:
                             return 1;
                         case Latte.Types.PreviewWindows:
                             return 2;
                         }
 
                         return 0;
                     }
 
                     onCurrentIndexChanged: {
                         switch(currentIndex) {
                         case 0:
                             plasmoid.configuration.leftClickAction = Latte.Types.PresentWindows;
                             break;
                         case 1:
                             plasmoid.configuration.leftClickAction = Latte.Types.CycleThroughTasks;
                             break;
                         case 2:
                             plasmoid.configuration.leftClickAction = Latte.Types.PreviewWindows;
                             break;
                         }
                     }
                 }
 
                 PlasmaComponents.Label {
                     text: i18n("Middle Click")
                 }
 
                 PlasmaComponents3.ComboBox {
                     id: middleClickAction
                     Layout.fillWidth: true
                     model: [
                         i18nc("The click action", "None"),
                         i18n("Close Window or Group"),
                         i18n("New Instance"),
                         i18n("Minimize/Restore Window or Group"),
                         i18n("Cycle Through Tasks"),
                         i18n("Toggle Task Grouping")
                     ]
 
                     currentIndex: plasmoid.configuration.middleClickAction
                     onCurrentIndexChanged: plasmoid.configuration.middleClickAction = currentIndex
                 }
 
                 PlasmaComponents.Label {
                     text: i18n("Hover")
                 }
 
                 PlasmaComponents3.ComboBox {
                     id: hoverAction
                     Layout.fillWidth: true
                     model: [
                         i18nc("none action", "None"),
                         i18n("Preview Windows"),
                         i18n("Highlight Windows"),
                         i18n("Preview and Highlight Windows"),
                     ]
 
                     currentIndex: {
                         switch(plasmoid.configuration.hoverAction) {
                         case Latte.Types.NoneAction:
                             return 0;
                         case Latte.Types.PreviewWindows:
                             return 1;
                         case Latte.Types.HighlightWindows:
                             return 2;
                         case Latte.Types.PreviewAndHighlightWindows:
                             return 3;
                         }
 
                         return 0;
                     }
 
                     onCurrentIndexChanged: {
                         switch(currentIndex) {
                         case 0:
                             plasmoid.configuration.hoverAction = Latte.Types.NoneAction;
                             break;
                         case 1:
                             plasmoid.configuration.hoverAction = Latte.Types.PreviewWindows;
                             break;
                         case 2:
                             plasmoid.configuration.hoverAction = Latte.Types.HighlightWindows;
                             break;
                         case 3:
                             plasmoid.configuration.hoverAction = Latte.Types.PreviewAndHighlightWindows;
                             break;
                         }
                     }
                 }
             }
 
             RowLayout {
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.topMargin: units.smallSpacing
                 spacing: units.smallSpacing
                 enabled: !disableAllWindowsFunctionality
 
                 PlasmaComponents3.ComboBox {
                     id: modifier
                     Layout.maximumWidth: theme.mSize(theme.defaultFont).width * 5
                     model: ["Shift", "Ctrl", "Alt", "Meta"]
 
                     currentIndex: plasmoid.configuration.modifier
                     onCurrentIndexChanged: plasmoid.configuration.modifier = currentIndex
                 }
 
                 PlasmaComponents.Label {
                     text: "+"
                 }
 
                 PlasmaComponents3.ComboBox {
                     id: modifierClick
                     Layout.maximumWidth: theme.mSize(theme.defaultFont).width * 10
                     model: [i18n("Left Click"), i18n("Middle Click"), i18n("Right Click")]
 
                     currentIndex: plasmoid.configuration.modifierClick
                     onCurrentIndexChanged: plasmoid.configuration.modifierClick = currentIndex
                 }
 
                 PlasmaComponents.Label {
                     text: "="
                 }
 
                 PlasmaComponents3.ComboBox {
                     id: modifierClickAction
                     Layout.fillWidth: true
                     model: [i18nc("The click action", "None"), i18n("Close Window or Group"),
                         i18n("New Instance"), i18n("Minimize/Restore Window or Group"),  i18n("Cycle Through Tasks"), i18n("Toggle Task Grouping")]
 
                     currentIndex: plasmoid.configuration.modifierClickAction
                     onCurrentIndexChanged: plasmoid.configuration.modifierClickAction = currentIndex
                 }
             }
         }
         //! END: Actions
 
         //! BEGIN: Actions
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             visible: dialog.expertLevel
 
             LatteExtraControls.Header {
                 text: i18n("Recycling")
             }
 
             PlasmaComponents.Button {
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.topMargin: units.smallSpacing
                 Layout.fillWidth: true
 
                 text: i18n("Remove Latte Tasks Applet")
                 enabled: latteView.latteTasksPresent()
                 tooltip: i18n("Remove Latte Tasks plasmoid")
 
                 onClicked: {
                     latteView.removeTasksPlasmoid();
                 }
             }
         }
 
         //! Bottom spacer
         PlasmaComponents.Label{
             id: bottomMarginSpacer
             text:" "
         }
     }
 }