diff --git a/app/view/containmentinterface.cpp b/app/view/containmentinterface.cpp
index a4c49227..0919dc6e 100644
--- a/app/view/containmentinterface.cpp
+++ b/app/view/containmentinterface.cpp
@@ -1,639 +1,639 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "containmentinterface.h"
 
 // local
 #include "view.h"
 #include "../lattecorona.h"
 #include "../layout/genericlayout.h"
 #include "../settings/universalsettings.h"
 
 // Qt
 #include <QDebug>
 
 // Plasma
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 #include <PlasmaQuick/AppletQuickItem>
 
 // KDE
 #include <KLocalizedString>
 #include <KPluginMetaData>
 
 namespace Latte {
 namespace ViewPart {
 
 ContainmentInterface::ContainmentInterface(Latte::View *parent)
     : QObject(parent),
       m_view(parent)
 {
     m_corona = qobject_cast<Latte::Corona *>(m_view->corona());
 
     m_latteTasksModel = new TasksModel(this);
     m_plasmaTasksModel = new TasksModel(this);
 
     m_appletsExpandedConnectionsTimer.setInterval(2000);
     m_appletsExpandedConnectionsTimer.setSingleShot(true);
 
     connect(&m_appletsExpandedConnectionsTimer, &QTimer::timeout, this, &ContainmentInterface::updateAppletsTracking);
 
     connect(m_view, &View::containmentChanged
             , this, [&]() {
         if (m_view->containment()) {
             connect(m_view->containment(), &Plasma::Containment::appletAdded, this, &ContainmentInterface::on_appletAdded);
 
             m_appletsExpandedConnectionsTimer.start();
         }
     });
 
     connect(m_latteTasksModel, &TasksModel::countChanged, this, &ContainmentInterface::onLatteTasksCountChanged);
     connect(m_plasmaTasksModel, &TasksModel::countChanged, this, &ContainmentInterface::onPlasmaTasksCountChanged);
 }
 
 ContainmentInterface::~ContainmentInterface()
 {
 }
 
 void ContainmentInterface::identifyShortcutsHost()
 {
     if (m_shortcutsHost) {
         return;
     }
 
     if (QQuickItem *graphicItem = m_view->containment()->property("_plasma_graphicObject").value<QQuickItem *>()) {
         const auto &childItems = graphicItem->childItems();
 
         for (QQuickItem *item : childItems) {
             if (item->objectName() == "containmentViewLayout" ) {
                 for (QQuickItem *subitem : item->childItems()) {
                     if (subitem->objectName() == "PositionShortcutsAbilityHost") {
                         m_shortcutsHost = subitem;
                         identifyMethods();
                         return;
                     }
                 }
             }
         }
     }
 }
 
 void ContainmentInterface::identifyMethods()
 {
     int aeIndex = m_shortcutsHost->metaObject()->indexOfMethod("activateEntryAtIndex(QVariant)");
     int niIndex = m_shortcutsHost->metaObject()->indexOfMethod("newInstanceForEntryAtIndex(QVariant)");
     int sbIndex = m_shortcutsHost->metaObject()->indexOfMethod("setShowAppletShortcutBadges(QVariant,QVariant,QVariant,QVariant)");
     int afiIndex = m_shortcutsHost->metaObject()->indexOfMethod("appletIdForIndex(QVariant)");
 
     m_activateEntryMethod = m_shortcutsHost->metaObject()->method(aeIndex);
     m_appletIdForIndexMethod = m_shortcutsHost->metaObject()->method(afiIndex);
     m_newInstanceMethod = m_shortcutsHost->metaObject()->method(niIndex);
     m_showShortcutsMethod = m_shortcutsHost->metaObject()->method(sbIndex);
 }
 
 bool ContainmentInterface::applicationLauncherHasGlobalShortcut() const
 {
     if (!containsApplicationLauncher()) {
         return false;
     }
 
     uint launcherAppletId = applicationLauncherId();
 
     const auto applets = m_view->containment()->applets();
 
     for (auto applet : applets) {
         if (applet->id() == launcherAppletId) {
             return !applet->globalShortcut().isEmpty();
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::applicationLauncherInPopup() const
 {
     if (!containsApplicationLauncher()) {
         return false;
     }
 
     uint launcherAppletId = applicationLauncherId();
     QString launcherPluginId;
 
     const auto applets = m_view->containment()->applets();
 
     for (auto applet : applets) {
         if (applet->id() == launcherAppletId) {
             launcherPluginId = applet->kPackage().metadata().pluginId();
         }
     }
 
     return launcherPluginId != "org.kde.plasma.kickerdash";
 }
 
 bool ContainmentInterface::containsApplicationLauncher() const
 {
     return (applicationLauncherId() >= 0);
 }
 
 bool ContainmentInterface::isCapableToShowShortcutBadges()
 {
     identifyShortcutsHost();
 
     if (!hasLatteTasks() && hasPlasmaTasks()) {
         return false;
     }
 
     return m_showShortcutsMethod.isValid();
 }
 
 int ContainmentInterface::applicationLauncherId() const
 {
     const auto applets = m_view->containment()->applets();
 
     auto launcherId{-1};
 
     for (auto applet : applets) {
         const auto provides = applet->kPackage().metadata().value(QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.launchermenu"))) {
             if (!applet->globalShortcut().isEmpty()) {
                 return applet->id();
             } else if (launcherId == -1) {
                 launcherId = applet->id();
             }
         }
     }
 
     return launcherId;
 }
 
 bool ContainmentInterface::updateBadgeForLatteTask(const QString identifier, const QString value)
 {
     if (!hasLatteTasks()) {
         return false;
     }
 
     const auto &applets = m_view->containment()->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;
 }
 
 bool ContainmentInterface::activatePlasmaTask(const int index)
 {
     bool containsPlasmaTaskManager{hasPlasmaTasks() && !hasLatteTasks()};
 
     if (!containsPlasmaTaskManager) {
         return false;
     }
 
     const auto &applets = m_view->containment()->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()) {
                         int methodIndex{metaObject->indexOfMethod("activateTaskAtIndex(QVariant)")};
 
                         if (methodIndex == -1) {
                             continue;
                         }
 
                         QMetaMethod method = metaObject->method(methodIndex);
 
                         if (method.invoke(item, Q_ARG(QVariant, index - 1))) {
                             showShortcutBadges(false, true);
 
                             return true;
                         }
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::newInstanceForPlasmaTask(const int index)
 {
     bool containsPlasmaTaskManager{hasPlasmaTasks() && !hasLatteTasks()};
 
     if (!containsPlasmaTaskManager) {
         return false;
     }
 
     const auto &applets = m_view->containment()->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()) {
-                        int methodIndex{metaObject->indexOfMethod("ewInstanceForTaskAtIndex(QVariant)")};
+                        int methodIndex{metaObject->indexOfMethod("newInstanceForTaskAtIndex(QVariant)")};
 
                         if (methodIndex == -1) {
                             continue;
                         }
 
                         QMetaMethod method = metaObject->method(methodIndex);
 
                         if (method.invoke(item, Q_ARG(QVariant, index - 1))) {
                             showShortcutBadges(false, true);
 
                             return true;
                         }
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::activateEntry(const int index)
 {
     identifyShortcutsHost();
 
     if (!m_activateEntryMethod.isValid()) {
         return false;
     }
 
     return m_activateEntryMethod.invoke(m_shortcutsHost, Q_ARG(QVariant, index));
 }
 
 bool ContainmentInterface::newInstanceForEntry(const int index)
 {
     identifyShortcutsHost();
 
     if (!m_newInstanceMethod.isValid()) {
         return false;
     }
 
     return m_newInstanceMethod.invoke(m_shortcutsHost, Q_ARG(QVariant, index));
 }
 
 bool ContainmentInterface::hideShortcutBadges()
 {
     identifyShortcutsHost();
 
     if (!m_showShortcutsMethod.isValid()) {
         return false;
     }
 
     return m_showShortcutsMethod.invoke(m_shortcutsHost, Q_ARG(QVariant, false), Q_ARG(QVariant, false), Q_ARG(QVariant, false), Q_ARG(QVariant, -1));
 }
 
 bool ContainmentInterface::showOnlyMeta()
 {
     if (!m_corona->universalSettings()->kwin_metaForwardedToLatte()) {
         return false;
     }
 
     return showShortcutBadges(false, true);
 }
 
 bool ContainmentInterface::showShortcutBadges(const bool showLatteShortcuts, const bool showMeta)
 {
     identifyShortcutsHost();
 
     if (!m_showShortcutsMethod.isValid() || !isCapableToShowShortcutBadges()) {
         return false;
     }
 
     int appLauncherId = m_corona->universalSettings()->kwin_metaForwardedToLatte() && showMeta ? applicationLauncherId() : -1;
 
     return m_showShortcutsMethod.invoke(m_shortcutsHost, Q_ARG(QVariant, showLatteShortcuts), Q_ARG(QVariant, true), Q_ARG(QVariant, showMeta), Q_ARG(QVariant, appLauncherId));
 }
 
 int ContainmentInterface::appletIdForVisualIndex(const int index)
 {
     identifyShortcutsHost();
 
     if (!m_appletIdForIndexMethod.isValid()) {
         return false;
     }
 
     QVariant appletId{-1};
 
     m_appletIdForIndexMethod.invoke(m_shortcutsHost, Q_RETURN_ARG(QVariant, appletId), Q_ARG(QVariant, index));
 
     return appletId.toInt();
 }
 
 
 void ContainmentInterface::deactivateApplets()
 {
     if (!m_view->containment() || !m_view->inReadyState()) {
         return;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (ai) {
             ai->setExpanded(false);
         }
     }
 }
 
 bool ContainmentInterface::appletIsExpandable(const int id)
 {
     if (!m_view->containment() || !m_view->inReadyState()) {
         return false;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         if (applet && applet->id() == (uint)id) {
             if (m_view->layout() && m_view->layout()->isInternalContainment(applet)) {
                 return true;
             }
 
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 return appletIsExpandable(ai);
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::appletIsExpandable(PlasmaQuick::AppletQuickItem *appletQuickItem)
 {
     if (!appletQuickItem || !m_view->inReadyState()) {
         return false;
     }
 
     return (appletQuickItem->fullRepresentation() != nullptr
             && appletQuickItem->preferredRepresentation() != appletQuickItem->fullRepresentation());
 }
 
 bool ContainmentInterface::hasExpandedApplet() const
 {
     return m_expandedAppletIds.count() > 0;
 }
 
 bool ContainmentInterface::hasLatteTasks() const
 {
     return (m_latteTasksModel->count() > 0);
 }
 
 bool ContainmentInterface::hasPlasmaTasks() const
 {
     return (m_plasmaTasksModel->count() > 0);
 }
 
 void ContainmentInterface::addExpandedApplet(const int &id)
 {
     if (m_expandedAppletIds.contains(id) && appletIsExpandable(id)) {
         return;
     }
 
     bool isExpanded = hasExpandedApplet();
 
     m_expandedAppletIds << id;
 
     if (isExpanded != hasExpandedApplet()) {
         emit hasExpandedAppletChanged();
     }
 
     emit expandedAppletStateChanged();
 }
 
 void ContainmentInterface::removeExpandedApplet(const int &id)
 {
     if (!m_expandedAppletIds.contains(id)) {
         return;
     }
 
     bool isExpanded = hasExpandedApplet();
 
     m_expandedAppletIds.removeAll(id);
 
     if (isExpanded != hasExpandedApplet()) {
         emit hasExpandedAppletChanged();
     }
 
     emit expandedAppletStateChanged();
 }
 
 QAbstractListModel *ContainmentInterface::latteTasksModel() const
 {
     return m_latteTasksModel;
 }
 
 QAbstractListModel *ContainmentInterface::plasmaTasksModel() const
 {
     return m_plasmaTasksModel;
 }
 
 void ContainmentInterface::on_appletExpandedChanged()
 {
     PlasmaQuick::AppletQuickItem *appletItem = static_cast<PlasmaQuick::AppletQuickItem *>(QObject::sender());
 
     if (appletItem) {
         if (appletItem->isExpanded()) {
             addExpandedApplet(appletItem->applet()->id());
         } else {
             removeExpandedApplet(appletItem->applet()->id());
         }
     }
 }
 
 void ContainmentInterface::onLatteTasksCountChanged()
 {
     if ((m_hasLatteTasks && m_latteTasksModel->count()>0)
             || (!m_hasLatteTasks && m_latteTasksModel->count() == 0)) {
         return;
     }
 
     m_hasLatteTasks = (m_latteTasksModel->count() > 0);
     emit hasLatteTasksChanged();
 }
 
 void ContainmentInterface::onPlasmaTasksCountChanged()
 {
     if ((m_hasPlasmaTasks && m_plasmaTasksModel->count()>0)
             || (!m_hasPlasmaTasks && m_plasmaTasksModel->count() == 0)) {
         return;
     }
 
     m_hasPlasmaTasks = (m_plasmaTasksModel->count() > 0);
     emit hasPlasmaTasksChanged();
 }
 
 bool ContainmentInterface::appletIsExpanded(const int id)
 {
     return m_expandedAppletIds.contains(id);
 }
 
 void ContainmentInterface::toggleAppletExpanded(const int id)
 {
     if (!m_view->containment() || !m_view->inReadyState()) {
         return;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         if (applet->id() == (uint)id && !m_view->layout()->isInternalContainment(applet)/*block for internal containments*/) {
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 if (appletIsExpandable(ai)) {
                     ai->setExpanded(!ai->isExpanded());
                 } else {
                     emit applet->activated();
                 }
             }
         }
     }
 }
 
 void ContainmentInterface::updateAppletsTracking()
 {
     if (!m_view->containment()) {
         return;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         on_appletAdded(applet);
     }
 }
 
 void ContainmentInterface::on_appletAdded(Plasma::Applet *applet)
 {
     if (!m_view->containment() || !applet) {
         return;
     }
 
     if (m_view->layout() && m_view->layout()->isInternalContainment(applet)) {
         //! internal containment case
         Plasma::Containment *internalC = m_view->layout()->internalContainmentOf(applet);
         PlasmaQuick::AppletQuickItem *contAi = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (contAi && !m_appletsExpandedConnections.contains(contAi)) {
             m_appletsExpandedConnections[contAi] = connect(contAi, &PlasmaQuick::AppletQuickItem::expandedChanged, this, &ContainmentInterface::on_appletExpandedChanged);
 
             connect(contAi, &QObject::destroyed, this, [&, contAi](){
                 m_appletsExpandedConnections.remove(contAi);
                 removeExpandedApplet(contAi->applet()->id());
             });
         }
 
         for (const auto internalApplet : internalC->applets()) {
             PlasmaQuick::AppletQuickItem *ai = internalApplet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai && !m_appletsExpandedConnections.contains(ai) ){
                 m_appletsExpandedConnections[ai] = connect(ai, &PlasmaQuick::AppletQuickItem::expandedChanged, this, &ContainmentInterface::on_appletExpandedChanged);
 
                 connect(ai, &QObject::destroyed, this, [&, ai](){
                     m_appletsExpandedConnections.remove(ai);
                     removeExpandedApplet(ai->applet()->id());
                 });
             }
         }
     } else {
         PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (!ai) {
             return;
         }
 
         KPluginMetaData meta = applet->kPackage().metadata();
         const auto &provides = KPluginMetaData::readStringList(meta.rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (meta.pluginId() == "org.kde.latte.plasmoid") {
             //! populate latte tasks applet
             m_latteTasksModel->addTask(ai);
         } else if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             //! populate plasma tasks applet
             m_plasmaTasksModel->addTask(ai);
         } else if (!m_appletsExpandedConnections.contains(ai)) {
             m_appletsExpandedConnections[ai] = connect(ai, &PlasmaQuick::AppletQuickItem::expandedChanged, this, &ContainmentInterface::on_appletExpandedChanged);
 
             connect(ai, &QObject::destroyed, this, [&, ai](){
                 m_appletsExpandedConnections.remove(ai);
                 removeExpandedApplet(ai->applet()->id());
             });
         }
     }
 
 }
 
 
 }
 }
diff --git a/containment/package/contents/ui/abilities/PositionShortcuts.qml b/containment/package/contents/ui/abilities/PositionShortcuts.qml
index da665dda..555716ca 100644
--- a/containment/package/contents/ui/abilities/PositionShortcuts.qml
+++ b/containment/package/contents/ui/abilities/PositionShortcuts.qml
@@ -1,66 +1,66 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.8
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.plasmoid 2.0
 
 import "./privates" as Ability
 
 Ability.PositionShortcutsPrivate {
     id: _shortcuts
     objectName: "PositionShortcutsAbilityHost"
 
     //! do not update during dragging/moving applets inConfigureAppletsMode
     updateIsBlocked: (root.dragOverlay && root.dragOverlay.pressed)
                      || layouter.appletsInParentChange
 
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletShortcutBadges(showPositionShortcuts, showShortcuts, showMeta, applicationLauncher){
         showPositionShortcutBadges = showPositionShortcuts;
         showAppletShortcutBadges = showShortcuts;
         showMetaBadge = showMeta;
         applicationLauncherId = applicationLauncher;
     }
 
     //! this is called from Latte::View::ContainmentInterface
-    function activateEntryAtIndex(index) {
-        if (typeof index !== "number") {
+    function activateEntryAtIndex(entryIndex) {
+        if (typeof entryIndex !== "number") {
             return;
         }
 
-        sglActivateEntryAtIndex(index);
+        sglActivateEntryAtIndex(entryIndex);
     }
 
     //! this is called from Latte::View::ContainmentInterface
-    function newInstanceForEntryAtIndex(index) {
-        if (typeof index !== "number") {
+    function newInstanceForEntryAtIndex(entryIndex) {
+        if (typeof entryIndex !== "number") {
             return;
         }
 
-        sglNewInstanceForEntryAtIndex(index);
+        sglNewInstanceForEntryAtIndex(entryIndex);
     }
 
     //! this is called from Latte::View::ContainmentInterface
-    function appletIdForIndex(index) {
-        return indexer.appletIdForVisibleIndex(index);
+    function appletIdForIndex(entryIndex) {
+        return indexer.appletIdForVisibleIndex(entryIndex);
     }
 }
diff --git a/containment/package/contents/ui/abilities/privates/PositionShortcutsPrivate.qml b/containment/package/contents/ui/abilities/privates/PositionShortcutsPrivate.qml
index e25a0a40..0a133add 100644
--- a/containment/package/contents/ui/abilities/privates/PositionShortcutsPrivate.qml
+++ b/containment/package/contents/ui/abilities/privates/PositionShortcutsPrivate.qml
@@ -1,83 +1,81 @@
 /*
 *  Copyright 2020 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
 
-Item {
+import org.kde.latte.abilities.definitions 0.1 as AbilityDefinition
+
+AbilityDefinition.PositionShortcuts {
     id: _shortcutsprivate
     property Item layouts: null
     property bool updateIsBlocked: false
 
     readonly property bool unifiedGlobalShortcuts: appletIdStealingPositionShortcuts === -1
 
-    property bool showPositionShortcutBadges: false
     property bool showAppletShortcutBadges: false
     property bool showMetaBadge: false
     property int applicationLauncherId: -1
 
     property int appletIdStealingPositionShortcuts: -1
 
-    signal sglActivateEntryAtIndex(int entryIndex);
-    signal sglNewInstanceForEntryAtIndex(int entryIndex);
-
     Binding {
         target: _shortcutsprivate
         property: "appletIdStealingPositionShortcuts"
         when: !updateIsBlocked
         value: {
             var sLayout = layouts.startLayout;
             for (var i=0; i<sLayout.children.length; ++i){
                 var appletItem = sLayout.children[i];
                 if (appletItem
                         && appletItem.index>=0
                         && appletItem.communicator
-                        && appletItem.communicator.onPositionShortcutsAreSupported
+                        && appletItem.communicator.positionShortcutsAreSupported
                         && appletItem.communicator.bridge.shortcuts.client.isStealingGlobalPositionShortcuts) {
                     return appletItem.index;
                 }
             }
 
             var mLayout = layouts.mainLayout;
             for (var i=0; i<mLayout.children.length; ++i){
                 var appletItem = mLayout.children[i];
                 if (appletItem
                         && appletItem.index>=0
                         && appletItem.communicator
-                        && appletItem.communicator.onPositionShortcutsAreSupported
+                        && appletItem.communicator.positionShortcutsAreSupported
                         && appletItem.communicator.bridge.shortcuts.client.isStealingGlobalPositionShortcuts) {
                     return appletItem.index;
                 }
             }
 
             var eLayout = layouts.endLayout;
             for (var i=0; i<eLayout.children.length; ++i){
                 var appletItem = eLayout.children[i];
                 if (appletItem
                         && appletItem.index>=0
                         && appletItem.communicator
-                        && appletItem.communicator.onPositionShortcutsAreSupported
+                        && appletItem.communicator.positionShortcutsAreSupported
                         && appletItem.communicator.bridge.shortcuts.client.isStealingGlobalPositionShortcuts) {
                     return appletItem.index;
                 }
             }
 
             return -1;
         }
     }
 }
diff --git a/containment/package/contents/ui/applet/AppletItem.qml b/containment/package/contents/ui/applet/AppletItem.qml
index ef329b53..bdbbea63 100644
--- a/containment/package/contents/ui/applet/AppletItem.qml
+++ b/containment/package/contents/ui/applet/AppletItem.qml
@@ -1,1199 +1,1199 @@
 /*
 *  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.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "colorizer" as Colorizer
 import "communicator" as Communicator
 import "indicator" as Indicator
 import "../debug" as Debug
 
 Item {
     id: appletItem
 
     visible: false
     width: isInternalViewSplitter && !root.inConfigureAppletsMode ? 0 : computeWidth
     height: isInternalViewSplitter && !root.inConfigureAppletsMode ? 0 : computeHeight
 
     //any applets that exceed their limits should not take events from their surrounding applets
     clip: !isSeparator
 
     signal mousePressed(int x, int y, int button);
     signal mouseReleased(int x, int y, int button);
 
     property bool animationsEnabled: true
     property bool parabolicEffectIsSupported: true
     property bool canShowAppletNumberBadge: !isSeparator && !isHidden && !isLattePlasmoid
                                             && !isSpacer && !isInternalViewSplitter
 
     //! Fill Applet(s)
     property bool inFillCalculations: false //temp record, is used in calculations for fillWidth,fillHeight applets
     property bool isAutoFillApplet: {
         if (!applet || !applet.Layout)
             return false;
 
         if (((root.isHorizontal && applet.Layout.fillWidth===true)
              || (root.isVertical && applet.Layout.fillHeight===true))
                 && (applet.status !== PlasmaCore.Types.HiddenStatus))
             return true;
         else
             return false;
     }
     property int maxAutoFillLength: -1 //it is used in calculations for fillWidth,fillHeight applets
     property int minAutoFillLength: -1 //it is used in calculations for fillWidth,fillHeight applets
 
     property bool userBlocksColorizing: false
     property bool appletBlocksColorizing: !communicator.requires.latteSideColoringEnabled
     property bool appletBlocksParabolicEffect: communicator.requires.parabolicEffectLocked
     property bool lockZoom: false
 
     property bool isActive: (isExpanded
                              && applet.pluginName !== root.plasmoidName
                              && applet.pluginName !== "org.kde.activeWindowControl"
                              && applet.pluginName !== "org.kde.plasma.appmenu")
 
     property bool isExpanded: false
 
     property bool isHidden: (applet && applet.status === PlasmaCore.Types.HiddenStatus)
                             || (isInternalViewSplitter && !root.inConfigureAppletsMode)
     property bool isInternalViewSplitter: (internalSplitterId > 0)
     property bool isLattePlasmoid: latteApplet !== null
     property bool isZoomed: false
     property bool isSeparator: applet && (applet.pluginName === "audoban.applet.separator"
                                           || applet.pluginName === "org.kde.latte.separator")
     property bool isSpacer: applet && (applet.pluginName === "org.kde.latte.spacer")
     property bool isSystray: applet && (applet.pluginName === "org.kde.plasma.systemtray" || applet.pluginName === "org.nomad.systemtray" )
 
     property bool firstChildOfStartLayout: index === appletItem.layouter.startLayout.firstVisibleIndex
     property bool firstChildOfMainLayout: index === appletItem.layouter.mainLayout.firstVisibleIndex
     property bool lastChildOfMainLayout: index === appletItem.layouter.mainLayout.lastVisibleIndex
     property bool lastChildOfEndLayout: index === appletItem.layouter.endLayout.lastVisibleIndex
 
     readonly property bool atScreenEdge: {
         if (root.panelAlignment !== LatteCore.Types.Justify || root.inConfigureAppletsMode || plasmoid.configuration.offset!==0) {
             return false;
         }
 
         if (root.panelAlignment === LatteCore.Types.Justify) {
             //! Justify case
             if (root.maxLengthPerCentage!==100) {
                 return false;
             }
 
             if (root.isHorizontal) {
                 if (firstChildOfStartLayout) {
                     return latteView && latteView.x === latteView.screenGeometry.x;
                 } else if (lastChildOfEndLayout) {
                     return latteView && ((latteView.x + latteView.width) === (latteView.screenGeometry.x + latteView.screenGeometry.width));
                 }
             } else {
                 if (firstChildOfStartLayout) {
                     return latteView && latteView.y === latteView.screenGeometry.y;
                 } else if (lastChildOfEndLayout) {
                     return latteView && ((latteView.y + latteView.height) === (latteView.screenGeometry.y + latteView.screenGeometry.height));
                 }
             }
 
             return false;
         }
 
         //! [disabled] because it is probably not needed at all. If in the future there is a report
         //! describing a case that this would be useful this disablement choice can be rethought
         /*if (root.panelAlignment === LatteCore.Types.Left) {
             //! Left case
             return firstChildOfMainLayout;
         } else if (root.panelAlignment === LatteCore.Types.Right) {
             //! Right case
             return lastChildOfMainLayout
         }
 
         if (root.panelAlignment === LatteCore.Types.Top) {
             return firstChildOfMainLayout && latteView && latteView.y === latteView.screenGeometry.y;
         } else if (root.panelAlignment === LatteCore.Types.Bottom) {
             return lastChildOfMainLayout && latteView && ((latteView.y + latteView.height) === (latteView.screenGeometry.y + latteView.screenGeometry.height));
         }*/
 
         return false;
     }
 
     //applet is in starting edge
     property bool firstAppletInContainer: (index >=0) &&
                                           ((index === layouter.startLayout.firstVisibleIndex)
                                            || (index === layouter.mainLayout.firstVisibleIndex)
                                            || (index === layouter.endLayout.firstVisibleIndex))
     //applet is in ending edge
     property bool lastAppletInContainer: (index >=0) &&
                                          ((index === layouter.startLayout.lastVisibleIndex)
                                           || (index === layouter.mainLayout.lastVisibleIndex)
                                           || (index === layouter.endLayout.lastVisibleIndex))
 
     readonly property bool acceptMouseEvents: applet && !isLattePlasmoid && !originalAppletBehavior && !appletItem.isSeparator && !communicator.requires.parabolicEffectLocked
     readonly property bool originalAppletBehavior: (appletItem.parabolic.factor.zoom === 1 && !lockZoom /*hacky flag to keep Latte behavior*/)
                                                    || (appletItem.parabolic.factor.zoom>1 && !parabolicEffectIsSupported)
                                                    || (appletItem.parabolic.factor.zoom>1 && parabolicEffectIsSupported && lockZoom)
 
     readonly property bool isSquare: communicator.overlayLatteIconIsActive
     readonly property bool screenEdgeMarginSupported: communicator.requires.screenEdgeMarginSupported
 
     property int animationTime: appletItem.animations.speedFactor.normal * (1.2*appletItem.animations.duration.small)
     property int index: -1
     property int maxWidth: root.isHorizontal ? root.height : root.width
     property int maxHeight: root.isHorizontal ? root.height : root.width
     property int internalSplitterId: 0
 
     property int previousIndex: -1
     property int spacersMaxSize: Math.max(0,Math.ceil(0.55 * metrics.iconSize) - metrics.totals.lengthEdges)
     property int status: applet ? applet.status : -1
 
     //! separators tracking
     readonly property bool tailAppletIsSeparator: {
         if (isSeparator || index<0) {
             return false;
         }
 
         var tail = index - 1;
 
         while(tail>=0 && indexer.hidden.indexOf(tail)>=0) {
             //! when a tail applet contains sub-indexing and does not influence
             //! tracking is considered hidden
             tail = tail - 1;
         }
 
         if (tail >= 0 && indexer.clients.indexOf(tail)>=0) {
             //! tail applet contains items sub-indexing
             var tailBridge = indexer.getClientBridge(tail);
 
             if (tailBridge && tailBridge.client) {
                 return tailBridge.client.lastHeadItemIsSeparator;
             }
         }
 
         // tail applet is normal
         return (indexer.separators.indexOf(tail)>=0);
     }
 
     readonly property bool headAppletIsSeparator: {
         if (isSeparator || index<0) {
             return false;
         }
 
         var head = index + 1;
 
         while(head>=0 && indexer.hidden.indexOf(head)>=0) {
             //! when a head applet contains sub-indexing and does not influence
             //! tracking is considered hidden
             head = head + 1;
         }
 
         if (head >= 0 && indexer.clients.indexOf(head)>=0) {
             //! head applet contains items sub-indexing
             var headBridge = indexer.getClientBridge(head);
 
             if (headBridge && headBridge.client) {
                 return headBridge.client.firstTailItemIsSeparator;
             }
         }
 
         // head applet is normal
         return (indexer.separators.indexOf(head)>=0);
     }
 
     //! local margins
     readonly property bool parabolicEffectMarginsEnabled: appletItem.parabolic.factor.zoom>1 && !originalAppletBehavior && !communicator.parabolicEffectIsSupported
 
     property int lengthAppletPadding: metrics.fraction.lengthAppletPadding === -1 || parabolicEffectMarginsEnabled ?
                                           metrics.padding.length : metrics.padding.lengthApplet
 
     property int lengthAppletFullMargin: 0
     property int lengthAppletFullMargins: 2 * lengthAppletFullMargin
 
     property int internalWidthMargins: {
         if (root.isVertical) {
             return metrics.totals.thicknessEdges;
         }
 
         /*TODO, Fitt's case: is temporary until the atScreenEdge applets are aligned properly to the corner and the wrapper
           is taking all the space needed in order to fill right. For atScreenEdge appplets that should be: applet size + lengthAppletPadding + lengthAppletExtMargin.
           The indicator should follow also the applet alignment in this in order to feel right
           */
         return 2 * lengthAppletPadding;
     }
 
     property int internalHeightMargins: {
         if (root.isHorizontal) {
             return root.metrics.totals.thicknessEdges;
         }
 
         /*TODO,Fitt's case: is temporary until the atScreenEdge applets are aligned properly to the corner and the wrapper
           is taking all the space needed in order to fill right. For atScreenEdge appplets that should be: applet size + lengthAppletPadding + lengthAppletExtMargin.
           The indicator should follow also the applet alignment in this in order to feel right
           */
         return 2 * lengthAppletPadding;
     }
 
     //! are set by the indicator
     property int iconOffsetX: 0
     property int iconOffsetY: 0
 
     property real computeWidth: root.isVertical ? wrapper.width :
                                                   hiddenSpacerLeft.width+wrapper.width+hiddenSpacerRight.width
 
     property real computeHeight: root.isVertical ? hiddenSpacerLeft.height + wrapper.height + hiddenSpacerRight.height :
                                                    wrapper.height
 
     property string title: isInternalViewSplitter ? "Now Dock Splitter" : ""
 
     property Item applet: null
     property Item latteApplet: applet && (applet.pluginName === root.plasmoidName) ?
                                    (applet.children[0] ? applet.children[0] : null) : null
     property Item latteStyleApplet: applet && ((applet.pluginName === "org.kde.latte.spacer") || (applet.pluginName === "org.kde.latte.separator")) ?
                                         (applet.children[0] ? applet.children[0] : null) : null
 
     property Item appletWrapper: applet && (applet.pluginName === root.plasmoidName )? wrapper : wrapper.wrapperContainer
 
     property Item tooltipVisualParent: titleTooltipParent
 
     readonly property alias communicator: _communicator
     readonly property alias wrapper: _wrapper
 
     property Item animations: null
     property Item indexer: null
     property Item layouter: null
     property Item metrics: null
     property Item parabolic: null
     property Item shortcuts: null
 
     property bool containsMouse: appletMouseArea.containsMouse || (isLattePlasmoid && latteApplet.containsMouse)
     property bool pressed: viewSignalsConnector.pressed || clickedAnimation.running
 
 
     //// BEGIN :: Animate Applet when a new applet is dragged in the view
 
     //when the applet moves caused by its resize, don't animate.
     //this is completely heuristic, but looks way less "jumpy"
     property bool movingForResize: false
     property int oldX: x
     property int oldY: y
 
     onXChanged: {
         if (root.isVertical) {
             return;
         }
 
         if (movingForResize) {
             movingForResize = false;
             return;
         }
 
         var draggingAppletInConfigure = root.dragOverlay && root.dragOverlay.currentApplet;
         var isCurrentAppletInDragging = draggingAppletInConfigure && (root.dragOverlay.currentApplet === appletItem);
         var dropApplet = root.dragInfo.entered && foreDropArea.visible
 
         if (isCurrentAppletInDragging || !draggingAppletInConfigure && !dropApplet) {
             return;
         }
 
         if (!root.isVertical) {
             translation.x = oldX - x;
             translation.y = 0;
         } else {
             translation.y = oldY - y;
             translation.x = 0;
         }
 
         translAnim.running = true
 
         if (!root.isVertical) {
             oldX = x;
             oldY = 0;
         } else {
             oldY = y;
             oldX = 0;
         }
     }
 
     onYChanged: {
         if (root.isHorizontal) {
             return;
         }
 
         if (movingForResize) {
             movingForResize = false;
             return;
         }
 
         var draggingAppletInConfigure = root.dragOverlay && root.dragOverlay.currentApplet;
         var isCurrentAppletInDragging = draggingAppletInConfigure && (root.dragOverlay.currentApplet === appletItem);
         var dropApplet = root.dragInfo.entered && foreDropArea.visible
 
         if (isCurrentAppletInDragging || !draggingAppletInConfigure && !dropApplet) {
             return;
         }
         if (!root.isVertical) {
             translation.x = oldX - x;
             translation.y = 0;
         } else {
             translation.y = oldY - y;
             translation.x = 0;
         }
 
         translAnim.running = true;
 
         if (!root.isVertical) {
             oldX = x;
             oldY = 0;
         } else {
             oldY = y;
             oldX = 0;
         }
     }
 
     transform: Translate {
         id: translation
     }
 
     NumberAnimation {
         id: translAnim
         duration: appletItem.animations.duration.large
         easing.type: Easing.InOutQuad
         target: translation
         properties: "x,y"
         to: 0
     }
 
     Behavior on lengthAppletPadding {
         NumberAnimation {
             duration: 0.8 * appletItem.animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
 
     //// END :: Animate Applet when a new applet is dragged in the view
 
     /// BEGIN functions
     function activateAppletForNeutralAreas(mouse){
         //if the event is at the active indicator or spacers area then try to expand the applet,
         //unfortunately for other applets there is no other way to activate them yet
         //for example the icon-only applets
         var choords = mapToItem(appletItem.appletWrapper, mouse.x, mouse.y);
 
         var wrapperContainsMouse = choords.x>=0 && choords.y>=0 && choords.x<appletItem.appletWrapper.width && choords.y<appletItem.appletWrapper.height;
         var appletItemContainsMouse = mouse.x>=0 && mouse.y>=0 && mouse.x<width && mouse.y<height;
 
         //console.log(" APPLET :: " + mouse.x +  " _ " + mouse.y);
         //console.log(" WRAPPER :: " + choords.x + " _ " + choords.y);
 
         var inThicknessNeutralArea = !wrapperContainsMouse && (appletItem.metrics.margin.screenEdge>0);
         var appletNeutralAreaEnabled = !(inThicknessNeutralArea && root.dragActiveWindowEnabled);
 
         if (appletItemContainsMouse && !wrapperContainsMouse && appletNeutralAreaEnabled) {
             //console.log("PASSED");
             latteView.extendedInterface.toggleAppletExpanded(applet.id);
         } else {
             //console.log("REJECTED");
         }
     }
 
     function checkIndex(){
         index = -1;
 
         for(var i=0; i<appletItem.layouter.startLayout.count; ++i){
             var child = layoutsContainer.startLayout.children[i];
             if (child === appletItem){
                 index = layoutsContainer.startLayout.beginIndex + i;
                 break;
             }
         }
 
         for(var i=0; i<appletItem.layouter.mainLayout.count; ++i){
             var child = layoutsContainer.mainLayout.children[i];
             if (child === appletItem){
                 index = layoutsContainer.mainLayout.beginIndex + i;
                 break;
             }
         }
 
         for(var i=0; i<appletItem.layouter.endLayout.count; ++i){
             var child = layoutsContainer.endLayout.children[i];
             if (child === appletItem){
                 //create a very high index in order to not need to exchange hovering messages
                 //between layoutsContainer.mainLayout and layoutsContainer.endLayout
                 index = layoutsContainer.endLayout.beginIndex + i;
                 break;
             }
         }
 
         if(appletItem.latteApplet){
             if(index===layoutsContainer.startLayout.beginIndex || index===layoutsContainer.mainLayout.beginIndex || index===layoutsContainer.endLayout.beginIndex)
                 latteApplet.disableLeftSpacer = false;
             else
                 latteApplet.disableLeftSpacer = true;
 
             if( index === layoutsContainer.startLayout.beginIndex + appletItem.layouter.startLayout.count - 1
                     || index===layoutsContainer.mainLayout.beginIndex + appletItem.layouter.mainLayout.count - 1
                     || index === layoutsContainer.endLayout.beginIndex + appletItem.layouter.endLayout.count - 1)
                 latteApplet.disableRightSpacer = false;
             else
                 latteApplet.disableRightSpacer = true;
         }
     }
 
     //this functions gets the signal from the plasmoid, it can be used for signal items
     //outside the LatteApplet Plasmoid
     //property int debCounter: 0;
 
     function sltClearZoom(){
         if (communicator.parabolicEffectIsSupported) {
             communicator.bridge.parabolic.client.sglClearZoom();
         } else {
             restoreAnimation.start();
         }
     }
 
     function updateParabolicEffectIsSupported(){
         parabolicEffectIsSupportedTimer.start();
     }
 
     //! Reduce calculations and give the time to applet to adjust to prevent binding loops
     Timer{
         id: parabolicEffectIsSupportedTimer
         interval: 100
         onTriggered: {
             if (wrapper.zoomScale !== 1) {
                 return;
             }
 
             if (appletItem.isLattePlasmoid) {
                 appletItem.parabolicEffectIsSupported = true;
                 return;
             }
 
             var maxSize = appletItem.metrics.iconSize + lengthAppletFullMargins;
             var maxForMinimumSize = appletItem.metrics.iconSize + lengthAppletFullMargins;
 
             if ( isSystray
                     || appletItem.isAutoFillApplet
                     || (((applet && root.isHorizontal && (applet.width > maxSize || applet.Layout.minimumWidth > maxForMinimumSize))
                          || (applet && root.isVertical && (applet.height > maxSize || applet.Layout.minimumHeight > maxForMinimumSize)))
                         && !appletItem.isSpacer
                         && !communicator.canShowOverlaiedLatteIcon) ) {
                 appletItem.parabolicEffectIsSupported = false;
             } else {
                 appletItem.parabolicEffectIsSupported = true;
             }
         }
     }
 
     function slotDestroyInternalViewSplitters() {
         if (isInternalViewSplitter) {
             destroy();
         }
     }
 
     //! pos in global root positioning
     function containsPos(pos) {
         var relPos = root.mapToItem(appletItem,pos.x, pos.y);
 
         if (relPos.x>=0 && relPos.x<=width && relPos.y>=0 && relPos.y<=height)
             return true;
 
         return false;
     }
 
     function refersEntryIndex(entryIndex) {
         return (entryIndex === parabolicManager.pseudoAppletIndex(appletItem.index));
     }
 
     ///END functions
 
     //BEGIN connections
     onAppletChanged: {
         if (!applet) {
             destroy();
         }
     }
 
     onIndexChanged: {
         if (appletItem.latteApplet) {
             root.latteAppletPos = index;
         }
 
         if (index>-1) {
             previousIndex = index;
         }
     }
 
     onIsExpandedChanged: {
         if (isExpanded) {
             root.hideTooltipLabel();
         }
     }
 
     onIsSystrayChanged: {
         updateParabolicEffectIsSupported();
     }
 
     onLatteAppletChanged: {
         if(appletItem.latteApplet){
             root.latteApplet = appletItem.latteApplet;
             root.latteAppletContainer = appletItem;
             root.latteAppletPos = index;
             appletItem.latteApplet.latteView = root;
             appletItem.latteApplet.forceHidePanel = true;
 
             appletItem.latteApplet.signalPreviewsShown.connect(slotPreviewsShown);
         }
     }
 
     onIsAutoFillAppletChanged: updateParabolicEffectIsSupported();
 
     Component.onCompleted: {
         checkIndex();
         root.updateIndexes.connect(checkIndex);
         root.destroyInternalViewSplitters.connect(slotDestroyInternalViewSplitters);
 
         parabolic.sglClearZoom.connect(sltClearZoom);
     }
 
     Component.onDestruction: {
         appletItem.animations.needBothAxis.removeEvent(appletItem);
 
         if(root.latteAppletPos>=0 && root.latteAppletPos === index){
             root.latteApplet = null;
             root.latteAppletContainer = null;
             root.latteAppletPos = -1;
         }
 
         root.updateIndexes.disconnect(checkIndex);
         root.destroyInternalViewSplitters.disconnect(slotDestroyInternalViewSplitters);
 
         parabolic.sglClearZoom.disconnect(sltClearZoom);
 
         if (appletItem.latteApplet) {
             appletItem.latteApplet.signalPreviewsShown.disconnect(slotPreviewsShown);
         }
     }
 
     //! Bindings
 
     Binding {
         //! is used to aboid loop binding warnings on startup
         target: appletItem
         property: "lengthAppletFullMargin"
         when: !communicator.inStartup
         value: lengthAppletPadding + metrics.margin.length;
     }
 
     //! Connections
     Connections{
         target: appletItem.shortcuts
 
         onSglActivateEntryAtIndex: {
-            if (parabolicManager.pseudoIndexBelongsToLatteApplet(entryIndex) && appletItem.isLattePlasmoid) {
-                latteApplet.activateTaskAtIndex(entryIndex - latteApplet.tasksBaseIndex);
-            } else if (shortcuts.unifiedGlobalShortcuts && refersEntryIndex(entryIndex)) {
+            var visibleIndex = appletItem.indexer.visibleIndex(appletItem.index);
+
+            if (visibleIndex === entryIndex && !communicator.positionShortcutsAreSupported) {
                 latteView.extendedInterface.toggleAppletExpanded(applet.id);
             }
         }
 
         onSglNewInstanceForEntryAtIndex: {
-            if (parabolicManager.pseudoIndexBelongsToLatteApplet(entryIndex) && appletItem.isLattePlasmoid) {
-                latteApplet.newInstanceForTaskAtIndex(entryIndex - latteApplet.tasksBaseIndex);
-            } else if (shortcuts.unifiedGlobalShortcuts && refersEntryIndex(entryIndex)) {
+            var visibleIndex = appletItem.indexer.visibleIndex(appletItem.index);
+
+            if (visibleIndex === entryIndex && !communicator.positionShortcutsAreSupported) {
                 latteView.extendedInterface.toggleAppletExpanded(applet.id);
             }
         }
     }
 
     Connections {
         id: viewSignalsConnector
         target: root.latteView ? root.latteView : null
         enabled: !appletItem.isLattePlasmoid && !appletItem.isSeparator && !appletItem.isSpacer && !appletItem.isHidden
 
         property bool pressed: false
         property bool blockWheel: false
 
         onMousePressed: {
             if (appletItem.containsPos(pos)) {
                 viewSignalsConnector.pressed = true;
                 var local = appletItem.mapFromItem(root, pos.x, pos.y);
 
                 appletItem.mousePressed(local.x, local.y, button);
 
                 if (button === Qt.LeftButton) {
                     appletItem.activateAppletForNeutralAreas(local);
                 }
             }
         }
 
         onMouseReleased: {
             if (appletItem.containsPos(pos)) {
                 viewSignalsConnector.pressed = false;
                 var local = appletItem.mapFromItem(root, pos.x, pos.y);
                 appletItem.mouseReleased(local.x, local.y, button);
             }
         }
 
         onWheelScrolled: {
             if (!appletItem.applet || !root.mouseWheelActions || viewSignalsConnector.blockWheel
                     || (root.latteViewIsHidden || root.inSlidingIn || root.inSlidingOut)) {
                 return;
             }
 
             blockWheel = true;
             scrollDelayer.start();
 
             if (appletItem.containsPos(pos) && root.latteView.extendedInterface.appletIsExpandable(applet.id)) {
                 var angle = angleDelta.y / 8;
                 var expanded = root.latteView.extendedInterface.appletIsExpanded(applet.id);
 
                 if ((angle > 12 && !expanded) /*positive direction*/
                         || (angle < -12 && expanded) /*negative direction*/) {
                     latteView.extendedInterface.toggleAppletExpanded(applet.id);
                 }
             }
         }
     }
 
     Connections {
         target: root.latteView ? root.latteView.extendedInterface : null
         enabled: !appletItem.isLattePlasmoid && !appletItem.isSeparator && !appletItem.isSpacer && !appletItem.isHidden
 
         onExpandedAppletStateChanged: {
             if (latteView.extendedInterface.hasExpandedApplet && appletItem.applet) {
                 appletItem.isExpanded = latteView.extendedInterface.appletIsExpandable(appletItem.applet.id)
                         && latteView.extendedInterface.appletIsExpanded(appletItem.applet.id);
             } else {
                 appletItem.isExpanded = false;
             }
         }
     }
     ///END connections
 
     //! It is used for any communication needed with the underlying applet
     Communicator.Engine{
         id: _communicator
 
         //set up the overlayed appletItems and properties for when a overlaiedIconItem must be presented to the user
         //because the plasma widgets specific implementation breaks the Latte experience
         onOverlayLatteIconIsActiveChanged:{
             if (!overlayLatteIconIsActive && applet.opacity===0) {
                 applet.opacity = 1;
             } else if (overlayLatteIconIsActive && applet.opacity>0) {
                 applet.opacity = 0;
 
                 if (applet.pluginName === "org.kde.plasma.folder") {
                     applet.parent =  wrapper.containerForOverlayIcon;
                     applet.anchors.fill = wrapper.containerForOverlayIcon;
                 }
             }
         }
     }
 
     /*  Rectangle{
         anchors.fill: parent
         color: "transparent"
         border.color: "green"
         border.width: 1
     }*/
 
 
     /* DEPRECATED in favor of VIEW::MouseSignalsTracking
     MouseArea{
         id: appletMouseAreaBottom
         anchors.fill: parent
         propagateComposedEvents: true
         visible: (!appletMouseArea.visible || !appletMouseArea.enabled) && !root.editMode && !originalAppletBehavior
 
         onPressed: {
             appletItem.activateAppletForNeutralAreas(mouse);
             mouse.accepted = false;
         }
 
         onReleased: {
             mouse.accepted = false;
         }
     }*/
 
     //! Main Applet Shown Area
     Flow{
         id: appletFlow
         width: appletItem.computeWidth
         height: appletItem.computeHeight
 
         // a hidden spacer for the first element to add stability
         // IMPORTANT: hidden spacers must be tested on vertical !!!
         HiddenSpacer{id: hiddenSpacerLeft}
 
         Item {
             width: wrapper.width
             height: wrapper.height
 
             Indicator.Bridge{
                 id: indicatorBridge
             }
 
             //! Indicator Back Layer
             Indicator.Loader{
                 id: indicatorBackLayer
                 level: Indicator.LevelOptions {
                     id: backLevelOptions
                     isBackground: true
                     bridge: indicatorBridge
 
                     Binding {
                         target: appletItem
                         property: "iconOffsetX"
                         value: backLevelOptions.requested.iconOffsetX
                     }
 
                     Binding {
                         target: appletItem
                         property: "iconOffsetY"
                         value: backLevelOptions.requested.iconOffsetY
                     }
                 }
             }
 
             ItemWrapper{
                 id: _wrapper
 
                 TitleTooltipParent{
                     id: titleTooltipParent
                     metrics: appletItem.metrics
                     parabolic: appletItem.parabolic
                 }
             }
 
             //! The Applet Colorizer
             Colorizer.Applet {
                 id: appletColorizer
                 anchors.fill: parent
                 opacity: mustBeShown ? 1 : 0
 
                 readonly property bool mustBeShown: colorizerManager.mustBeShown
                                                     && !appletItem.userBlocksColorizing
                                                     && !appletItem.appletBlocksColorizing
                                                     && !appletItem.isInternalViewSplitter
 
                 Behavior on opacity {
                     NumberAnimation {
                         duration: 1.2 * appletItem.animations.duration.proposed
                         easing.type: Easing.OutCubic
                     }
                 }
             }
 
             //! Indicator Front Layer
             Indicator.Loader{
                 id: indicatorFrontLayer
                 level: Indicator.LevelOptions {
                     isForeground: true
                     bridge: indicatorBridge
                 }
             }
 
             //! Applet Shortcut Visual Badge
             Item {
                 id: shortcutBadgeContainer
 
                 width: {
                     if (root.isHorizontal) {
                         return appletItem.metrics.iconSize * wrapper.zoomScale
                     } else {
                         return badgeThickness;
                     }
                 }
 
                 height: {
                     if (root.isHorizontal) {
                         return badgeThickness;
                     } else {
                         return appletItem.metrics.iconSize * wrapper.zoomScale
                     }
                 }
 
                 readonly property int badgeThickness: {
                     if (plasmoid.location === PlasmaCore.Types.BottomEdge
                             || plasmoid.location === PlasmaCore.Types.RightEdge) {
                         return ((appletItem.metrics.iconSize + appletItem.metrics.margin.thickness) * wrapper.zoomScale) + appletItem.metrics.margin.screenEdge;
                     }
 
                     return ((appletItem.metrics.iconSize + appletItem.metrics.margin.thickness) * wrapper.zoomScale);
                 }
 
                 ShortcutBadge{
                     anchors.fill: parent
                 }
 
                 states:[
                     State{
                         name: "horizontal"
                         when: plasmoid.formFactor === PlasmaCore.Types.Horizontal
 
                         AnchorChanges{
                             target: shortcutBadgeContainer;
                             anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                             anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                         }
                     },
                     State{
                         name: "vertical"
                         when: plasmoid.formFactor === PlasmaCore.Types.Vertical
 
                         AnchorChanges{
                             target: shortcutBadgeContainer;
                             anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                             anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                         }
                     }
                 ]
             }
         }
 
         // a hidden spacer on the right for the last item to add stability
         HiddenSpacer{id: hiddenSpacerRight; rightSpacer: true}
     }// Flow with hidden spacers inside
 
     //Busy Indicator
     PlasmaComponents.BusyIndicator {
         z: 1000
         visible: applet && applet.busy
         running: visible
         anchors.centerIn: parent
         width: Math.min(parent.width, parent.height)
         height: width
     }
 
     Loader {
         id: addingAreaLoader
         width: root.isHorizontal ? parent.width : parent.width - appletItem.metrics.margin.screenEdge
         height: root.isHorizontal ? parent.height - appletItem.metrics.margin.screenEdge : parent.height
 
         active: isLattePlasmoid
 
         sourceComponent: LatteComponents.AddingArea{
             id: addingAreaItem
             anchors.fill: parent
             // width: root.isHorizontal ? parent.width : parent.width - appletItem.metrics.margin.screenEdge
             // height: root.isHorizontal ? parent.height - appletItem.metrics.margin.screenEdge : parent.height
 
             radius: appletItem.metrics.iconSize/10
             opacity: root.addLaunchersMessage ? 1 : 0
             backgroundOpacity: 0.75
             duration: appletItem.animations.speedFactor.current
 
             title: i18n("Tasks Area")
         }
 
         //! AddingAreaItem States
         states:[
             State{
                 name: "bottom"
                 when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: appletItem.metrics.margin.screenEdge;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "top"
                 when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: appletItem.metrics.margin.screenEdge;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "left"
                 when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: appletItem.metrics.margin.screenEdge;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "right"
                 when: plasmoid.location === PlasmaCore.Types.RightEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: appletItem.metrics.margin.screenEdge;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             }
         ]
     }
 
     MouseArea{
         id: appletMouseArea
 
         anchors.fill: parent
         enabled: visible
         hoverEnabled: latteApplet ? false : true
         propagateComposedEvents: true
 
         //! a way must be found in order for this be enabled
         //! only to support springloading for plasma 5.10
         //! also on this is based the tooltips behavior by enabling it
         //! plasma tooltips are disabled
         visible: acceptMouseEvents
 
         property bool blockWheel: false
 
         onEntered: {
             appletItem.parabolic.stopRestoreZoomTimer();
 
             if (restoreAnimation.running) {
                 restoreAnimation.stop();
             }
 
             if (!(isSeparator || isSpacer)) {
                 root.showTooltipLabel(appletItem, applet.title);
             }
 
             if (originalAppletBehavior || communicator.requires.parabolicEffectLocked || !parabolicEffectIsSupported) {
                 return;
             }
 
             if (root.isHalfShown || (root.latteApplet
                                      && (root.latteApplet.noTasksInAnimation>0 || root.latteApplet.contextMenu))) {
                 return;
             }
 
             if (root.isHorizontal){
                 layoutsContainer.currentSpot = mouseX;
                 wrapper.calculateScales(mouseX);
             }
             else{
                 layoutsContainer.currentSpot = mouseY;
                 wrapper.calculateScales(mouseY);
             }
         }
 
         onExited:{
             if (communicator.appletIconItemIsShown()) {
                 communicator.setAppletIconItemActive(false);
             }
 
             root.hideTooltipLabel();
 
             if (appletItem.parabolic.factor.zoom>1){
                 appletItem.parabolic.startRestoreZoomTimer();
             }
         }
 
         onPositionChanged: {
             if (originalAppletBehavior || !parabolicEffectIsSupported) {
                 mouse.accepted = false;
                 return;
             }
 
             if (root.isHalfShown || (root.latteApplet
                                      && (root.latteApplet.noTasksInAnimation>0 || root.latteApplet.contextMenu))) {
                 return;
             }
 
             var rapidMovement = appletItem.parabolic.lastIndex>=0 && Math.abs(appletItem.parabolic.lastIndex-index)>1;
 
             if (rapidMovement) {
                 parabolic.setDirectRenderingEnabled(true);
             }
 
             if( ((wrapper.zoomScale == 1 || wrapper.zoomScale === appletItem.parabolic.factor.zoom) && !parabolic.directRenderingEnabled) || parabolic.directRenderingEnabled) {
                 if (root.isHorizontal){
                     var step = Math.abs(layoutsContainer.currentSpot-mouse.x);
                     if (step >= appletItem.animations.hoverPixelSensitivity){
                         layoutsContainer.currentSpot = mouse.x;
 
                         wrapper.calculateScales(mouse.x);
                     }
                 }
                 else{
                     var step = Math.abs(layoutsContainer.currentSpot-mouse.y);
                     if (step >= appletItem.animations.hoverPixelSensitivity){
                         layoutsContainer.currentSpot = mouse.y;
 
                         wrapper.calculateScales(mouse.y);
                     }
                 }
             }
 
             mouse.accepted = false;
         }
 
         //! these are needed in order for these events to be really forwarded underneath
         //! otherwise there were applets that did not receive them e.g. lock/logout applet
         //! when parabolic effect was used
         onPressed: mouse.accepted = false;
         onReleased: mouse.accepted = false;
     }
 
     //! Debug Elements
     Loader{
         anchors.bottom: parent.bottom
         anchors.left: parent.left
 
         active: root.debugModeLayouter
         sourceComponent: Debug.Tag{
             label.text: (root.isHorizontal ? appletItem.width : appletItem.height) + labeltext
             label.color: appletItem.isAutoFillApplet ? "green" : "white"
 
             readonly property string labeltext: {
                 if (appletItem.isAutoFillApplet) {
                     return " / max_fill:"+appletItem.maxAutoFillLength + " / min_fill:"+appletItem.minAutoFillLength;
                 }
 
                 return "";
             }
         }
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
         interval: 500
 
         onTriggered: viewSignalsConnector.blockWheel = false;
     }
 
     //BEGIN states
     states: [
         State {
             name: "left"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined;}
             }
         },
         State {
             name: "right"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right;}
             }
         },
         State {
             name: "bottom"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined;}
             }
         },
         State {
             name: "top"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined;}
             }
         }
     ]
     //END states
 
     //BEGIN animations
     ///////Restore Zoom Animation/////
     ParallelAnimation{
         id: restoreAnimation
 
         PropertyAnimation {
             target: wrapper
             property: "zoomScale"
             to: 1
             duration: 3 * appletItem.animationTime
             easing.type: Easing.InCubic
         }
     }
 
 
     /////Clicked Animation/////
     SequentialAnimation{
         id: clickedAnimation
         alwaysRunToEnd: true
         running: appletItem.isSquare && !originalAppletBehavior && appletItem.pressed
                  && (appletItem.animations.speedFactor.current > 0) && !indicators.info.providesClickedAnimation
 
         ParallelAnimation{
             PropertyAnimation {
                 target: wrapper.clickedEffect
                 property: "brightness"
                 to: -0.35
                 duration: appletItem.animations.duration.large
                 easing.type: Easing.OutQuad
             }
         }
         ParallelAnimation{
             PropertyAnimation {
                 target: wrapper.clickedEffect
                 property: "brightness"
                 to: 0
                 duration: appletItem.animations.duration.large
                 easing.type: Easing.OutQuad
             }
         }
     }
     //END animations
 }
diff --git a/containment/package/contents/ui/applet/communicator/Engine.qml b/containment/package/contents/ui/applet/communicator/Engine.qml
index dec60327..2324bd87 100644
--- a/containment/package/contents/ui/applet/communicator/Engine.qml
+++ b/containment/package/contents/ui/applet/communicator/Engine.qml
@@ -1,127 +1,127 @@
 /*
 *  Copyright 2018  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 org.kde.latte.abilities.definitions 0.1 as AbilityDefinition
 
 import "../../../code/AppletIdentifier.js" as AppletIdentifier
 
 Item{
     id: mainCommunicator
 
     //             -------------------------------------
     //              BEGIN OF INTERNAL APPLET PROPERTIES
     //             LATTE<->APPLET COMMUNICATION PROTOCOL
     //             -------------------------------------
     //
     // NAME: latteBridge
     //   USAGE: property QtObject latteBridge: null
     //   EXPLANATION: The main shared object that Latte is using to communicate with the applet
     property bool appletContainsLatteBridge: appletRootItem && appletRootItem.hasOwnProperty("latteBridge") ? true : false
     //!              END OF INTERNAL APPLET PROPERTIES
     //             -------------------------------------
 
     //! BEGIN OF PROPERTIES
     //this is used for folderView and icon widgets to fake their visual icons
     readonly property bool canShowOverlaiedLatteIcon: appletIconItem && appletIconItem.visible
     readonly property bool overlayLatteIconIsActive: canShowOverlaiedLatteIcon && requires.latteIconOverlayEnabled
 
     property bool inStartup: true
 
     property Item appletRootItem: appletDiscoveredRootItem ? appletDiscoveredRootItem : appletDefaultRootItem
     property Item appletDiscoveredRootItem: null
     property Item appletDefaultRootItem: applet && applet.children && applet.children.length>0 ? applet.children[0] : null
 
     property Item appletIconItem; //first applet's IconItem to be used by Latte
     property Item appletImageItem; //first applet's ImageItem to be used by Latte
     //! END OF PROPERTIES
 
     //! BEGIN OF PUBLIC PROPERTIES SET THROUGH LATTEBRIDGE.ACTIONS   
     readonly property Item requires: AbilityDefinition.AppletRequirements{}
     //! END OF PUBLIC PROPERTIES SET THROUGH LATTEBRIDGE.ACTIONS
 
     //! BEGIN OF ABILITIES SUPPORT
     readonly property bool indexerIsSupported: bridge && bridge.indexer.client
-    readonly property bool onPositionShortcutsAreSupported: bridge && bridge.shortcuts.client
     readonly property bool parabolicEffectIsSupported: bridge && bridge.parabolic.client
+    readonly property bool positionShortcutsAreSupported: bridge && bridge.shortcuts.client
 
     readonly property Item bridge: bridgeLoader.active ? bridgeLoader.item : null
     //! END OF ABILITIES SUPPORT
 
     //! BEGIN OF FUNCTIONS
     function appletIconItemIsShown() {
         return appletIconItem && appletIconItem.visible;
     }
 
     function appletImageItemIsShown() {
         return appletImageItem && appletImageItem.visible;
     }
 
     function reconsiderAppletIconItem() {
         AppletIdentifier.reconsiderAppletIconItem();
     }
 
     function setAppletIconItemActive(isActive) {
         if (appletIconItem) {
             appletIconItem.active = isActive;
         }
     }
     //! END OF FUNCTIONS
 
     //! BEGIN OF CONNECTIONS
     Connections{
         target: appletItem
         onAppletChanged: {
             if (applet) {
                 AppletIdentifier.checkAndUpdateAppletRootItem();
                 AppletIdentifier.reconsiderAppletIconItem();
                 overlayInitTimer.start();
             }
         }
     }
 
     //! END OF CONNECTIONS
 
     //! BEGIN OF LOADERS
     Loader{
         id: bridgeLoader
         active: appletContainsLatteBridge
         sourceComponent: LatteBridge{}
     }
     //! END OF LOADERS
 
     //! BEGIN OF TIMERS
     //a timer that is used in  order to init some Communicator values
     Timer {
         id: overlayInitTimer
         interval: 1000
         onTriggered: {
             AppletIdentifier.checkAndUpdateAppletRootItem();
             AppletIdentifier.reconsiderAppletIconItem();
             mainCommunicator.inStartup = false;
 
             if (root.debugModeTimers) {
                 console.log("containment timer: appletItem fakeInitTimer called...");
             }
         }
     }
 
     //! END OF TIMERS
 }
diff --git a/declarativeimports/abilities/applets/PositionShortcuts.qml b/declarativeimports/abilities/applets/PositionShortcuts.qml
new file mode 100644
index 00000000..a6ffc6b3
--- /dev/null
+++ b/declarativeimports/abilities/applets/PositionShortcuts.qml
@@ -0,0 +1,57 @@
+/*
+*  Copyright 2020 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 org.kde.latte.abilities.definitions 0.1 as AbilityDefinition
+
+AbilityDefinition.PositionShortcuts {
+    id: shortcuts
+    property Item bridge: null
+    readonly property bool isActive: bridge !== null
+
+    property bool isStealingGlobalPositionShortcuts: false
+    readonly property bool showPositionShortcutBadges: ref.shortcuts.showPositionShortcutBadges
+
+    readonly property AbilityDefinition.ParabolicEffect local: AbilityDefinition.ParabolicEffect {}
+
+    Item {
+        id: ref
+        readonly property Item shortcuts: bridge ? bridge.shortcuts.host : local
+    }
+
+    onIsActiveChanged: {
+        if (isActive) {
+            bridge.shortcuts.client = shortcuts;
+        }
+    }
+
+    Component.onCompleted: {
+        if (isActive) {
+            bridge.shortcuts.client = shortcuts;
+        }
+    }
+
+    Component.onDestruction: {
+        if (isActive) {
+            bridge.shortcuts.client = null;
+        }
+    }
+}
+
diff --git a/declarativeimports/abilities/applets/qmldir b/declarativeimports/abilities/applets/qmldir
index f70feb63..f0c7c277 100644
--- a/declarativeimports/abilities/applets/qmldir
+++ b/declarativeimports/abilities/applets/qmldir
@@ -1,7 +1,8 @@
 module org.kde.latte.abilities.applets
 
 Animations 0.1 Animations.qml
 Indexer 0.1 Indexer.qml
 Metrics 0.1 Metrics.qml
 ParabolicEffect 0.1 ParabolicEffect.qml
+PositionShortcuts 0.1 PositionShortcuts.qml
 Requirements 0.1 Requirements.qml
diff --git a/declarativeimports/abilities/bridge/PositionShortcuts.qml b/declarativeimports/abilities/bridge/PositionShortcuts.qml
index 144899a8..ddc687b5 100644
--- a/declarativeimports/abilities/bridge/PositionShortcuts.qml
+++ b/declarativeimports/abilities/bridge/PositionShortcuts.qml
@@ -1,28 +1,47 @@
 /*
 *  Copyright 2020 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
 
 Item {
     id: shortcutsBridge
     property int appletIndex: -1
 
     property Item host: null
     property Item client: null
+
+    readonly property bool isConnected: host && client
+
+    onIsConnectedChanged: {
+        if (isConnected) {
+            host.sglActivateEntryAtIndex.connect(client.sglActivateEntryAtIndex);
+            host.sglNewInstanceForEntryAtIndex.connect(client.sglNewInstanceForEntryAtIndex);
+        } else {
+            host.sglActivateEntryAtIndex.disconnect(client.sglActivateEntryAtIndex);
+            host.sglNewInstanceForEntryAtIndex.disconnect(client.sglNewInstanceForEntryAtIndex);
+        }
+    }
+
+    Component.onDestruction: {
+        if (isConnected) {
+            host.sglActivateEntryAtIndex.disconnect(client.sglActivateEntryAtIndex);
+            host.sglNewInstanceForEntryAtIndex.disconnect(client.sglNewInstanceForEntryAtIndex);
+        }
+    }
 }
diff --git a/declarativeimports/abilities/bridge/PositionShortcuts.qml b/declarativeimports/abilities/definitions/PositionShortcuts.qml
similarity index 76%
copy from declarativeimports/abilities/bridge/PositionShortcuts.qml
copy to declarativeimports/abilities/definitions/PositionShortcuts.qml
index 144899a8..440881da 100644
--- a/declarativeimports/abilities/bridge/PositionShortcuts.qml
+++ b/declarativeimports/abilities/definitions/PositionShortcuts.qml
@@ -1,28 +1,27 @@
 /*
-*  Copyright 2020 Michail Vourlakos <mvourlakos@gmail.com>
+*  Copyright 2020  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
 
 Item {
-    id: shortcutsBridge
-    property int appletIndex: -1
+    property bool showPositionShortcutBadges: false
 
-    property Item host: null
-    property Item client: null
+    signal sglActivateEntryAtIndex(int entryIndex);
+    signal sglNewInstanceForEntryAtIndex(int entryIndex);
 }
diff --git a/declarativeimports/abilities/definitions/qmldir b/declarativeimports/abilities/definitions/qmldir
index 387c0169..3a05bf10 100644
--- a/declarativeimports/abilities/definitions/qmldir
+++ b/declarativeimports/abilities/definitions/qmldir
@@ -1,8 +1,9 @@
 module org.kde.latte.abilities.definitions
 
 Animations 0.1 Animations.qml
 AppletRequirements 0.1 AppletRequirements.qml
 Indexer 0.1 Indexer.qml
 Metrics 0.1 Metrics.qml
 ParabolicEffect 0.1 ParabolicEffect.qml
+PositionShortcuts 0.1 PositionShortcuts.qml
 
diff --git a/plasmoid/package/contents/ui/abilities/Indexer.qml b/plasmoid/package/contents/ui/abilities/Indexer.qml
index de3a4e33..317b1978 100644
--- a/plasmoid/package/contents/ui/abilities/Indexer.qml
+++ b/plasmoid/package/contents/ui/abilities/Indexer.qml
@@ -1,182 +1,185 @@
 /*
 *  Copyright 2020 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 org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.abilities.applets 0.1 as AppletAbility
 
 AppletAbility.Indexer {
     id: _indexer
     property Item layout: null   
 
     readonly property bool tailAppletIsSeparator: isActive ? bridge.indexer.tailAppletIsSeparator : false
     readonly property bool headAppletIsSeparator: isActive ? bridge.indexer.headAppletIsSeparator : false
 
     property int visibleItemsCount: 0
     property int allItemsCount: 0 /*is needed to be set from consumer developer in order to avoid binding loops warnings*/
 
     property int firstVisibleItemIndex: -1
     property int lastVisibleItemIndex: -1
 
     readonly property int maxIndex: 99999
 
     Binding {
         target: _indexer
         property: "firstVisibleItemIndex"
         when: layout.children.length >= allItemsCount
         value: {
             var ind = maxIndex;
             for(var i=0; i<layout.children.length; ++i) {
                 var item = layout.children[i];
                 if (item && item.itemIndex>=0
                         && hidden.indexOf(item.itemIndex)<0
                         && separators.indexOf(item.itemIndex)<0
                         && item.itemIndex < ind) {
                     ind = item.itemIndex;
                 }
             }
 
             return ind === maxIndex ? -1 : ind;
         }
     }
 
     Binding {
         target: _indexer
         property: "lastVisibleItemIndex"
         when: layout.children.length >= allItemsCount
         value: {
             var ind = -1;
 
             for(var i=0; i<layout.children.length; ++i) {
                 var item = layout.children[i];
                 if (item && item.itemIndex>=0
                         && hidden.indexOf(item.itemIndex)<0
                         && separators.indexOf(item.itemIndex)<0
                         && item.itemIndex > ind) {
 
                     //console.log("org.kde.latte SETTING UP ::: " + item.itemIndex + " / " + layout.children.length);
                     ind = item.itemIndex;
                 }
             }
 
             return ind;
         }
     }
 
     Binding {
         target: _indexer
         property: "visibleItemsCount"
         value: {
             var count = 0;
             for(var i=0; i<layout.children.length; ++i) {
                 var item = layout.children[i];
                 if (item && item.itemIndex>=0
                         && hidden.indexOf(item.itemIndex)<0
                         && separators.indexOf(item.itemIndex)<0) {
                     count = count + 1;
                 }
             }
             return count;
         }
     }
 
     readonly property bool firstTailItemIsSeparator: {
         if (visibleItemsCount === layout.children.length) {
             return false;
         }
 
         for(var i=0; i<firstVisibleItemIndex; ++i) {
             if (separators.indexOf(i)>=0) {
                 return true;
             }
         }
 
         return false;
     }
 
     readonly property bool lastHeadItemIsSeparator: {
         if (visibleItemsCount === layout.children.length) {
             return false;
         }
 
         var len = layout.children.length;
 
         for(var i=len-1; i>lastVisibleItemIndex; --i) {
             if (separators.indexOf(i)>=0) {
                 return true;
             }
         }
 
         return false;
     }
 
     separators: {
         var seps = [];
 
         for (var i=0; i<layout.children.length; ++i){
             var item = layout.children[i];
             if (item && item.isSeparator && item.itemIndex>=0) {
                 seps.push(item.itemIndex);
             }
         }
 
         return seps;
     }
 
     hidden: {
         var hdns = [];
 
         for (var i=0; i<layout.children.length; ++i){
             var item = layout.children[i];
             if (item && item.isHidden && item.itemIndex>=0) {
                 hdns.push(item.itemIndex);
             }
         }
 
         return hdns;
     }
 
     function visibleIndex(taskIndex) {
-        if (taskIndex < firstVisibleItemIndex || taskIndex>lastVisibleItemIndex) {
+        if (taskIndex<firstVisibleItemIndex
+                || taskIndex>lastVisibleItemIndex
+                || hidden.indexOf(taskIndex) >= 0
+                || separators.indexOf(taskIndex) >= 0) {
             return -1;
         }
 
         var vindex = -1;
         if (latteBridge) {
             vindex = latteBridge.indexer.host.visibleIndex(latteBridge.indexer.appletIndex);
         }
 
         for (var i=0; i<layout.children.length; ++i){
             var item = layout.children[i];
-            if (hidden.indexOf(item.itemIndex) >=0 || separators.indexOf(item.itemIndex) >=0) {
+            if (hidden.indexOf(item.itemIndex)>=0 || separators.indexOf(item.itemIndex)>=0) {
                 continue;
             }
 
             if (item.itemIndex<taskIndex) {
                 vindex = vindex + 1;
             }
         }
 
         return vindex;
 
     }
 
 }
diff --git a/declarativeimports/abilities/bridge/PositionShortcuts.qml b/plasmoid/package/contents/ui/abilities/PositionShortcuts.qml
similarity index 77%
copy from declarativeimports/abilities/bridge/PositionShortcuts.qml
copy to plasmoid/package/contents/ui/abilities/PositionShortcuts.qml
index 144899a8..c975b60d 100644
--- a/declarativeimports/abilities/bridge/PositionShortcuts.qml
+++ b/plasmoid/package/contents/ui/abilities/PositionShortcuts.qml
@@ -1,28 +1,29 @@
 /*
 *  Copyright 2020 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 2.7
 
-Item {
-    id: shortcutsBridge
-    property int appletIndex: -1
+import org.kde.plasma.plasmoid 2.0
+import org.kde.plasma.core 2.0 as PlasmaCore
 
-    property Item host: null
-    property Item client: null
+import org.kde.latte.abilities.applets 0.1 as AppletAbility
+
+AppletAbility.PositionShortcuts {
+    id: shortcuts
 }
diff --git a/plasmoid/package/contents/ui/main.qml b/plasmoid/package/contents/ui/main.qml
index 9e50a1ed..bec87a23 100644
--- a/plasmoid/package/contents/ui/main.qml
+++ b/plasmoid/package/contents/ui/main.qml
@@ -1,2084 +1,2042 @@
 /*
 *  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.8
 import QtQuick.Layouts 1.1
 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.plasmoid 2.0
 
 import org.kde.taskmanager 0.1 as TaskManager
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.activities 0.1 as Activities
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import org.kde.latte.abilities.applets 0.1 as AppletAbility
 
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "abilities" as Ability
 import "previews" as Previews
 import "task" as Task
 import "taskslayout" as TasksLayout
 import "../code/tools.js" as TaskTools
 import "../code/activitiesTools.js" as ActivitiesTools
 import "../code/ColorizerTools.js" as ColorizerTools
 
 Item {
     id:root
 
     Layout.fillWidth: scrollingEnabled && !root.vertical
     Layout.fillHeight: scrollingEnabled && root.vertical
 
     Layout.minimumWidth: -1
     Layout.minimumHeight: -1
     Layout.preferredWidth: tasksWidth
     Layout.preferredHeight: tasksHeight
     Layout.maximumWidth: -1
     Layout.maximumHeight: -1
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.vertical
     LayoutMirroring.childrenInherit: true
 
     property bool plasma515: latteView ? latteView.plasma515 : LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,15,0)
     property bool plasma518: latteView ? latteView.plasma518 : LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,18,0)
 
     property bool editMode: latteView ? latteView.editMode : plasmoid.userConfiguring
     property bool inConfigureAppletsMode: latteView ? latteView.inConfigureAppletsMode : true
     property bool disableRestoreZoom: false //blocks restore animation in rightClick
     property bool disableAllWindowsFunctionality: root.showWindowsOnlyFromLaunchers && !indicators.isEnabled
     property bool dropNewLauncher: false
     property bool inActivityChange: false
     property bool inDraggingPhase: false
     property bool initializationStep: false //true
     property bool isHovered: false
     property bool showBarLine: plasmoid.configuration.showBarLine
-    property bool showTaskShortcutBadges: false
-    property int tasksBaseIndex: 0
     property bool useThemePanel: plasmoid.configuration.useThemePanel
     property bool taskInAnimation: noTasksInAnimation > 0 ? true : false
     property bool transparentPanel: plasmoid.configuration.transparentPanel
     property bool vertical: plasmoid.formFactor === PlasmaCore.Types.Vertical ? true : false
 
     property int clearWidth
     property int clearHeight
 
     property int newDroppedPosition: -1
     property int noInitCreatedBuffers: 0
     property int noTasksInAnimation: 0
     property int themePanelSize: plasmoid.configuration.panelSize
 
     property int location : {
         if (plasmoid.location === PlasmaCore.Types.LeftEdge
                 || plasmoid.location === PlasmaCore.Types.RightEdge
                 || plasmoid.location === PlasmaCore.Types.TopEdge) {
             return plasmoid.location;
         }
 
         return PlasmaCore.Types.BottomEdge;
     }
 
     property int tasksStarting: 0
 
     ///Don't use Math.floor it adds one pixel in animations and creates glitches
     property int widthMargins: root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
     property int heightMargins: !root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
 
     property int internalWidthMargins: root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthPaddings
     property int internalHeightMargins: !root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthPaddings
 
     property real textColorBrightness: ColorizerTools.colorBrightness(themeTextColor)
     property color minimizedDotColor: {
         if (latteView) {
             return latteView.minimizedDotColor;
         }
 
         return textColorBrightness > 127.5 ? Qt.darker(themeTextColor, 1.7) : Qt.lighter(themeBackgroundColor, 7)
     }
 
     property color themeTextColor: theme.textColor
     property color themeBackgroundColor: theme.backgroundColor
 
     property color lightTextColor: textColorBrightness > 127.5 ? themeTextColor : themeBackgroundColor
 
     //a small badgers record (id,value)
     //in order to track badgers when there are changes
     //in launcher reference from libtaskmanager
     property variant badgers:[]
     property variant launchersOnActivities: []
 
     //global plasmoid reference to the context menu
     property QtObject contextMenu: null
     property QtObject contextMenuComponent: Qt.createComponent("ContextMenu.qml");
     property Item dragSource: null
     property Item parabolicManager: _parabolicManager
     property Item tasksExtendedManager: _tasksExtendedManager
     readonly property alias animations: _animations
     readonly property alias indexer: _indexer
     readonly property alias metrics: _metrics
     readonly property alias parabolic: _parabolic
+    readonly property alias shortcuts: _shortcuts
 
     readonly property alias containsDrag: mouseHandler.containsDrag
     readonly property bool dragAreaEnabled: latteView ? (root.dragSource !== null
                                                          || latteView.dragInfo.isSeparator
                                                          || latteView.dragInfo.isTask
                                                          || !latteView.dragInfo.isPlasmoid)
                                                       : true
 
     //! it is used to play the animation correct when the user removes a launcher
     property string launcherForRemoval: ""
 
     //BEGIN Latte Dock properties
     property bool badges3DStyle: latteView ? latteView.badges3DStyle : true
     property bool dockIsShownCompletely: latteView ? latteView.dockIsShownCompletely : true
     property bool enableShadows: latteView ? latteView.enableShadows > 0 : plasmoid.configuration.showShadows
     property bool forceHidePanel: false
 
     property bool disableLeftSpacer: false
     property bool disableRightSpacer: false
     property bool dockIsHidden: latteView ? latteView.dockIsHidden : false
     property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
     property bool highlightWindows: hoverAction === LatteTasks.Types.HighlightWindows || hoverAction === LatteTasks.Types.PreviewAndHighlightWindows
     property bool parabolicEffectEnabled: latteView ? latteView.parabolicEffectEnabled : parabolic.factor.zoom && !root.editMode
 
     property bool scrollingEnabled: plasmoid.configuration.scrollTasksEnabled
     property bool autoScrollTasksEnabled: scrollingEnabled && plasmoid.configuration.autoScrollTasksEnabled
     property bool manualScrollTasksEnabled: scrollingEnabled &&  manualScrollTasksType !== LatteTasks.Types.ManualScrollDisabled
     property int manualScrollTasksType: plasmoid.configuration.manualScrollTasksType
 
     property bool showInfoBadge: plasmoid.configuration.showInfoBadge
     property bool showProgressBadge: plasmoid.configuration.showInfoBadge
     property bool showAudioBadge: plasmoid.configuration.showAudioBadge
     property bool infoBadgeProminentColorEnabled: plasmoid.configuration.infoBadgeProminentColorEnabled
     property bool audioBadgeActionsEnabled: plasmoid.configuration.audioBadgeActionsEnabled
     property bool showOnlyCurrentScreen: plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: plasmoid.configuration.showOnlyCurrentActivity
     property bool showPreviews:  hoverAction === LatteTasks.Types.PreviewWindows || hoverAction === LatteTasks.Types.PreviewAndHighlightWindows
     property bool showWindowActions: plasmoid.configuration.showWindowActions
     property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers
 
     property bool titleTooltips: latteView ? latteView.titleTooltips : false
     property alias windowPreviewIsShown: windowsPreviewDlg.visible
 
     property int launchersGroup: plasmoid.configuration.launchersGroup
 
     property int leftClickAction: plasmoid.configuration.leftClickAction
     property int middleClickAction: plasmoid.configuration.middleClickAction
     property int hoverAction: plasmoid.configuration.hoverAction
     property int modifier: plasmoid.configuration.modifier
     property int modifierClickAction: plasmoid.configuration.modifierClickAction
     property int modifierClick: plasmoid.configuration.modifierClick
     property int modifierQt:{
         if (modifier === LatteTasks.Types.Shift)
             return Qt.ShiftModifier;
         else if (modifier === LatteTasks.Types.Ctrl)
             return Qt.ControlModifier;
         else if (modifier === LatteTasks.Types.Alt)
             return Qt.AltModifier;
         else if (modifier === LatteTasks.Types.Meta)
             return Qt.MetaModifier;
         else return -1;
     }
     property int taskScrollAction: plasmoid.configuration.taskScrollAction
 
     onTaskScrollActionChanged: {
         if (taskScrollAction > LatteTasks.Types.ScrollToggleMinimized) {
             //! migrating scroll action to LatteTasks.Types.ScrollAction
             plasmoid.configuration.taskScrollAction = plasmoid.configuration.taskScrollAction-LatteTasks.Types.ScrollToggleMinimized;
         }
     }
 
     //! Real properties are need in order for parabolic effect to be 1px precise perfect.
     //! This way moving from Tasks to Applets and vice versa is pretty stable when hovering with parabolic effect.
     property real tasksHeight:  mouseHandler.height
     property real tasksWidth: mouseHandler.width
 
     //updated from Binding
     property int alignment
 
     readonly property real currentPanelOpacity: latteView ? latteView.currentPanelTransparency / 100 : 1
 
     property int appShadowSize: latteView ? latteView.appShadowSize : Math.ceil(0.12*metrics.iconSize)
     property string appShadowColor: latteView ? latteView.appShadowColor : "#ff080808"
     property string appShadowColorSolid: latteView ? latteView.appShadowColorSolid : "#ff080808"
 
     property alias tasksCount: tasksModel.count
 
     readonly property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property bool viewLayoutIsCurrent: latteView && viewLayout && latteView.layoutsManager
                                                 && viewLayout.name === latteView.layoutsManager.currentLayoutName
     readonly property string viewLayoutName: viewLayout ? viewLayout.name : ""
     readonly property QtObject viewLayout : latteView && latteView.viewLayout ? latteView.viewLayout : null
 
     property var badgesForActivate: latteView ? latteView.badgesForActivate : []
 
 
     property Item latteView: null
     readonly property Item indicators: latteView ? latteView.indicatorsManager : indicatorsStandaloneLoader.item
     //END Latte Dock Panel properties
 
     //BEGIN Latte Dock Communicator
     property QtObject latteBridge: null
 
     readonly property bool enforceLattePalette: latteBridge && latteBridge.applyPalette && latteBridge.palette
     readonly property bool latteInEditMode: latteBridge && latteBridge.inEditMode
     //END  Latte Dock Communicator
 
     Plasmoid.preferredRepresentation: Plasmoid.fullRepresentation
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     signal draggingFinished();
     signal hiddenTasksUpdated();
     signal launchersUpdatedFor(string launcher);
     signal presentWindows(variant winIds);
     signal requestLayout;
     signal signalPreviewsShown();
     //signal signalDraggingState(bool value);
     signal showPreviewForTasks(QtObject group);
     //trigger updating scaling of neighbour delegates of zoomed delegate
     signal updateScale(int delegateIndex, real newScale, real step)
     signal mimicEnterForParabolic();
     signal publishTasksGeometries();
     signal windowsHovered(variant winIds, bool hovered)
 
     //onAnimationsChanged: console.log(animations);
     /* Rectangle{
                 anchors.fill: parent
                 border.width: 1
                 border.color: "red"
                 color: "white"
             } */
     onLatteViewChanged: {
         if (latteView) {
             plasmoid.action("configure").visible = false;
             plasmoid.configuration.isInLatteDock = true;
 
             if (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                     || root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                 tasksModel.updateLaunchersList();
             }
         } else {
             plasmoid.configuration.isInLatteDock = false;
         }
     }
 
     onLaunchersGroupChanged:{
         if(latteView) {
             tasksModel.updateLaunchersList();
         }
     }
 
     Connections {
         target: plasmoid
         onLocationChanged: {
             iconGeometryTimer.start();
         }
     }
 
     Connections {
         target: plasmoid.configuration
 
         // onLaunchersChanged: tasksModel.launcherList = plasmoid.configuration.launchers
         onGroupingAppIdBlacklistChanged: tasksModel.groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
         onGroupingLauncherUrlBlacklistChanged: tasksModel.groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
     }
 
 
     Connections{
         target: latteView
         onDockIsHiddenChanged:{
             if (latteView.dockIsHidden) {
                 windowsPreviewDlg.hide("3.3");
             }
         }
     }
 
 
     Connections{
         target: latteView && latteView.layoutsManager ? latteView.layoutsManager : null
 
         onCurrentLayoutNameChanged: root.publishTasksGeometries();
     }
 
     Binding {
         target: plasmoid
         property: "status"
         value: (tasksModel.anyTaskDemandsAttentionInValidTime || root.dragSource ?
                     PlasmaCore.Types.NeedsAttentionStatus : PlasmaCore.Types.PassiveStatus);
     }
 
     /////
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
     //!
     Item {
         id: graphicsSystem
         readonly property bool isAccelerated: (GraphicsInfo.api !== GraphicsInfo.Software)
                                               && (GraphicsInfo.api !== GraphicsInfo.Unknown)
     }
 
     Loader {
         id: indicatorsStandaloneLoader
         active: !latteView && !plasmoid.configuration.isInLatteDock
         source: "indicators/Manager.qml"
     }
 
     Binding {
         target: root
         property: "alignment"
         value: {
             if (latteView) {
                 if (latteView.panelAlignment === -1) {
                     return;
                 }
 
                 if (latteView.panelAlignment === LatteCore.Types.Justify) {
                     if (latteView.latteAppletPos>=0 && latteView.latteAppletPos<100) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? LatteCore.Types.Left : LatteCore.Types.Top;
                     } else if (latteView.latteAppletPos>=100 && latteView.latteAppletPos<200) {
                         return LatteCore.Types.Center;
                     } else if (latteView.latteAppletPos>=200) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? LatteCore.Types.Right : LatteCore.Types.Bottom;
                     }
 
                     return LatteCore.Types.Center;
                 }
 
                 return latteView.panelAlignment;
             }
 
             return LatteCore.Types.Center;
         }
     }
 
     /////
 
     function launchersDropped(urls){
         mouseHandler.urlsDropped(urls);
     }
 
     ///UPDATE
     function launcherExists(url) {
         return (ActivitiesTools.getIndex(url, tasksModel.launcherList)>=0);
     }
 
     function taskExists(url) {
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.launcherUrl===url && task.isWindow) {
                 return true;
             }
         }
         return false;
     }
 
     function launchersDrop(event) {
         var createLaunchers = false;
 
         if (event.mimeData.hasUrls) {
             createLaunchers = event.mimeData.urls.every(function (item) {
                 return backend.isApplication(item)
             });
         }
 
         return createLaunchers;
     }
 
     function currentLauncherList() {
         var launch = [];
         var launchersList = [];
 
         if (viewLayout) {
             if (latteView && latteView.layoutsManager
                     && latteView.viewLayout && latteView.universalSettings
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     launchersList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     launchersList = latteView.universalSettings.launchers;
                 }
             }
         } else {
             launchersList = plasmoid.configuration.launchers59;
         }
 
 
         for(var i=0; i<launchersList.length; ++i){
             var launcherRecord = launchersList[i];
 
             if (launcherRecord.indexOf("[") === -1) {
                 //global launcher
                 launch.push(launcherRecord);
             } else {
                 //launcher assigned to activities
                 var end = launcherRecord.indexOf("\n");
                 var explicitLauncher = launcherRecord.substring(end+1,launcherRecord.length);
                 if (explicitLauncher !== "" && launcherRecord.indexOf(activityInfo.currentActivity) > -1) {
                     launch.push(explicitLauncher);
                 }
             }
         }
 
         return launch;
     }
 
     function currentListViewLauncherList() {
         var launch = [];
 
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = icList.childAtIndex(i);
 
             if (task!==undefined && task.launcherUrl!=="" && tasksModel.launcherInCurrentActivity(task.launcherUrl)) {
                 launch.push(task.launcherUrl);
             }
         }
 
         return launch;
     }
 
     function forcePreviewsHiding(debug) {
         //console.log("   Tasks: Force hide previews event called: "+debug);
         windowsPreviewDlg.visible = false;
         windowsPreviewDlg.mainItem.visible = false;
         windowsPreviewDlg.activeItem = null;
     }
 
     function hidePreview(){
         windowsPreviewDlg.hide(11);
     }
 
     onDragSourceChanged: {
         if (dragSource == null) {
             root.draggingFinished();
             tasksModel.syncLaunchers();
 
             restoreDraggingPhaseTimer.start();
         } else {
             inDraggingPhase = true;
         }
     }
 
     /////Window previews///////////
 
     Previews.ToolTipDelegate2 {
         id: toolTipDelegate
         visible: false
     }
 
     ////BEGIN interfaces
 
     LatteTasks.Dialog{
         id: windowsPreviewDlg
         // hideOnWindowDeactivate: false
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: root.location
         mainItem: toolTipDelegate
         visible: false
 
         property bool signalSent: false
         property Item activeItem: null
 
         Component.onCompleted: mainItem.visible = true;
 
         onContainsMouseChanged: {
             //! Orchestrate restore zoom and previews window hiding. Both should be
             //! triggered together.
             if (containsMouse) {
                 hidePreviewWinTimer.stop();
                 parabolic.stopRestoreZoomTimer();
                 parabolic.setDirectRenderingEnabled(false);
             } else {
                 hide(7.3);
                 parabolic.startRestoreZoomTimer();
             }
         }
 
         function hide(debug){
             //console.log("   Tasks: hide previews event called: "+debug);
             if (containsMouse || !visible) {
                 return;
             }
 
             if (latteView && signalSent) {
                 //it is used to unblock dock hiding
                 signalSent = false;
             }
 
             if (!root.contextMenu) {
                 root.disableRestoreZoom = false;
             }
 
             hidePreviewWinTimer.start();
         }
 
         function show(taskItem){
             if (root.disableAllWindowsFunctionality) {
                 return;
             }
 
             hidePreviewWinTimer.stop();
 
             // console.log("preview show called...");
             if ((!activeItem || (activeItem !== taskItem)) && !root.contextMenu) {
                 //console.log("preview show called: accepted...");
 
                 //this can be used from others to hide their appearance
                 //e.g but applets from the dock to hide themselves
                 if (!visible) {
                     root.signalPreviewsShown();
                 }
 
                 activeItem = taskItem;
                 toolTipDelegate.parentTask = taskItem;
 
                 if (latteView && !signalSent) {
                     //it is used to block dock hiding
                     signalSent = true;
                 }
 
                 //! Workaround in order to update properly the previews thumbnails
                 //! when switching between single thumbnail to another single thumbnail
                 mainItem.visible = false;
                 visible = true;
                 mainItem.visible = true;
             }
         }
     }
 
     //! Delay windows previews hiding
     Timer {
         id: hidePreviewWinTimer
         interval: 300
         onTriggered: {
             //! Orchestrate restore zoom and previews window hiding. Both should be
             //! triggered together.
             var contains = (windowsPreviewDlg.containsMouse
                             || (windowsPreviewDlg.activeItem && windowsPreviewDlg.activeItem.containsMouse) /*main task*/
                             || (windowsPreviewDlg.activeItem /*dragging file(s) from outside*/
                                 && mouseHandler.hoveredItem
                                 && !root.dragSource
                                 && mouseHandler.hoveredItem === windowsPreviewDlg.activeItem));
 
             if (!contains) {
                 root.forcePreviewsHiding();
             }
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown. It is mostly used under wayland in order to avoid crashes. When the context
     //! menu will be shown there is a chance that previews window has already appeared in that
     //! case the previews window must become hidden
     Timer {
         id: windowsPreviewCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (windowsPreviewDlg.visible && root.contextMenu) {
                 windowsPreviewDlg.hide("8.2");
             }
         }
     }
 
     //! Timer to delay the removal of the window through the context menu in case the
     //! the window is zoomed
     Timer{
         id: delayWindowRemovalTimer
         //this is the animation time needed in order for tasks to restore their zoom first
         interval: 7 * (animations.speedFactor.current * animations.duration.small)
 
         property var modelIndex
 
         onTriggered: {
             tasksModel.requestClose(delayWindowRemovalTimer.modelIndex)
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: delayWindowRemovalTimer called...");
             }
         }
     }
 
     Timer {
         id: activityChangeDelayer
         interval: 150
         onTriggered: {
             root.inActivityChange = false;
             activityInfo.previousActivity = activityInfo.currentActivity;
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: activityChangeDelayer called...");
             }
         }
     }
 
     /////Window Previews/////////
 
 
     property bool loadLaunchersFirstTime: false;
 
     onViewLayoutChanged: {
         if (viewLayout && !loadLaunchersFirstTime) {
             tasksModel.updateLaunchersList();
             loadLaunchersFirstTime = true;
         }
     }
 
     TaskManager.TasksModel {
         id: tasksModel
 
         virtualDesktop: virtualDesktopInfo.currentDesktop
         screenGeometry: root.screenGeometry
         // comment in order to support LTS Plasma 5.8
         // screen: plasmoid.screen
         activity: viewLayout ? viewLayout.lastUsedActivity : activityInfo.currentActivity
 
         filterByVirtualDesktop: root.showOnlyCurrentDesktop
         filterByScreen: root.showOnlyCurrentScreen
         filterByActivity: root.showOnlyCurrentActivity
 
         launchInPlace: true
         separateLaunchers: false
         groupInline: false
 
         groupMode: groupTasksByDefault ? TaskManager.TasksModel.GroupApplications : TaskManager.TasksModel.GroupDisabled
         sortMode: TaskManager.TasksModel.SortManual
 
         property bool anyTaskDemandsAttentionInValidTime: false
 
         function updateLaunchersList(){
             if (latteView
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     console.log("Tasks: Applying LAYOUT Launchers List...");
                     tasksModel.launcherList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     console.log("Tasks: Applying GLOBAL Launchers List...");
                     tasksModel.launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 console.log("Tasks: Applying UNIQUE Launchers List...");
                 tasksModel.launcherList = plasmoid.configuration.launchers59;
             }
         }
 
         function launcherInCurrentActivity(url) {
             var activities = tasksModel.launcherActivities(url);
 
             var NULL_UUID = "00000000-0000-0000-0000-000000000000";
 
             if (activities.indexOf(NULL_UUID) !== -1 || activities.indexOf(activityInfo.currentActivity) !== -1)
                 return true;
 
             return false;
         }
 
         onActivityChanged: {
             ActivitiesTools.currentActivity = String(activity);
         }
 
         onLauncherListChanged: {
             if (viewLayout) {
                 if (latteView && latteView.layoutsManager
                         && latteView.viewLayout && latteView.universalSettings
                         && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                             || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                     if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                         latteView.viewLayout.launchers = launcherList;
                     } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                         latteView.universalSettings.launchers = launcherList;
                     }
 
                     if (inDraggingPhase) {
                         if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                             latteView.layoutsManager.launchersSignals.validateLaunchersOrder(root.viewLayoutName,
                                                                                              plasmoid.id,
                                                                                              root.launchersGroup,
                                                                                              currentLauncherList());
                         }
                     }
                 } else {
                     plasmoid.configuration.launchers59 = launcherList;
                 }
             } else {
                 plasmoid.configuration.launchers59 = launcherList;
             }
         }
 
         onGroupingAppIdBlacklistChanged: {
             plasmoid.configuration.groupingAppIdBlacklist = groupingAppIdBlacklist;
         }
 
         onGroupingLauncherUrlBlacklistChanged: {
             plasmoid.configuration.groupingLauncherUrlBlacklist = groupingLauncherUrlBlacklist;
         }
 
         onAnyTaskDemandsAttentionChanged: {
             if (anyTaskDemandsAttention){
                 anyTaskDemandsAttentionInValidTime = true;
                 attentionTimerComponent.createObject(root);
             }
         }
 
 
         Component.onCompleted: {
             ActivitiesTools.launchersOnActivities = root.launchersOnActivities
             ActivitiesTools.currentActivity = String(activityInfo.currentActivity);
             ActivitiesTools.plasmoid = plasmoid;
 
             //var loadedLaunchers = ActivitiesTools.restoreLaunchers();
             ActivitiesTools.importLaunchersToNewArchitecture();
 
             if (viewLayout && latteView.universalSettings
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     launcherList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 launcherList = plasmoid.configuration.launchers59;
             }
 
             groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
             groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
 
             icList.model = tasksModel;
             tasksStarting = count;
 
             ///Plasma 5.9 enforce grouping at all cases
             if (LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,9,0)) {
                 groupingWindowTasksThreshold = -1;
             }
         }
     }
 
     //! TaskManagerBackend required a groupDialog setting otherwise it crashes. This patch
     //! sets one just in order not to crash TaskManagerBackend
     PlasmaCore.Dialog {
         //ghost group Dialog to not crash TaskManagerBackend
         id: groupDialogGhost
         visible: false
 
         type: PlasmaCore.Dialog.PopupMenu
         flags: Qt.WindowStaysOnTopHint
         hideOnWindowDeactivate: true
         location: root.location
     }
 
 
     TaskManagerApplet.Backend {
         id: backend
 
         taskManagerItem: root
         toolTipItem: toolTipDelegate
         highlightWindows: root.highlightWindows
 
         onAddLauncher: {
             tasksModel.requestAddLauncher(url);
         }
 
         Component.onCompleted: {
             //! In Plasma 5.9 TaskManagerBackend required a groupDialog setting
             //! otherwise it crashes.
             //! frameworks 5.29.0 provide id 335104
             //! work only after Plasma 5.9 and frameworks 5.29
             //! + added a check for groupDialog also when it is present
             //!   in plasma 5.8 (that was introduced after 5.8.5)
             if (LatteCore.Environment.frameworksVersion >= 335104 || (groupDialog !== undefined)) {
                 groupDialog = groupDialogGhost;
             }
         }
     }
 
     TaskManagerApplet.DragHelper {
         id: dragHelper
 
         dragIconSize: units.iconSizes.medium
     }
 
     TaskManager.VirtualDesktopInfo {
         id: virtualDesktopInfo
     }
 
     TaskManager.ActivityInfo {
         id: activityInfo
 
         property string previousActivity: ""
         onCurrentActivityChanged: {
             root.inActivityChange = true;
             activityChangeDelayer.start();
         }
 
         Component.onCompleted: previousActivity = currentActivity;
     }
 
     PlasmaCore.DataSource {
         id: mpris2Source
         engine: "mpris2"
         connectedSources: sources
         function sourceNameForLauncherUrl(launcherUrl, pid) {
             if (!launcherUrl || launcherUrl === "") {
                 return "";
             }
 
             // MPRIS spec explicitly mentions that "DesktopEntry" is with .desktop extension trimmed
             // Moreover, remove URL parameters, like wmClass (part after the question mark)
             var desktopFileName = launcherUrl.toString().split('/').pop().split('?')[0].replace(".desktop", "")
             if (desktopFileName.indexOf("applications:") === 0) {
                 desktopFileName = desktopFileName.substr(13)
             }
 
             for (var i = 0, length = connectedSources.length; i < length; ++i) {
                 var source = connectedSources[i];
                 // we intend to connect directly, otherwise the multiplexer steals the connection away
                 if (source === "@multiplex") {
                     continue;
                 }
 
                 var sourceData = data[source];
                 if (!sourceData) {
                     continue;
                 }
 
                 if (sourceData.DesktopEntry === desktopFileName || (pid && sourceData.InstancePid === pid)) {
                     return source;
                 }
 
                 var metadata = sourceData.Metadata;
                 if (metadata) {
                     var kdePid = metadata["kde:pid"];
                     if (kdePid && pid === kdePid) {
                         return source;
                     }
                 }
             }
 
             return ""
         }
 
         function startOperation(source, op) {
             var service = serviceForSource(source)
             var operation = service.operationDescription(op)
             return service.startOperationCall(operation)
         }
 
         function goPrevious(source) {
             startOperation(source, "Previous");
         }
         function goNext(source) {
             startOperation(source, "Next");
         }
         function play(source) {
             startOperation(source, "Play");
         }
         function pause(source) {
             startOperation(source, "Pause");
         }
         function playPause(source) {
             startOperation(source, "PlayPause");
         }
         function stop(source) {
             startOperation(source, "Stop");
         }
         function raise(source) {
             startOperation(source, "Raise");
         }
         function quit(source) {
             startOperation(source, "Quit");
         }
     }
 
     Loader {
         id: pulseAudio
         source: "PulseAudio.qml"
         active: root.showAudioBadge
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     TasksExtendedManager {
         id: _tasksExtendedManager
     }
 
     Ability.Animations {
         id: _animations
         bridge: latteBridge
     }
 
     Ability.Indexer {
         id: _indexer
         bridge: latteBridge
         layout: icList.contentItem
 
         allItemsCount: tasksModel.count
     }
 
     Ability.Metrics {
         id: _metrics
         bridge: latteBridge
     }
 
     Ability.ParabolicEffect {
         id: _parabolic
         bridge: latteBridge
         local.restoreZoomIsBlocked: root.contextMenu || windowsPreviewDlg.containsMouse
     }
 
+    Ability.PositionShortcuts {
+        id: _shortcuts
+        bridge: latteBridge
+    }
+
     AppletAbility.Requirements{
         id: _requires
         bridge: latteBridge
 
         activeIndicatorEnabled: false
         latteIconOverlayEnabled: false
         lengthMarginsEnabled: false
         latteSideColoringEnabled: false
         screenEdgeMarginSupported: true        
         innerZoomFactor: {
             if (!_animations.active || !LatteCore.WindowSystem.compositingActive) {
                 return 1;
             }
 
             var hasHighThicknessAnimation = _animations.launcherBouncingEnabled || _animations.windowInAttentionEnabled || _animations.windowAddedInGroupEnabled;
 
             return hasHighThicknessAnimation ? 1.65 : 1.0;
         }
     }
 
     Component{
         id: attentionTimerComponent
         Timer{
             id: attentionTimer
             interval:8500
             onTriggered: {
                 tasksModel.anyTaskDemandsAttentionInValidTime = false;
                 destroy();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: attentionTimer called...");
                 }
             }
             Component.onCompleted: {
                 start();
             }
         }
     }
 
     //this timer restores the draggingPhase flag to false
     //after a dragging has finished... This delay is needed
     //in order to not animate any tasks are added after a
     //dragging
     Timer {
         id: restoreDraggingPhaseTimer
         interval: 150
         onTriggered: inDraggingPhase = false;
     }
 
     ///Red Liner!!! show the upper needed limit for animations
     Rectangle{
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: root.vertical ? 1 : 2 * metrics.iconSize
         height: root.vertical ? 2 * metrics.iconSize : 1
         color: "red"
         x: (root.location === PlasmaCore.Types.LeftEdge) ? neededSpace : parent.width - neededSpace
         y: (root.location === PlasmaCore.Types.TopEdge) ? neededSpace : parent.height - neededSpace
 
         visible: plasmoid.configuration.zoomHelper
 
         property int neededSpace: parabolic.factor.zoom*metrics.totals.length
     }
 
     Item{
         id:barLine
         anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
         anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
         anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
         anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: ( icList.orientation === Qt.Horizontal ) ? icList.width + spacing : smallSize
         height: ( icList.orientation === Qt.Vertical ) ? icList.height + spacing : smallSize
 
         property int spacing: latteBridge ? 0 : metrics.iconSize / 2
         property int smallSize: Math.max(0.10 * metrics.iconSize, 16)
 
         Behavior on opacity{
             NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
         }
 
         /// plasmoid's default panel
         BorderImage{
             anchors.fill:parent
             source: "../images/panel-west.png"
             border { left:8; right:8; top:8; bottom:8 }
 
             opacity: (plasmoid.configuration.showBarLine && !plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
 
             visible: (opacity == 0) ? false : true
 
             horizontalTileMode: BorderImage.Stretch
             verticalTileMode: BorderImage.Stretch
 
             Behavior on opacity{
                 NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
             }
         }
 
 
         /// item which is used as anchors for the plasma's theme
         Item{
             id:belower
 
             width: (root.location === PlasmaCore.Types.LeftEdge) ? shadowsSvgItem.margins.left : shadowsSvgItem.margins.right
             height: (root.location === PlasmaCore.Types.BottomEdge)? shadowsSvgItem.margins.bottom : shadowsSvgItem.margins.top
 
             anchors.top: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
             anchors.bottom: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
             anchors.right: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
             anchors.left: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
         }
 
 
         /// the current theme's panel
         PlasmaCore.FrameSvgItem{
             id: shadowsSvgItem
 
             anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? belower.bottom : undefined
             anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? belower.top : undefined
             anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? belower.left : undefined
             anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? belower.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
             width: root.vertical ? panelSize + margins.left + margins.right: parent.width
             height: root.vertical ? parent.height : panelSize + margins.top + margins.bottom
 
             imagePath: "translucent/widgets/panel-background"
             prefix:"shadow"
 
             opacity: (plasmoid.configuration.showBarLine && plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
             visible: (opacity == 0) ? false : true
 
             property int panelSize: ((root.location === PlasmaCore.Types.BottomEdge) ||
                                      (root.location === PlasmaCore.Types.TopEdge)) ?
                                         plasmoid.configuration.panelSize + belower.height:
                                         plasmoid.configuration.panelSize + belower.width
 
             Behavior on opacity{
                 NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
             }
 
 
             PlasmaCore.FrameSvgItem{
                 anchors.margins: belower.width-1
                 anchors.fill:parent
                 imagePath: plasmoid.configuration.transparentPanel ? "translucent/widgets/panel-background" :
                                                                      "widgets/panel-background"
             }
         }
 
 
         TasksLayout.MouseHandler {
             id: mouseHandler
             anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? scrollableList.bottom : undefined
             anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? scrollableList.top : undefined
             anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? scrollableList.left : undefined
             anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? scrollableList.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? scrollableList.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? scrollableList.verticalCenter : undefined
 
             width: root.vertical ? maxSize : icList.width
             height: root.vertical ? icList.height : maxSize
 
             target: icList
 
             visible: root.dragAreaEnabled
 
             property int maxSize: (parabolic.local.lastIndex>=0 || windowPreviewIsShown || animations.hasThicknessAnimation) ?
                                       (parabolic.factor.maxZoom * metrics.totals.thickness) + metrics.margin.screenEdge :
                                       metrics.totals.thickness + metrics.margin.screenEdge
 
             function onlyLaunchersInList(list){
                 return list.every(function (item) {
                     return backend.isApplication(item)
                 });
             }
 
             function urlsDroppedOnArea(urls){
                 // If all dropped URLs point to application desktop files, we'll add a launcher for each of them.
                 if (onlyLaunchersInList(urls)) {
                     urls.forEach(function (item) {
                         addLauncher(item);
                     });
                     return;
                 }
 
                 if (!hoveredItem) {
                     return;
                 }
 
                 // DeclarativeMimeData urls is a QJsonArray but requestOpenUrls expects a proper QList<QUrl>.
                 var urlsList = backend.jsonArrayToUrlList(urls);
 
                 // Otherwise we'll just start a new instance of the application with the URLs as argument,
                 // as you probably don't expect some of your files to open in the app and others to spawn launchers.
                 tasksModel.requestOpenUrls(hoveredItem.modelIndex(), urlsList);
             }
 
             onUrlsDropped: {               
                 //! inform synced docks for new dropped launchers
                 if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers && onlyLaunchersInList(urls)) {
                     latteView.layoutsManager.launchersSignals.urlsDropped(root.viewLayoutName,
                                                                           root.launchersGroup, urls);
                     return;
                 }
 
                 //! if the list does not contain only launchers then just open the corresponding
                 //! urls with the relevant app
                 urlsDroppedOnArea(urls);
             }
         }
 
         /* Rectangle {
             anchors.fill: scrollableList
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
         TasksLayout.ScrollableList {
             id: scrollableList
             width: !root.vertical ? length : thickness
             height: root.vertical ? length : thickness
             contentWidth: icList.width
             contentHeight: icList.height
 
             property int thickness:0 // through Binding to avoid binding loops
             property int length:0 // through Binding to avoid binding loops
 
             //onCurrentPosChanged: console.log("CP :: "+ currentPos + " icW:"+icList.width + " rw: "+root.width + " w:" +width);
 
             layer.enabled: contentsExceed && root.scrollingEnabled
             layer.effect: OpacityMask {
                 maskSource: TasksLayout.ScrollOpacityMask{
                     width: scrollableList.width
                     height: scrollableList.height
                 }
             }
 
             Binding {
                 target: scrollableList
                 property: "thickness"
                 when: latteView && !latteView.maskManager.inTempHiding
                 value: {
                     if (latteView) {
                         return animations.hasThicknessAnimation ? latteView.maskManager.thicknessZoom : latteView.maskManager.thicknessNormal;
                     }
 
                     return metrics.totals.thickness * parabolic.factor.zoom;
                 }
             }
 
             Binding {
                 target: scrollableList
                 property: "length"
                 when: latteView && !latteView.maskManager.inTempHiding
                 value: {
                     if (root.vertical) {
                         return Math.min(root.height, icList.height)
                     }
 
                     return Math.min(root.width, icList.width);
                 }
             }
 
             TasksLayout.ScrollPositioner {
                 id: listViewBase
 
                 ListView {
                     id:icList
                     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
                     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
                     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
                     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
                     anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
                     anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
                     width: !root.vertical ? contentWidth : mouseHandler.maxSize
                     height: root.vertical ? contentHeight : mouseHandler.maxSize
                     boundsBehavior: Flickable.StopAtBounds
                     orientation: plasmoid.formFactor === PlasmaCore.Types.Vertical ? Qt.Vertical : Qt.Horizontal
                     delegate: Task.TaskItem{
                         animations: _animations
                         indexer: _indexer
                         metrics: _metrics
                         parabolic: _parabolic
                         requires: _requires
+                        shortcuts: _shortcuts
                     }
 
                     property int currentSpot : -1000
                     property int previousCount : 0
 
                     property int tasksCount: tasksModel.count
 
                     //the duration of this animation should be as small as possible
                     //it fixes a small issue with the dragging an item to change it's
                     //position, if the duration is too big there is a point in the
                     //list that an item is going back and forth too fast
 
                     //more of a trouble
                     moveDisplaced: Transition {
                         NumberAnimation { properties: "x,y"; duration: animations.speedFactor.current*animations.duration.large; easing.type: Easing.Linear }
                     }
 
                     ///this transition can not be used with dragging !!!! I breaks
                     ///the lists indexes !!!!!
                     ///move: Transition {
                     ///    NumberAnimation { properties: "x,y"; duration: 400; easing.type: Easing.Linear }
                     ///}
 
                     function childAtPos(x, y){
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             var choords = mapFromItem(task,0, 0);
 
                             if( (task.objectName==="TaskItem") && (x>=choords.x) && (x<=choords.x+task.width)
                                     && (y>=choords.y) && (y<=choords.y+task.height)){
                                 return task;
                             }
                         }
 
                         return null;
                     }
 
                     function childAtIndex(position) {
                         var tasks = icList.contentItem.children;
 
                         if (position < 0)
                             return;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task.lastValidIndex === position
                                     || (task.lastValidIndex === -1 && task.itemIndex === position )) {
                                 return task;
                             }
                         }
 
                         return undefined;
                     }
 
                     function launcherModelIndex(url) {
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task && (task.launcherUrl===url)) {
                                 return task.itemIndex;
                             }
                         }
 
                         return -1;
                     }
                 }
             } // ScrollPositioner
         } // ScrollableList
 
         TasksLayout.ScrollEdgeShadows {
             id: scrollShadows
             width: !root.vertical ? scrollableList.width : thickness
             height: !root.vertical ? thickness : scrollableList.height
             visible: scrollableList.contentsExceed
 
             flickable: scrollableList
         } // ScrollEdgeShadows
 
         LatteComponents.AddingArea {
             id: newDroppedLauncherVisual
             width: root.vertical ? metrics.totals.thickness : scrollableList.width
             height: root.vertical ? scrollableList.height : metrics.totals.thickness
 
             visible: backgroundOpacity > 0
             radius: metrics.iconSize/10
             backgroundOpacity: root.dropNewLauncher && mouseHandler.onlyLaunchers && (root.dragSource == null)? 0.75 : 0
             duration: animations.speedFactor.current
 
             title: i18n("Tasks Area")
 
             states: [
                 ///Bottom Edge
                 State {
                     name: "left"
                     when: root.location===PlasmaCore.Types.LeftEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:undefined; bottom:undefined; left:scrollableList.left; right:undefined;
                             horizontalCenter:undefined; verticalCenter:scrollableList.verticalCenter}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:0; bottomMargin:0; leftMargin:metrics.margin.screenEdge; rightMargin:0;}
                     }
                 },
                 State {
                     name: "right"
                     when: root.location===PlasmaCore.Types.RightEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:undefined; bottom:undefined; left:undefined; right:scrollableList.right;
                             horizontalCenter:undefined; verticalCenter:scrollableList.verticalCenter}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:0; bottomMargin:0; leftMargin:0; rightMargin:metrics.margin.screenEdge;}
                     }
                 },
                 State {
                     name: "top"
                     when: root.location===PlasmaCore.Types.TopEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:scrollableList.top; bottom:undefined; left:undefined; right:undefined;
                             horizontalCenter:scrollableList.horizontalCenter; verticalCenter:undefined}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:metrics.margin.screenEdge; bottomMargin:0; leftMargin:0; rightMargin:0;}
                     }
                 },
                 State {
                     name: "bottom"
                     when: root.location!==PlasmaCore.Types.TopEdge
                           && root.location !== PlasmaCore.Types.LeftEdge
                           && root.location !== PlasmaCore.Types.RightEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:undefined; bottom:scrollableList.bottom; left:undefined; right:undefined;
                             horizontalCenter:scrollableList.horizontalCenter; verticalCenter:undefined}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:0; bottomMargin:metrics.margin.screenEdge; leftMargin:0; rightMargin:0;}
                     }
                 }
             ]
         }
     }
 
     //// helpers
 
     Timer {
         id: iconGeometryTimer
         // INVESTIGATE: such big interval but unfortunately it does not work otherwise
         interval: 500
         repeat: false
 
         onTriggered: {
             root.publishTasksGeometries();
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: iconGeometryTimer called...");
             }
         }
     }
 
 
     ///REMOVE
     ////Activities List
     ////it can be used to cleanup the launchers from garbage-deleted activities....
     Item{
         id: activityModelInstance
         property int count: activityModelRepeater.count
 
         Repeater {
             id:activityModelRepeater
             model: Activities.ActivityModel {
                 id: activityModel
                 //  shownStates: "Running"
             }
             delegate: Item {
                 visible: false
                 property string activityId: model.id
                 property string activityName: model.name
             }
         }
 
         function activities(){
             var activitiesResult = [];
 
             for(var i=0; i<activityModelInstance.count; ++i){
                 console.log(children[i].activityId);
                 activitiesResult.push(children[i].activityId);
             }
 
             return activitiesResult;
         }
 
         ///REMOVE
         onCountChanged: {
             /*  if(activityInfo.currentActivity != "00000000-0000-0000-0000-000000000000"){
                 console.log("----------- Latte Plasmoid Signal: Activities number was changed ---------");
                 var allActivities = activities();
                 ActivitiesTools.cleanupRecords(allActivities);
                 console.log("----------- Latte Plasmoid Signal End ---------");
             }*/
         }
     }
 
     Timer{
         id:launchersOrderValidatorTimer
         interval: 400
 
         property var launchers: []
 
         function launchersAreInSync() {
             return arraysAreEqual(currentListViewLauncherList(), launchers);
         }
 
         function launcherValidPos(url) {
             for (var i=0; i<launchers.length; ++i) {
                 if (launchers[i] === url) {
                     return i;
                 }
             }
 
             return -1;
         }
 
         function arraysAreEqual(list1, list2) {
             if (list1.length !== list2.length) {
                 console.log("  arrays have different size...")
                 return false;
             }
 
             for (var i=0; i<list1.length; ++i) {
                 if (list1[i] !== list2[i]) {
                     return false;
                 }
             }
 
             return true;
         }
 
         //! true if upward is the best way to iterate through current
         //! in order to make it equal with goal
         function upwardIsBetter(current, goal)
         {
             var tCurrent = current.slice();
 
             if (!arraysAreEqual(tCurrent, goal)) {
                 for (var i=0; i<tCurrent.length; ++i) {
                     if (tCurrent[i] !== goal[i]) {
                         var val = tCurrent[i];
                         tCurrent.splice(i, 1);
                         tCurrent.splice(goal.indexOf(val), 0, val);
 
                         if (arraysAreEqual(tCurrent, goal)){
                             return true;
                         } else {
                             return false;
                         }
                     }
                 }
             }
 
             return false;
         }
 
 
         onTriggered: {
             if (launchersAreInSync()) {
                 stop();
                 console.log("launchers synced at:" + launchers);
                 launchers.length = 0;
                 parabolicManager.updateTasksEdgesIndexes();
                 tasksModel.syncLaunchers();
             } else {
                 var currentLaunchers = currentListViewLauncherList();
 
                 if (upwardIsBetter(currentLaunchers, launchers)) {
                     console.log("UPWARD....");
                     for (var i=0; i<currentLaunchers.length; ++i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 } else {
                     console.log("DOWNWARD....");
                     for (var i=currentLaunchers.length-1; i>=0; --i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 }
 
                 console.log("why we reached ??? ");
                 console.log("CURRENT ::: " + currentLaunchers);
                 console.log("VALID   ::: " + launchers);
             }
         }
     }
 
     /////////
 
     //// functions
     function addInternalSeparatorAtPos(pos) {
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.viewLayoutName,
                                                                       root.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
-    // This is called by dockcorona in response to a Meta+number shortcut.
     function activateTaskAtIndex(index) {
-        if (typeof index !== "number") {
-            return;
-        }
-
-        var tasks = icList.contentItem.children;
-
-        //! this is used to bypass the internal separators if they exist
-        var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
-
-        for(var i=0; i<tasks.length; ++i){
-            var task = tasks[i];
-
-            if (task.itemIndex === confirmedIndex) {
-                if (task.isGroupParent) {
-                    task.activateNextTask();
-                } else {
-                    task.activateTask();
-                }
-                break;
-            }
-        }
+        // This is called with Meta+number shortcuts by plasmashell when Tasks are in a plasma panel.
+        shortcuts.sglActivateEntryAtIndex(index);
     }
 
-    // This is called by dockcorona in response to a Meta+Alt+number shortcut.
     function newInstanceForTaskAtIndex(index) {
-        if (typeof index !== "number") {
-            return;
-        }
-
-        var tasks = icList.contentItem.children;
-
-        //! this is used to bypass the internal separators if they exist
-        var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
-
-        for(var i=0; i<tasks.length; ++i){
-            var task = tasks[i];
-
-            if (task.itemIndex === confirmedIndex) {
-                TaskTools.activateTask(task.modelIndex(), task.m, Qt.ControlModifier , task);
-                break;
-            }
-        }
+        // This is called with Meta+Alt+number shortcuts by plasmashell when Tasks are in a plasma panel.
+        shortcuts.sglNewInstanceForEntryAtIndex(index);
     }
 
     function getBadger(identifier) {
         var ident1 = identifier;
         var n = ident1.lastIndexOf('/');
 
         var result = n>=0 ? ident1.substring(n + 1) : identifier;
 
         for(var i=0; i<badgers.length; ++i) {
             if (result.indexOf(badgers[i].id) >= 0) {
                 return badgers[i];
             }
         }
     }
 
     function updateBadge(identifier, value) {
         var tasks = icList.contentItem.children;
         var identifierF = identifier.concat(".desktop");
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task && task.launcherUrl && task.launcherUrl.indexOf(identifierF) >= 0) {
                 task.badgeIndicator = value === "" ? 0 : Number(value);
                 var badge = getBadger(identifierF);
                 if (badge) {
                     badge.value = value;
                 } else {
                     badgers.push({id: identifierF, value: value});
                 }
             }
         }
     }
 
     function getLauncherList() {
         return plasmoid.configuration.launchers59;
     }
 
     //! BEGIN ::: external launchers signals in order to update the tasks model
     function extSignalAddLauncher(group, launcher) {
         if (group === root.launchersGroup) {
             tasksModel.requestAddLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncher(group, launcher) {
         if (group === root.launchersGroup) {
             root.launcherForRemoval = launcher;
             tasksModel.requestRemoveLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalAddLauncherToActivity(group, launcher, activity) {
         if (group === root.launchersGroup) {
             var launcherActivities = tasksModel.launcherActivities(launcher);
 
             if (activity !== tasksModel.activity && (launcherActivities[0] === "00000000-0000-0000-0000-000000000000")) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestAddLauncherToActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncherFromActivity(group, launcher, activity) {
         if (group === root.launchersGroup) {
             if (activity === tasksModel.activity) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestRemoveLauncherFromActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalUrlsDropped(group, urls) {
         if (group === root.launchersGroup) {
             mouseHandler.urlsDroppedOnArea(urls);
         }
     }
 
     function extSignalMoveTask(group, from, to) {
         if (group === root.launchersGroup && !root.dragSource) {
             tasksModel.move(from, to);
             parabolicManager.updateTasksEdgesIndexes();
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalValidateLaunchersOrder(group, launchers) {
         if (group === root.launchersGroup && !root.dragSource) {
             launchersOrderValidatorTimer.stop();
             launchersOrderValidatorTimer.launchers = launchers;
             launchersOrderValidatorTimer.start();
         }
     }
 
     //! END ::: external launchers signals in order to update the tasks model
 
 
     //! it is used to add the fake desktop file which represents
     //! the separator (fake launcher)
     function addSeparator(pos){
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     function removeLastSeparator(){
         var separatorName = parabolicManager.lastPresentSeparatorName();
 
         if (separatorName !== "") {
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.removeLauncher(root.viewLayoutName,
                                                                          root.launchersGroup, separatorName);
             } else {
                 root.launcherForRemoval = separatorName;
                 tasksModel.requestRemoveLauncher(separatorName);
             }
         }
     }
 
-    //! show/hide tasks numbered badges e.g. from global shortcuts
-    function setShowTaskShortcutBadges(showBadges){
-        showTaskShortcutBadges = showBadges;
-    }
-
-    //! setup the tasks first index based on the fact that this is a plasmoid
-    //! and applets could exist before it
-    function setTasksBaseIndex(base){
-        tasksBaseIndex = base;
-    }
-
     function previewContainsMouse() {
         return windowsPreviewDlg.containsMouse;
     }
 
     function containsMouse(){
         //console.log("s1...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         //if (previewContainsMouse())
         //  windowsPreviewDlg.hide(4);
 
         if (previewContainsMouse())
             return true;
 
         //console.log("s3...");
         var tasks = icList.contentItem.children;
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if(task && task.containsMouse){
                 // console.log("Checking "+i+" - "+task.index+" - "+task.containsMouse);
                 return true;
             }
         }
 
         return false;
     }
 
     function hasLauncher(url) {
         return tasksModel.launcherPosition(url) != -1;
     }
 
     function addLauncher(url) {
         //workaround to protect in case the launcher contains the iconData
         var pos = url.indexOf("?iconData=");
 
         if (pos>0) {
             url = url.substring( 0, url.indexOf("?iconData=" ) );
         }
 
         var path = url;
         var filename = path.split("/").pop();
         tasksExtendedManager.addToBeAddedLauncher(filename);
 
         tasksModel.requestAddLauncher(url);
         launchersUpdatedFor(url);
         tasksModel.syncLaunchers();
     }
 
     function resetDragSource() {
         dragSource.z = 0;
         dragSource = null;
     }
 
     ///REMOVE
     /*function createContextMenu(task) {
         var menu = root.contextMenuComponent.createObject(task);
         menu.visualParent = task;
         menu.mpris2Source = mpris2Source;
         menu.activitiesCount = activityModelInstance.count;
         return menu;
     }*/
 
     function createContextMenu(rootTask, modelIndex, args) {
         var initialArgs = args || {}
         initialArgs.visualParent = rootTask;
         initialArgs.modelIndex = modelIndex;
         initialArgs.mpris2Source = mpris2Source;
         initialArgs.backend = backend;
 
         root.contextMenu = root.contextMenuComponent.createObject(rootTask, initialArgs);
 
         return root.contextMenu;
     }
 
     Component.onCompleted:  {
         root.presentWindows.connect(backend.presentWindows);
         root.windowsHovered.connect(backend.windowsHovered);
         dragHelper.dropped.connect(resetDragSource);
     }
 
     Component.onDestruction: {
         root.presentWindows.disconnect(backend.presentWindows);
         root.windowsHovered.disconnect(backend.windowsHovered);
         dragHelper.dropped.disconnect(resetDragSource);
     }
 
     //BEGIN states
     // Alignments
     // 0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Bottom Edge
         State {
             name: "bottomCenter"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomLeft"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomRight"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Top Edge
         State {
             name: "topCenter"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "topLeft"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "topRight"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ////Left Edge
         State {
             name: "leftCenter"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "leftTop"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "leftBottom"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Right Edge
         State {
             name: "rightCenter"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "rightTop"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "rightBottom"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         }
 
     ]
     //END states
 
 }
diff --git a/plasmoid/package/contents/ui/task/ShortcutBadge.qml b/plasmoid/package/contents/ui/task/ShortcutBadge.qml
index f61ea46d..aae7b294 100644
--- a/plasmoid/package/contents/ui/task/ShortcutBadge.qml
+++ b/plasmoid/package/contents/ui/task/ShortcutBadge.qml
@@ -1,85 +1,86 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 import QtGraphicalEffects 1.0
 
 import org.kde.latte.components 1.0 as LatteComponents
 
 Loader{
     id: shorcutBadge
     anchors.fill: iconImageBuffer
-    active: root.showTaskShortcutBadges && !taskItem.isSeparator && fixedIndex>=0 && fixedIndex<20
+    active: taskItem.shortcuts.showPositionShortcutBadges && !taskItem.isSeparator && !taskItem.isHidden
     asynchronous: true
     visible: badgeString !== ""
 
     property int fixedIndex:-1
     property string badgeString: (shorcutBadge.fixedIndex>=1 && shorcutBadge.fixedIndex<20 && root.badgesForActivate.length===19) ?
                                      root.badgesForActivate[shorcutBadge.fixedIndex-1] : ""
 
-    Connections {
-        target: root
-        onShowTaskShortcutBadgesChanged: {
-            shorcutBadge.fixedIndex = taskItem.indexer.visibleIndex(taskItem.itemIndex);
+    onActiveChanged: {
+        if (active && taskItem.shortcuts.showPositionShortcutBadges) {
+            fixedIndex = taskItem.indexer.visibleIndex(taskItem.itemIndex);
+        } else {
+            fixedIndex = -1;
         }
     }
 
     Component.onCompleted: {
         fixedIndex = taskItem.indexer.visibleIndex(taskItem.itemIndex);
     }
 
     sourceComponent: Item{
         Loader{
             anchors.fill: taskNumber
             active: root.enableShadows && graphicsSystem.isAccelerated
 
             sourceComponent: DropShadow{
                 color: root.appShadowColor
                 fast: true
                 samples: 2 * radius
                 source: taskNumber
                 radius: root.appShadowSize/2
                 verticalOffset: 2
             }
         }
 
         LatteComponents.BadgeText {
             id: taskNumber
             // when iconSize < 48, height is always = 24, height / iconSize > 50%
             // we prefer center aligned badges to top-left aligned ones
             property bool centerInParent: taskItem.metrics.iconSize < 48
 
             anchors.left: centerInParent? undefined : parent.left
             anchors.top: centerInParent? undefined : parent.top
             anchors.centerIn: centerInParent? parent : undefined
             minimumWidth: 0.4 * (wrapper.mScale * taskItem.metrics.iconSize)
             height: Math.max(24, 0.4 * (wrapper.mScale * taskItem.metrics.iconSize))
 
             style3d: root.badges3DStyle
             textValue: shorcutBadge.badgeString
             borderColor: root.lightTextColor
 
             showNumber: false
             showText: true
 
             proportion: 0
             radiusPerCentage: 100
         }
     }
 }
diff --git a/plasmoid/package/contents/ui/task/TaskItem.qml b/plasmoid/package/contents/ui/task/TaskItem.qml
index 42c65930..75499a7f 100644
--- a/plasmoid/package/contents/ui/task/TaskItem.qml
+++ b/plasmoid/package/contents/ui/task/TaskItem.qml
@@ -1,1659 +1,1683 @@
 /*
 *  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.Layouts 1.1
 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.plasmoid 2.0
 
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.latte.core 0.2 as LatteCore
 
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "animations" as TaskAnimations
 import "indicator" as Indicator
 
 MouseArea{
     id: taskItem
 
     visible: false //true//(isStartup && animations.speedFactor.current !== 0) ? false : true
 
     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
     objectName: "TaskItem"
 
     width: {
         if (!visible)
             return 0;
 
         if (isSeparator) {
             if (root.vertical) {
                 return taskItem.metrics.totals.thickness + taskItem.metrics.margin.screenEdge;
             } else {
                 if (root.dragSource || !root.parabolicEffectEnabled) {
                     return LatteCore.Environment.separatorLength+2*taskItem.metrics.margin.length;
                 }
             }
 
             return 0;
         }
 
         if (root.vertical) {
             return wrapper.width;
         } else {
             return hiddenSpacerLeft.width+wrapper.width+hiddenSpacerRight.width;
         }
     }
 
     /*onWidthChanged: {
         console.log("T: " + itemIndex + " - " + launcherUrl + " - " + width + " _ "+ hiddenSpacerLeft.width + " _ " + wrapper.width + " _ " + hiddenSpacerRight.width);
     }*/
 
     height: {
         if (!visible)
             return 0;
 
         if (isSeparator) {
             if (!root.vertical) {
                 return taskItem.metrics.totals.thickness + taskItem.metrics.margin.screenEdge;
             } else {
                 if (root.dragSource || !root.parabolicEffectEnabled) {
                     return LatteCore.Environment.separatorLength+2*taskItem.metrics.margin.length;
                 }
             }
 
             return 0;
         }
 
         if (root.vertical) {
             return hiddenSpacerLeft.height + wrapper.height + hiddenSpacerRight.height;
         } else {
             return wrapper.height;
         }
     }
 
     acceptedButtons: Qt.LeftButton | Qt.MidButton | Qt.RightButton
     hoverEnabled: visible && (!inAnimation) && (!IsStartup) && (!root.taskInAnimation)
                   &&(!inBouncingAnimation) && !isSeparator
     // hoverEnabled: false
     //opacity : isSeparator && (hiddenSpacerLeft.neighbourSeparator || hiddenSpacerRight.neighbourSeparator) ? 0 : 1
 
     property bool buffersAreReady: false
     property bool delayingRemove: ListView.delayRemove
     property bool scalesUpdatedOnce: false
     //states that exist in windows in a Group of windows
     property bool hasActive: isActive
     property bool hasMinimized: (IsGroupParent === true) ? subWindows.hasMinimized : isMinimized
     property bool hasShown: (IsGroupParent === true) ? subWindows.hasShown : !isMinimized && isWindow
     property bool inAttention: isDemandingAttention && plasmoid.status === PlasmaCore.Types.RequiresAttentionStatus ? true : false
     /*animations flags*/
     property bool inAnimation: true
     property bool inAddRemoveAnimation: true
     property bool inAttentionAnimation: false
     property bool inBlockingAnimation: false
     property bool inBouncingAnimation: false
     property bool inFastRestoreAnimation: false
     property bool inMimicParabolicAnimation: false
     property bool inNewWindowAnimation: false
     property real mimicParabolicScale: -1
     property bool inPopup: false
     property bool inRemoveStage: false
 
     property bool isAbleToShowPreview: true
     property bool isActive: (IsActive === true) ? true : false
     property bool isDemandingAttention: (IsDemandingAttention === true) ? true : false
     property bool isDragged: false
     property bool isGroupable: (IsGroupable === true) ? true : false
     property bool isGroupParent: (IsGroupParent === true) ? true : false
     readonly property bool isHidden: !visible || isForcedHidden
     property bool isForcedHidden: false
     property bool isLauncher: (IsLauncher === true) ? true : false
     property bool isMinimized: (IsMinimized === true) ? true : false
     property bool isSeparator: false
     property bool isStartup: (IsStartup === true) ? true : false
     property bool isWindow: (IsWindow === true) ? true : false
     property bool isZoomed: false
 
     property bool canPublishGeometries: (isWindow || isStartup || isGroupParent) && visible && width>=taskItem.metrics.iconSize && height>=taskItem.metrics.iconSize
                                         && !taskItem.delayingRemove
                                         && (wrapper.mScale===1 || wrapper.mScale===taskItem.parabolic.factor.zoom) //don't publish during zoom animation
 
     property bool hoveredFromDragging: (mouseHandler.hoveredItem === taskItem) || (mouseHandler.ignoredItem === taskItem)
 
     property bool pressed: false
     property bool wheelIsBlocked: false
 
     property int animationTime: (taskItem.animations.active ? taskItem.animations.speedFactor.current : 2) * (1.2 *taskItem.animations.duration.small)
     property int badgeIndicator: 0 //it is used from external apps
     property int itemIndex: index
     property int lastValidIndex: -1 //used for the removal animation
     property int lastButtonClicked: -1;
     property int pressX: -1
     property int pressY: -1
     property int resistanceDelay: 450
     property int spacersMaxSize: Math.max(0,Math.ceil(0.55*taskItem.metrics.iconSize) - taskItem.metrics.totals.lengthEdges)
     property int windowsCount: subWindows.windowsCount
     property int windowsMinimizedCount: subWindows.windowsMinimized
 
     //! are set by the indicator
     property int iconOffsetX: 0
     property int iconOffsetY: 0
 
     property string activity: tasksModel.activity
 
     readonly property var m: model
     readonly property int pid: model && model.AppPid ? model.AppPid : -1
     readonly property string appName: model && model.AppName ? model.AppName : ""
 
     property string modelLauncherUrl: (LauncherUrlWithoutIcon && LauncherUrlWithoutIcon !== null) ? LauncherUrlWithoutIcon : ""
     property string modelLauncherUrlWithIcon: (LauncherUrl && LauncherUrl !== null) ? LauncherUrl : ""
     property string launcherUrl: ""
     property string launcherUrlWithIcon: ""
     property string launcherName: ""
 
     property Item tooltipVisualParent: wrapper.titleTooltipVisualParent
     property Item previewsVisualParent: wrapper.previewsTooltipVisualParent
     property Item wrapperAlias: wrapper
 
     //abilities
     property Item animations: null
     property Item indexer: null
     property Item metrics: null
     property Item parabolic: null
     property Item requires: null
+    property Item shortcuts: null
 
     onModelLauncherUrlChanged: {
         if (modelLauncherUrl !== ""){
             launcherUrl = modelLauncherUrl;
 
             //!extract the launcherName if possible
             var nameStarts = launcherUrl.lastIndexOf("/");
             if (nameStarts === -1){
                 nameStarts = launcherUrl.lastIndexOf(":");
             }
 
             var nameEnds = launcherUrl.lastIndexOf(".desktop");
 
             if (nameStarts!==-1 && nameEnds!==-1 && nameStarts<nameEnds) {
                 launcherName = launcherUrl.substring(nameStarts+1,nameEnds);
             }
         }
 
         if (parabolicManager.isSeparator(modelLauncherUrl)){
             isSeparator = true;
         } else {
             isSeparator = false;
         }
     }
 
     onModelLauncherUrlWithIconChanged: {
         if (modelLauncherUrlWithIcon !== ""){
             launcherUrlWithIcon = modelLauncherUrlWithIcon;
         }
     }
 
     onHoveredFromDraggingChanged: {
         if (hoveredFromDragging) {
             scrollableList.autoScrollFor(taskItem, true);
         }
     }
 
     //! separators flags
     readonly property bool tailItemIsSeparator: {
         if (isSeparator || itemIndex < 0 ) {
             return false;
         }
 
         var tail = index - 1;
 
         while(tail>=0 && taskItem.indexer.hidden.indexOf(tail)>=0) {
             tail = tail - 1;
         }
 
         var hasTailItemSeparator = taskItem.indexer.separators.indexOf(tail)>=0;
 
         if (!hasTailItemSeparator && itemIndex === taskItem.indexer.firstVisibleItemIndex){
             return taskItem.indexer.tailAppletIsSeparator;
         }
 
         return hasTailItemSeparator;
     }
 
     readonly property bool headItemIsSeparator: {
         if (isSeparator || itemIndex < 0 ) {
             return false;
         }
 
         var head = index + 1;
 
         while(head>=0 && taskItem.indexer.hidden.indexOf(head)>=0) {
             head = head + 1;
         }
 
         var hasHeadItemSeparator = taskItem.indexer.separators.indexOf(head)>=0;
 
         if (!hasHeadItemSeparator && itemIndex === taskItem.indexer.lastVisibleItemIndex){
             return taskItem.indexer.headAppletIsSeparator;
         }
 
         return hasHeadItemSeparator;
     }
 
     ////// Audio streams //////
     property Item audioStreamOverlay
     property var audioStreams: []
     readonly property bool hasAudioStream: root.showAudioBadge && audioStreams.length > 0 && !isLauncher
     readonly property bool playingAudio: hasAudioStream && audioStreams.some(function (item) {
         return !item.corked
     })
 
     readonly property bool muted: hasAudioStream && audioStreams.every(function (item) {
         return item.muted
     })
 
     readonly property int volume: {
         if (!hasAudioStream){
             return 0;
         }
 
         var maxVolume = 0;
         for (var i=0; i<audioStreams.length; ++i){
             if (audioStreams[i].volume > maxVolume)
                 maxVolume = audioStreams[i].volume;
         }
 
         return maxVolume;
     }
 
     //////
 
     property QtObject contextMenu: null
     property QtObject draggingResistaner: null
     property QtObject hoveredTimerObj: null
 
     signal groupWindowAdded();
     signal groupWindowRemoved();
     signal checkWindowsStates();
 
     Behavior on opacity {
         // NumberAnimation { duration: (IsStartup || (IsLauncher) ) ? 0 : 400 }
         NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
     }
 
     Loader{
         anchors.fill: parent
         active: latteView && latteView.debugMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.color:  "blue"
             border.width: 1
         }
     }
 
 
     SubWindows{
         id: subWindows
 
         property int previousCount: 0
 
         onWindowsCountChanged: {
             if (root.showWindowsOnlyFromLaunchers && !root.indicatorsEnabled) {
                 return;
             }
 
             if ((windowsCount >= 2) && (windowsCount > previousCount)
                     && !(taskItem.containsMouse || parabolicManager.neighbourIsHovered(itemIndex)) ){
                 if(root.dragSource == null)
                     taskItem.groupWindowAdded();
             }
             else if ((windowsCount >=1) &&(windowsCount < previousCount)){
                 //sometimes this is triggered in dragging with no reason
                 if(root.dragSource == null && !taskItem.delayingRemove)
                     taskItem.groupWindowRemoved();
             }
 
             if (windowsCount>=1) {
                 taskItem.slotPublishGeometries();
             }
 
             //! workaround in order to update correctly the previousCount
             //! windowsCount can not return to zero because is such case
             //! the window task is removed and the launcher is added from
             //! libtaskmanager
             if (windowsCount>=1) {
                 previousCount = windowsCount;
             }
         }
     }
 
     Loader {
         id: isSeparatorRectangle
         active: (opacityN>0)
 
         width: taskItem.width
         height: taskItem.height
         anchors.centerIn: separatorItem
 
         property real opacityN: isSeparator && root.contextMenu && root.contextMenu.visualParent === taskItem ? 1 : 0
 
         Behavior on opacityN {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             opacity: isSeparatorRectangle.opacityN
             radius: 3
 
             property color tempColor: theme.highlightColor
             color: tempColor
             border.width: 1
             border.color: theme.highlightColor
 
             onTempColorChanged: tempColor.a = 0.35;
 
         }
     }
 
     Item{
         id:separatorItem
 
         anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
         anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
         anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
         anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         anchors.bottomMargin: (root.location === PlasmaCore.Types.BottomEdge) ? margin : 0
         anchors.topMargin: (root.location === PlasmaCore.Types.TopEdge) ? margin : 0
         anchors.leftMargin: (root.location === PlasmaCore.Types.LeftEdge) ? margin : 0
         anchors.rightMargin: (root.location === PlasmaCore.Types.RightEdge) ? margin : 0
 
         opacity: (separatorShadow.active) || forceHiddenState ? 0 : 0.4
         visible: taskItem.isSeparator
 
         width: root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+taskItem.metrics.totals.lengthEdges: 1)
         height: !root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+taskItem.metrics.totals.lengthEdges: 1)
 
         property bool forceHiddenState: false
 
         readonly property int margin: taskItem.metrics.margin.screenEdge + metrics.margin.thickness
 
         Behavior on opacity {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         Connections{
             target: root
 
             //! During dock sliding-in because the parabolic effect isnt trigerred
             //! immediately but we wait first the dock to go to its final normal
             //! place we might miss the activation of the parabolic effect.
             //! By catching that signal we are trying to solve this.
             onDockIsShownCompletelyChanged: {
                 if (dockIsShownCompletely && taskItem.containsMouse) {
                     if (root.vertical) {
                         taskItem.mousePosChanged(taskItem.mouseY);
                     } else {
                         taskItem.mousePosChanged(taskItem.mouseX);
                     }
                 }
             }
 
             onShowWindowsOnlyFromLaunchersChanged: {
                 if (!root.editMode) {
                     return;
                 }
 
                 taskItem.updateVisibilityBasedOnLaunchers();
             }
 
             onInActivityChangeChanged: {
                 if (root.showWindowsOnlyFromLaunchers && !root.inActivityChange) {
                     taskItem.updateVisibilityBasedOnLaunchers();
                 }
             }
         }
 
         Rectangle {
             anchors.centerIn: parent
 
             width: root.vertical ? taskItem.metrics.iconSize - 4  : 1
             height: !root.vertical ? taskItem.metrics.iconSize - 4 : 1
             color: enforceLattePalette ? latteBridge.palette.textColor : theme.textColor
         }
 
 
     }
 
     ///Shadow in tasks
     Loader{
         id: separatorShadow
         anchors.fill: separatorItem
         active: root.enableShadows && isSeparator && graphicsSystem.isAccelerated
         opacity: separatorItem.forceHiddenState ? 0 : 0.4
 
         Behavior on opacity {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         sourceComponent: DropShadow{
             anchors.fill: parent
             color: root.appShadowColor
             fast: true
             samples: 2 * radius
             source: separatorItem
             radius: root.appShadowSize
             verticalOffset: 2
         }
     }
 
     /* Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
     Flow{
         id: taskFlow
         width: parent.width
         height: parent.height
 
         // a hidden spacer for the first element to add stability
         // IMPORTANT: hidden spacers must be tested on vertical !!!
         HiddenSpacer{ id:hiddenSpacerLeft;}
 
         Item{
             width: wrapper.width
             height: wrapper.height
 
             Indicator.Bridge{
                 id: indicatorBridge
             }
 
             Indicator.Loader{
                 id: indicatorBackLayer
                 level: Indicator.LevelOptions {
                     id: backLevelOptions
                     isBackground: true
                     bridge: indicatorBridge
 
                     Binding {
                         target: taskItem
                         property: "iconOffsetX"
                         value: backLevelOptions.requested.iconOffsetX
                     }
 
                     Binding {
                         target: taskItem
                         property: "iconOffsetY"
                         value: backLevelOptions.requested.iconOffsetY
                     }
                 }
             }
 
             Wrapper{id: wrapper}
 
             Indicator.Loader{
                 id: indicatorFrontLayer
                 level: Indicator.LevelOptions {
                     isForeground: true
                     bridge: indicatorBridge
                 }
             }
         }
 
         // a hidden spacer on the right for the last item to add stability
         HiddenSpacer{ id:hiddenSpacerRight; rightSpacer: true }
     }// Flow with hidden spacers inside
 
     Component {
         id: taskInitComponent
         Timer {
             id: timer
 
             interval: 800
             repeat: false
 
             onTriggered: {
                 //      taskItem.hoverEnabled = true;
                 slotPublishGeometries();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: taskInitComponentTimer called...");
                 }
 
                 timer.destroy();
             }
 
             Component.onCompleted: timer.start()
         }
     }
 
     ////// Values Changes /////
     //restore scales when there is no zoom factor for that item or
     //the mouse is out of the ListView
     // onItemIndexChanged: {
     //  }
 
     onAppNameChanged: updateAudioStreams()
     onPidChanged: updateAudioStreams()
     onHasAudioStreamChanged: updateAudioStreams()
 
     onCanPublishGeometriesChanged: {
         if (canPublishGeometries) {
             slotPublishGeometries();
             taskInitComponent.createObject(taskItem);
         }
     }
 
     onItemIndexChanged: {
         if (itemIndex>=0) {
             lastValidTimer.start();
         }
     }
 
     onLastValidIndexChanged: {
         if (lastValidIndex>=0 && lastValidIndex<root.tasksCount){
             if (!isForcedHidden && (lastValidIndex < parabolicManager.firstRealTaskIndex || lastValidIndex > parabolicManager.lastRealTaskIndex)) {
                 parabolicManager.updateTasksEdgesIndexes();
             }
         }
     }
 
     onIsDraggedChanged: {
         if(isDragged && (!root.inConfigureAppletsMode)){
             root.dragSource = taskItem;
             dragHelper.startDrag(taskItem, model.MimeType, model.MimeData,
                                  model.LauncherUrlWithoutIcon, model.decoration);
             pressX = -1;
             pressY = -1;
         }
     }
 
     onIsMinimizedChanged: {
         checkWindowsStates();
     }
 
     onIsActiveChanged: {
         checkWindowsStates();
         if (isActive) {
             scrollableList.focusOn(taskItem);
         }
     }
 
     onIsSeparatorChanged: {
         if (isSeparator) {
             if (tasksExtendedManager.isLauncherToBeMoved(launcherUrl) && itemIndex>=0) {
                 tasksExtendedManager.moveLauncherToCorrectPos(launcherUrl, itemIndex);
             }
         }
     }
 
     onLauncherUrlChanged: updateBadge();
 
     ////// End of Values Changes /////
 
 
     ///////////////// Mouse Area Events ///////////////////
     onEntered: {
         taskItem.parabolic.stopRestoreZoomTimer();
 
         restoreAnimation.stop();
 
         if ((taskItem.parabolic.local.lastIndex !== itemIndex) && isLauncher && windowsPreviewDlg.visible) {
             windowsPreviewDlg.hide(1);
         }
 
         if (root.latteView && !root.showPreviews && root.titleTooltips){
             showTitleTooltip();
         }
 
         //! show previews if enabled
         if(isAbleToShowPreview && ((root.showPreviews && windowsPreviewDlg.activeItem !== taskItem) || root.highlightWindows)){
             if (hoveredTimerObj) {
                 //! don't delay showing preview in normal states,
                 //! that is when the dock wasn't hidden
                 if (!hoveredTimerObj.running) {
                     hoveredTimerObj.start();
                 }
             } else {
                 if (!root.disableAllWindowsFunctionality) {
                     hoveredTimerObj = hoveredTimerComponent.createObject(taskItem);
                 }
             }
         }
 
         if (root.autoScrollTasksEnabled) {
             scrollableList.autoScrollFor(taskItem, false);
         }
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
     }
 
     // IMPORTANT: This must be improved ! even for small milliseconds  it reduces performance
     onExited: {
         scalesUpdatedOnce = false;
         isAbleToShowPreview = true;
 
         if (root.latteView && (!root.showPreviews || (root.showPreviews && isLauncher))){
             root.latteView.hideTooltipLabel();
         }
 
         if (root.showPreviews) {
             root.hidePreview(17.5);
         }
 
         if (taskItem.parabolic.factor.zoom>1){
             taskItem.parabolic.startRestoreZoomTimer();
         }
     }
 
     //! mouseX-Y values are delayed to be updated onEntered events and at the same time
     //! onPositionChanged signal may be delayed. we can fix this by don't delay at all
     //! when mouseX-Y is updated based on the plasmoid formFactor
     function mousePosChanged(mousePos) {
         if (mousePos<0 ||
                 (inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             var rapidMovement = taskItem.parabolic.local.lastIndex>=0 && Math.abs(taskItem.parabolic.local.lastIndex-itemIndex)>1;
 
             if (rapidMovement) {
                 taskItem.parabolic.setDirectRenderingEnabled(true);
             }
 
             if( ((wrapper.mScale == 1 || wrapper.mScale === taskItem.parabolic.factor.zoom) && !taskItem.parabolic.directRenderingEnabled)
                     || taskItem.parabolic.directRenderingEnabled || !scalesUpdatedOnce) {
                 if(root.dragSource == null){
                     var step = Math.abs(icList.currentSpot-mousePos);
                     if (step >= taskItem.animations.hoverPixelSensitivity){
                         icList.currentSpot = mousePos;
 
                         wrapper.calculateScales(mousePos);
                     }
                 }
             }
         }
     }
 
     onMouseXChanged: {
         if (!root.vertical) {
             mousePosChanged(mouseX);
         }
     }
 
     onMouseYChanged: {
         if (root.vertical) {
             mousePosChanged(mouseY);
         }
     }
 
 
 
     onPositionChanged: {
         if ((inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             // mouse.button is always 0 here, hence checking with mouse.buttons
             if (pressX != -1 && mouse.buttons == Qt.LeftButton
                     && isDragged
                     && dragHelper.isDrag(pressX, pressY, mouse.x, mouse.y) ) {
                 root.dragSource = taskItem;
                 dragHelper.startDrag(taskItem, model.MimeType, model.MimeData,
                                      model.LauncherUrlWithoutIcon, model.decoration);
                 pressX = -1;
                 pressY = -1;
             }
         }
     }
 
     onContainsMouseChanged:{
         if(!containsMouse && !inAnimation) {
             pressed=false;
         }
 
         ////disable hover effect///
         if (isWindow && root.highlightWindows && !containsMouse) {
             root.windowsHovered( root.plasma515 ? model.WinIdList : model.LegacyWinIdList , false);
         }
     }
 
     onPressed: {
         //console.log("Pressed Task Delegate..");
         if (LatteCore.WindowSystem.compositingActive && !LatteCore.WindowSystem.isPlatformWayland) {
             if(root.leftClickAction !== LatteTasks.Types.PreviewWindows) {
                 isAbleToShowPreview = false;
                 windowsPreviewDlg.hide(2);
             }
         }
 
         slotPublishGeometries();
 
         var modAccepted = modifierAccepted(mouse);
 
         if ((mouse.button == Qt.LeftButton)||(mouse.button == Qt.MidButton) || modAccepted) {
             lastButtonClicked = mouse.button;
             pressed = true;
             pressX = mouse.x;
             pressY = mouse.y;
 
             if(draggingResistaner == null && !modAccepted)
                 draggingResistaner = resistanerTimerComponent.createObject(taskItem);
         }
         else if (mouse.button == Qt.RightButton && !modAccepted){
             // When we're a launcher, there's no window controls, so we can show all
             // places without the menu getting super huge.
             if (model.IsLauncher === true && !isSeparator) {
                 showContextMenu({showAllPlaces: true})
             } else {
                 showContextMenu();
             }
         }
     }
 
     onReleased: {
         //console.log("Released Task Delegate...");
         if (draggingResistaner != null){
             draggingResistaner.destroy();
             draggingResistaner = null;
         }
 
         if(pressed && (!inBlockingAnimation || inAttentionAnimation) && !isSeparator){
 
             if (modifierAccepted(mouse) && !root.disableAllWindowsFunctionality){
                 if( !taskItem.isLauncher ){
                     if (root.modifierClickAction == LatteTasks.Types.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.modifierClickAction == LatteTasks.Types.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.modifierClickAction == LatteTasks.Types.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.modifierClickAction == LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.modifierClickAction == LatteTasks.Types.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.MidButton && !root.disableAllWindowsFunctionality){
                 if( !taskItem.isLauncher ){
                     if (root.middleClickAction == LatteTasks.Types.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.middleClickAction == LatteTasks.Types.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.middleClickAction == LatteTasks.Types.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.middleClickAction == LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.middleClickAction == LatteTasks.Types.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.LeftButton){
                 if( !taskItem.isLauncher ){
                     if ( (root.leftClickAction === LatteTasks.Types.PreviewWindows && isGroupParent)
                             || ( (LatteCore.WindowSystem.isPlatformWayland || !LatteCore.WindowSystem.compositingActive)
                                 && root.leftClickAction === LatteTasks.Types.PresentWindows
                                 && isGroupParent) ) {
                         if(windowsPreviewDlg.activeItem !== taskItem || !windowsPreviewDlg.visible){
                             showPreviewWindow();
                         } else {
                             root.forcePreviewsHiding(21.1);
                         }
                     } else if ( (root.leftClickAction === LatteTasks.Types.PresentWindows && !(isGroupParent && !LatteCore.WindowSystem.compositingActive))
                                || ((root.leftClickAction === LatteTasks.Types.PreviewWindows && !isGroupParent)) ) {
                         activateTask();
                     } else if (root.leftClickAction === LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     }
                 } else {
                     activateTask();
                 }
             }
 
             backend.cancelHighlightWindows();
         }
 
         pressed = false;
     }
 
     onWheel: {
         var wheelActionsEnabled = (root.taskScrollAction !== LatteTasks.Types.ScrollNone || manualScrollTasksEnabled);
 
         if (isSeparator
                 || wheelIsBlocked
                 || !wheelActionsEnabled
                 || inBouncingAnimation
                 || (latteView && (latteView.dockIsHidden || latteView.inSlidingIn || latteView.inSlidingOut))){
 
             return;
         }
 
         var angleVertical = wheel.angleDelta.y / 8;
         var angleHorizontal = wheel.angleDelta.x / 8;
 
         wheelIsBlocked = true;
         scrollDelayer.start();
 
         var verticalDirection = (Math.abs(angleVertical) > Math.abs(angleHorizontal));
         var mainAngle = verticalDirection ? angleVertical : angleHorizontal;
 
         var positiveDirection = (mainAngle > 12);
         var negativeDirection = (mainAngle < -12);
 
         var parallelScrolling = (verticalDirection && plasmoid.formFactor === PlasmaCore.Types.Vertical)
                 || (!verticalDirection && plasmoid.formFactor === PlasmaCore.Types.Horizontal);
 
         if (positiveDirection) {
             slotPublishGeometries();
 
             var overflowScrollingAccepted = (root.manualScrollTasksEnabled
                                              && scrollableList.contentsExceed
                                              && (root.manualScrollTasksType === LatteTasks.Types.ManualScrollVerticalHorizontal
                                                  || (root.manualScrollTasksType === LatteTasks.Types.ManualScrollOnlyParallel && parallelScrolling)) );
 
 
             if (overflowScrollingAccepted) {
                 scrollableList.decreasePos();
             } else {
                 if (isLauncher || root.disableAllWindowsFunctionality) {
                     wrapper.runLauncherAnimation();
                 } else if (isGroupParent) {
                     subWindows.activateNextTask();
                 } else {
                     var taskIndex = modelIndex();
 
                     if (isMinimized) {
                         tasksModel.requestToggleMinimized(taskIndex);
                     }
 
                     tasksModel.requestActivate(taskIndex);
                 }
 
                 // hidePreviewWindow();
             }
         } else if (negativeDirection) {
             slotPublishGeometries();
 
             var overflowScrollingAccepted = (root.manualScrollTasksEnabled
                                              && scrollableList.contentsExceed
                                              && (root.manualScrollTasksType === LatteTasks.Types.ManualScrollVerticalHorizontal
                                                  || (root.manualScrollTasksType === LatteTasks.Types.ManualScrollOnlyParallel && parallelScrolling)) );
 
 
             if (overflowScrollingAccepted) {
                 scrollableList.increasePos();
             } else {
                 if (isLauncher || root.disableAllWindowsFunctionality) {
                     // do nothing
                 } else if (isGroupParent) {
                     if (root.taskScrollAction === LatteTasks.Types.ScrollToggleMinimized) {
                         subWindows.minimizeTask();
                     } else {
                         subWindows.activatePreviousTask();
                     }
                 } else {
                     var taskIndex = modelIndex();
 
                     var hidingTask = (!isMinimized && root.taskScrollAction === LatteTasks.Types.ScrollToggleMinimized);
 
                     if (isMinimized || hidingTask) {
                         tasksModel.requestToggleMinimized(taskIndex);
                     }
 
                     if (!hidingTask) {
                         tasksModel.requestActivate(taskIndex);
                     }
                 }
 
                 // hidePreviewWindow();
             }
         }
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
 
         interval: 400
 
         onTriggered: taskItem.wheelIsBlocked = false;
     }
 
     ///////////////// End Of Mouse Area Events ///////////////////
 
     ///// Handlers for Signals /////
     function animationStarted(){
         //    console.log("Animation started: " + index);
         inAnimation = true;
     }
 
     function animationEnded(){
         //   console.log("Animation ended: " + index);
         inAnimation = false;
     }
 
     function sltClearZoom(){
         restoreAnimation.start();
     }
 
     function handlerDraggingFinished(){
         isDragged = false;
     }
     ///// End of Handlers //////
 
 
 
     ///// Helper functions /////
     function activateNextTask() {
         subWindows.activateNextTask();
     }
 
     function activateTask() {
         if( taskItem.isLauncher || root.disableAllWindowsFunctionality){
             if (LatteCore.WindowSystem.compositingActive) {
                 wrapper.runLauncherAnimation();
             } else {
                 launcherAction();
             }
         }
         else{
             if (model.IsGroupParent) {
                 if (LatteCore.WindowSystem.compositingActive && backend.canPresentWindows()) {
                     root.presentWindows(root.plasma515 ? model.WinIdList: model.LegacyWinIdList );
                 }
             } else {
                 if (isMinimized) {
                     var i = modelIndex();
                     tasksModel.requestToggleMinimized(i);
                     tasksModel.requestActivate(i);
                 } else if (isActive) {
                     tasksModel.requestToggleMinimized(modelIndex());
                 } else {
                     tasksModel.requestActivate(modelIndex());
                 }
             }
         }
     }
 
     function showPreviewWindow() {
         if (root.disableAllWindowsFunctionality || !isAbleToShowPreview) {
             return;
         }
 
         if(windowsPreviewDlg.activeItem !== taskItem){
             if (!root.latteView
                     || (root.latteView && !root.latteView.isHalfShown && !root.latteView.inSlidingIn && !root.latteView.inSlidingOut)) {
                 if (root.latteView && root.titleTooltips) {
                     root.latteView.hideTooltipLabel();
                 }
 
                 taskItem.preparePreviewWindow(false);
                 windowsPreviewDlg.show(taskItem);
             }
         }
     }
 
     function showTitleTooltip() {
         if (root.latteView && root.titleTooltips){
             var displayText = isWindow ? model.display : model.AppName;
             var maxCharacters = 80;
 
             var fixedDisplayText = displayText.length>maxCharacters ? displayText.substring(0,maxCharacters-1) + "..." : displayText;
 
             root.latteView.showTooltipLabel(taskItem, fixedDisplayText);
         }
     }
 
     function hidePreviewWindow() {
         if(windowsPreviewDlg.activeItem === taskItem){
             windowsPreviewDlg.hide("14.1");
 
             if (root.latteView && root.titleTooltips && containsMouse) {
                 showTitleTooltip();
             }
         }
     }
 
     function preparePreviewWindow(hideClose){
         windowsPreviewDlg.visualParent = previewsVisualParent;
 
         toolTipDelegate.parentTask = taskItem;
 
         //! WORKAROUND, in order for toolTipDelegate to re-instantiate the previews model when
         //! previews are changing from single instance preview to another single instance
         toolTipDelegate.rootIndex = undefined;
         toolTipDelegate.rootIndex = tasksModel.makeModelIndex(itemIndex, -1);
 
         toolTipDelegate.hideCloseButtons = hideClose;
 
         toolTipDelegate.appName = Qt.binding(function() {
             return model.AppName;
         });
 
         if (!isLauncher) {
             toolTipDelegate.pidParent = Qt.binding(function() {
                 return model.AppPid;
             });
         } else {
             toolTipDelegate.pidParent = -1;
         }
 
         toolTipDelegate.windows = Qt.binding(function() {
             return root.plasma515 ? model.WinIdList : model.LegacyWinIdList ;
         });
         toolTipDelegate.isGroup = Qt.binding(function() {
             return model.IsGroupParent == true;
         });
         toolTipDelegate.icon = Qt.binding(function() {
             return model.decoration;
         });
         toolTipDelegate.launcherUrl = Qt.binding(function() {
             return model.LauncherUrlWithoutIcon;
         });
         toolTipDelegate.isLauncher = Qt.binding(function() {
             return model.IsLauncher == true;
         });
         toolTipDelegate.isMinimizedParent = Qt.binding(function() {
             return model.IsMinimized == true;
         });
         toolTipDelegate.displayParent = Qt.binding(function() {
             return model.display;
         });
         toolTipDelegate.genericName = Qt.binding(function() {
             return model.GenericName;
         });
         toolTipDelegate.virtualDesktopParent = Qt.binding(function() {
             return (model.VirtualDesktops !== undefined && model.VirtualDesktops.length > 0) ? model.VirtualDesktops : [0];
         });
         toolTipDelegate.isOnAllVirtualDesktopsParent = Qt.binding(function() {
             return model.IsOnAllVirtualDesktops == true;
         });
         toolTipDelegate.activitiesParent = Qt.binding(function() {
             return model.Activities;
         });
     }
 
 
     function launcherAction(){
         // if ((lastButtonClicked == Qt.LeftButton)||(lastButtonClicked == Qt.MidButton)){
         if (LatteCore.WindowSystem.compositingActive) {
             inBouncingAnimation = true;
             tasksExtendedManager.addWaitingLauncher(taskItem.launcherUrl);
         }
 
         if (root.disableAllWindowsFunctionality) {
             tasksModel.requestNewInstance(modelIndex());
         } else {
             tasksModel.requestActivate(modelIndex());
         }
     }
 
     ///window previews///
     function generateSubText(task) {
         var subTextEntries = new Array();
 
         if (!plasmoid.configuration.showOnlyCurrentDesktop
                 && virtualDesktopInfo.numberOfDesktops > 1
                 && model.IsOnAllVirtualDesktops !== true
                 && model.VirtualDesktop != -1
                 && model.VirtualDesktop != undefined) {
             subTextEntries.push(i18n("On %1", virtualDesktopInfo.desktopNames[model.VirtualDesktop - 1]));
         }
 
         if (model.Activities == undefined) {
             return subTextEntries.join("\n");
         }
 
         if (model.Activities.length == 0 && activityInfo.numberOfRunningActivities > 1) {
             subTextEntries.push(i18nc("Which virtual desktop a window is currently on",
                                       "Available on all activities"));
         } else if (model.Activities.length > 0) {
             var activityNames = new Array();
 
             for (var i = 0; i < model.Activities.length; i++) {
                 var activity = model.Activities[i];
 
                 if (plasmoid.configuration.showOnlyCurrentActivity) {
                     if (activity != activityInfo.currentActivity) {
                         activityNames.push(activityInfo.activityName(model.Activities[i]));
                     }
                 } else if (activity != activityInfo.currentActivity) {
                     activityNames.push(activityInfo.activityName(model.Activities[i]));
                 }
             }
 
             if (plasmoid.configuration.showOnlyCurrentActivity) {
                 if (activityNames.length > 0) {
                     subTextEntries.push(i18nc("Activities a window is currently on (apart from the current one)",
                                               "Also available on %1", activityNames.join(", ")));
                 }
             } else if (activityNames.length > 0) {
                 subTextEntries.push(i18nc("Which activities a window is currently on",
                                           "Available on %1", activityNames.join(", ")));
             }
         }
 
         return subTextEntries.join("\n");
     }
     ///window previews////
 
     function modelIndex(){
         return tasksModel.makeModelIndex(index);
     }
 
     function showContextMenu(args) {
         if (isSeparator && !root.editMode)
             return;
 
         if (!root.contextMenu) {
             contextMenu = root.createContextMenu(taskItem, modelIndex(), args);
             contextMenu.show();
         } else {
             //! make sure that context menu isnt deleted multiple times and creates a crash
             //! bug case: 397635
             var cMenu = root.contextMenu;
             root.contextMenu = null;
             cMenu.destroy();
         }
     }
 
     function modifierAccepted(mouse){
         if (mouse.modifiers & root.modifierQt){
             if ((mouse.button === Qt.LeftButton && root.modifierClick === LatteTasks.Types.LeftClick)
                     || (mouse.button === Qt.MiddleButton && root.modifierClick === LatteTasks.Types.MiddleClick)
                     || (mouse.button === Qt.RightButton && root.modifierClick === LatteTasks.Types.RightClick))
                 return true;
         }
 
         return false;
     }
 
     function setBlockingAnimation(value){
         inBlockingAnimation = value;
     }
 
     function slotMimicEnterForParabolic(){
         if (containsMouse) {
             if (inMimicParabolicAnimation) {
                 mimicParabolicScale = taskItem.parabolic.factor.zoom;
             }
 
             wrapper.calculateScales(icList.currentSpot);
         }
     }
 
     function slotShowPreviewForTasks(group) {
         if (group === taskItem && !windowsPreviewDlg.visible) {
             preparePreviewWindow(true);
             windowsPreviewDlg.show(taskItem);
         }
     }
 
     function slotPublishGeometries() {
         //! this way we make sure that layouts that are in different activities that the current layout
         //! don't publish their geometries
         if ( canPublishGeometries && (!latteView || root.viewLayoutIsCurrent)) {
             var globalChoords = backend.globalRect(wrapper.visualIconItem);
             var limits = backend.globalRect(scrollableList);
 
             //! Limit the published geometries boundaries at scrolling area boundaries
             var adjX = Math.min(limits.x+limits.width, Math.max(limits.x, globalChoords.x));
             var adjY = Math.min(limits.y+limits.height, Math.max(limits.y, globalChoords.y));
 
             var length = taskItem.metrics.iconSize * wrapper.mScale;
             var thickness = length;
 
             //! Magic Lamp effect doesn't like coordinates outside the screen and
             //! width,heights of zero value... So we now normalize the geometries
             //! sent in order to avoid such circumstances
             if (root.vertical) {
                 if (adjY !== globalChoords.y) {
                     if (((globalChoords.y+globalChoords.height) < limits.y) || (globalChoords.y)>(limits.y+limits.height)) {
                         //! totally out of boundaries
                         length = 4;
                     } else {
                         //! semi-part out of boundaries
                         length = Math.max(4, Math.abs(adjY - globalChoords.y));
                     }
 
                     globalChoords.height = length;
                 }
             } else {
                 if (adjX !== globalChoords.x) {
                     if (((globalChoords.x+globalChoords.width) < limits.x) || (globalChoords.x)>(limits.x+limits.width)) {
                         //! totally out of boundaries
                         length = 4;
                     } else {
                         //! semi-part out of boundaries
                         length = Math.max(4, Math.abs(adjX - globalChoords.x));
                     }
 
                     globalChoords.width = length;
                 }
             }
 
             globalChoords.x = adjX;
             globalChoords.y = adjY;
 
             if (latteView && latteView.dockIsHidden) {
                 if (root.location === PlasmaCore.Types.BottomEdge) {
                     globalChoords.y = root.screenGeometry.y+root.screenGeometry.height-1;
                     globalChoords.height = 1;
                 } else if (root.location === PlasmaCore.Types.TopEdge) {
                     globalChoords.y = root.screenGeometry.y+1;
                     globalChoords.height = 1;
                 } else if (root.location === PlasmaCore.Types.LeftEdge) {
                     globalChoords.x = root.screenGeometry.x+1;
                     globalChoords.width = 1;
                 } else if (root.location === PlasmaCore.Types.RightEdge) {
                     globalChoords.x = root.screenGeometry.x+root.screenGeometry.width - 1;
                     globalChoords.width = 1;
                 }
             }
 
             tasksModel.requestPublishDelegateGeometry(taskItem.modelIndex(), globalChoords, taskItem);
         }
     }
 
     function slotWaitingLauncherRemoved(launch) {
         if ((isWindow || isStartup || isLauncher) && !visible && launch === launcherUrl) {
             wrapper.mScale = 1;
             visible = true;
         }
     }
 
 
     function updateAudioStreams() {
         if (root.dragSource !== null) {
             audioStreams = [];
             return;
         }
 
         var pa = pulseAudio.item;
         if (!pa) {
             audioStreams = [];
             return;
         }
 
         var streams = pa.streamsForPid(taskItem.pid);
         if (streams.length) {
             pa.registerPidMatch(taskItem.appName);
         } else {
             // We only want to fall back to appName matching if we never managed to map
             // a PID to an audio stream window. Otherwise if you have two instances of
             // an application, one playing and the other not, it will look up appName
             // for the non-playing instance and erroneously show an indicator on both.
             if (!pa.hasPidMatch(taskItem.appName)) {
                 var streams_result;
                 streams_result = pa.streamsForAppName(taskItem.appName);
                 if (streams_result.length===0 && launcherName !== "") {
                     streams_result = pa.streamsForAppName(launcherName);
                 }
                 streams = streams_result;
             }
         }
 
         // fix a binding loop concerning audiostreams, the audiostreams
         // should be updated only when they have changed
         var changed = false;
 
         if (streams.length !== audioStreams.length) {
             changed = true;
         } else {
             for(var i=0; i<streams.length; ++i) {
                 if (streams[i] !== audioStreams[i]) {
                     changed = true;
                     break;
                 }
             }
         }
 
         if (changed) {
             taskItem.audioStreams = streams;
         }
     }
 
     function slotLaunchersChangedFor(launcher) {
         if (root.showWindowsOnlyFromLaunchers && launcher === launcherUrl) {
             updateVisibilityBasedOnLaunchers()
         }
     }
 
     function updateVisibilityBasedOnLaunchers(){
         var launcherExists = !(((tasksModel.launcherPosition(taskItem.launcherUrl) == -1)
                                 && (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) == -1) )
                                || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl));
 
         if (root.showWindowsOnlyFromLaunchers) {
             var hideWindow =  !launcherExists && taskItem.isWindow;
 
             if (hideWindow) {
                 isForcedHidden = true;
                 taskRealRemovalAnimation.start();
             } else if (launcherExists && taskItem.isWindow && !taskItem.isVisible) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         } else {
             var showWindow =  !launcherExists && taskItem.isWindow;
 
             if (showWindow) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         }
     }
 
     function toggleMuted() {
         if (muted) {
             taskItem.audioStreams.forEach(function (item) { item.unmute(); });
         } else {
             taskItem.audioStreams.forEach(function (item) { item.mute(); });
         }
     }
 
     function increaseVolume() {
         taskItem.audioStreams.forEach(function (item) { item.increaseVolume(); });
     }
 
     function decreaseVolume() {
         taskItem.audioStreams.forEach(function (item) { item.decreaseVolume(); });
     }
 
     function updateBadge() {
         var badger = root.getBadger(launcherUrl);
 
         if (badger) {
             badgeIndicator = parseInt(badger.value);
         } else {
             badgeIndicator = 0;
         }
     }
 
     Connections {
         target: pulseAudio.item
         ignoreUnknownSignals: true // Plasma-PA might not be available
         onStreamsChanged: taskItem.updateAudioStreams()
     }
 
     Connections {
         target: root
         //trying to fix #440, showing the audio icon indicator to irrelevant tasks
         //after dragging an existent task with audio
         onDragSourceChanged: taskItem.updateAudioStreams()
         onShowAudioBadgeChanged: taskItem.updateAudioStreams()
     }
 
     Connections {
         target: scrollableList
         onAnimationsFinishedChanged: {
             if (scrollableList.animationsFinished) {
                 taskItem.slotPublishGeometries();
             }
         }
     }
 
+    Connections {
+        target: shortcuts
+        onSglActivateEntryAtIndex: {
+            var visibleIndex = taskItem.indexer.visibleIndex(taskItem.itemIndex);
+
+            if (visibleIndex === entryIndex) {
+                if (taskItem.isGroupParent) {
+                    taskItem.activateNextTask();
+                } else {
+                    taskItem.activateTask();
+                }
+            }
+        }
+
+        onSglNewInstanceForEntryAtIndex: {
+            var visibleIndex = taskItem.indexer.visibleIndex(taskItem.itemIndex);
+
+            if (visibleIndex === entryIndex) {
+                tasksModel.requestNewInstance(taskItem.modelIndex());
+            }
+        }
+    }
+
     Connections {
         target: latteView
         onDockIsHiddenChanged: {
             if (dockIsHidden) {
                 taskItem.slotPublishGeometries();
             }
         }
 
         onDockIsShownCompletelyChanged: {
             if (dockIsShownCompletely) {
                 taskItem.slotPublishGeometries();
             }
         }
     }
 
 
     ///// End of Helper functions ////
 
     Component.onCompleted: {
         root.draggingFinished.connect(handlerDraggingFinished);
         root.publishTasksGeometries.connect(slotPublishGeometries);
         root.showPreviewForTasks.connect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.connect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.connect(slotLaunchersChangedFor);
 
         parabolic.sglClearZoom.connect(sltClearZoom);
 
         var hasShownLauncher = ((tasksModel.launcherPosition(taskItem.launcherUrl) !== -1)
                                 || (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) !== -1) );
 
         //startup without launcher
         var hideStartup =  ((!hasShownLauncher || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl))
                             && taskItem.isStartup);
 
         if (!LatteCore.WindowSystem.compositingActive) {
             visible = true;
         } else if ( (isWindow || isStartup || isLauncher) && tasksExtendedManager.waitingLauncherExists(launcherUrl)) {
             tasksExtendedManager.waitingLauncherRemoved.connect(slotWaitingLauncherRemoved);
             visible = false;
         } else if (hideStartup){
             visible = false;
         } else {
             visible = true;
         }
 
         showWindowAnimation.showWindow();
         updateAudioStreams();
     }
 
     Component.onDestruction: {
         root.draggingFinished.disconnect(handlerDraggingFinished);
         root.publishTasksGeometries.disconnect(slotPublishGeometries);
         root.showPreviewForTasks.disconnect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.disconnect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.disconnect(slotLaunchersChangedFor);
 
         parabolic.sglClearZoom.disconnect(sltClearZoom);
 
         tasksExtendedManager.waitingLauncherRemoved.disconnect(slotWaitingLauncherRemoved);
 
         wrapper.sendEndOfNeedBothAxisAnimation();
     }
 
     /////Animations
 
     TaskAnimations.ShowWindowAnimation{ id: showWindowAnimation }
 
     TaskAnimations.RestoreAnimation{ id: restoreAnimation }
 
     //A Timer to check how much time the task is hovered in order to check if we must
     //show window previews
     Component {
         id: hoveredTimerComponent
         Timer {
             id: hoveredTimer
 
             interval: Math.max(150,plasmoid.configuration.previewsDelay)
 
             repeat: false
 
             onTriggered: {
                 if (root.disableAllWindowsFunctionality || !isAbleToShowPreview) {
                     return;
                 }
 
                 if (taskItem.containsMouse) {
                     if (root.showPreviews) {
                         showPreviewWindow();
                     }
 
                     if (taskItem.isWindow && root.highlightWindows) {
                         root.windowsHovered( root.plasma515 ? model.WinIdList : model.LegacyWinIdList , taskItem.containsMouse);
                     }
                 }
 
                 hoveredTimer.destroy();
             }
 
             Component.onCompleted: hoveredTimer.start()
         }
     }
 
 
     //A Timer to help in resist a bit to dragging, the user must try
     //to press a little first before dragging Started
     Component {
         id: resistanerTimerComponent
         Timer {
             id: resistanerTimer
             interval: taskItem.resistanceDelay
             repeat: false
 
             onTriggered: {
                 if (!taskItem.inBlockingAnimation){
                     taskItem.isDragged = true;
                 }
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: resistanerTimer called...");
                 }
 
                 resistanerTimer.destroy();
             }
 
             Component.onCompleted: resistanerTimer.start()
         }
     }
 
     ///trying to compete with the crazy situation in the tasksModel
     ///with launchers and startups... There are windows that stay
     ///startup mode e.g. chrome, libreoffice... not showing startups
     ///the user can lose windows...
     ///Based on the animations, windows are shown directly, startups
     ///are shown after 5secs of existence, and launchers after 200ms
     ///for launchers this is set in order to give to a window the time
     ///to disappear and then show the launcher...
 
 
     //   property int mainDelay: IsLauncher ? 800 : 400
     //   property int mainDelay: icList.delayingRemoval ? 2*showWindowAnimation.speed : 450
 
     //BE CAREFUL: this interval (e.g. 700ms) must be lower from the removal animation
     //duration e.g.(800ms) because there are situations that because of this some
     //launchers delay A LOT to reappear, e.g google-chrome
     //I will blacklist google-chrome as I have not found any other case for this bug
     //to appear, but even this way there are cases that still appears...
     property int mainDelay: (AppId == "google-chrome") ? 0 : 2 * taskItem.animations.speedFactor.current * showWindowAnimation.speed
     property int windowDelay: taskItem.isStartup ? 3 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large : mainDelay
 
     Component {
         id: delayShowWindow
         Timer {
             id: timerWindow
 
             interval: windowDelay
 
             repeat: false
 
             onTriggered: {
                 //console.log("I am in here: "+taskItem.windowDelay);
                 // showWindowAnimation.execute();
                 if(!taskItem.buffersAreReady)
                     showWindowAnimation.showWindow();
                 else
                     showWindowAnimation.execute();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: timerWindow called...");
                 }
 
                 timerWindow.destroy();
             }
 
             Component.onCompleted: timerWindow.start()
         }
     }
 
     // when changing activities and desktops the index of the tasks
     // is updated immediately to -1, this timer protects this indexing
     // change in order to provide a beautiful removal tasks animation
     Timer {
         id: lastValidTimer
         interval: 100 ///the interval does not follow the animations timing
         repeat: false
 
         onTriggered: {
             if (taskItem.itemIndex >= 0){
                 taskItem.lastValidIndex = taskItem.itemIndex;
 
                 if (root.showWindowsOnlyFromLaunchers) {
                     parabolicManager.updateTasksEdgesIndexes();
                 }
             }
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: lastValidTimer called...");
             }
         }
     }
 
     ///Item's Removal Animation
     ListView.onRemove: TaskAnimations.RealRemovalAnimation{ id: taskRealRemovalAnimation }
 
 }// main Item