diff --git a/plasmoid/package/contents/ui/MouseHandler.qml b/plasmoid/package/contents/ui/MouseHandler.qml
index 294d441d..81a5cb4a 100644
--- a/plasmoid/package/contents/ui/MouseHandler.qml
+++ b/plasmoid/package/contents/ui/MouseHandler.qml
@@ -1,253 +1,253 @@
 /*
 *  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.draganddrop 2.0
 
 import org.kde.taskmanager 0.1 as TaskManager
 
 import org.kde.latte 0.1 as Latte
 
 import "../code/tools.js" as TaskTools
 
 Item {
     // signal urlDropped(url url)
     signal urlsDropped(var urls)
 
     property Item target
     property Item ignoredItem
     property bool moved: false
 
     property alias hoveredItem: dropHandler.hoveredItem
     property alias onlyLaunchers: dropHandler.onlyLaunchers
 
 
     Timer {
         id: ignoreItemTimer
 
         repeat: false
         interval: 200
 
         onTriggered: {
             ignoredItem = null;
         }
     }
 
     Connections {
         target: root
         onDragSourceChanged: {
             if (!dragSource) {
                 ignoredItem = null;
                 ignoreItemTimer.stop();
             }
         }
     }
 
     DropArea {
         id: dropHandler
 
         anchors.fill: parent
 
         preventStealing: true;
 
         property int droppedPosition: -1;
         property bool onlyLaunchers: false;
         property bool droppingSeparator: false;
 
         property Item hoveredItem
 
         function isDroppingSeparator(event) {
             return ((event.mimeData.formats.indexOf("text/x-plasmoidservicename") === 0)
                     && (String(event.mimeData.getDataAsByteArray("text/x-plasmoidservicename")) === "audoban.applet.separator"));
         }
 
         onDragEnter:{
             if(root.dragSource == null){
                 onlyLaunchers = false;
                 droppingSeparator = false;
                 root.dropNewLauncher = false;
                 var createLaunchers = false;
 
                 if (event.mimeData.hasUrls || (event.mimeData.formats.indexOf("text/x-plasmoidservicename") !== 0)) {
                     root.dropNewLauncher = true;
 
                     if (event.mimeData.hasUrls){
                         createLaunchers = event.mimeData.urls.every(function (item) {
                             return backend.isApplication(item)
                         });
                     }
                 } else if (isDroppingSeparator(event)) {
                     droppingSeparator = true;
                     root.dropNewLauncher = true;
                     return;
                 } else {
                     event.ignore();
                 }
 
                 if (createLaunchers) {
                     onlyLaunchers = true;
                 }
             }
         }
 
         onDragMove: {
             /* if(root.dragSource == null){
                 root.dropNewLauncher = true;
             } */
 
             if (target.animating) {
                 return;
             }
 
             var above = target.childAtPos(event.x, event.y);
 
             // If we're mixing launcher tasks with other tasks and are moving
             // a (small) launcher task across a non-launcher task, don't allow
             // the latter to be the move target twice in a row for a while, as
             // it will naturally be moved underneath the cursor as result of the
             // initial move, due to being far larger than the launcher delegate.
             // TODO: This restriction (minus the timer, which improves things)
             // has been proven out in the EITM fork, but could be improved later
             // by tracking the cursor movement vector and allowing the drag if
             // the movement direction has reversed, etablishing user intent to
             // move back.
             if (root.dragSource == null
                     && ignoredItem == above)
                 return;
 
             if (root.dragSource != null
                     && root.dragSource.m.IsLauncher === true && above != null
                     && above.m != null
                     && above.m.IsLauncher !== true && above == ignoredItem) {
                 return;
             } else {
                 //ignoredItem = null;
             }
 
             //at some point it was needed the following  && above != ignoredItem
             //but know not... strange... && above != ignoredItem
             //I use the ignoredItem in order to reduce the move calls as much
             //as possible
             if (tasksModel.sortMode == TaskManager.TasksModel.SortManual && root.dragSource && ignoredItem == null) {
                 var insertAt = TaskTools.insertIndexAt(above, event.x, event.y);
 
                 if (root.dragSource != above && root.dragSource.itemIndex != insertAt) {
                     //      console.log(root.dragSource.itemIndex + " - "+insertAt);
                     root.dragSource.z = 100;
                     ignoredItem = above;
 
                     var pos = root.dragSource.itemIndex;
                     tasksModel.move(pos, insertAt);
                     if (latteDock && latteDock.launchersGroup >= Latte.Dock.LayoutLaunchers) {
                         latteDock.universalLayoutManager.launchersSignals.moveTask(root.managedLayoutName,
                                                                                    plasmoid.id,
                                                                                    latteDock.launchersGroup, pos, insertAt);
                     }
                     root.separatorsUpdated();
                     ignoreItemTimer.restart();
                 }
             } else if (!root.dragSource && above && hoveredItem != above) {
                 hoveredItem = above;
                 //root.dropNewLauncher = true;
                 activationTimer.restart();
             } else if (!above) {
                 //root.dropNewLauncher = true;
                 hoveredItem = null;
                 activationTimer.stop();
             }
 
-            if (hoveredItem && windowsPreviewDlg.visible && toolTipDelegate.parentIndex !== hoveredItem.itemIndex ) {
+            if (hoveredItem && windowsPreviewDlg.visible && toolTipDelegate.rootIndex !== hoveredItem.modelIndex() ) {
                 windowsPreviewDlg.hide(6);
             }
         }
 
         onDragLeave: {
             hoveredItem = null;
             root.dropNewLauncher = false;
             onlyLaunchers = false;
             root.separatorsUpdated();
             activationTimer.stop();
         }
 
         onDrop: {
             // Reject internal drops.
             root.dropNewLauncher = false;
             onlyLaunchers = false;
             root.separatorsUpdated();
 
             if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") >= 0) {
                 return;
             }
 
             if (droppingSeparator) {
                 droppingSeparator = false;
                 if (hoveredItem && hoveredItem.itemIndex >=0){
                     root.addInternalSeparatorAtPos(hoveredItem.itemIndex);
                 } else {
                     root.addInternalSeparatorAtPos(0);
                 }
                 return;
             }
 
             if (event.mimeData.hasUrls) {
                 parent.urlsDropped(event.mimeData.urls);
             }
         }
 
         Timer {
             id: activationTimer
 
             interval: 250
             repeat: false
 
             onTriggered: {
                 if (dropHandler.onlyLaunchers || !root.dropNewLauncher || dropHandler.droppingSeparator) {
                     return;
                 }
 
                 if (parent.hoveredItem.m.IsGroupParent === true) {
                     root.showPreviewForTasks(parent.hoveredItem);
                     // groupDialog.visualParent = parent.hoveredItem;
                     // groupDialog.visible = true;
                 } else if (parent.hoveredItem.m.IsLauncher !== true) {
                     if(windowsPreviewDlg.visible && toolTipDelegate.currentItem !==parent.hoveredItem.itemIndex ) {
                         windowsPreviewDlg.hide(5);
                         toolTipDelegate.currentItem=-1;
                     }
 
                     tasksModel.requestActivate(parent.hoveredItem.modelIndex());
                 }
             }
         }
     }
     /*
     MouseArea {
         id: wheelHandler
 
         anchors.fill: parent
         property int wheelDelta: 0;
         enabled: plasmoid.configuration.wheelEnabled
 
         onWheel: wheelDelta = TaskTools.wheelActivateNextPrevTask(wheelDelta, wheel.angleDelta.y);
     } */
 }
diff --git a/plasmoid/package/contents/ui/ToolTipDelegate2.qml b/plasmoid/package/contents/ui/ToolTipDelegate2.qml
index 2283722d..1fe6eb76 100644
--- a/plasmoid/package/contents/ui/ToolTipDelegate2.qml
+++ b/plasmoid/package/contents/ui/ToolTipDelegate2.qml
@@ -1,222 +1,218 @@
 /*
 *   Copyright 2013 by Sebastian Kügler <sebas@kde.org>
 *   Copyright 2014 by Martin Gräßlin <mgraesslin@kde.org>
 *   Copyright 2016 by Kai Uwe Broulik <kde@privat.broulik.de>
 *   Copyright 2017 by Roman Gilg <subdiff@gmail.com>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2, or
 *   (at your option) any later version.
 *
 *   This program 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 Library General Public License for more details
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  2.010-1301, USA.
 */
 
 import QtQuick 2.6
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 import QtQml.Models 2.2
 
 import org.kde.draganddrop 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import org.kde.kquickcontrolsaddons 2.0 as KQuickControlsAddons
 
 import org.kde.taskmanager 0.1 as TaskManager
 
 
 PlasmaExtras.ScrollArea {
     id: mainToolTip
     property Item parentTask
-    property int parentIndex: -1
+    property var rootIndex
 
     property string appName
     property int pidParent
     property bool isGroup
     property bool hideCloseButtons
 
     property var windows
     readonly property bool isWin: windows !== undefined
 
     property variant icon
     property url launcherUrl
     property bool isLauncher
     property bool isMinimizedParent
 
     property bool containsMouse: false
 
     // Needed for generateSubtext()
     property string displayParent
     property string genericName
     property int virtualDesktopParent
     property bool isOnAllVirtualDesktopsParent
     property var activitiesParent
     //
-    readonly property bool isVerticalPanel: plasmoid.formFactor == PlasmaCore.Types.Vertical
+    readonly property bool isVerticalPanel: plasmoid.formFactor === PlasmaCore.Types.Vertical
 
     Layout.minimumWidth: contentItem.width
     Layout.maximumWidth: Layout.minimumWidth
 
     Layout.minimumHeight: contentItem.height
     Layout.maximumHeight: Layout.minimumHeight
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft
     LayoutMirroring.childrenInherit: true
 
     property int textWidth: theme.mSize(theme.defaultFont).width * 20
 
     verticalScrollBarPolicy: Qt.ScrollBarAlwaysOff
     horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
 
     Component.onCompleted: {
         flickableItem.interactive = Qt.binding(function() {
             return isVerticalPanel ? contentItem.height > viewport.height : contentItem.width > viewport.width
         });
     }
+
     Item{
         width: contentItem.width
         height: contentItem.height
 
+        //! DropArea
         DropArea {
             id: dropMainArea
-            anchors.fill: contentItem
+            anchors.fill: parent
             enabled: isGroup
-
             preventStealing: true
 
-            property bool dragInside: false
-
             property QtObject currentWindow
 
             onDragLeave: {
                 windowsPreviewDlg.hide();
             }
 
             onDragMove: {
-                var current = groupTask.childAtPos(event.x, event.y);
+                var current = mainToolTip.instanceAtPos(event.x, event.y);
 
                 if (current && currentWindow !== current && current.submodelIndex) {
                     currentWindow = current;
                     tasksModel.requestActivate(current.submodelIndex);
                 }
             }
-        }
+        } //! DropArea
 
+        //! Underneath MouseArea
         MouseArea {
-            id: contentItem
-            width: childrenRect.width
-            height: childrenRect.height
-
+            id: contentItemMouseArea
+            anchors.fill: parent
             hoverEnabled: true
 
             onContainsMouseChanged: {
-                checkMouseInside();
+                mainToolTip.mouseIsInside();
             }
+        }//! MouseArea
 
-            function checkMouseInside(){
-                var isInside = containsMouse || childrenContainMouse() || (parentTask && parentTask.containsMouse);
-                if (isInside){
-                    //root.disableRestoreZoom = true;
-                    mainToolTip.containsMouse = true;
-
-                    if(!root.latteDock)
-                        checkListHovered.stop();
-                }
-                else{
-                    //root.disableRestoreZoom = false;
-                    mainToolTip.containsMouse = false;
-
-                    if(!root.latteDock)
-                        checkListHovered.startDuration(100);
-                    else
-                        root.latteDock.startCheckRestoreZoomTimer();
-                }
-            }
+        Loader {
+            id: contentItem
+            active: mainToolTip.rootIndex !== undefined
+            asynchronous: true
+            sourceComponent: isGroup ? groupToolTip : singleTooltip
 
-            function childrenContainMouse() {
-                return singleTask.containsMouse() || groupTask.containsMouse();
-            }
+            Component {
+                id: singleTooltip
 
-            ToolTipInstance {
-                id: singleTask
-                visible: !isGroup
+                ToolTipInstance {
+                    submodelIndex: mainToolTip.rootIndex
+                }
             }
 
-            Grid {
-                id: groupTask
-                rows: !isVerticalPanel
-                columns: isVerticalPanel
-                flow: isVerticalPanel ? Grid.TopToBottom : Grid.LeftToRight
-                spacing: units.largeSpacing
-
-                width: isGroup ? childrenRect.width : 0
-                height: isGroup ? childrenRect.height : 0
+            Component {
+                id: groupToolTip
 
-                visible: isGroup && parentIndex !== -1
+                Grid {
+                    rows: !isVerticalPanel
+                    columns: isVerticalPanel
+                    flow: isVerticalPanel ? Grid.TopToBottom : Grid.LeftToRight
+                    spacing: units.largeSpacing
 
-                Loader {
-                    id: modelLoader
-                    active: groupTask.visible
-
-                    sourceComponent: Repeater {
+                    Repeater {
                         id: groupRepeater
-
                         model: DelegateModel {
-                            id: delegateModel
+                            model: mainToolTip.rootIndex ? tasksModel : null
+                            rootIndex: mainToolTip.rootIndex
 
-                            model: parentIndex !== -1 && isGroup ? tasksModel : undefined
-                            rootIndex: tasksModel.makeModelIndex(parentIndex, -1)
-                            delegate: ToolTipInstance {}
-                        }
-
-                        Component.onCompleted: {
-                            parent = groupTask
+                            delegate: ToolTipInstance {
+                                submodelIndex: tasksModel.makeModelIndex(mainToolTip.rootIndex.row, index)
+                            }
                         }
                     }
                 }
+            }
+        } //! Loader
+    } //! Item
 
+    //! Central Functionality
+    function mouseIsInside(){
+        var isInside = contentItemMouseArea.containsMouse || instancesContainMouse() || (parentTask && parentTask.containsMouse);
 
-                function containsMouse(){
-                    for(var i=1; i<children.length-1; ++i) {
-                        if(children[i].containsMouse())
-                            return true;
-                    }
+        if (isInside){
+            mainToolTip.containsMouse = true;
 
-                    return false;
-                }
+            if(!root.latteDock)
+                checkListHovered.stop();
+        } else {
+            mainToolTip.containsMouse = false;
+
+            if(!root.latteDock)
+                checkListHovered.startDuration(100);
+            else
+                root.latteDock.startCheckRestoreZoomTimer();
+        }
+    }
 
-                function childAtPos(x, y){
-                    var tasks = groupTask.children;
+    function instancesContainMouse() {
+        var previewInstances = isGroup ? contentItem.children[0].children : contentItem.children;
+        var instancesLength = previewInstances.length;
 
-                    for(var i=0; i<tasks.length; ++i){
-                        var task = tasks[i];
+        for(var i=instancesLength-1; i>=0; --i) {
+            if( (typeof(previewInstances[i].containsMouse) === "function") //ignore unrelevant objects
+                    &&  previewInstances[i].containsMouse())
+                return true;
+        }
 
-                        var choords = contentItem.mapFromItem(task,0, 0);
+        return false;
+    }
 
-                        if(choords.y < 0)
-                            choords.y = 0;
-                        if(choords.x < 0)
-                            choords.x = 0;
+    function instanceAtPos(x, y){
+        var previewInstances = isGroup ? contentItem.children[0].children : contentItem.children;
+        var instancesLength = previewInstances.length;
 
-                        if( (x>=choords.x) && (x<=choords.x+task.width)
-                                && (y>=choords.y) && (y<=choords.y+task.height)){
-                            return task;
-                        }
-                    }
+        for(var i=0; i<instancesLength; ++i){
+            var instance = previewInstances[i];
+            var choords = contentItem.mapFromItem(instance,0, 0);
 
-                    return null;
-                }
+            if(choords.y < 0)
+                choords.y = 0;
+            if(choords.x < 0)
+                choords.x = 0;
+
+            if( (x>=choords.x) && (x<=choords.x+instance.width)
+                    && (y>=choords.y) && (y<=choords.y+instance.height)){
+                return instance;
             }
         }
+        return null;
     }
 }
+
+
diff --git a/plasmoid/package/contents/ui/ToolTipInstance.qml b/plasmoid/package/contents/ui/ToolTipInstance.qml
index 5d039821..dcc1b666 100644
--- a/plasmoid/package/contents/ui/ToolTipInstance.qml
+++ b/plasmoid/package/contents/ui/ToolTipInstance.qml
@@ -1,528 +1,528 @@
 /*
 *   Copyright 2013 by Sebastian Kügler <sebas@kde.org>
 *   Copyright 2014 by Martin Gräßlin <mgraesslin@kde.org>
 *   Copyright 2016 by Kai Uwe Broulik <kde@privat.broulik.de>
 *   Copyright 2017 by Roman Gilg <subdiff@gmail.com>
 *
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU Library General Public License as
 *   published by the Free Software Foundation; either version 2, or
 *   (at your option) any later version.
 *
 *   This program 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 Library General Public License for more details
 *
 *   You should have received a copy of the GNU Library General Public
 *   License along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   51 Franklin Street, Fifth Floor, Boston, MA  2.010-1301, USA.
 */
 
 import QtQuick 2.6
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 import QtQml.Models 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import org.kde.kquickcontrolsaddons 2.0 as KQuickControlsAddons
 
 import org.kde.draganddrop 2.0
 
 import org.kde.taskmanager 0.1 as TaskManager
 
 import org.kde.latte 0.1 as Latte
 
 Column {
     id: instance
-    property var submodelIndex: tasksModel.makeModelIndex(parentIndex, isGroup ? itemIndex : -1)
+    property var submodelIndex
     property int flatIndex: isGroup && itemIndex>=0 ? itemIndex : 0
 
     property bool isActive: (typeof model !== 'undefined') && (typeof model.IsActive !== 'undefined') ? IsActive : false
     property bool isMinimized: (typeof model !== 'undefined') && (typeof model.IsMinimized !== 'undefined') ? IsMinimized : false
 
     property int appPid: (typeof model !== 'undefined') && (typeof model.AppPid !== 'undefined') ? AppPid : -1
     property int itemIndex: (typeof model !== 'undefined') && (typeof model.index !== 'undefined') ? index : 0
     property int virtualDesktop: (typeof model !== 'undefined') && (typeof model.VirtualDesktop !== 'undefined') ? VirtualDesktop : 0
     property var activities : (typeof model !== 'undefined') && (typeof model.Activities !== 'undefined') ? Activities : []
 
     spacing: units.smallSpacing
 
     property string mprisSourceName: mpris2Source.sourceNameForLauncherUrl(toolTipDelegate.launcherUrl, isGroup ? appPid : pidParent)
     property var playerData: mprisSourceName != "" ? mpris2Source.data[mprisSourceName] : 0
     property bool hasPlayer: !!mprisSourceName && !!playerData
     property bool playing: hasPlayer && playerData.PlaybackStatus === "Playing"
     property bool canControl: hasPlayer && playerData.CanControl
     property bool canGoBack: hasPlayer && playerData.CanGoPrevious
     property bool canGoNext: hasPlayer && playerData.CanGoNext
     property bool canRaise: hasPlayer && playerData.CanRaise
     property var currentMetadata: hasPlayer ? playerData.Metadata : ({})
 
     readonly property string track: {
         var xesamTitle = currentMetadata["xesam:title"]
         if (xesamTitle) {
             return xesamTitle;
         }
         // if no track title is given, print out the file name
         var xesamUrl = currentMetadata["xesam:url"] ? currentMetadata["xesam:url"].toString() : ""
         if (!xesamUrl) {
             return "";
         }
         var lastSlashPos = xesamUrl.lastIndexOf('/')
         if (lastSlashPos < 0) {
             return "";
         }
         var lastUrlPart = xesamUrl.substring(lastSlashPos + 1)
         return decodeURIComponent(lastUrlPart);
     }
     readonly property string artist: currentMetadata["xesam:artist"] || ""
     readonly property string albumArt: currentMetadata["mpris:artUrl"] || ""
 
     //
     function containsMouse() {
         return area1.containsMouse || area2.containsMouse || area3.containsMouse || area4.containsMouse;
         //|| ( area5 && area5.containsMouse) || (area6 && area6.containsMouse) || (area7 && area7.containsMouse);
     }
 
     // launcher icon + text labels + close button
     RowLayout {
         id: header
         Layout.minimumWidth: childrenRect.width
         Layout.maximumWidth: Layout.minimumWidth
 
         Layout.minimumHeight: childrenRect.height
         Layout.maximumHeight: Layout.minimumHeight
 
         anchors.horizontalCenter: parent.horizontalCenter
 
         // launcher icon
         PlasmaCore.IconItem {
             Layout.preferredWidth: units.iconSizes.medium
             Layout.preferredHeight: units.iconSizes.medium
             source: icon
             animated: false
             usesPlasmaTheme: false
             visible: !isWin
         }
         // all textlabels
         Column {
             spacing: 0.75 * units.smallSpacing
             PlasmaComponents.Label {
                 width: isWin ? textWidth : undefined
                 height: 1.25 * theme.mSize(theme.defaultFont).height
                 font.pointSize: -1
                 font.pixelSize: height
                 elide: Text.ElideRight
                 text: appName
                 opacity: flatIndex == 0
                 textFormat: Text.PlainText
                 horizontalAlignment: Text.AlignLeft
             }
             // window title
             PlasmaComponents.Label {
                 width: isWin ? textWidth : undefined
                 height: theme.mSize(theme.defaultFont).height
                 font.pointSize: -1
                 font.pixelSize: height
                 elide: Text.ElideRight
                 text: generateTitle()
                 textFormat: Text.PlainText
                 horizontalAlignment: Text.AlignLeft
                 opacity: 0.75
             }
             // subtext
             PlasmaComponents.Label {
                 width: isWin ? textWidth : undefined
                 height: 0.75 * theme.mSize(theme.defaultFont).height
                 font.pointSize: -1
                 font.pixelSize: height
                 elide: Text.ElideRight
                 text: isWin ? generateSubText() : ""
                 textFormat: Text.PlainText
                 horizontalAlignment: Text.AlignLeft
                 opacity: 0.6
                 visible: text !== ""
             }
         }
         // close button
         MouseArea {
             id: area1
             Layout.alignment: Qt.AlignRight | Qt.AlignTop
 
             height: units.iconSizes.smallMedium
             width: height
 
             visible: isWin && !hideCloseButtons
 
             acceptedButtons: Qt.LeftButton
             hoverEnabled: true
             onClicked: {
                 //NOTE: compatibility with plasma 5.8
                 if (backend.cancelHighlightWindows)
                     backend.cancelHighlightWindows()
 
                 tasksModel.requestClose(submodelIndex)
             }
-            onContainsMouseChanged: contentItem.checkMouseInside();
+            onContainsMouseChanged: mainToolTip.mouseIsInside();
 
             PlasmaCore.IconItem {
                 anchors.fill: parent
                 active: parent.containsMouse
 
                 source: "window-close"
                 animated: false
             }
         }
     }
 
     // thumbnail container
     Item {
         id: thumbnail
         width: header.width
         // similar to 0.5625 = 1 / (16:9) as most screens are
         // round necessary, otherwise shadow mask for players has gap!
         height: Math.round(0.5 * width)
         anchors.horizontalCenter: parent.horizontalCenter
 
         visible: isWin
 
         Item {
             id: thumbnailSourceItem
             anchors.fill: parent
             anchors.bottomMargin: 2
 
             readonly property bool isMinimized: isGroup ? instance.isMinimized : mainToolTip.isMinimizedParent
             // TODO: this causes XCB error message when being visible the first time
-            property int winId: isWin && windows[flatIndex] != undefined ? windows[flatIndex] : 0
+            property int winId: isWin && windows[flatIndex] !== undefined ? windows[flatIndex] : 0
 
 
             Loader{
                 id:previewThumbX11Loader
                 anchors.fill: parent
                 active: !Latte.WindowSystem.isPlatformWayland
                 visible: !albumArtImage.visible && !thumbnailSourceItem.isMinimized
 
                 sourceComponent: PlasmaCore.WindowThumbnail {
                     winId: thumbnailSourceItem.winId
                 }
             }
 
             ToolTipWindowMouseArea {
                 id: area2
 
                 anchors.fill: Latte.WindowSystem.isPlatformWayland ? parent : previewThumbX11Loader
                 rootTask: parentTask
                 modelIndex: submodelIndex
                 winId: thumbnailSourceItem.winId
             }
 
             Image {
                 id: albumArtImage
                 // also Image.Loading to prevent loading thumbnails just because the album art takes a split second to load
                 readonly property bool available: status === Image.Ready || status === Image.Loading
 
                 anchors.fill: parent
                 sourceSize: Qt.size(parent.width, parent.height)
                 asynchronous: true
                 source: albumArt
                 fillMode: Image.PreserveAspectCrop
                 visible: available
 
                 ToolTipWindowMouseArea {
                     id: area3
 
                     anchors.fill: parent
                     rootTask: parentTask
                     modelIndex: instance.submodelIndex
                     winId: thumbnailSourceItem.winId
                 }
             }
 
             // when minimized, we don't have a preview, so show the icon
             PlasmaCore.IconItem {
                 anchors.fill: parent
                 source: icon
                 animated: false
                 usesPlasmaTheme: false
                 visible: (thumbnailSourceItem.isMinimized && !albumArtImage.visible) //X11 case
                          || (!previewThumbX11Loader.active && !albumArtImage.visible) //Wayland case
 
                 ToolTipWindowMouseArea {
                     id: area4
 
                     anchors.fill: parent
                     rootTask: parentTask
                     modelIndex: submodelIndex
                     winId: thumbnailSourceItem.winId
                 }
             }
         }
 
 
         Loader {
             anchors.fill: thumbnail
             sourceComponent: hasPlayer ? playerControlsComp : undefined
         }
 
         Component {
             id: playerControlsComp
 
             Item {
                 anchors.fill: parent
 
                 // TODO: When could this really be the case? A not-launcher-task always has a window!?
                 // if there's no window associated with this task, we might still be able to raise the player
                 //                MouseArea {
                 //                    id: raisePlayerArea
                 //                    anchors.fill: parent
 
                 //                    visible: !isWin || !windows[0] && canRaise
                 //                    onClicked: mpris2Source.raise(mprisSourceName)
                 //                }
 
                 Item {
                     id: playerControlsFrostedGlass
                     anchors.fill: parent
                     visible: false // OpacityMask would render it
 
                     Rectangle {
                         width: parent.width
                         height: parent.height - playerControlsRow.height
                         opacity: 0
                     }
 
                     Rectangle {
                         anchors.bottom: parent.bottom
                         width: parent.width
                         height: playerControlsRow.height
                         color: theme.backgroundColor
                         opacity: 0.8
                     }
                 }
 
                 OpacityMask {
                     id: playerControlsOpacityMask
                     anchors.fill: parent
                     source: playerControlsFrostedGlass
                     maskSource: thumbnailSourceItem
                 }
 
                 // prevent accidental click-through when a control is disabled
                 MouseArea {
                     anchors.fill: playerControlsRow
                 }
 
                 RowLayout {
                     id: playerControlsRow
                     anchors {
                         horizontalCenter: parent.horizontalCenter
                         bottom: parent.bottom
                     }
                     width: parent.width
                     spacing: 0
                     enabled: canControl
 
                     ColumnLayout {
                         Layout.fillWidth: true
                         spacing: 0
 
                         PlasmaExtras.Heading {
                             Layout.fillWidth: true
                             level: 4
                             wrapMode: Text.NoWrap
                             elide: Text.ElideRight
                             text: track || ""
                         }
 
                         PlasmaExtras.Heading {
                             Layout.fillWidth: true
                             level: 5
                             wrapMode: Text.NoWrap
                             elide: Text.ElideRight
                             text: artist || ""
                         }
                     }
 
                     MouseArea {
                         id: area5
 
                         height: units.iconSizes.smallMedium
                         width: height
                         enabled: canGoBack
 
                         acceptedButtons: Qt.LeftButton
                         hoverEnabled: true
                         onClicked: mpris2Source.goPrevious(mprisSourceName)
-                        onContainsMouseChanged: contentItem.checkMouseInside();
+                        onContainsMouseChanged: mainToolTip.mouseIsInside();
 
                         PlasmaCore.IconItem {
                             anchors.fill: parent
                             enabled: canGoBack
                             active: parent.containsMouse
 
                             source: LayoutMirroring.enabled ? "media-skip-forward" : "media-skip-backward"
                             animated: false
                         }
                     }
 
                     MouseArea {
                         id: area6
 
                         height: units.iconSizes.medium
                         width: height
 
                         acceptedButtons: Qt.LeftButton
                         hoverEnabled: true
                         onClicked: mpris2Source.playPause(mprisSourceName)
-                        onContainsMouseChanged: contentItem.checkMouseInside();
+                        onContainsMouseChanged: mainToolTip.mouseIsInside();
 
                         PlasmaCore.IconItem {
                             anchors.fill: parent
                             active: parent.containsMouse
 
                             source: playing ? "media-playback-pause" : "media-playback-start"
                             animated: false
                         }
                     }
 
                     MouseArea {
                         id: area7
 
                         height: units.iconSizes.smallMedium
                         width: height
                         enabled: canGoNext
 
                         acceptedButtons: Qt.LeftButton
                         hoverEnabled: true
                         onClicked: mpris2Source.goNext(mprisSourceName)
-                        onContainsMouseChanged: contentItem.checkMouseInside();
+                        onContainsMouseChanged: mainToolTip.mouseIsInside();
 
                         PlasmaCore.IconItem {
                             anchors.fill: parent
                             enabled: canGoNext
                             active: parent.containsMouse
 
                             source: LayoutMirroring.enabled ? "media-skip-backward" : "media-skip-forward"
                             animated: false
                         }
                     }
                 }
             }
         }
 
         //active window line
         Rectangle{
             width: parent.width
             height: 2
             color: theme.buttonFocusColor
             anchors.bottom: parent.bottom
             visible: isGroup ? isActive : (parentTask ? parentTask.isActive : false)
         }
     }
 
     function generateTitle() {
         if (!isWin) {
             return genericName != undefined ? genericName : "";
         }
 
         var text;
         var modelExists = (typeof model !== 'undefined');
 
         if (isGroup && modelExists) {
             if (model.display === undefined) {
                 return "";
             }
             text = model.display.toString();
         } else {
             text = displayParent;
         }
 
         // KWin appends increasing integers in between pointy brackets to otherwise equal window titles.
         // In this case save <#number> as counter and delete it at the end of text.
         var counter = text.match(/<\d+>\W*$/);
         text = text.replace(/\s*<\d+>\W*$/, "");
 
         // Remove appName from the end of text.
         var appNameRegex = new RegExp(appName + "$", "i");
         text = text.replace(appNameRegex, "");
         text = text.replace(/\s*(?:-|—)*\s*$/, "");
 
         // Add counter back at the end.
-        if (counter != null) {
-            if (text == "") {
+        if (counter !== null) {
+            if (text === "") {
                 text = counter;
             } else {
                 text = text + " " + counter;
             }
         }
 
         // In case the window title had only redundant informations (i.e. appName), text is now empty.
         // Add a hyphen to indicate that and avoid empty space.
-        if (text == "") {
+        if (text === "") {
             text = "—";
         }
         return text.toString();
     }
 
     function generateSubText() {
-        if (activitiesParent == undefined) {
+        if (activitiesParent === undefined) {
             return "";
         }
 
         var subTextEntries = [];
 
         var vd = isGroup ? virtualDesktop : virtualDesktopParent;
 
         if (!plasmoid.configuration.showOnlyCurrentDesktop
                 && virtualDesktopInfo.numberOfDesktops > 1
                 && (isGroup ? IsOnAllVirtualDesktops : isOnAllVirtualDesktopsParent) !== true
-                && vd != -1
-                && vd != undefined
-                && virtualDesktopInfo.desktopNames[vd - 1] != undefined) {
+                && vd !== -1
+                && vd !== undefined
+                && virtualDesktopInfo.desktopNames[vd - 1] !== undefined) {
             subTextEntries.push(i18n("On %1", virtualDesktopInfo.desktopNames[vd - 1]));
         }
 
         var act = isGroup ? activities : activitiesParent;
 
         if (act === undefined) {
             return subTextEntries.join("\n");
         }
 
-        if (act.length == 0 && activityInfo.numberOfRunningActivities > 1) {
+        if (act.length === 0 && activityInfo.numberOfRunningActivities > 1) {
             subTextEntries.push(i18nc("Which virtual desktop a window is currently on",
                                       "Available on all activities"));
         } else if (act.length > 0) {
             var activityNames = [];
 
             for (var i = 0; i < act.length; i++) {
                 var activity = act[i];
                 var activityName = activityInfo.activityName(act[i]);
-                if (activityName == "") {
+                if (activityName === "") {
                     continue;
                 }
                 if (plasmoid.configuration.showOnlyCurrentActivity) {
-                    if (activity != activityInfo.currentActivity) {
+                    if (activity !== activityInfo.currentActivity) {
                         activityNames.push(activityName);
                     }
-                } else if (activity != activityInfo.currentActivity) {
+                } else if (activity !== activityInfo.currentActivity) {
                     activityNames.push(activityName);
                 }
             }
 
             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");
     }
 }
diff --git a/plasmoid/package/contents/ui/ToolTipWindowMouseArea.qml b/plasmoid/package/contents/ui/ToolTipWindowMouseArea.qml
index c77dc0f4..6a75e981 100644
--- a/plasmoid/package/contents/ui/ToolTipWindowMouseArea.qml
+++ b/plasmoid/package/contents/ui/ToolTipWindowMouseArea.qml
@@ -1,53 +1,52 @@
 /*
 *  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.components 2.0 as PlasmaComponents
 
 import org.kde.latte 0.1 as Latte
 
 MouseArea {
     property var modelIndex
     property int winId // FIXME Legacy
     property Item rootTask
 
     acceptedButtons: Qt.LeftButton | Qt.RightButton
     hoverEnabled: true
     enabled: Latte.WindowSystem.isPlatformWayland ||
              (!Latte.WindowSystem.isPlatformWayland && winId != 0)
 
     onClicked: {
         if (mouse.button == Qt.LeftButton) {
             tasksModel.requestActivate(modelIndex);
         } else {
             root.createContextMenu(rootTask, modelIndex).show();
         }
         icList.hoveredIndex = -1;
-        windowsPreviewDlg.hide();
-        //rootTask.hideToolTipTemporarily();
+        windowsPreviewDlg.hide("7.1");
     }
 
     onContainsMouseChanged: {
-        contentItem.checkMouseInside();
+        mainToolTip.mouseIsInside();
         root.windowsHovered([winId], containsMouse);
     }
 }
 
diff --git a/plasmoid/package/contents/ui/main.qml b/plasmoid/package/contents/ui/main.qml
index 6e2c8c1e..51830cd2 100644
--- a/plasmoid/package/contents/ui/main.qml
+++ b/plasmoid/package/contents/ui/main.qml
@@ -1,1944 +1,1938 @@
 /*
 *  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.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 0.1 as Latte
 
 import "task" as Task
 import "../code/tools.js" as TaskTools
 import "../code/activitiesTools.js" as ActivitiesTools
 
 Item {
     id:root
 
     // Layout.fillHeight: userPanelPosition === 0 ? true : false
     // Layout.fillWidth: userPanelPosition === 0 ? true : false
 
     ///IMPORTANT: These values must be tested when the Now Dock Panel support
     ///also the four new anchors. A small issue is shown between the animation
     /// of the now dock plasmoid and the neighbour widgets...
     Layout.minimumWidth: (userPanelPosition !== 0)&&(!latteDock) ? clearWidth : -1
     Layout.minimumHeight: (userPanelPosition !== 0)&&(!latteDock) ? clearHeight : -1
     Layout.preferredWidth: (userPanelPosition !== 0)&&(!latteDock) ? tasksWidth : -1
     Layout.preferredHeight: (userPanelPosition !== 0)&&(!latteDock) ? tasksHeight : -1
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.vertical
     LayoutMirroring.childrenInherit: true
 
     property bool debugLocation: false
 
     //it is used to check both the applet and the containment for direct render
     property bool globalDirectRender: latteDock ? latteDock.globalDirectRender : icList.directRender
 
     property bool editMode: latteDock ? latteDock.editMode : plasmoid.userConfiguring
     property bool disableRestoreZoom: false //blocks restore animation in rightClick
     property bool disableAllWindowsFunctionality: root.showWindowsOnlyFromLaunchers && root.activeIndicator === Latte.Dock.NoneIndicator
     property bool dropNewLauncher: false
     readonly property bool hasInternalSeparator: parabolicManager.hasInternalSeparator
     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 showTasksNumbers: false
     property int tasksNumbersBase: 0
     property bool useThemePanel: plasmoid.configuration.useThemePanel
     property bool taskInAnimation: noTasksInAnimation > 0 ? true : false
     property bool transparentPanel: plasmoid.configuration.transparentPanel
     property bool vertical: ((root.position === PlasmaCore.Types.LeftPositioned) ||
                              (root.position === PlasmaCore.Types.RightPositioned)) ? true : false
 
     property int clearWidth
     property int clearHeight
 
     property int newLocationDebugUse: PlasmaCore.Types.BottomPositioned
     property int newDroppedPosition: -1
     property int noInitCreatedBuffers: 0
     property int noTasksInAnimation: 0
     property int themePanelSize: plasmoid.configuration.panelSize
 
     property int position : PlasmaCore.Types.BottomPositioned
     property int tasksStarting: 0
     property int realSize: iconSize + iconMargin
 
     ///Dont use Math.floor it adds one pixel in animations and creates glitches
     property int widthMargins: root.vertical ? thickMargin : iconMargin
     property int heightMargins: !root.vertical ? thickMargin : iconMargin
 
 
     // formula for luminance according to:
     // https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
     property real textColorRs: {
         var color = theme.textColor.r;
         if (color <= 0.03928) {
             return color / 12.92;
         } else {
             return Math.pow( ((color + 0.055) / 1.055), 2.4 );
         }
     }
 
     property real textColorGs: {
         var color = theme.textColor.g;
         if (color <= 0.03928) {
             return color / 12.92;
         } else {
             return Math.pow( ((color + 0.055) / 1.055), 2.4 );
         }
     }
 
     property real textColorBs: {
         var color = theme.textColor.b;
         if (color <= 0.03928) {
             return color / 12.92;
         } else {
             return Math.pow( ((color + 0.055) / 1.055), 2.4 );
         }
     }
 
     property real textColorLuma: 0.2126*textColorRs + 0.7152*textColorGs + 0.0722*textColorBs
     property color minimizedDotColor: {
         if (latteDock) {
             return latteDock.minimizedDotColor;
         }
 
         return textColorLuma > 0.6 ? Qt.darker(theme.textColor, 1.7) : Qt.lighter(theme.textColor, 7)
     }
 
     //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: []
     property variant waitingLaunchers: []
 
     //! launchers that are shown after a window removal and must be shown
     //! immediately because they are already present!
     property variant immediateLaunchers: []
 
     //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
 
 
     //separator calculations based on audoban's design
     property int maxSeparatorLength: {
         if (root.vertical)
             return 5 + heightMargins;
         else
             return 5 + widthMargins;
     }
 
     property real missingSeparatorLength: {
         if (!root.isVertical)
             return ((iconSize + widthMargins) * zoomFactor) - maxSeparatorLength;
         else
             return ((iconSize + heightMargins) * zoomFactor) - maxSeparatorLength;
     }
 
 
     //! it is used to play the animation correct when the user removes a launcher
     property string launcherForRemoval: ""
 
     //BEGIN Latte Dock properties
     property bool dockIsShownCompletely: latteDock ? latteDock.dockIsShownCompletely : true
     property bool enableShadows: latteDock ? latteDock.enableShadows > 0 : plasmoid.configuration.showShadows
     property bool forceHidePanel: false
     property bool directRenderDelayerIsRunning: latteDock ? latteDock.directRenderDelayerIsRunning : directRenderDelayerForEnteringTimer.running
     property bool disableLeftSpacer: false
     property bool disableRightSpacer: false
     property bool dockIsHidden: latteDock ? latteDock.dockIsHidden : false
     property bool groupTasksByDefault: latteDock ? latteDock.groupTasksByDefault: true
     property bool highlightWindows: latteDock ? latteDock.highlightWindows: plasmoid.configuration.highlightWindows
     property bool indicateAudioStreams: latteDock ? latteDock.indicateAudioStreams : plasmoid.configuration.indicateAudioStreams
     property bool mouseWheelActions: latteDock ? latteDock.mouseWheelActions : true
     property bool reverseLinesPosition: latteDock ? latteDock.reverseLinesPosition : plasmoid.configuration.reverseLinesPosition
     property bool dotsOnActive: latteDock ? latteDock.dotsOnActive : plasmoid.configuration.dotsOnActive
     property bool showGlow: latteDock ? latteDock.showGlow : plasmoid.configuration.showGlow
     property bool glow3D: latteDock ? latteDock.glow3D : false
     property bool showOnlyCurrentScreen: latteDock ? latteDock.showOnlyCurrentScreen : plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: latteDock ? latteDock.showOnlyCurrentDesktop : plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: latteDock ? latteDock.showOnlyCurrentActivity : plasmoid.configuration.showOnlyCurrentActivity
     property bool showPreviews:  latteDock ? latteDock.showToolTips : plasmoid.configuration.showToolTips
     property bool showWindowActions: latteDock ? latteDock.showWindowActions : plasmoid.configuration.showWindowActions
     property bool showWindowsOnlyFromLaunchers: latteDock ? latteDock.showWindowsOnlyFromLaunchers : false
     property bool smartLaunchersEnabled: latteDock ? latteDock.smartLaunchersEnabled : plasmoid.configuration.smartLaunchersEnabled
     property bool threeColorsWindows: latteDock ? latteDock.threeColorsWindows : plasmoid.configuration.threeColorsWindows
     property bool titleTooltips: latteDock ? latteDock.titleTooltips : false
     property alias windowPreviewIsShown: windowsPreviewDlg.visible
 
     property int activeIndicator: latteDock ? latteDock.activeIndicator : Latte.Dock.AllIndicator
     property int activeIndicatorType: latteDock ? latteDock.activeIndicatorType : Latte.Dock.LineIndicator
     property int animationStep: latteDock ? latteDock.animationStep : 1
     property int directRenderAnimationTime: latteDock ? latteDock.directRenderAnimationTime : 0
     property int dockHoveredIndex : latteDock ? latteDock.hoveredIndex : -1
     property int iconMargin: latteDock ? latteDock.iconMargin : 0.12*iconSize
     property int iconSize: latteDock ? latteDock.iconSize : Math.max(plasmoid.configuration.iconSize, 16)
     property int glowOption: latteDock ? latteDock.glowOption : Latte.Dock.GlowAll
     property real glowOpacity: latteDock ? latteDock.glowOpacity : 0.35
 
     property int middleClickAction: latteDock ? latteDock.middleClickAction : plasmoid.configuration.middleClickAction
     property int modifier: latteDock ? latteDock.modifier : -1
     property int modifierClickAction: latteDock ? latteDock.modifierClickAction : -1
     property int modifierClick: latteDock ? latteDock.modifierClick : -1
     property int modifierQt:{
         if (modifier === Latte.Dock.Shift)
             return Qt.ShiftModifier;
         else if (modifier === Latte.Dock.Ctrl)
             return Qt.ControlModifier;
         else if (modifier === Latte.Dock.Alt)
             return Qt.AltModifier;
         else if (modifier === Latte.Dock.Meta)
             return Qt.MetaModifier;
         else return -1;
     }
 
     //decouple iconMargin which now is used only for length calculations with thickMargins
     //which are used for thickness calculations
     property int thickMarginBase: latteDock ? latteDock.thickMarginBase : Math.ceil(iconMargin/2)
     property int thickMarginHigh: latteDock ? latteDock.thickMarginHigh : Math.ceil(iconMargin/2)
     property int thickMargin: thickMarginBase + thickMarginHigh
 
     property int statesLineSize: latteDock ? latteDock.statesLineSize : Math.ceil( root.iconSize/13 )
     property int tasksHeight: mouseHandler.height
     property int tasksWidth: mouseHandler.width
     property int userPanelPosition: latteDock ? latteDock.panelAlignment : plasmoid.configuration.plasmoidPosition
 
     property real durationTime: latteDock ? latteDock.durationTime : plasmoid.configuration.durationTime
     property real zoomFactor: latteDock ? latteDock.zoomFactor : ( 1 + (plasmoid.configuration.zoomLevel / 20) )
 
     property int appShadowSize: latteDock ? latteDock.appShadowSize : Math.ceil(0.12*iconSize)
     property string appShadowColor: latteDock ? latteDock.appShadowColor : "#ff080808"
     property string appShadowColorSolid: latteDock ? latteDock.appShadowColorSolid : "#ff080808"
 
     property alias tasksCount: tasksModel.count
     property alias hoveredIndex: icList.hoveredIndex
 
     property QtObject currentLayout : latteDock && latteDock.dockManagedLayout ? latteDock.dockManagedLayout : null
     property var managedLayoutName: currentLayout ? currentLayout.name : ""
 
     property Item latteDock: null
     //END Now Dock Panel properties
 
 
     Plasmoid.preferredRepresentation: Plasmoid.fullRepresentation
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     signal clearZoomSignal();
     signal draggingFinished();
     signal hiddenTasksUpdated();
     signal launchersUpdatedFor(string launcher);
     signal presentWindows(variant winIds);
     signal requestLayout;
     signal separatorsUpdated();
     signal signalActionsBlockHiding(int value);
     signal signalAnimationsNeedBothAxis(int value);
     signal signalAnimationsNeedLength(int value);
     signal signalAnimationsNeedThickness(int value);
     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 waitingLauncherRemoved(string launch);
     signal windowsHovered(variant winIds, bool hovered)
 
     //onAnimationsChanged: console.log(animations);
     /* Rectangle{
                 anchors.fill: parent
                 border.width: 1
                 border.color: "red"
                 color: "white"
             } */
     onLatteDockChanged: {
         if (latteDock)
             plasmoid.configuration.isInLatteDock = true;
         else
             plasmoid.configuration.isInLatteDock = false;
     }
 
 
     Connections {
         target: plasmoid
         onLocationChanged: {
             root.updatePosition();
             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: latteDock
         onDockIsHiddenChanged:{
             if (latteDock.dockIsHidden) {
                 windowsPreviewDlg.hide("3.3");
             }
         }
 
         onLaunchersGroupChanged:{
             if( latteDock && latteDock.editMode) {
                 tasksModel.updateLaunchersList();
             }
         }
     }
 
 
     Connections{
         target: latteDock && latteDock.universalLayoutManager ? latteDock.universalLayoutManager : null
 
         onCurrentLayoutNameChanged: root.publishTasksGeometries();
     }
 
     Connections{
         target: icList
 
         onHoveredIndexChanged:{
             if (latteDock && icList.hoveredIndex>-1){
                 latteDock.setHoveredIndex(-1);
             }
         }
     }
 
 
     /////
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
     /////
 
     function initializeHoveredIndex() {
         icList.hoveredIndex = -1;
         icList.currentSpot = -1000;
     }
 
     function launchersDropped(urls){
         mouseHandler.urlsDroppedOnArea(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;
     }
 
     /// waiting launchers... this is used in order to check
     /// a window or startup if its launcher is playing its animation
     function addWaitingLauncher(launch){
         for(var i=0; i<waitingLaunchers.length; ++i){
             if (waitingLaunchers[i]===launch) {
                 return;
             }
         }
 
         waitingLaunchers.push(launch);
     }
 
     function removeWaitingLauncher(launch){
         for(var i=0; i<waitingLaunchers.length; ++i){
             if (waitingLaunchers[i]===launch) {
                 waitingLaunchers.splice(i,1);
                 waitingLauncherRemoved(launch);
                 return;
             }
         }
     }
 
     function waitingLauncherExists(launch){
         for(var i=0; i<waitingLaunchers.length; ++i){
             if (waitingLaunchers[i]===launch) {
                 return true;
             }
         }
 
         return false;
     }
 
     //! ImmediateLaunchers
     function addImmediateLauncher(launch){
         if (!immediateLauncherExists(launch)) {
             //console.log("Immediate Launcher Added::: "+launch);
             immediateLaunchers.push(launch);
         }
     }
 
     function removeImmediateLauncher(launch){
         for(var i=0; i<immediateLaunchers.length; ++i){
             if (immediateLaunchers[i]===launch) {
                 immediateLaunchers.splice(i,1);
                 //console.log("Immediate Launcher Removed::: "+launch);
                 return;
             }
         }
     }
 
     function immediateLauncherExists(launch){
         for(var i=0; i<immediateLaunchers.length; ++i){
             if (immediateLaunchers[i]===launch) {
                 return true;
             }
         }
 
         return false;
     }
 
     //!
 
     function hidePreview(){
         windowsPreviewDlg.hide(11);
     }
 
     onDragSourceChanged: {
         if (dragSource == null) {
             restoreDraggingPhaseTimer.start();
             root.draggingFinished();
             root.signalActionsBlockHiding(-1);
 
             tasksModel.syncLaunchers();
         } else {
             inDraggingPhase = true;
             root.signalActionsBlockHiding(1);
         }
     }
 
     /////Window previews///////////
 
     ToolTipDelegate2 {
         id: toolTipDelegate
         visible: false
     }
 
     ////BEGIN interfaces
 
     PlasmaCore.Dialog{
         id: windowsPreviewDlg
         // hideOnWindowDeactivate: false
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: plasmoid.location
         mainItem: toolTipDelegate
         visible: false
 
         property bool contextMenu: false
         property bool signalSent: false
         property Item activeItem: null
 
         onVisibleChanged: {
             if (visible) {
                 windowsPreviewCheckerToNotShowTimer.start();
             }
         }
 
         function hide(debug){
-            //console.log("on hide previews event called: "+debug);
+          //  console.log("on hide previews event called: "+debug);
 
             if (latteDock && signalSent) {
                 //it is used to unblock dock hiding
                 root.signalActionsBlockHiding(-1);
                 signalSent = false;
                 //root.signalDraggingState(false);
             }
 
             windowsPreviewDlg.activeItem = null;
 
-            toolTipDelegate.containsMouse = false;
-            toolTipDelegate.parentTask = null;
-            toolTipDelegate.parentIndex = -1;
-            toolTipDelegate.windows = [];
-            toolTipDelegate.isGroup = false;
-
             if (!contextMenu)
                 root.disableRestoreZoom = false;
 
             visible = false;
         }
 
         function show(taskItem){
             if (root.disableAllWindowsFunctionality) {
                 return;
             }
 
-            //console.log("preview show called...");
+          //  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();
                 }
 
                 //used to initialize windows previews buffers from task to task
                 if (!Latte.WindowSystem.isPlatformWayland) {
                     visible = false;
                 }
                 activeItem = taskItem;
                 toolTipDelegate.parentTask = taskItem;
 
                 if (latteDock && !signalSent) {
                     //it is used to block dock hiding
                     root.signalActionsBlockHiding(1);
                     signalSent = true;
                     //root.signalDraggingState(true);
                 }
 
                 if (!Latte.WindowSystem.isPlatformWayland) {
                     showPreviewWinTimer.start();
                 } else {
                     visible = true;
                 }
             }
         }
     }
 
     //! I cant find another way to fix the issue with window thumbnails
     //! there are many cases that not correct previews are shown are
     //! no previews in cases that they should (X11 related)
     Timer {
         id: showPreviewWinTimer
         interval: 50
         onTriggered: {
             windowsPreviewDlg.visible = true;
 
             if (latteDock && latteDock.debugModeTimers) {
                 console.log("plasmoid timer: showPreviewTimer called...");
             }
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown
     Timer {
         id: windowsPreviewCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (windowsPreviewDlg.visible && root.contextMenu) {
                 windowsPreviewDlg.hide();
             }
         }
     }
 
     //! 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 * (root.durationTime * units.shortDuration)
 
         property var modelIndex
 
         onTriggered: {
             tasksModel.requestClose(delayWindowRemovalTimer.modelIndex)
 
             if (latteDock && latteDock.debugModeTimers) {
                 console.log("plasmoid timer: delayWindowRemovalTimer called...");
             }
         }
     }
 
     Timer {
         id: activityChangeDelayer
         interval: 150
         onTriggered: {
             root.inActivityChange = false;
             activityInfo.previousActivity = activityInfo.currentActivity;
 
             if (latteDock && latteDock.debugModeTimers) {
                 console.log("plasmoid timer: activityChangeDelayer called...");
             }
         }
     }
 
     /////Window Previews/////////
 
 
     property bool loadLaunchersFirstTime: false;
 
     onCurrentLayoutChanged: {
         if (currentLayout && !loadLaunchersFirstTime) {
             tasksModel.updateLaunchersList();
             loadLaunchersFirstTime = true;
         }
     }
 
     TaskManager.TasksModel {
         id: tasksModel
 
         virtualDesktop: virtualDesktopInfo.currentDesktop
         screenGeometry: latteDock ? latteDock.screenGeometry : plasmoid.screenGeometry
         // comment in order to support LTS Plasma 5.8
         // screen: plasmoid.screen
         activity: activityInfo.currentActivity
 
         filterByVirtualDesktop: root.showOnlyCurrentDesktop
         filterByScreen: root.showOnlyCurrentScreen
         filterByActivity: root.showOnlyCurrentActivity
 
         launchInPlace: true
         separateLaunchers: true
         groupInline: false
 
         groupMode: groupTasksByDefault ? TaskManager.TasksModel.GroupApplications : TaskManager.TasksModel.GroupDisabled
         sortMode: TaskManager.TasksModel.SortManual
 
         function updateLaunchersList(){
             if (latteDock.universalSettings
                     && (latteDock.launchersGroup === Latte.Dock.LayoutLaunchers
                         || latteDock.launchersGroup === Latte.Dock.GlobalLaunchers)) {
                 if (latteDock.launchersGroup === Latte.Dock.LayoutLaunchers) {
                     tasksModel.launcherList = latteDock.dockManagedLayout.launchers;
                 } else if (latteDock.launchersGroup === Latte.Dock.GlobalLaunchers) {
                     tasksModel.launcherList = latteDock.universalSettings.launchers;
                 }
             } else {
                 tasksModel.launcherList = plasmoid.configuration.launchers59;
             }
         }
 
         onActivityChanged: {
             ActivitiesTools.currentActivity = String(activity);
         }
 
         onLauncherListChanged: {
             if (currentLayout) {
                 if (latteDock && latteDock.universalLayoutManager
                         && latteDock.dockManagedLayout && latteDock.universalSettings
                         && (latteDock.launchersGroup === Latte.Dock.LayoutLaunchers
                             || latteDock.launchersGroup === Latte.Dock.GlobalLaunchers)) {
 
                     if (latteDock.launchersGroup === Latte.Dock.LayoutLaunchers) {
                         latteDock.dockManagedLayout.launchers = launcherList;
                     } else if (latteDock.launchersGroup === Latte.Dock.GlobalLaunchers) {
                         latteDock.universalSettings.launchers = launcherList;
                     }
                 } else {
                     plasmoid.configuration.launchers59 = launcherList;
                 }
             } else {
                 plasmoid.configuration.launchers59 = launcherList;
             }
         }
 
         onGroupingAppIdBlacklistChanged: {
             plasmoid.configuration.groupingAppIdBlacklist = groupingAppIdBlacklist;
         }
 
         onGroupingLauncherUrlBlacklistChanged: {
             plasmoid.configuration.groupingLauncherUrlBlacklist = groupingLauncherUrlBlacklist;
         }
 
         onAnyTaskDemandsAttentionChanged: {
             if (anyTaskDemandsAttention){
                 plasmoid.status = PlasmaCore.Types.RequiresAttentionStatus;
                 attentionTimerComponent.createObject(root);
             }
         }
 
 
         Component.onCompleted: {
             ActivitiesTools.launchersOnActivities = root.launchersOnActivities
             ActivitiesTools.currentActivity = String(activityInfo.currentActivity);
             ActivitiesTools.plasmoid = plasmoid;
 
             //var loadedLaunchers = ActivitiesTools.restoreLaunchers();
             ActivitiesTools.importLaunchersToNewArchitecture();
 
             if (currentLayout && latteDock.universalSettings
                     && (latteDock.launchersGroup === Latte.Dock.LayoutLaunchers
                         || latteDock.launchersGroup === Latte.Dock.GlobalLaunchers)) {
 
                 if (latteDock.launchersGroup === Latte.Dock.LayoutLaunchers) {
                     launcherList = latteDock.dockManagedLayout.launchers;
                 } else if (latteDock.launchersGroup === Latte.Dock.GlobalLaunchers) {
                     launcherList = latteDock.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 (Latte.WindowSystem.plasmaDesktopVersion >= Latte.WindowSystem.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: plasmoid.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 (Latte.WindowSystem.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 || sourceData.DesktopEntry !== desktopFileName) {
                     continue;
                 }
 
                 if (pid === undefined || 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 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.indicateAudioStreams
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     /*  IconsModel{
         id: iconsmdl
     }*/
 
     Component{
         id: attentionTimerComponent
         Timer{
             id: attentionTimer
             interval:8500
             onTriggered: {
                 plasmoid.status = PlasmaCore.Types.PassiveStatus;
                 destroy();
 
                 if (latteDock && latteDock.debugModeTimers) {
                     console.log("plasmoid timer: attentionTimer called...");
                 }
             }
             Component.onCompleted: {
                 start();
             }
         }
     }
 
     //Timer to check if the mouse is still inside the ListView
     //IMPORTANT ::: This timer should be used only when the Latte plasmoid
     //is not inside a Latte dock
     Timer{
         id:checkListHovered
         repeat:false;
         interval: 120
 
         property int normalInterval: Math.max(120, 2 * (root.durationTime * 1.2 * units.shortDuration) + 50)
 
         onTriggered: {
             if(root.latteDock)
                 console.log("Plasmoid, checkListHoveredTimer was called, even though it shouldnt...");
 
             if (!root.containsMouse()) {
 
                 icList.directRender = false;
 
                 root.clearZoom();
             }
 
             interval = normalInterval;
 
             if (latteDock && latteDock.debugModeTimers) {
                 console.log("plasmoid timer: checkListHovered called...");
             }
         }
 
         function startNormal(){
             interval = normalInterval;
 
             start();
         }
 
         function startDuration( duration){
             interval = duration;
 
             start();
         }
     }
 
     //! Delayer in order to not activate directRendering when the mouse
     //! enters until the timer has ended. This way we make sure that the
     //! zoom-in animations will have ended.
     Timer{
         id:directRenderDelayerForEnteringTimer
         interval: 3.2 * root.durationTime * units.shortDuration
     }
 
     //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 annimations
     Rectangle{
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: root.vertical ? 1 : 2 * root.iconSize
         height: root.vertical ? 2 * root.iconSize : 1
         color: "red"
         x: (root.position === PlasmaCore.Types.LeftPositioned) ? neededSpace : parent.width - neededSpace
         y: (root.position === PlasmaCore.Types.TopPositioned) ? neededSpace : parent.height - neededSpace
 
         visible: plasmoid.configuration.zoomHelper
 
         property int neededSpace: zoomFactor*(iconSize+iconMargin) + statesLineSize
     }
 
     Item{
         id:barLine
 
         /*    anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? parent.bottom : undefined
         anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? parent.top : undefined
         anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? parent.left : undefined
         anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? parent.right : undefined
 
         anchors.horizontalCenter: !parent.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: parent.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: root.iconSize / 2
         property int smallSize: Math.max(3.7*root.statesLineSize, 16)
 
         Behavior on opacity{
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
 
         /// 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: root.durationTime*units.longDuration }
             }
         }
 
 
         /// item which is used as anchors for the plasma's theme
         Item{
             id:belower
 
             width: (root.position === PlasmaCore.Types.LeftPositioned) ? shadowsSvgItem.margins.left : shadowsSvgItem.margins.right
             height: (root.position === PlasmaCore.Types.BottomPositioned)? shadowsSvgItem.margins.bottom : shadowsSvgItem.margins.top
 
             anchors.top: (root.position === PlasmaCore.Types.BottomPositioned) ? parent.bottom : undefined
             anchors.bottom: (root.position === PlasmaCore.Types.TopPositioned) ? parent.top : undefined
             anchors.right: (root.position === PlasmaCore.Types.LeftPositioned) ? parent.left : undefined
             anchors.left: (root.position === PlasmaCore.Types.RightPositioned) ? parent.right : undefined
         }
 
 
         /// the current theme's panel
         PlasmaCore.FrameSvgItem{
             id: shadowsSvgItem
 
             anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? belower.bottom : undefined
             anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? belower.top : undefined
             anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? belower.left : undefined
             anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? 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.position === PlasmaCore.Types.BottomPositioned) ||
                                      (root.position === PlasmaCore.Types.TopPositioned)) ?
                                         plasmoid.configuration.panelSize + belower.height:
                                         plasmoid.configuration.panelSize + belower.width
 
             Behavior on opacity{
                 NumberAnimation { duration: root.durationTime*units.longDuration }
             }
 
 
             PlasmaCore.FrameSvgItem{
                 anchors.margins: belower.width-1
                 anchors.fill:parent
                 imagePath: plasmoid.configuration.transparentPanel ? "translucent/widgets/panel-background" :
                                                                      "widgets/panel-background"
             }
         }
 
 
         MouseHandler {
             id: mouseHandler
             anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? icList.bottom : undefined
             anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? icList.top : undefined
             anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? icList.left : undefined
             anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? icList.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? icList.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? icList.verticalCenter : undefined
 
             width: root.vertical ? maxSize : icList.width
             height: root.vertical ? icList.height : maxSize
 
             target: icList
 
             property int maxSize: (((root.hoveredIndex>=0 || dockHoveredIndex>=0 ) || windowPreviewIsShown) && !root.dragSource) ?
                                       root.statesLineSize + root.zoomFactor * (root.iconSize + root.thickMargin) :
                                       root.statesLineSize + root.iconSize + root.thickMargin
 
             function urlsDroppedOnArea(urls){
                 // If all dropped URLs point to application desktop files, we'll add a launcher for each of them.
                 var createLaunchers = urls.every(function (item) {
                     return backend.isApplication(item)
                 });
 
                 if (createLaunchers) {
                     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: {
                 if (latteDock && latteDock.launchersGroup >= Latte.Dock.LayoutLaunchers) {
                     latteDock.universalLayoutManager.launchersSignals.urlsDropped(root.managedLayoutName,
                                                                                   latteDock.launchersGroup, urls);
                 } else {
                     urlsDroppedOnArea(urls);
                 }
             }
         }
 
 
         ListView {
             id:icList
             boundsBehavior: Flickable.StopAtBounds
 
             property int currentSpot : -1000
             property int hoveredIndex : -1
             property int previousCount : 0
 
             property int tasksCount: tasksModel.count
 
             property bool directRender: false
 
             //   onTasksCountChanged: updateImplicits();
 
             //  property int count: children ? children.length : 0
             /*   anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? parent.bottom : undefined
             anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? parent.top : undefined
             anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? parent.left : undefined
             anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? 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
 
             orientation: Qt.Horizontal
 
             delegate: Task.TaskDelegate{}
 
             /* Rectangle{
                 anchors.fill: parent
                 border.width: 1
                 border.color: "red"
                 color: "transparent"
             } */
 
             //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: root.durationTime*units.longDuration; 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==="TaskDelegate") && (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;
             }
         }
 
         Task.VisualAddItem{
             id: newDroppedLauncherVisual
             anchors.fill: mouseHandler
 
             visible: opacity == 0 ? false : true
             opacity: root.dropNewLauncher && mouseHandler.onlyLaunchers && (root.dragSource == null)? 1 : 0
         }
     }
 
     //// helpers
 
     Timer {
         id: iconGeometryTimer
         // INVESTIGATE: such big interval but unfortunately it doesnot work otherwise
         interval: 500
         repeat: false
 
         onTriggered: {
             root.publishTasksGeometries();
 
             if (latteDock && latteDock.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 ---------");
             }*/
         }
     }
 
     /////////
 
     //// functions
     function movePanel(obj, newPosition){
         var bLine = obj;
         if (newPosition === PlasmaCore.Types.BottomPositioned){
             bLine.anchors.horizontalCenter = bLine.parent.horizontalCenter;
             bLine.anchors.verticalCenter = undefined;
             bLine.anchors.bottom = bLine.parent.bottom;
             bLine.anchors.top = undefined;
             bLine.anchors.left = undefined;
             bLine.anchors.right = undefined;
         }
         else if (newPosition === PlasmaCore.Types.TopPositioned){
             bLine.anchors.horizontalCenter = bLine.parent.horizontalCenter;
             bLine.anchors.verticalCenter = undefined;
             bLine.anchors.bottom = undefined;
             bLine.anchors.top = bLine.parent.top;
             bLine.anchors.left = undefined;
             bLine.anchors.right = undefined;
         }
         else if (newPosition === PlasmaCore.Types.LeftPositioned){
             bLine.anchors.horizontalCenter = undefined;
             bLine.anchors.verticalCenter = bLine.parent.verticalCenter;
             bLine.anchors.bottom = undefined;
             bLine.anchors.top = undefined;
             bLine.anchors.left = bLine.parent.left;
             bLine.anchors.right = undefined;
         }
         else if (newPosition === PlasmaCore.Types.RightPositioned){
             bLine.anchors.horizontalCenter = undefined;
             bLine.anchors.verticalCenter = bLine.parent.verticalCenter;
             bLine.anchors.bottom = undefined;
             bLine.anchors.top = undefined;
             bLine.anchors.left =undefined;
             bLine.anchors.right = bLine.parent.right;
         }
     }
 
     property int ncounter:0
 
     function updateImplicits(){
         if(icList.previousCount !== icList.count){
             icList.previousCount = icList.count;
 
             var zoomedLength = Math.floor( 1.2 * (iconSize+thickMargin) * (root.zoomFactor));
             var bigAxis = (tasksModel.count-1) * (iconSize+thickMargin) + zoomedLength;
             var smallAxis = zoomedLength + statesLineSize;
 
             var clearBigAxis = tasksModel.count * (iconSize+thickMargin) + (barLine.spacing/2);
             var clearSmallAxis = (iconSize+thickMargin)+statesLineSize;
 
             //  debugging code
             //     ncounter++;
             //      console.log("Implicits______ "+ncounter+". - "+tasksModel.count);
 
             if (root.vertical){
                 root.implicitWidth = smallAxis;
                 root.implicitHeight = bigAxis;
                 root.clearWidth = clearSmallAxis;
                 root.clearHeight = clearBigAxis;
             }
             else{
                 root.implicitWidth = bigAxis;
                 root.implicitHeight = smallAxis;
                 root.clearWidth = clearBigAxis;
                 root.clearHeight = clearSmallAxis;
             }
 
             iconGeometryTimer.restart();
         }
     }
 
     PlasmaComponents.Button{
         id: orientationBtn
         text:"Orientation"
 
         anchors.centerIn: parent
         visible: root.debugLocation
 
         onClicked:{
             switch(root.position){
             case PlasmaCore.Types.BottomPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.LeftEdge;
                 break;
             case PlasmaCore.Types.LeftPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.TopEdge;
                 break;
             case PlasmaCore.Types.TopPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.RightEdge;
                 break;
             case PlasmaCore.Types.RightPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.BottomEdge;
                 break;
             }
             updatePosition();
         }
     }
 
     function addInternalSeparatorAtPos(pos) {
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             parabolicManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteDock && latteDock.launchersGroup >= Latte.Dock.LayoutLaunchers) {
                 latteDock.universalLayoutManager.launchersSignals.addLauncher(root.managedLayoutName,
                                                                               latteDock.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     // This is called by dockcorona in response to a Meta+number shortcut.
     function activateTaskAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         var tasks = icList.contentItem.children;
 
         //! this is used to bypass the internal separators if they exist
         var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.itemIndex === confirmedIndex) {
                 if (task.isGroupParent) {
                     task.activateNextTask();
                 } else {
                     task.activateTask();
                 }
                 break;
             }
         }
     }
 
     // This is called by dockcorona in response to a Meta+Alt+number shortcut.
     function newInstanceForTaskAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         var tasks = icList.contentItem.children;
 
         //! this is used to bypass the internal separators if they exist
         var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.itemIndex === confirmedIndex) {
                 TaskTools.activateTask(task.modelIndex(), task.m, Qt.ControlModifier , task);
                 break;
             }
         }
     }
 
     function setHoveredIndex(ind) {
         icList.hoveredIndex = ind;
     }
 
     function updatePosition(){
         var newPosition;
         var tempVertical=false;
 
         var positionUsed;
 
 
         if (root.debugLocation)
             positionUsed = root.newLocationDebugUse;
         else
             positionUsed = plasmoid.location;
 
         switch (positionUsed) {
         case PlasmaCore.Types.LeftEdge:
             newPosition = PlasmaCore.Types.LeftPositioned;
             tempVertical = true;
             break;
         case PlasmaCore.Types.RightEdge:
             newPosition = PlasmaCore.Types.RightPositioned;
             tempVertical = true;
             break;
         case PlasmaCore.Types.TopEdge:
             newPosition = PlasmaCore.Types.TopPositioned;
             break;
         default:
             newPosition = PlasmaCore.Types.BottomPositioned;
             break
         }
 
         movePanel(barLine,newPosition);
         movePanel(icList,newPosition);
 
         if(tempVertical)
             icList.orientation = Qt.Vertical;
         else
             icList.orientation = Qt.Horizontal;
 
         root.position = newPosition;
     }
 
     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 === latteDock.launchersGroup) {
             tasksModel.requestAddLauncher(launcher);
             launchersUpdatedFor(launcher);
         }
     }
 
     function extSignalRemoveLauncher(group, launcher) {
         if (group === latteDock.launchersGroup) {
             root.launcherForRemoval = launcher;
             tasksModel.requestRemoveLauncher(launcher);
             launchersUpdatedFor(launcher);
         }
     }
 
     function extSignalAddLauncherToActivity(group, launcher, activity) {
         if (group === latteDock.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);
         }
     }
 
     function extSignalRemoveLauncherFromActivity(group, launcher, activity) {
         if (group === latteDock.launchersGroup) {
             if (activity === tasksModel.activity) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestRemoveLauncherFromActivity(launcher, activity);
             launchersUpdatedFor(launcher);
         }
     }
 
     function extSignalUrlsDropped(group, urls) {
         if (group === latteDock.launchersGroup) {
             mouseHandler.urlsDroppedOnArea(urls);
         }
     }
 
     function extSignalMoveTask(group, from, to) {
         if (group === latteDock.launchersGroup && !root.dragSource) {
             tasksModel.move(from, to);
             parabolicManager.updateTasksEdgesIndexes();
             root.separatorsUpdated();
         }
     }
 
     //! 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 !== "") {
             parabolicManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteDock && latteDock.launchersGroup >= Latte.Dock.LayoutLaunchers) {
                 latteDock.universalLayoutManager.launchersSignals.addLauncher(latteDock.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     function removeLastSeparator(){
         var separatorName = parabolicManager.lastPresentSeparatorName();
 
         if (separatorName !== "") {
             if (latteDock && latteDock.launchersGroup >= Latte.Dock.LayoutLaunchers) {
                 latteDock.universalLayoutManager.launchersSignals.removeLauncher(root.managedLayoutName,
                                                                                  latteDock.launchersGroup, separatorName);
             } else {
                 root.launcherForRemoval = separatorName;
                 tasksModel.requestRemoveLauncher(separatorName);
             }
         }
     }
 
     //! show/hide tasks numbered badges e.g. from global shortcuts
     function setShowTasksNumbers(showNumbers){
         showTasksNumbers = showNumbers;
     }
 
     //! setup the tasks first index based on the fact that this is a plasmoid
     //! and applets could exist before it
     function setTasksNumbersBase(base){
         tasksNumbersBase = base;
     }
 
     function previewContainsMouse() {
         if(toolTipDelegate && toolTipDelegate.containsMouse && toolTipDelegate.parentTask)
             return true;
         else
             return false;
     }
 
     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 clearZoom(){
         //console.log("Plasmoid clear...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         if (!previewContainsMouse())
             windowsPreviewDlg.hide(4.2);
 
         if (!latteDock) {
             initializeHoveredIndex();
         }
 
         root.clearZoomSignal();
     }
 
     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=" ) );
         }
 
         tasksModel.requestAddLauncher(url);
         launchersUpdatedFor(url);
     }
 
     function resetDragSource() {
         dragSource.z = 0;
         dragSource = null;
     }
 
     function setGlobalDirectRender(value) {
         if (waitingLaunchers.length > 0)
             return;
 
         if (latteDock) {
             latteDock.setGlobalDirectRender(value);
         } else {
             if (value === true) {
                 if (root.containsMouse()) {
                     icList.directRender = true;
                 } else {
                     //    console.log("direct render true ignored...");
                 }
             } else {
                 icList.directRender = false;
             }
         }
     }
 
     function startCheckRestoreZoomTimer(duration) {
         if (latteDock) {
             latteDock.startCheckRestoreZoomTimer();
         } else {
             if (duration > 0) {
                 checkListHovered.startDuration(duration);
             } else {
                 checkListHovered.startNormal();
             }
         }
     }
 
     function stopCheckRestoreZoomTimer() {
         if (latteDock) {
             latteDock.stopCheckRestoreZoomTimer();
         } else {
             checkListHovered.stop();
         }
     }
 
     function startDirectRenderDelayerDuringEntering(){
         if (latteDock) {
             latteDock.startDirectRenderDelayerDuringEntering();
         } else {
             directRenderDelayerForEnteringTimer.start();
         }
     }
 
     ///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:  {
         updatePosition();
 
         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
     //user set Panel Positions
     // 0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
 
         ///Bottom Edge
         State {
             name: "bottomCenter"
             when: (root.position === PlasmaCore.Types.BottomPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.BottomPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.BottomPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.TopPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.TopPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.TopPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.LeftPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.LeftPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.LeftPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.RightPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.RightPosition && userPanelPosition===Latte.Dock.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.position === PlasmaCore.Types.RightPosition && userPanelPosition===Latte.Dock.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/TaskDelegate.qml b/plasmoid/package/contents/ui/task/TaskDelegate.qml
index fce98432..8b55e151 100644
--- a/plasmoid/package/contents/ui/task/TaskDelegate.qml
+++ b/plasmoid/package/contents/ui/task/TaskDelegate.qml
@@ -1,1565 +1,1565 @@
 /*
 *  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 0.1 as Latte
 
 import "animations" as TaskAnimations
 
 MouseArea{
     id: mainItemContainer
 
     visible: false //true//(isStartup && root.durationTime !== 0) ? false : true
 
     anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? parent.bottom : undefined
     anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? parent.top : undefined
     anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? parent.left : undefined
     anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? parent.right : undefined
 
     objectName: "TaskDelegate"
 
     width: {
         if (!visible)
             return 0;
 
         if (isSeparator)
             return root.vertical ? separatorItem.width : (root.dragSource || root.editMode ? 5+root.iconMargin : 0);
 
         if (root.vertical) {
             if (!inAttentionAnimation)
                 return wrapper.width;
             else
                 return wrapper.maxThickness;
         } 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)
             return !root.vertical ? separatorItem.height : (root.dragSource || root.editMode ? 5+root.iconMargin: 0);
 
         if (root.vertical) {
             return hiddenSpacerLeft.height + wrapper.height + hiddenSpacerRight.height;
         } else {
             if (!inAttentionAnimation)
                 return wrapper.height;
             else
                 return wrapper.maxThickness;
         }
     }
 
     acceptedButtons: Qt.LeftButton | Qt.MidButton | Qt.RightButton
     hoverEnabled: visible && (!inAnimation) && (!IsStartup) && (!root.taskInAnimation)
                   && (!root.editMode || root.debugLocation)&&(!inBouncingAnimation) && !isSeparator
     // hoverEnabled: false
     //opacity : isSeparator && (hiddenSpacerLeft.neighbourSeparator || hiddenSpacerRight.neighbourSeparator) ? 0 : 1
 
     property bool blockWheel: false
     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) ? tasksWindows.hasMinimized : isMinimized
     property bool hasShown: (IsGroupParent === true) ? tasksWindows.hasShown : !isMinimized
     property bool inAddRemoveAnimation: true
     property bool inAnimation: true
     property bool inAttentionAnimation: false
     property bool inBlockingAnimation: false
     property bool inBouncingAnimation: false
     property bool inFastRestoreAnimation: false
     property bool inMimicParabolicAnimation: false
     property real mimicParabolicScale: -1
     property bool inPopup: false
     property bool inRemoveStage: false
     property bool inWheelAction: false
 
     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
     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>=root.iconSize && height>=root.iconSize
                                         && !mainItemContainer.delayingRemove
                                         && (wrapper.mScale===1 || wrapper.mScale===root.zoomFactor) //dont publish during zoomFactor
 
     property bool pressed: false
     readonly property bool showAttention: isDemandingAttention && plasmoid.status === PlasmaCore.Types.RequiresAttentionStatus ?
                                               true : false
 
     property int animationTime: root.durationTime * 1.2 * units.shortDuration
     property int badgeIndicator: 0 //it is used from external apps
     property int hoveredIndex: icList.hoveredIndex
     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*root.iconSize) - root.iconMargin)
 
     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
 
     onModelLauncherUrlChanged: {
         if (modelLauncherUrl !== ""){
             launcherUrl = modelLauncherUrl;
 
             //!extract the launcherName if possible
             var nameStarts = launcherUrl.lastIndexOf("/");
             if (nameStarts === -1){
                 nameStarts = launcherUrl.lastIndexOf(":");
             }
 
             var nameEnds = launcherUrl.lastIndexOf(".desktop");
 
             if (nameStarts!==-1 && nameEnds!==-1 && nameStarts<nameEnds) {
                 launcherName = launcherUrl.substring(nameStarts+1,nameEnds);
             }
         }
 
         if (parabolicManager.isSeparator(modelLauncherUrl)){
             isSeparator = true;
         } else {
             isSeparator = false;
         }
     }
 
     onModelLauncherUrlWithIconChanged: {
         if (modelLauncherUrlWithIcon !== ""){
             launcherUrlWithIcon = modelLauncherUrlWithIcon;
         }
     }
 
     ////// Audio streams //////
     property Item audioStreamOverlay
     property var audioStreams: []
     readonly property bool hasAudioStream: root.indicateAudioStreams && 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: root.durationTime*units.longDuration }
     }
 
     TaskWindows{
         id: tasksWindows
 
         property int previousCount: 0
 
         onWindowsCountChanged: {
             if (root.showWindowsOnlyFromLaunchers && root.activeIndicator === Latte.Dock.NoneIndicator) {
                 return;
             }
 
             if ((windowsCount >= 2) && (windowsCount > previousCount)
                     && !(mainItemContainer.containsMouse || parabolicManager.neighbourIsHovered(itemIndex)) ){
                 if(root.dragSource == null)
                     mainItemContainer.groupWindowAdded();
             }
             else if ((windowsCount >=1) &&(windowsCount < previousCount)){
                 //sometimes this is triggered in dragging with no reason
                 if(root.dragSource == null && !mainItemContainer.delayingRemove)
                     mainItemContainer.groupWindowRemoved();
             }
 
             if (windowsCount>=1) {
                 mainItemContainer.slotPublishGeometries();
             }
 
             previousCount = windowsCount;
         }
     }
 
     Loader {
         id: isSeparatorRectangle
         active: (opacityN>0)
 
         width: mainItemContainer.width
         height: mainItemContainer.height
         anchors.centerIn: separatorItem
 
         property real opacityN: isSeparator && root.contextMenu && root.contextMenu.visualParent === mainItemContainer ? 1 : 0
 
         Behavior on opacityN {
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
 
         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.rightMargin: root.position === PlasmaCore.Types.RightPositioned ? localThickMargin : 0
         anchors.leftMargin: root.position === PlasmaCore.Types.LeftPositioned ? localThickMargin : 0
         anchors.bottomMargin: root.position === PlasmaCore.Types.BottomPositioned ? localThickMargin : 0
         anchors.topMargin: root.position === PlasmaCore.Types.TopPositioned ? localThickMargin : 0
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
         anchors.right: root.position === PlasmaCore.Types.RightPositioned ? parent.right : undefined;
         anchors.left: root.position === PlasmaCore.Types.LeftPositioned ? parent.left : undefined;
         anchors.top: root.position === PlasmaCore.Types.TopPositioned ? parent.top : undefined;
         anchors.bottom: root.position === PlasmaCore.Types.BottomPositioned ? parent.bottom : undefined;
 
         //opacity: separatorShadow.active || root.internalSeparatorHidden ? 0 : 0.4
         opacity: separatorShadow.active || forceHiddenState ? 0 : 0.4
 
         visible: mainItemContainer.isSeparator
 
         width: root.vertical ? root.iconSize : (root.dragSource || root.editMode) ? 5+root.iconMargin: 1
         height: !root.vertical ? root.iconSize : (root.dragSource || root.editMode) ? 5+root.iconMargin: 1
 
         property int localThickMargin: !root.reverseLinesPosition ? root.statesLineSize + root.thickMarginBase + 4 : root.thickMarginBase + 4
 
         property bool forceHiddenState: false
 
         Behavior on opacity {
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
 
         function updateForceHiddenState() {
             if (!isSeparator || root.editMode || root.dragSource) {
                 forceHiddenState = false;
             } else {
                 var firstPosition = (index>=0) && (index < parabolicManager.firstRealTaskIndex);
                 var sepNeighbour = mainItemContainer.hasNeighbourSeparator(index-1, false);
                 var firstSepFromLastSeparatorsGroup = (index>=0) && (index > parabolicManager.lastRealTaskIndex);
 
                 forceHiddenState = (firstPosition || sepNeighbour || firstSepFromLastSeparatorsGroup);
             }
         }
 
         Component.onCompleted: {
             updateForceHiddenState();
             root.hiddenTasksUpdated.connect(updateForceHiddenState);
         }
 
         Component.onDestruction: {
             root.hiddenTasksUpdated.disconnect(updateForceHiddenState);
         }
 
         onForceHiddenStateChanged: root.separatorsUpdated();
 
         Connections{
             target: root
             onEditModeChanged: separatorItem.updateForceHiddenState();
             onDragSourceChanged: separatorItem.updateForceHiddenState();
             onSeparatorsUpdated: separatorItem.updateForceHiddenState();
 
             //! 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 && mainItemContainer.containsMouse) {
                     if (root.vertical) {
                         mainItemContainer.mousePosChanged(mainItemContainer.mouseY);
                     } else {
                         mainItemContainer.mousePosChanged(mainItemContainer.mouseX);
                     }
                 }
             }
 
             onGlobalDirectRenderChanged:{
                 if (root.globalDirectRender && restoreAnimation.running) {
                     // console.log("Cleat Task Scale !!!!");
                     restoreAnimation.stop();
                 }
             }
 
             onShowWindowsOnlyFromLaunchersChanged: {
                 if (!root.editMode) {
                     return;
                 }
 
                 mainItemContainer.updateVisibilityBasedOnLaunchers();
             }
 
             onInActivityChangeChanged: {
                 if (root.showWindowsOnlyFromLaunchers && !root.inActivityChange) {
                     mainItemContainer.updateVisibilityBasedOnLaunchers();
                 }
             }
         }
 
         Rectangle {
             anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
             anchors.right: root.position === PlasmaCore.Types.RightPositioned ? parent.right : undefined;
             anchors.left: root.position === PlasmaCore.Types.LeftPositioned ? parent.left : undefined;
             anchors.top: root.position === PlasmaCore.Types.TopPositioned ? parent.top : undefined;
             anchors.bottom: root.position === PlasmaCore.Types.BottomPositioned ? parent.bottom : undefined;
 
             radius: 2
 
             width: root.vertical ? root.iconSize - 8  : 1
             height: !root.vertical ? root.iconSize - 8 : 1
             color: theme.textColor
         }
     }
 
     ///Shadow in tasks
     Loader{
         id: separatorShadow
         anchors.fill: separatorItem
         active: root.enableShadows && isSeparator
         opacity: separatorItem.forceHiddenState ? 0 : 0.4
 
         Behavior on opacity {
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
 
         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 !!!
         TaskHiddenSpacer{ id:hiddenSpacerLeft;}
 
         TaskWrapper{ id: wrapper }
 
         // a hidden spacer on the right for the last item to add stability
         TaskHiddenSpacer{ id:hiddenSpacerRight; rightSpacer: true }
     }// Flow with hidden spacers inside
 
     /*Rectangle{
         anchors.fill: taskFlow
         color: "transparent"
         border.width: 1
         border.color: "blue"
     }*/
 
     Component {
         id: taskInitComponent
         Timer {
             id: timer
 
             interval: 800
             repeat: false
 
             onTriggered: {
                 //      mainItemContainer.hoverEnabled = true;
                 slotPublishGeometries();
 
                 if (latteDock && latteDock.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(mainItemContainer);
         }
     }
 
     onHoveredIndexChanged: {
         var distanceFromHovered = Math.abs(index - icList.hoveredIndex);
 
         /*if( (distanceFromHovered > 1) && (hoveredIndex !== -1)){
             if(!isDragged)
                 wrapper.mScale = 1;
         }*/
 
         if (distanceFromHovered >= 1 && !inAttentionAnimation && !inFastRestoreAnimation && !inMimicParabolicAnimation) {
             hiddenSpacerLeft.nScale = 0;
             hiddenSpacerRight.nScale = 0;
         }
     }
 
     onItemIndexChanged: {
         if (isSeparator) {
             root.separatorsUpdated();
         }
 
         if (itemIndex>=0)
             lastValidTimer.start();
     }
 
     onLastValidIndexChanged: {
         if (lastValidIndex>=0 && lastValidIndex<root.tasksCount){
             if (!isForcedHidden && (lastValidIndex < parabolicManager.firstRealTaskIndex || lastValidIndex > parabolicManager.lastRealTaskIndex)) {
                 parabolicManager.updateTasksEdgesIndexes();
             }
         }
 
         if (parabolicManager.hasInternalSeparator) {
             root.separatorsUpdated();
         }
     }
 
     onIsDraggedChanged: {
         if(isDragged && (!root.editMode)){
             root.dragSource = mainItemContainer;
             dragHelper.startDrag(mainItemContainer, model.MimeType, model.MimeData,
                                  model.LauncherUrlWithoutIcon, model.decoration);
             pressX = -1;
             pressY = -1;
         }
     }
 
     onIsMinimizedChanged: {
         checkWindowsStates();
     }
 
     onIsActiveChanged: {
         checkWindowsStates();
     }
 
     onIsForcedHiddenChanged: root.hiddenTasksUpdated();
 
     onIsSeparatorChanged: {
         if (isSeparator) {
             root.separatorsUpdated();
 
             if (parabolicManager.isLauncherToBeMoved(launcherUrl) && itemIndex>=0) {
                 parabolicManager.moveLauncherToCorrectPos(launcherUrl, itemIndex);
             }
         } else {
             root.separatorsUpdated();
         }
     }
 
     onLauncherUrlChanged: updateBadge();
 
     ////// End of Values Changes /////
 
 
     ///////////////// Mouse Area Events ///////////////////
     onEntered: {
         if (root.editMode)
             return;
 
         root.stopCheckRestoreZoomTimer();
 
         if (restoreAnimation.running) {
             restoreAnimation.stop();
         }
 
         // console.log("entered task:" + icList.hoveredIndex);
         if (icList.hoveredIndex === -1 && root.dockHoveredIndex ===-1) {
             root.startDirectRenderDelayerDuringEntering();
         }
 
         if ((icList.hoveredIndex !== itemIndex) && isLauncher && windowsPreviewDlg.visible) {
             windowsPreviewDlg.hide(1);
         }
 
         if (!latteDock || (latteDock && !(latteDock.dockIsHidden || latteDock.inSlidingIn || latteDock.inSlidingOut))){
             icList.hoveredIndex = index;
         }
 
         if (root.latteDock && (!root.showPreviews)){
             var displayText = isWindow ? model.display : model.AppName;
             var maxCharacters = 80;
 
             var fixedDisplayText = displayText.length>maxCharacters ? displayText.substring(0,maxCharacters-1) + "..." : displayText;
 
             root.latteDock.showTooltipLabel(mainItemContainer, fixedDisplayText);
         }
 
         if (root.latteDock && root.latteDock.isHalfShown) {
             return;
         }
 
         /*  if((!inAnimation)&&(root.dragSource == null)&&(!root.taskInAnimation) && hoverEnabled){
             if (inAttentionAnimation) {
                 var subSpacerScale = (root.zoomFactor-1)/2;
                 hiddenSpacerLeft.nScale = subSpacerScale;
                 hiddenSpacerRight.nScale = subSpacerScale;
             }
 
             if (!inBlockingAnimation || inAttentionAnimation) {
                 if (icList.orientation == Qt.Horizontal){
                     icList.currentSpot = mouseX;
                     wrapper.calculateScales(mouseX);
                 }
                 else{
                     icList.currentSpot = mouseY;
                     wrapper.calculateScales(mouseY);
                 }
             }
         }*/
     }
 
     // IMPORTANT: This must be improved ! even for small miliseconds  it reduces performance
     onExited: {
         mainItemContainer.scalesUpdatedOnce = false;
 
         if (root.latteDock && (!root.showPreviews || (root.showPreviews && isLauncher))){
             root.latteDock.hideTooltipLabel();
         }
 
         if(mainItemContainer.contextMenu && mainItemContainer.contextMenu.status == PlasmaComponents.DialogStatus.Open){
             ///dont check to restore zooms
         }
         else{
             if(!inAnimation){
                 root.startCheckRestoreZoomTimer();
             }
         }
 
         /* if(draggingResistaner != null){
                 draggingResistaner.destroy();
                 draggingResistaner = null;
                 isDragged = false;
             }*/
     }
 
     //! 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 dont delay at all
     //! when mouseX-Y is updated based on the plasmoid formFactor
     function mousePosChanged(mousePos) {
         if (root.editMode || mousePos<0 ||
                 (inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         root.stopCheckRestoreZoomTimer();
 
         if (root.latteDock && root.latteDock.isHalfShown) {
             return;
         }
 
         //! show previews
         if(root.showPreviews && !windowsPreviewDlg.visible && windowsPreviewDlg.activeItem !== mainItemContainer){
             if (hoveredTimerObj) {
                 //! dont delay showing preview in normal states,
                 //! that is when the dock wasnt hidden
                 if (!hoveredTimerObj.running) {
                     hoveredTimerObj.start();
                 }
             } else {
                 if (!root.disableAllWindowsFunctionality) {
                     hoveredTimerObj = hoveredTimerComponent.createObject(mainItemContainer);
                 }
             }
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             if (icList.hoveredIndex === -1 && root.dockHoveredIndex ===-1) {
                 root.startDirectRenderDelayerDuringEntering();
             }
 
             if (!latteDock || (latteDock && !(latteDock.dockIsHidden || latteDock.inSlidingIn || latteDock.inSlidingOut))){
                 icList.hoveredIndex = index;
             }
 
             if (!root.globalDirectRender && !root.directRenderDelayerIsRunning) {
                 root.setGlobalDirectRender(true);
             }
 
             if( ((wrapper.mScale == 1 || wrapper.mScale === root.zoomFactor) && !root.globalDirectRender)
                     || root.globalDirectRender || !scalesUpdatedOnce) {
                 if(root.dragSource == null){
                     var step = Math.abs(icList.currentSpot-mousePos);
                     if (step >= root.animationStep){
                         icList.currentSpot = mousePos;
 
                         wrapper.calculateScales(mousePos);
                     }
                 }
             }
         }
     }
 
     onMouseXChanged: {
         if (!root.vertical) {
             mousePosChanged(mouseX);
         }
     }
 
     onMouseYChanged: {
         if (root.vertical) {
             mousePosChanged(mouseY);
         }
     }
 
 
 
     onPositionChanged: {
         if (root.editMode || (inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         if (root.latteDock && root.latteDock.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
                     && !root.editMode
                     && dragHelper.isDrag(pressX, pressY, mouse.x, mouse.y) ) {
                 root.dragSource = mainItemContainer;
                 dragHelper.startDrag(mainItemContainer, model.MimeType, model.MimeData,
                                      model.LauncherUrlWithoutIcon, model.decoration);
                 pressX = -1;
                 pressY = -1;
             }
         }
     }
 
     onContainsMouseChanged:{
         if(!containsMouse){
             //  hiddenSpacerLeft.nScale = 0;
             //  hiddenSpacerRight.nScale = 0;
 
             if(!inAnimation)
                 pressed=false;
         }
 
         ////window previews/////////
         if (isWindow) {
             if(containsMouse && (root.showPreviews || (!root.showPreviews && root.highlightWindows)) && Latte.WindowSystem.compositingActive){
                 if (hoveredTimerObj) {
                     hoveredTimerObj.restart();
                 } else {
                     if (!root.disableAllWindowsFunctionality) {
                         hoveredTimerObj = hoveredTimerComponent.createObject(mainItemContainer);
                     }
                 }
             }
             else{
                 if (hoveredTimerObj){
                     hoveredTimerObj.stop();
                     hoveredTimerObj.destroy();
                 }
             }
         }
 
         ////disable hover effect///
         if (isWindow && root.highlightWindows && !containsMouse) {
             root.windowsHovered(model.LegacyWinIdList, false);
         }
     }
 
     onPressed: {
         //console.log("Pressed Task Delegate..");
         if (Latte.WindowSystem.compositingActive && !Latte.WindowSystem.isPlatformWayland) {
             windowsPreviewDlg.hide(2);
         }
 
         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(mainItemContainer);
         }
         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();
             }
 
             //root.createContextMenu(mainItemContainer).show();
         }
 
         if (hoveredTimerObj){
             hoveredTimerObj.restart();
             /*hoveredTimerObj.stop();
             hoveredTimerObj.destroy();*/
         }
     }
 
     onReleased: {
         //console.log("Released Task Delegate...");
         if (draggingResistaner != null){
             draggingResistaner.destroy();
             draggingResistaner = null;
         }
 
         if(pressed && (!inBlockingAnimation || inAttentionAnimation) && !isSeparator){
 
             if (modifierAccepted(mouse) && !root.disableAllWindowsFunctionality){
                 if( !mainItemContainer.isLauncher){
                     if (root.modifierClickAction == Latte.Dock.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.modifierClickAction == Latte.Dock.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.modifierClickAction == Latte.Dock.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.modifierClickAction == Latte.Dock.CycleThroughTasks) {
                         if (isGroupParent)
                             tasksWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.modifierClickAction == Latte.Dock.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.MidButton && !root.disableAllWindowsFunctionality){
                 if( !mainItemContainer.isLauncher){
                     if (root.middleClickAction == Latte.Dock.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.middleClickAction == Latte.Dock.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.middleClickAction == Latte.Dock.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.middleClickAction == Latte.Dock.CycleThroughTasks) {
                         if (isGroupParent)
                             tasksWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.middleClickAction == Latte.Dock.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.LeftButton){
                 activateTask();
             }
 
             backend.cancelHighlightWindows();
         }
 
         pressed = false;
 
         if(!inAnimation) {
             startCheckRestoreZoomTimer(3*units.longDuration);
         }
     }
 
     onWheel: {
         if (isSeparator || !root.mouseWheelActions || blockWheel || inWheelAction || inBouncingAnimation
                 || (latteDock && (latteDock.dockIsHidden || latteDock.inSlidingIn || latteDock.inSlidingOut))){
             return;
         }
 
         var angle = wheel.angleDelta.y / 8;
 
         blockWheel = true;
         scrollDelayer.start();
 
         //positive direction
         if (angle > 12) {
             if (isLauncher || root.disableAllWindowsFunctionality) {
                 inWheelAction = true;
                 wrapper.runLauncherAnimation();
             } else if (isGroupParent) {
                 tasksWindows.activateNextTask();
             } else {
                 var taskIndex = modelIndex();
 
                 if (isMinimized) {
                     inWheelAction = true;
                     tasksModel.requestToggleMinimized(taskIndex);
                     wheelActionDelayer.start();
                 }
 
                 tasksModel.requestActivate(taskIndex);
             }
             //negative direction
         } else if (angle < -12) {
             if (isLauncher || root.disableAllWindowsFunctionality) {
                 // do nothing
             } else if (isGroupParent) {
                 tasksWindows.activatePreviousTask();
             } else {
                 var taskIndex = modelIndex();
 
                 if (isMinimized) {
                     inWheelAction = true;
                     tasksModel.requestToggleMinimized(taskIndex);
                     wheelActionDelayer.start();
                 }
 
                 tasksModel.requestActivate(taskIndex);
             }
         }
     }
 
     //! 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: mainItemContainer.blockWheel = 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 clearZoom(){
         if(!root)
             return;
 
         if (root.hoveredIndex === -1 && root.dockHoveredIndex === -1) {
             restoreAnimation.start();
         }
     }
 
     function handlerDraggingFinished(){
         isDragged = false;
     }
     ///// End of Handlers //////
 
 
 
     ///// Helper functions /////
     function activateNextTask() {
         tasksWindows.activateNextTask();
     }
 
     function activateTask() {
         if( mainItemContainer.isLauncher || root.disableAllWindowsFunctionality){
             if (Latte.WindowSystem.compositingActive) {
                 wrapper.runLauncherAnimation();
             } else {
                 launcherAction();
             }
         }
         else{
             if (model.IsGroupParent) {
                 if (Latte.WindowSystem.compositingActive && backend.canPresentWindows()) {
                     root.presentWindows(model.LegacyWinIdList);
                 } else {
                     if ((windowsPreviewDlg.visualParent === previewsVisualParent)&&(windowsPreviewDlg.visible)) {
                         windowsPreviewDlg.hide(3);
                     } else {
                         preparePreviewWindow(false);
                         windowsPreviewDlg.show(mainItemContainer);
                     }
                 }
             } else {
                 if (IsMinimized === true) {
                     var i = modelIndex();
                     tasksModel.requestToggleMinimized(i);
                     tasksModel.requestActivate(i);
                 } else if (IsActive === true) {
                     tasksModel.requestToggleMinimized(modelIndex());
                 } else {
                     tasksModel.requestActivate(modelIndex());
                 }
             }
         }
     }
 
     function hasNeighbourSeparator(ind, positive) {
         var cursor = ind;
 
         while (((!positive && cursor>=0) || (positive && cursor<=root.tasksCount-1))
                && parabolicManager.taskIsForcedHidden(cursor) ) {
             cursor = positive ? cursor + 1 : cursor - 1;
         }
 
         return parabolicManager.taskIsSeparator(cursor);
     }
 
     function preparePreviewWindow(hideClose){
         windowsPreviewDlg.visualParent = previewsVisualParent;
 
         toolTipDelegate.parentTask = mainItemContainer;
-        toolTipDelegate.parentIndex = itemIndex;
+        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 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.VirtualDesktop != undefined ? model.VirtualDesktop : 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 (Latte.WindowSystem.compositingActive) {
             inBouncingAnimation = true;
             root.addWaitingLauncher(mainItemContainer.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 launcherIsPresent(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;
     }
 
     function modelIndex(){
         return tasksModel.makeModelIndex(index);
     }
 
     function showContextMenu(args) {
         if (isSeparator && !root.editMode)
             return;
 
         if (!root.contextMenu) {
             contextMenu = root.createContextMenu(mainItemContainer, modelIndex(), args);
             contextMenu.show();
         } else {
             root.contextMenu.close();
         }
     }
 
     function modifierAccepted(mouse){
         if (mouse.modifiers & root.modifierQt){
             if ((mouse.button === Qt.LeftButton && root.modifierClick === Latte.Dock.LeftClick)
                     || (mouse.button === Qt.MiddleButton && root.modifierClick === Latte.Dock.MiddleClick)
                     || (mouse.button === Qt.RightButton && root.modifierClick === Latte.Dock.RightClick))
                 return true;
         }
 
         return false;
     }
 
     function setBlockingAnimation(value){
         inBlockingAnimation = value;
     }
 
     function slotMimicEnterForParabolic(){
         if (containsMouse) {
             if (inMimicParabolicAnimation) {
                 mimicParabolicScale = root.zoomFactor;
             }
 
             wrapper.calculateScales(icList.currentSpot);
         }
     }
 
     function slotShowPreviewForTasks(group) {
         if (group === mainItemContainer && !windowsPreviewDlg.visible) {
             preparePreviewWindow(true);
             windowsPreviewDlg.show(mainItemContainer);
         }
     }
 
     function slotPublishGeometries() {
         //! this way we make sure that layouts that are in different activities that the current layout
         //! dont publish their geometries
         if ( canPublishGeometries
                 && (!latteDock
                     || (latteDock && currentLayout && latteDock.universalLayoutManager &&
                         currentLayout.name === latteDock.universalLayoutManager.currentLayoutName))) {
             var globalChoords = backend.globalRect(mainItemContainer);
 
             //! Magic Lamp effect doesnt 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) {
                 globalChoords.width = 1;
                 globalChoords.height = Math.max(root.iconSize, mainItemContainer.height);
             } else {
                 globalChoords.height = 1;
                 globalChoords.width = Math.max(root.iconSize, mainItemContainer.width);
             }
 
             if (root.position === PlasmaCore.Types.BottomPositioned) {
                 globalChoords.y = plasmoid.screenGeometry.y+plasmoid.screenGeometry.height-1;
             } else if (root.position === PlasmaCore.Types.TopPositioned) {
                 globalChoords.y = plasmoid.screenGeometry.y+1;
             } else if (root.position === PlasmaCore.Types.LeftPositioned) {
                 globalChoords.x = plasmoid.screenGeometry.x+1;
             } else if (root.position === PlasmaCore.Types.RightPositioned) {
                 globalChoords.x = plasmoid.screenGeometry.x+plasmoid.screenGeometry.width - 1;
             }
 
             tasksModel.requestPublishDelegateGeometry(mainItemContainer.modelIndex(), globalChoords, mainItemContainer);
         }
     }
 
     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(mainItemContainer.pid);
         if (streams.length) {
             pa.registerPidMatch(mainItemContainer.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(mainItemContainer.appName)) {
                 var streams_result;
                 streams_result = pa.streamsForAppName(mainItemContainer.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) {
             mainItemContainer.audioStreams = streams;
         }
     }
 
     function slotLaunchersChangedFor(launcher) {
         if (root.showWindowsOnlyFromLaunchers && launcher === launcherUrl) {
             updateVisibilityBasedOnLaunchers()
         }
     }
 
     function updateVisibilityBasedOnLaunchers(){
         var launcherExists = !(((tasksModel.launcherPosition(mainItemContainer.launcherUrl) == -1)
                                 && (tasksModel.launcherPosition(mainItemContainer.launcherUrlWithIcon) == -1) )
                                || !launcherIsPresent(mainItemContainer.launcherUrl));
 
         if (root.showWindowsOnlyFromLaunchers) {
             var hideWindow =  !launcherExists && mainItemContainer.isWindow;
 
             if (hideWindow) {
                 isForcedHidden = true;
                 taskRealRemovalAnimation.start();
             } else if (launcherExists && mainItemContainer.isWindow && !mainItemContainer.isVisible) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         } else {
             var showWindow =  !launcherExists && mainItemContainer.isWindow;
 
             if (showWindow) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         }
     }
 
     function toggleMuted() {
         if (muted) {
             mainItemContainer.audioStreams.forEach(function (item) { item.unmute(); });
         } else {
             mainItemContainer.audioStreams.forEach(function (item) { item.mute(); });
         }
     }
 
     function increaseVolume() {
         mainItemContainer.audioStreams.forEach(function (item) { item.increaseVolume(); });
     }
 
     function decreaseVolume() {
         mainItemContainer.audioStreams.forEach(function (item) { item.decreaseVolume(); });
     }
 
     function updateBadge() {
         var badger = root.getBadger(launcherUrl);
 
         if (badger && !isLauncher) {
             badgeIndicator = parseInt(badger.value);
         } else {
             badgeIndicator = 0;
         }
     }
 
     Connections {
         target: pulseAudio.item
         ignoreUnknownSignals: true // Plasma-PA might not be available
         onStreamsChanged: mainItemContainer.updateAudioStreams()
     }
 
     Connections {
         target: root
         //trying to fix #440, showing the audio icon indicator to irrelevant tasks
         //after dragging an existent task with audio
         onDragSourceChanged: mainItemContainer.updateAudioStreams()
         onIndicateAudioStreamsChanged: mainItemContainer.updateAudioStreams()
     }
 
     Connections {
         target: root
         onHoveredIndexChanged: {
             if ((restoreAnimation.running) && (root.hoveredIndex !== -1)) {
                 restoreAnimation.stop();
             }
         }
 
         onDockHoveredIndexChanged: {
             if ((restoreAnimation.running) && (root.dockHoveredIndex !== -1)) {
                 restoreAnimation.stop();
             }
         }
     }
 
 
     ///// End of Helper functions ////
 
     Component.onCompleted: {
         root.draggingFinished.connect(handlerDraggingFinished);
         root.clearZoomSignal.connect(clearZoom);
         root.publishTasksGeometries.connect(slotPublishGeometries);
         root.showPreviewForTasks.connect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.connect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.connect(slotLaunchersChangedFor);
 
         var hasShownLauncher = ((tasksModel.launcherPosition(mainItemContainer.launcherUrl) !== -1)
                                     || (tasksModel.launcherPosition(mainItemContainer.launcherUrlWithIcon) !== -1) );
 
         //startup without launcher
         var hideStartup =  ((!hasShownLauncher || !launcherIsPresent(mainItemContainer.launcherUrl))
                             && mainItemContainer.isStartup);
 
         if (!Latte.WindowSystem.compositingActive) {
             visible = true;
         } else if ( (isWindow || isStartup || isLauncher) && root.waitingLauncherExists(launcherUrl)) {
             root.waitingLauncherRemoved.connect(slotWaitingLauncherRemoved);
             visible = false;
         } else if (hideStartup){
             visible = false;
         } else {
             visible = true;
         }
 
         showWindowAnimation.showWindow();
         updateAudioStreams();
     }
 
     Component.onDestruction: {
         root.waitingLauncherRemoved.disconnect(slotWaitingLauncherRemoved);
         root.draggingFinished.disconnect(handlerDraggingFinished);
         root.clearZoomSignal.disconnect(clearZoom);
         root.publishTasksGeometries.disconnect(slotPublishGeometries);
         root.showPreviewForTasks.disconnect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.disconnect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.disconnect(slotLaunchersChangedFor);
 
         wrapper.sendEndOfNeedBothAxisAnimation();
     }
 
     /////Animations
 
     TaskAnimations.TaskShowWindowAnimation{ id: showWindowAnimation }
 
     TaskAnimations.TaskRestoreAnimation{ 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) {
                     return;
                 }
 
                 if(mainItemContainer.containsMouse && windowsPreviewDlg.activeItem !== mainItemContainer){
                     //console.log("Hovered Timer....");
                     if (root.showPreviews && (!root.latteDock
                                               || (root.latteDock && !root.latteDock.isHalfShown
                                                   && !root.latteDock.inSlidingIn && !root.latteDock.inSlidingOut))) {
                         mainItemContainer.preparePreviewWindow(false);
                         windowsPreviewDlg.show(mainItemContainer);
                     } else if (mainItemContainer.isWindow && root.highlightWindows) {
                         root.windowsHovered(model.LegacyWinIdList, mainItemContainer.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: mainItemContainer.resistanceDelay
             repeat: false
 
             onTriggered: {
                 if (!mainItemContainer.inBlockingAnimation){
                     mainItemContainer.isDragged = true;
                 }
 
                 if (latteDock && latteDock.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 desappear 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 situattions 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*root.durationTime*showWindowAnimation.speed
     property int windowDelay: mainItemContainer.isStartup ? 3*root.durationTime*units.longDuration : mainDelay
 
     Component {
         id: delayShowWindow
         Timer {
             id: timerWindow
 
             interval: windowDelay
 
             repeat: false
 
             onTriggered: {
                 //console.log("I am in here: "+mainItemContainer.windowDelay);
                 // showWindowAnimation.execute();
                 if(!mainItemContainer.buffersAreReady)
                     showWindowAnimation.showWindow();
                 else
                     showWindowAnimation.execute();
 
                 if (latteDock && latteDock.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 (mainItemContainer.itemIndex >= 0){
                 mainItemContainer.lastValidIndex = mainItemContainer.itemIndex;
 
                 if (root.showWindowsOnlyFromLaunchers) {
                     parabolicManager.updateTasksEdgesIndexes();
                 }
             }
 
             if (latteDock && latteDock.debugModeTimers) {
                 console.log("plasmoid timer: lastValidTimer called...");
             }
         }
     }
 
     // The best solution in order to catch when the wheel action ended is to
     // track the isMinimized state, but when the user has enabled window previews
     // at all times that flag doesnt work
     Timer {
         id: wheelActionDelayer
         interval: 200
         onTriggered: {
             mainItemContainer.inWheelAction = false;
 
             if (latteDock && latteDock.debugModeTimers) {
                 console.log("plasmoid timer: wheelActionDelayer called...");
             }
         }
     }
 
     ///Item's Removal Animation
     ListView.onRemove: TaskAnimations.TaskRealRemovalAnimation{ id: taskRealRemovalAnimation }
 
 }// main Item