diff --git a/plasmoid/package/contents/ui/ContextMenu.qml b/plasmoid/package/contents/ui/ContextMenu.qml
index fd481fcb..37c5b47b 100644
--- a/plasmoid/package/contents/ui/ContextMenu.qml
+++ b/plasmoid/package/contents/ui/ContextMenu.qml
@@ -1,1021 +1,1020 @@
 /*
 *  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 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.activities 0.1 as Activities
 import org.kde.taskmanager 0.1 as TaskManager
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "../code/activitiesTools.js" as ActivitiesTools
 
 PlasmaComponents.ContextMenu {
     id: menu
 
     property bool changingLayout: false
 
     property QtObject mpris2Source
     property QtObject backend
 
     property var modelIndex
     readonly property var atm: TaskManager.AbstractTasksModel
 
     readonly property var containmentActions: latteView ? latteView.containmentActions() : []
 
     placement: {
         if (root.location === PlasmaCore.Types.LeftEdge) {
             return PlasmaCore.Types.RightPosedTopAlignedPopup;
         } else if (root.location === PlasmaCore.Types.TopEdge) {
             return PlasmaCore.Types.BottomPosedLeftAlignedPopup;
         } else if (root.location === PlasmaCore.Types.RightEdge) {
             return PlasmaCore.Types.LeftPosedTopAlignedPopup;
         } else {
             return PlasmaCore.Types.TopPosedLeftAlignedPopup;
         }
     }
 
     minimumWidth: visualParent ? visualParent.width : 1
 
     property bool isOnAllActivitiesLauncher: true
     property bool showAllPlaces: false
 
     property int activitiesCount: 0
 
 
     onStatusChanged: {
         if (visualParent && get(atm.LauncherUrlWithoutIcon) != null && status == PlasmaComponents.DialogStatus.Open) {
             launcherToggleAction.checked = (tasksModel.launcherPosition(get(atm.LauncherUrlWithoutIcon)) != -1);
             activitiesDesktopsMenu.refresh();
         } else if (status == PlasmaComponents.DialogStatus.Closed) {
             root.contextMenu = null;
             menu.destroy();
             backend.ungrabMouse(visualParent);
         }
     }
 
     function get(modelProp) {
         return tasksModel.data(modelIndex, modelProp)
     }
 
     function show() {       
         loadDynamicLaunchActions(visualParent.m.LauncherUrlWithoutIcon);
         // backend.ungrabMouse(visualParent);
         openRelative();
 
         if (LatteCore.WindowSystem.isPlatformWayland){
             //!Hiding previews under wayland it needs a delay otherwise it creates crashes
             windowsPreviewCheckerToNotShowTimer.start();
         } else {
             windowsPreviewDlg.hide("9.4");
         }
 
         if (root.latteView){
             root.latteView.hideTooltipLabel();            
         }
     }
 
     function newMenuItem(parent) {
         return Qt.createQmlObject(
                     "import org.kde.plasma.components 2.0 as PlasmaComponents;" +
                     "PlasmaComponents.MenuItem {}",
                     parent);
     }
 
     function newSeparator(parent) {
         return Qt.createQmlObject(
                     "import org.kde.plasma.components 2.0 as PlasmaComponents;" +
                     "PlasmaComponents.MenuItem { separator: true }",
                     parent);
     }
 
     function loadDynamicLaunchActions(launcherUrl) {
         var sections = [];
 
         //From Plasma 5.10 and frameworks 5.34, places are also supported
         if (LatteCore.Environment.frameworksVersion >= 336384
                 && (typeof backend.placesActions === "function")) {
             sections = [
                         {
                             title:   i18n("Places"),
                             group:   "places",
                             actions: backend.placesActions(launcherUrl, showAllPlaces, menu)
                         },
                         {
                             title:   i18n("Recent Documents"),
                             group:   "recents",
                             actions: backend.recentDocumentActions(launcherUrl, menu)
                         },
                         {
                             title:   i18n("Actions"),
                             group:   "actions",
                             actions: backend.jumpListActions(launcherUrl, menu)
                         }
                     ];
         } else {
             sections = [
                         {
                             title:   i18n("Recent Documents"),
                             group:   "recents",
                             actions: backend.recentDocumentActions(launcherUrl, menu)
                         },
                         {
                             title:   i18n("Actions"),
                             group:   "actions",
                             actions: backend.jumpListActions(launcherUrl, menu)
                         }
                     ];
         }
 
         // QMenu does not limit its width automatically. Even if we set a maximumWidth
         // it would just cut off text rather than eliding. So we do this manually.
         var textMetrics = Qt.createQmlObject("import QtQuick 2.4; TextMetrics {}", menu);
         var maximumWidth = theme.mSize(theme.defaultFont).width * 22;
 
         sections.forEach(function (section) {
             // Always show the "Actions:" header, since we visually merge
             // This section with the one beneath it that shows universal actions
             if (section["actions"].length > 0 || section["group"] == "actions") {
                 var sectionHeader = newMenuItem(menu);
                 sectionHeader.text = section["title"];
                 sectionHeader.section = true;
                 menu.addMenuItem(sectionHeader, startNewInstanceItem);
             }
 
             for (var i = 0; i < section["actions"].length; ++i) {
                 var item = newMenuItem(menu);
                 item.action = section["actions"][i];
 
                 // Crude way of manually eliding...
                 var elided = false;
                 textMetrics.text = Qt.binding(function() {
                     return item.action.text;
                 });
 
                 while (textMetrics.width > maximumWidth) {
                     item.action.text = item.action.text.slice(0, -1);
                     elided = true;
                 }
 
                 if (elided) {
                     item.action.text += "...";
                 }
 
                 menu.addMenuItem(item, startNewInstanceItem);
             }
         });
 
         // Add Media Player control actions
         var sourceName = mpris2Source.sourceNameForLauncherUrl(launcherUrl, get(atm.AppPid));
 
         var winIdList = root.plasma515 ? atm.WinIdList : atm.LegacyWinIdList;
 
         if (sourceName && !(get(winIdList) !== undefined && get(winIdList).length > 1)) {
             var playerData = mpris2Source.data[sourceName]
 
             if (playerData.CanControl) {
                 var menuItem = menu.newMenuItem(menu);
                 menuItem.text = i18nc("Play previous track", "Previous Track");
                 menuItem.icon = "media-skip-backward";
                 menuItem.enabled = Qt.binding(function() {
                     return playerData.CanGoPrevious;
                 });
                 menuItem.clicked.connect(function() {
                     mpris2Source.goPrevious(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 menuItem = menu.newMenuItem(menu);
                 // PlasmaCore Menu doesn't actually handle icons or labels changing at runtime...
                 menuItem.text = Qt.binding(function() {
                     return playerData.PlaybackStatus === "Playing" ? i18nc("Pause playback", "Pause") : i18nc("Start playback", "Play");
                 });
                 menuItem.icon = Qt.binding(function() {
                     return playerData.PlaybackStatus === "Playing" ? "media-playback-pause" : "media-playback-start";
                 });
                 menuItem.enabled = Qt.binding(function() {
                     return playerData.PlaybackStatus === "Playing" ? playerData.CanPause : playerData.CanPlay;
                 });
                 menuItem.clicked.connect(function() {
                     mpris2Source.playPause(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 menuItem = menu.newMenuItem(menu);
                 menuItem.text = i18nc("Play next track", "Next Track");
                 menuItem.icon = "media-skip-forward";
                 menuItem.enabled = Qt.binding(function() {
                     return playerData.CanGoNext;
                 });
                 menuItem.clicked.connect(function() {
                     mpris2Source.goNext(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 menuItem = menu.newMenuItem(menu);
                 menuItem.text = i18nc("Stop playback", "Stop");
                 menuItem.icon = "media-playback-stop";
                 menuItem.clicked.connect(function() {
                     mpris2Source.stop(sourceName);
                 });
                 menu.addMenuItem(menuItem, virtualDesktopsMenuItem);
 
                 // Technically media controls and audio streams are separate but for the user they're
                 // semantically related, don't add a separator inbetween.
                 if (!menu.visualParent.hasAudioStream) {
                     menu.addMenuItem(newSeparator(menu), virtualDesktopsMenuItem);
                 }
 
                 // If we don't have a window associated with the player but we can quit
                 // it through MPRIS we'll offer a "Quit" option instead of "Close"
                 if (!closeWindowItem.visible && playerData.CanQuit) {
                     menuItem = menu.newMenuItem(menu);
                     menuItem.text = i18nc("Quit media player app", "Quit");
                     menuItem.icon = "application-exit";
                     menuItem.visible = Qt.binding(function() {
                         return !closeWindowItem.visible;
                     });
                     menuItem.clicked.connect(function() {
                         mpris2Source.quit(sourceName);
                     });
                     menu.addMenuItem(menuItem);
                 }
 
                 // If we don't have a window associated with the player but we can raise
                 // it through MPRIS we'll offer a "Restore" option
                 if (!startNewInstanceItem.visible && playerData.CanRaise) {
                     menuItem = menu.newMenuItem(menu);
                     menuItem.text = i18nc("Open or bring to the front window of media player app", "Restore");
                     menuItem.icon = playerData["Desktop Icon Name"];
                     menuItem.visible = Qt.binding(function() {
                         return !startNewInstanceItem.visible;
                     });
                     menuItem.clicked.connect(function() {
                         mpris2Source.raise(sourceName);
                     });
                     menu.addMenuItem(menuItem, startNewInstanceItem);
                 }
             }
         }
 
         // We allow mute/unmute whenever an application has a stream, regardless of whether it
         // is actually playing sound.
         // This way you can unmute, e.g. a telephony app, even after the conversation has ended,
         // so you still have it ringing later on.
         if (menu.visualParent.hasAudioStream) {
             var muteItem = menu.newMenuItem(menu);
             muteItem.checkable = true;
             muteItem.checked = Qt.binding(function() {
                 return menu.visualParent && menu.visualParent.muted;
             });
             muteItem.clicked.connect(function() {
                 menu.visualParent.toggleMuted();
             });
             muteItem.text = i18n("Mute");
             muteItem.icon = "audio-volume-muted";
             menu.addMenuItem(muteItem, virtualDesktopsMenuItem);
 
             menu.addMenuItem(newSeparator(menu), virtualDesktopsMenuItem);
         }
     }
 
     ///REMOVE
     function updateOnAllActivitiesLauncher(){
         //isOnAllActivitiesLauncher = ActivitiesTools.isOnAllActivities(visualParent.m.LauncherUrlWithoutIcon);
     }
 
     Component.onCompleted: {
         ActivitiesTools.launchersOnActivities = root.launchersOnActivities
         ActivitiesTools.currentActivity = activityInfo.currentActivity;
         ActivitiesTools.plasmoid = plasmoid;
 
         //From Plasma 5.10 and frameworks 5.34 jumpLists and
         //places are supported
         if (LatteCore.Environment.frameworksVersion >= 336384) {
             // Cannot have "Connections" as child of PlasmaCoponents.ContextMenu.
             backend.showAllPlaces.connect(function() {
                 visualParent.showContextMenu({showAllPlaces: true});
             });
         }
         //  updateOnAllActivitiesLauncher();
     }
 
 
     Component.onDestruction: {        
         if (!changingLayout) {
             root.contextMenu = null;
             backend.ungrabMouse(visualParent);
         }
     }
 
     /// Sub Items
 
     PlasmaComponents.MenuItem {
         id: startNewInstanceItem
         visible: (visualParent && visualParent.m.IsLauncher !== true && visualParent.m.IsStartup !== true)
 
         enabled: visualParent && visualParent.m.LauncherUrlWithoutIcon != null
 
         text: i18n("Start New Instance")
         icon: "list-add-symbolic"
 
         onClicked: tasksModel.requestNewInstance(menu.modelIndex)
     }
 
     PlasmaComponents.MenuItem {
         id: virtualDesktopsMenuItem
 
         visible: virtualDesktopInfo.numberOfDesktops > 1
                  && (visualParent && get(atm.IsLauncher) !== true
                      && get(atm.IsStartup) !== true
                      && (root.plasma515 ? get(atm.IsVirtualDesktopsChangeable) === true :
                                           get(atm.IsVirtualDesktopChangeable) === true ) )
 
         enabled: visible
 
         text: i18n("Move To &Desktop")
 
         Connections {
             target: virtualDesktopInfo
 
             onNumberOfDesktopsChanged: root.plasma515 ? Qt.callLater(virtualDesktopsMenu.refresh) : virtualDesktopsMenu.refresh()
             onDesktopNamesChanged: root.plasma515 ? Qt.callLater(virtualDesktopsMenu.refresh) : virtualDesktopsMenu.refresh()
         }
 
         Connections {
             target: root.plasma515 ? virtualDesktopInfo : null
 
             onDesktopIdsChanged: root.plasma515 ? Qt.callLater(virtualDesktopsMenu.refresh) : virtualDesktopsMenu.refresh()
         }
 
         PlasmaComponents.ContextMenu {
             id: virtualDesktopsMenu
 
             visualParent: virtualDesktopsMenuItem.action
 
             function refresh() {
                 clearMenuItems();
 
                 if (virtualDesktopInfo.numberOfDesktops <= 1) {
                     return;
                 }
 
                 var menuItem = menu.newMenuItem(virtualDesktopsMenu);
                 menuItem.text = i18n("Move &To Current Desktop");
                 menuItem.enabled = Qt.binding(function() {
                     if (root.plasma515) {
                         var vds = menu.get(atm.VirtualDesktops);
                         return menu.visualParent && (vds !== undefined) && vds.indexOf(virtualDesktopInfo.currentDesktop) == -1;
                     } else {
                         return menu.visualParent && menu.get(atm.VirtualDesktop) !== virtualDesktopInfo.currentDesktop;
                     }
                 });
                 menuItem.clicked.connect(function() {
                     if (root.plasma515) {
                         tasksModel.requestVirtualDesktops(menu.modelIndex, [virtualDesktopInfo.currentDesktop]);
                     } else {
                         tasksModel.requestVirtualDesktop(menu.modelIndex, virtualDesktopInfo.currentDesktop);
                     }
                 });
 
                 menuItem = menu.newMenuItem(virtualDesktopsMenu);
                 menuItem.text = i18n("&All Desktops");
                 menuItem.checkable = true;
                 menuItem.checked = Qt.binding(function() {
                     return menu.visualParent && menu.visualParent.m.IsOnAllVirtualDesktops === true;
                 });
                 menuItem.clicked.connect(function() {
                     if (root.plasma515) {
                         tasksModel.requestVirtualDesktops(menu.modelIndex, []);
                     } else {
                         tasksModel.requestVirtualDesktop(menu.modelIndex, 0);
                     }
                 });
                 backend.setActionGroup(menuItem.action);
 
                 menu.newSeparator(virtualDesktopsMenu);
 
                 for (var i = 0; i < virtualDesktopInfo.desktopNames.length; ++i) {
                     menuItem = menu.newMenuItem(virtualDesktopsMenu);
                     //menuItem.text = i18nc("1 = number of desktop, 2 = desktop name", "%1 Desktop %2", i + 1, virtualDesktopInfo.desktopNames[i]);
                     menuItem.text = (i + 1) + ". " + virtualDesktopInfo.desktopNames[i];
                     menuItem.checkable = true;
                     menuItem.checked = Qt.binding((function(i) {
                         return function() {
                             if (root.plasma515) {
                                 return (menu.visualParent && menu.get(atm.VirtualDesktops).indexOf(virtualDesktopInfo.desktopIds[i]) > -1);
                             } else {
                                 return (menu.visualParent && menu.get(atm.VirtualDesktop) === (i + 1));
                             }
                         };
                     })(i));
                     menuItem.clicked.connect((function(i) {
                         return function() {
                             if (root.plasma515) {
                                 return tasksModel.requestVirtualDesktops(menu.modelIndex, [virtualDesktopInfo.desktopIds[i]]);
                             } else {
                                 return tasksModel.requestVirtualDesktop(menu.modelIndex, i + 1);
                             }
                         };
                     })(i));
                     backend.setActionGroup(menuItem.action);
                 }
 
                 menu.newSeparator(virtualDesktopsMenu);
 
                 menuItem = menu.newMenuItem(virtualDesktopsMenu);
                 menuItem.text = i18n("&New Desktop");
                 menuItem.clicked.connect(function() {
                     if (root.plasma515) {
                         tasksModel.requestNewVirtualDesktop(menu.modelIndex);
                     } else {
                         tasksModel.requestVirtualDesktop(menu.modelIndex, virtualDesktopInfo.numberOfDesktops + 1)
                     }
                 });
             }
 
             Component.onCompleted: refresh()
         }
     }
 
 
     PlasmaComponents.MenuItem {
         id: activitiesDesktopsMenuItem
 
         visible: activityInfo.numberOfRunningActivities > 1
                  && (visualParent && !visualParent.m.IsLauncher
                      && !visualParent.m.IsStartup)
                  && !root.disableAllWindowsFunctionality
 
         enabled: visible
 
         text: i18n("Move To &Activity")
 
         Connections {
             target: activityInfo
 
             onNumberOfRunningActivitiesChanged: activitiesDesktopsMenu.refresh()
         }
 
         PlasmaComponents.ContextMenu {
             id: activitiesDesktopsMenu
 
             visualParent: activitiesDesktopsMenuItem.action
 
             function refresh() {
                 clearMenuItems();
 
                 if (activityInfo.numberOfRunningActivities <= 1) {
                     return;
                 }
 
                 var menuItem = menu.newMenuItem(activitiesDesktopsMenu);
                 menuItem.text = i18n("Add To Current Activity");
                 menuItem.enabled = Qt.binding(function() {
                     return menu.visualParent && menu.visualParent.m.Activities.length > 0 &&
                             menu.visualParent.m.Activities.indexOf(activityInfo.currentActivity) < 0;
                 });
                 menuItem.clicked.connect(function() {
                     tasksModel.requestActivities(menu.modelIndex, menu.visualParent.m.Activities.concat(activityInfo.currentActivity));
                 });
 
                 menuItem = menu.newMenuItem(activitiesDesktopsMenu);
                 menuItem.text = i18n("All Activities");
                 menuItem.checkable = true;
                 menuItem.checked = Qt.binding(function() {
                     return menu.visualParent && menu.visualParent.m.Activities.length === 0;
                 });
                 menuItem.clicked.connect(function() {
                     var checked = menuItem.checked;
                     var newActivities = menu.visualParent.m.Activities;
                     var size = newActivities.length;
 
                     newActivities = undefined; // will cast to an empty QStringList i.e all activities
                     if (size === 0) {
                         newActivities = new Array(activityInfo.currentActivity);
                     }
 
                     tasksModel.requestActivities(menu.modelIndex, newActivities);
                 });
 
                 menu.newSeparator(activitiesDesktopsMenu);
 
                 var runningActivities = activityInfo.runningActivities();
                 for (var i = 0; i < runningActivities.length; ++i) {
                     var activityId = runningActivities[i];
 
                     menuItem = menu.newMenuItem(activitiesDesktopsMenu);
                     menuItem.text = activityInfo.activityName(runningActivities[i]);
                     menuItem.checkable = true;
                     menuItem.checked = Qt.binding( (function(activityId) {
                         return function() {
                             return menu.visualParent && menu.visualParent.m.Activities.indexOf(activityId) >= 0;
                         };
                     })(activityId));
                     menuItem.clicked.connect((function(activityId) {
                         return function () {
                             var checked = menuItem.checked;
                             var newActivities = menu.visualParent.m.Activities;
                             var index = newActivities.indexOf(activityId)
 
                             if (index < 0) {
                                 newActivities = newActivities.concat(activityId);
                             } else {
                                 //newActivities = newActivities.splice(index, 1);  //this does not work!!!
                                 newActivities.splice(index, 1);
                             }
                             return tasksModel.requestActivities(menu.modelIndex, newActivities);
                         };
                     })(activityId));
                 }
 
                 menu.newSeparator(activitiesDesktopsMenu);
             }
 
             Component.onCompleted: refresh()
         }
     }
 
     PlasmaComponents.MenuItem {
         id: moreActionsMenuItem
 
         visible: (visualParent
                   && visualParent.m.IsLauncher !== true
                   && visualParent.m.IsStartup !== true
                   && root.showWindowActions
                   && !root.disableAllWindowsFunctionality)
 
         enabled: visible
 
         text: i18n("More Actions")
         icon: "view-more-symbolic"
 
         PlasmaComponents.ContextMenu {
             visualParent: moreActionsMenuItem.action
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.visualParent.m.IsMovable === true
 
                 text: i18n("&Move")
                 icon: "transform-move"
 
                 onClicked: tasksModel.requestMove(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.visualParent.m.IsResizable === true
 
                 text: i18n("Re&size")
                 icon: "transform-scale"
 
                 onClicked: tasksModel.requestResize(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 visible: (visualParent
                           && visualParent.m.IsLauncher !== true
                           && visualParent.m.IsStartup !== true
                           && root.showWindowActions
                           && !root.disableAllWindowsFunctionality)
 
                 enabled: visualParent && visualParent.m.IsMaximizable === true
 
                 checkable: true
                 checked: visualParent && visualParent.m.IsMaximized === true
 
                 text: i18n("Ma&ximize")
                 icon: "window-maximize"
 
                 onClicked: tasksModel.requestToggleMaximized(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 visible: (visualParent
                           && visualParent.m.IsLauncher !== true
                           && visualParent.m.IsStartup !== true
                           && root.showWindowActions
                           && !root.disableAllWindowsFunctionality)
 
                 enabled: visualParent && visualParent.m.IsMinimizable === true
 
                 checkable: true
                 checked: visualParent && visualParent.m.IsMinimized === true
 
                 text: i18n("Mi&nimize")
                 icon: "window-minimize"
 
                 onClicked: tasksModel.requestToggleMinimized(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 checkable: true
                 checked: menu.visualParent && menu.visualParent.m.IsKeepAbove === true
 
                 text: i18n("Keep &Above Others")
                 icon: "window-keep-above"
 
                 onClicked: tasksModel.requestToggleKeepAbove(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 checkable: true
                 checked: menu.visualParent && menu.visualParent.m.IsKeepBelow === true
 
                 text: i18n("Keep &Below Others")
                 icon: "window-keep-below"
 
                 onClicked: tasksModel.requestToggleKeepBelow(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.visualParent.m.IsFullScreenable === true
 
                 checkable: true
                 checked: menu.visualParent && menu.visualParent.m.IsFullScreen === true
 
                 text: i18n("&Fullscreen")
                 icon: "view-fullscreen"
 
                 onClicked: tasksModel.requestToggleFullScreen(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 enabled: menu.visualParent && menu.visualParent.m.IsShadeable === true
 
                 checkable: true
                 checked: menu.visualParent && menu.visualParent.m.IsShaded === true
 
                 text: i18n("&Shade")
                 icon: "window-shade"
 
                 onClicked: tasksModel.requestToggleShaded(menu.modelIndex)
             }
 
             PlasmaComponents.MenuItem {
                 separator: true
             }
 
             PlasmaComponents.MenuItem {
                 visible: (plasmoid.configuration.groupingStrategy != 0) && menu.visualParent.m.IsWindow === true
 
                 checkable: true
                 checked: menu.visualParent && menu.visualParent.m.IsGroupable === true
 
                 text: i18n("Allow this program to be grouped")
 
                 onClicked: tasksModel.requestToggleGrouping(menu.modelIndex)
             }
         }
     }
 
     /*    PlasmaComponents.MenuItem {
         separator: true
 
         visible: (visualParent
                   && visualParent.m.IsLauncher !== true
                   && visualParent.m.IsStartup !== true
                   && root.showWindowActions)
     }*/
 
     //// NEW Launchers Mechanism
     PlasmaComponents.MenuItem {
         id: launcherToggleAction
 
         visible: visualParent
                  && get(atm.IsLauncher) !== true
                  && get(atm.IsStartup) !== true
                  && (activityInfo.numberOfRunningActivities < 2)
         //&& plasmoid.immutability !== PlasmaCore.Types.SystemImmutable
 
         enabled: visualParent && get(atm.LauncherUrlWithoutIcon) !== ""
 
         checkable: true
 
         text: i18n("&Pin Launcher")
         icon: "window-pin"
 
         onClicked: {
             if (tasksModel.launcherPosition(get(atm.LauncherUrlWithoutIcon)) != -1) {
                 var launcher = get(atm.LauncherUrl);
 
                 if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                     latteView.layoutsManager.launchersSignals.removeLauncher(root.viewLayoutName,
                                                                              root.launchersGroup, launcher);
                 } else {
                     root.launcherForRemoval = launcher;
                     tasksModel.requestRemoveLauncher(launcher);
                     root.launchersUpdatedFor(launcher);
                 }
 
             } else {
                 var launcher = get(atm.LauncherUrl);
                 if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                     latteView.layoutsManager.launchersSignals.addLauncher(root.viewLayoutName,
                                                                           root.launchersGroup, launcher);
                 } else {
                     tasksModel.requestAddLauncher(launcher);
                     root.launchersUpdatedFor(launcher);
                 }
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         id: showLauncherInActivitiesItem
 
         text: i18n("&Pin Launcher")
         icon: "window-pin"
 
         visible: visualParent && (!visualParent.isSeparator || (visualParent.isSeparator && root.editMode))
         // && get(atm.IsLauncher) !== true
                  && get(atm.IsStartup) !== true
                  && plasmoid.immutability !== PlasmaCore.Types.SystemImmutable
                  && (activityInfo.numberOfRunningActivities >= 2)
 
         Connections {
             target: activityInfo
             onNumberOfRunningActivitiesChanged: activitiesDesktopsMenu.refresh()
         }
 
         PlasmaComponents.ContextMenu {
             id: activitiesLaunchersMenu
             visualParent: showLauncherInActivitiesItem.action
 
             function refresh() {
                 clearMenuItems();
 
                 if (menu.visualParent === null) return;
 
                 var createNewItem = function(id, title, url, activities) {
                     var result = menu.newMenuItem(activitiesLaunchersMenu);
                     result.text = title;
 
                     result.visible = true;
                     result.checkable = true;
 
                     result.checked = activities.some(function(activity) { return activity === id });
 
                     result.clicked.connect(
                                 function() {
                                     if (result.checked) {
                                         if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                                             latteView.layoutsManager.launchersSignals.addLauncherToActivity(root.viewLayoutName,
                                                                                                             root.launchersGroup, url, id);
                                         } else {
                                             if (id !== tasksModel.activity && (activities[0] === "00000000-0000-0000-0000-000000000000")) {
                                                 root.launcherForRemoval = url;
                                             }
 
                                             tasksModel.requestAddLauncherToActivity(url, id);
                                             root.launchersUpdatedFor(url);
                                         }
                                     } else {
                                         if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                                             latteView.layoutsManager.launchersSignals.removeLauncherFromActivity(root.viewLayoutName,
                                                                                                                  root.launchersGroup, url, id);
                                         } else {
                                             if (id === tasksModel.activity) {
                                                 root.launcherForRemoval = url;
                                             }
                                             tasksModel.requestRemoveLauncherFromActivity(url, id);
                                             root.launchersUpdatedFor(url);
                                         }
                                     }
                                 }
                                 );
 
                     return result;
                 }
 
                 if (menu.visualParent === null) return;
 
                 var url = menu.get(atm.LauncherUrlWithoutIcon);
 
                 var activities = tasksModel.launcherActivities(url);
 
                 var NULL_UUID = "00000000-0000-0000-0000-000000000000";
 
                 createNewItem(NULL_UUID, i18n("On All Activities"), url, activities);
 
                 if (activityInfo.numberOfRunningActivities <= 1) {
                     return;
                 }
 
                 createNewItem(activityInfo.currentActivity, i18n("On The Current Activity"), url, activities);
 
                 menu.newSeparator(activitiesLaunchersMenu);
 
                 var runningActivities = activityInfo.runningActivities();
 
                 runningActivities.forEach(function(id) {
                     createNewItem(id, activityInfo.activityName(id), url, activities);
                 });
             }
 
             Component.onCompleted: {
                 menu.onVisualParentChanged.connect(refresh);
                 refresh();
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         visible: (visualParent && !visualParent.isSeparator && get(atm.IsLauncher) === true)
                  && plasmoid.immutability !== PlasmaCore.Types.SystemImmutable
 
         text: i18n("Unpin Launcher")
         icon: "window-unpin"
 
         onClicked: {
             var launcher = get(atm.LauncherUrlWithoutIcon);
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.removeLauncher(root.viewLayoutName,
                                                                          root.launchersGroup, launcher);
             } else {
                 root.launcherForRemoval = launcher
                 tasksModel.requestRemoveLauncher(launcher);
                 root.launchersUpdatedFor(launcher);
             }
         }
     }
 
     //////END OF NEW ARCHITECTURE
 
     /*PlasmaComponents.MenuItem {
         separator: true
         visible: root.editMode
     }*/
 
     PlasmaComponents.MenuItem {
         id: addInternalSeparatorItem
         visible: root.editMode
 
         icon: "add"
         text: i18n("Add Separator")
 
         onClicked: {
             var pos=visualParent.itemIndex;
 
             root.addInternalSeparatorAtPos(pos);
         }
     }
 
     PlasmaComponents.MenuItem {
         id: removeInternalSeparatorItem
         visible: root.editMode && visualParent.isSeparator
 
         icon: "remove"
         text: i18n("Remove Separator")
         enabled: (root.indexer.separators.length > 0) && visualParent && visualParent.isSeparator
 
         onClicked: {
-            //root.removeLastSeparator();
             var launcher = get(atm.LauncherUrlWithoutIcon);
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.removeLauncher(root.viewLayoutName,
                                                                          root.launchersGroup, launcher);
             } else {
                 root.launcherForRemoval = launcher;
                 tasksModel.requestRemoveLauncher(launcher);
                 root.launchersUpdatedFor(launcher);
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         //text: i18n("Configure")
         //section: true
         separator: true
         visible: preferenceMenuItem.visible
     }
 
     /* PlasmaComponents.MenuItem {
         separator: true
         visible: root.editMode
     }*/
 
     PlasmaComponents.MenuItem {
         id: layoutsMenuItem
 
         action: latteView ?  containmentActions[1] : plasmoid.action("configure")
         enabled: visible
         visible: latteView && latteView.layoutsManager.menuLayouts.length>1
     }
 
     PlasmaComponents.MenuItem {
         id: preferenceMenuItem
 
         action: latteView ?  containmentActions[2] : plasmoid.action("configure")
         visible: latteView
     }
 
     PlasmaComponents.MenuItem {
         id: quitApplicationItem
         action: latteView ? containmentActions[3] : plasmoid.action("configure")
         visible:  latteView
     }
 
     PlasmaComponents.MenuItem {
         separator: true
         visible: preferenceMenuItem.visible
     }
 
     PlasmaComponents.MenuItem {
         id: alternativesMenuItem
         visible: root.editMode && !visualParent.isSeparator
         text: plasmoid.action("alternatives").text
         icon: plasmoid.action("alternatives").icon
 
         onClicked: plasmoid.action("alternatives").trigger();
     }
 
     PlasmaComponents.MenuItem {
         id: addWidgets
 
         action: latteView ? containmentActions[5] : plasmoid.action("configure");
         visible:  latteView
     }
 
     PlasmaComponents.MenuItem {
         id: configureItem
 
         action: latteView ? containmentActions[6] : plasmoid.action("configure")
     }
 
     //! BEGIN: Plasmoid actions when it isnt inside a Latte dock
     PlasmaComponents.MenuItem {
         id: configurePlasmoid
         visible: !latteView && !plasmoid.immutable
 
         text: plasmoid.action("configure").text
         icon: plasmoid.action("configure").icon
 
         onClicked: plasmoid.action("configure").trigger();
     }
     //! END: Plasmoid actions when it isnt inside a Latte dock
 
     PlasmaComponents.MenuItem {
         separator: true
         visible: closeWindowItem.visible
     }
 
     //!move window Close button at the very bottom in order to not alter users workflow
     //!comparing with the design decisions of other taskmanagers
     PlasmaComponents.MenuItem {
         id: closeWindowItem
         visible: (visualParent && visualParent.m.IsLauncher !== true && visualParent.m.IsStartup !== true)
 
         enabled: visualParent && visualParent.m.IsClosable === true
 
         text: i18n("&Close")
         icon: "window-close"
 
         onClicked: {
             if (parabolic.factor.zoom>1) {
                 delayWindowRemovalTimer.modelIndex = menu.modelIndex;
                 delayWindowRemovalTimer.start();
             } else {
                 tasksModel.requestClose(menu.modelIndex);
             }
         }
     }
 
     PlasmaComponents.MenuItem {
         separator: true
         visible: removePlasmoid.visible
     }
 
     PlasmaComponents.MenuItem {
         id: removePlasmoid
         visible: (latteView && latteView.editMode) || (!latteView && !plasmoid.immutable /*normal plasmoid in the desktop*/)
 
         text: plasmoid.action("remove").text
         icon: plasmoid.action("remove").icon
 
         onClicked: plasmoid.action("remove").trigger();
     }
 }
diff --git a/plasmoid/package/contents/ui/ParabolicManager.qml b/plasmoid/package/contents/ui/ParabolicManager.qml
deleted file mode 100644
index 7ec33019..00000000
--- a/plasmoid/package/contents/ui/ParabolicManager.qml
+++ /dev/null
@@ -1,264 +0,0 @@
-/*
-*  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 org.kde.plasma.plasmoid 2.0
-
-// holds all the logic around parabolic effect signals into one place.
-// ParabolicManager is responsible for triggering all the messages to tasks
-// that are neighbour to the hovered task. This will help a lot to catch cases
-// such as separators and proper clearing zoom.
-
-Item {
-    id: parManager
-
-    property bool hasInternalSeparator: false
-
-    property int firstRealTaskIndex: -1
-    property int lastRealTaskIndex: -1
-    property int countRealTasks: -1
-
-    Connections{
-        target: root
-        onTasksCountChanged: parManager.updateTasksEdgesIndexes();
-        onHiddenTasksUpdated: parManager.updateTasksEdgesIndexes();
-    }
-
-    Component.onCompleted: {
-        updateHasInternalSeparator();
-        updateTasksEdgesIndexes();
-    }
-
-    function updateTasksEdgesIndexes() {
-        var newFirstTask = firstRealTask();
-        var newLastTask = lastRealTask();
-
-        if (newFirstTask !== firstRealTaskIndex || newLastTask !== lastRealTaskIndex ){
-            firstRealTaskIndex = newFirstTask;
-            lastRealTaskIndex = newLastTask;
-        }
-
-        countRealTasks = realTasks();
-    }
-
-    function updateHasInternalSeparator() {
-        var count = icList.contentItem.children.length;
-        for (var i=0; i<count; ++i) {
-            var task = icList.childAtIndex(i);
-
-            if (task && task.isSeparator){
-                hasInternalSeparator = true;
-                return;
-            }
-        }
-
-        hasInternalSeparator = false;
-    }
-
-    function neighbourIsHovered(index) {
-        if (parManager.lastIndex<0)
-            return;
-
-        if (Math.abs(index - parManager.lastIndex)<=1)
-            return true;
-
-        return false;
-    }
-
-    function availableLowerIndex(from) {
-        var next = from;
-
-        while (next>=0
-               && (taskIsSeparator(next) || (root.showWindowsOnlyFromLaunchers && taskIsForcedHidden(next))) )
-            next = next - 1;
-
-        return next;
-    }
-
-    function availableHigherIndex(from) {
-        var next = from;
-
-        while (next<=root.tasksCount-1
-               && (taskIsSeparator(next) || (root.showWindowsOnlyFromLaunchers && taskIsForcedHidden(next))) ) {
-            next = next + 1;
-        }
-
-        return next;
-    }
-
-    function isSeparator(launcher){
-        return (launcher.indexOf("latte-separator")!==-1 && launcher.indexOf(".desktop")!==1);
-    }
-
-    function taskIsSeparator(taskIndex){
-        var task = icList.childAtIndex(taskIndex);
-
-        return (task && !task.isForcedHidden && task.isSeparator);
-    }
-
-    function taskIsForcedHidden(taskIndex) {
-        var task = icList.childAtIndex(taskIndex);
-
-        //!tasks that become hidden there is a chance to have index===-1 and to not be
-        //!able to be tracked down
-        return ((!task && (taskIndex>=0 && taskIndex<tasksModel.count)) || task.isForcedHidden);
-    }
-
-    function separatorExists(separator){
-        return (tasksModel.launcherPosition(separator)>=0);
-    }
-
-    //! the real index task after we take into account the separators before it
-    //! for example the first task if there is a separator before it is 1, it isnt 0
-    function realTaskIndex(pseudoIndex) {
-        if (hasInternalSeparator) {
-            var steps = pseudoIndex + 1;
-            var pos = 0;
-
-            while (steps > 0) {
-                if (!taskIsSeparator(pos)) {
-                    steps = steps - 1;
-                }
-
-                if (steps > 0)
-                    pos = pos + 1;
-            }
-
-            return pos;
-        } else {
-            return pseudoIndex;
-        }
-    }
-
-    //! the pseudo index task after we take into account the separators before it
-    //! for example the third task if there is a separator before it is 1, it isnt 2
-    function pseudoTaskIndex(realIndex) {
-        var pseudoIndex = realIndex;
-
-        if (hasInternalSeparator) {
-            for (var i=0; i<realIndex; i++){
-                if (taskIsSeparator(i)) {
-                    pseudoIndex = pseudoIndex-1;
-                }
-            }
-        }
-
-        return pseudoIndex + root.tasksBaseIndex;
-    }
-
-    //! first available task index found after consequent internal separators or hidden tasks in the start
-    function firstRealTask() {
-        if (hasInternalSeparator) {
-            var i=0;
-
-            while (i<=root.tasksCount-1) {
-                if (!taskIsSeparator(i) && !taskIsForcedHidden(i)) {
-                    return i;
-                }
-
-                i = i + 1;
-            }
-        }
-
-        return root.tasksCount > 0 ? 0 : -1;
-    }
-
-    //! last available task index found after consequent internal separators in the end
-    function lastRealTask() {
-        if (hasInternalSeparator || root.showWindowsOnlyFromLaunchers) {
-            var i = tasksModel.count - 1;
-
-            while (i>=0) {
-                if (!taskIsSeparator(i) && !taskIsForcedHidden(i) ) {
-                    return i;
-                }
-
-                i = i - 1;
-            }
-        }
-
-        return root.tasksCount > 0 ? root.tasksCount-1 : -1;
-    }
-
-    //! the real number of tasks if we remove the internal separators and hidden windows in the end
-    function realTasks() {
-        var space = lastRealTaskIndex - firstRealTaskIndex;
-
-        if (space >= 0) {
-            var ignored = 0;
-            for(var i=firstRealTaskIndex; i<lastRealTaskIndex; ++i) {
-                if (taskIsSeparator(i) || taskIsForcedHidden(i)) {
-                    ignored = ignored + 1;
-                }
-            }
-
-            return space + 1 - ignored;
-        }
-
-        return 0;
-    }
-
-    function freeAvailableSeparatorName() {
-        var available = false;
-        var no = 1;
-
-        var separatorName = "";
-
-        while(!available && no
-              <20) {
-            separatorName = "file:///latte-separator"+no+".desktop";
-            if (separatorExists(separatorName)) {
-                no = no + 1;
-            } else {
-                available = true;
-            }
-        }
-
-        if (available) {
-            return separatorName;
-        } else {
-            return "";
-        }
-    }
-
-    function lastPresentSeparatorName() {
-        var max = -1;
-        var arrayPos = -1;
-
-        var sLength = separators.length;
-
-        for (var i=0; i<sLength; ++i) {
-            //!safety checker
-            if (i>=separators.length)
-                return false;
-
-            if (separators[i].index > max) {
-                max = separators[i].index;
-                arrayPos = i;
-            }
-        }
-
-        if (arrayPos>-1)
-            return separators[arrayPos].launcherUrl;
-        else
-            return "";
-    }
-}
diff --git a/plasmoid/package/contents/ui/abilities/Launchers.qml b/plasmoid/package/contents/ui/abilities/Launchers.qml
new file mode 100644
index 00000000..e6689034
--- /dev/null
+++ b/plasmoid/package/contents/ui/abilities/Launchers.qml
@@ -0,0 +1,52 @@
+/*
+*  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 {
+    function isSeparator(launcher){
+        return (launcher.indexOf("latte-separator")!==-1 && launcher.indexOf(".desktop")!==1);
+    }
+
+    function separatorExists(separator){
+        return (tasksModel.launcherPosition(separator)>=0);
+    }
+
+    function freeAvailableSeparatorName() {
+        var available = false;
+        var no = 1;
+
+        var separatorName = "";
+
+        while(!available && no<20) {
+            separatorName = "file:///latte-separator"+no+".desktop";
+            if (separatorExists(separatorName)) {
+                no = no + 1;
+            } else {
+                available = true;
+            }
+        }
+
+        if (available) {
+            return separatorName;
+        } else {
+            return "";
+        }
+    }
+}
diff --git a/plasmoid/package/contents/ui/main.qml b/plasmoid/package/contents/ui/main.qml
index d961749a..e2bfba9c 100644
--- a/plasmoid/package/contents/ui/main.qml
+++ b/plasmoid/package/contents/ui/main.qml
@@ -1,2044 +1,2036 @@
 /*
 *  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 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 launchers: _launchers
     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 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.Launchers {
+        id: _launchers
+    }
+
     Ability.Metrics {
         id: _metrics
         bridge: latteBridge
     }
 
     Ability.ParabolicEffect {
         id: _parabolic
         bridge: latteBridge
         local.restoreZoomIsBlocked: root.contextMenu || windowsPreviewDlg.containsMouse
     }
 
     Ability.PositionShortcuts {
         id: _shortcuts
         bridge: latteBridge
         isStealingGlobalPositionShortcuts: plasmoid.configuration.isPreferredForPositionShortcuts
 
         onDisabledIsStealingGlobalPositionShortcuts: {
             plasmoid.configuration.isPreferredForPositionShortcuts = false;
         }
     }
 
     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
+                        launchers: _launchers
                         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();
+        var separatorName = launchers.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);
             }
         }
     }
 
     function activateTaskAtIndex(index) {
         // This is called with Meta+number shortcuts by plasmashell when Tasks are in a plasma panel.
         shortcuts.sglActivateEntryAtIndex(index);
     }
 
     function newInstanceForTaskAtIndex(index) {
         // 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);
-            }
-        }
-    }
-
     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/TaskItem.qml b/plasmoid/package/contents/ui/task/TaskItem.qml
index b9267d51..589d84f5 100644
--- a/plasmoid/package/contents/ui/task/TaskItem.qml
+++ b/plasmoid/package/contents/ui/task/TaskItem.qml
@@ -1,1685 +1,1682 @@
 /*
 *  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 launchers: 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)){
+        if (launchers.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)
                     && !root.dragSource ){
                 taskItem.groupWindowAdded();
             } else if ((windowsCount >= 1)
                      && (windowsCount < previousCount)
                      && !root.dragSource
                      && !taskItem.delayingRemove){
                 //sometimes this is triggered in dragging with no reason
                 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();
         }
     }
 
     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: {
             if (!taskItem.shortcuts.isEnabled) {
                 return;
             }
 
             var shortcutIndex = taskItem.shortcuts.shortcutIndex(taskItem.itemIndex);
 
             if (shortcutIndex === entryIndex) {
                 if (taskItem.isGroupParent) {
                     taskItem.activateNextTask();
                 } else {
                     taskItem.activateTask();
                 }
             }
         }
 
         onSglNewInstanceForEntryAtIndex: {
             if (!taskItem.shortcuts.isEnabled) {
                 return;
             }
 
             var shortcutIndex = taskItem.shortcuts.shortcutIndex(taskItem.itemIndex);
 
             if (shortcutIndex === 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