diff --git a/containment/package/contents/code/LayoutManager.js b/containment/package/contents/code/LayoutManager.js
index 12ed3e9d..f4ffc62d 100644
--- a/containment/package/contents/code/LayoutManager.js
+++ b/containment/package/contents/code/LayoutManager.js
@@ -1,496 +1,496 @@
 /*
 *  Copyright 2016        Smith AR <audoban@openmailbox.org>
 *            2016-2018   Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 var layout;
 var layoutS;
 var layoutE;
 var root;
 var metrics;
 var plasmoid;
 var lastSpacer;
 
 var childFoundId = 11;
 var inRestore=false;
 
 function restore() {
     inRestore = true;
     var configString = String(plasmoid.configuration.appletOrder)
 
     //array, a cell for encoded item order
     var itemsArray = configString.split(";");
 
     //map applet id->order in panel
     var idsOrder = new Object();
     //map order in panel -> applet pointer
     var appletsOrder = new Object();
 
     for (var i = 0; i < itemsArray.length; i++) {
         //property name: applet id
         //property value: order
         idsOrder[itemsArray[i]] = i;
     }
 
     for (var i = 0; i < plasmoid.applets.length; ++i) {
         if (idsOrder[plasmoid.applets[i].id] !== undefined) {
             appletsOrder[idsOrder[plasmoid.applets[i].id]] = plasmoid.applets[i];
             //ones that weren't saved in AppletOrder go to the end
         } else {
             appletsOrder["unordered"+i] = plasmoid.applets[i];
         }
     }
 
     //finally, restore the applets in the correct order
     for (var i in appletsOrder) {
         root.addApplet(appletsOrder[i], -1, -1)
     }
 
     if (plasmoid.configuration.alignment === 10 /*Justify*/) {
         // console.log("splitters restored:"+plasmoid.configuration.splitterPosition+ " - " + plasmoid.configuration.splitterPosition2);
         //add the splitters in the correct position if they exist
 
         var validSplitter1 = -1;
 
         if(plasmoid.configuration.splitterPosition !== -1){
             var missingApplets = 0;
 
             for (var i=0; i<plasmoid.configuration.splitterPosition; ++i) {
                 if (appletsOrder[i] === undefined) {
                     missingApplets = missingApplets + 1;
                 }
             }
 
             validSplitter1 = plasmoid.configuration.splitterPosition-missingApplets;
 
             // console.log("INTERNAL SPLITTER 1 ::: " + plasmoid.configuration.splitterPosition);
             // console.log("UNDEFINEDSPLITTER 1 ::: " + missingApplets);
             // console.log("VALID    SPLITTER 1 ::: " + validSplitter1);
 
             root.addInternalViewSplitter(validSplitter1);
         }
 
         if(plasmoid.configuration.splitterPosition2 !== -1){
             var missingApplets2 = 0;
             var spacers = plasmoid.configuration.splitterPosition !== -1 ? 1 : 0;
 
             for (var i=0; i<plasmoid.configuration.splitterPosition2-spacers; ++i) {
                 if (appletsOrder[i] === undefined) {
                     missingApplets2 = missingApplets2 + 1;
                 }
             }
 
             var validSplitter2 = plasmoid.configuration.splitterPosition2-missingApplets2;
 
             // console.log("INTERNAL SPLITTER 2 ::: " + plasmoid.configuration.splitterPosition2);
             // console.log("UNDEFINEDSPLITTER 2 ::: " + missingApplets2);
             // console.log("VALID    SPLITTER 2 ::: " + validSplitter2);
 
             root.addInternalViewSplitter(validSplitter2);
         }
     }
 
     //rewrite, so if in the orders there were now invalid ids or if some were missing creates a correct list instead
     save();
     restoreOptions();
 
     inRestore = false;
 
     if (plasmoid.configuration.alignment === 10/*Justify*/) {
         root.splitMainLayoutToLayouts();
         root.updateIndexes();
     }
 }
 
 function restoreOptions() {
     restoreOption("lockedZoomApplets");
     restoreOption("userBlocksColorizingApplets");
 }
 
 function restoreOption(option) {
     var configString;
 
     if (option === "lockedZoomApplets") {
         configString = String(plasmoid.configuration.lockedZoomApplets);
     } else if (option === "userBlocksColorizingApplets") {
         configString = String(plasmoid.configuration.userBlocksColorizingApplets);
     }
 
     //array, a cell for encoded item order
     var itemsArray = configString.split(";");
 
     for (var i = 0; i < itemsArray.length; i++) {
         for (var j = 0; j < layout.children.length; ++j) {
             var child = layout.children[j];
 
             if (child.applet && (child.applet.id == itemsArray[i])) {
                 if (option === "lockedZoomApplets") {
                     child.lockZoom = true;
                 } else if (option === "userBlocksColorizingApplets") {
                     child.userBlocksColorizing = true;
                 }
             }
         }
     }
 }
 
 function save() {
     var ids = new Array();
     var splitterExists = false;
     var splitterExists2 = false;
 
     for (var i = 0; i < layoutS.children.length; ++i) {
         var child = layoutS.children[i];
 
         if (child.applet && !child.isInternalViewSplitter) {
             ids.push(child.applet.id);
         } else if(child.isInternalViewSplitter && plasmoid.configuration.alignment === 10 && !splitterExists){
             splitterExists = true;
             plasmoid.configuration.splitterPosition = i;
         } else if(child.isInternalViewSplitter && plasmoid.configuration.alignment === 10 && splitterExists){
             splitterExists2 = true;
             plasmoid.configuration.splitterPosition2 = i;
         }
     }
 
     for (var i = 0; i < layout.children.length; ++i) {
         var child = layout.children[i];
 
         if (child.applet && !child.isInternalViewSplitter) {
             ids.push(child.applet.id);
         } else if(child.isInternalViewSplitter && plasmoid.configuration.alignment === 10 && !splitterExists){
             splitterExists = true;
             plasmoid.configuration.splitterPosition = i + layoutS.children.length;
         } else if(child.isInternalViewSplitter && plasmoid.configuration.alignment === 10 && splitterExists){
             splitterExists2 = true;
             plasmoid.configuration.splitterPosition2 = i + layoutS.children.length;
         }
     }
 
     for (var i = 0; i < layoutE.children.length; ++i) {
         var child = layoutE.children[i];
 
         if (child.applet && !child.isInternalViewSplitter) {
             ids.push(child.applet.id);
         } else if(child.isInternalViewSplitter && plasmoid.configuration.alignment === 10 && !splitterExists){
             splitterExists = true;
             plasmoid.configuration.splitterPosition = i + layoutS.children.length + layout.children.length;
         } else if(child.isInternalViewSplitter && plasmoid.configuration.alignment === 10 && splitterExists){
             splitterExists2 = true;
             plasmoid.configuration.splitterPosition2 = i + layoutS.children.length + layout.children.length;
         }
     }
 
     console.log("SAVING SPLITTERS :: " + plasmoid.configuration.splitterPosition + " _ " + plasmoid.configuration.splitterPosition2);
 
     //console.log("splitters saved:"+plasmoid.configuration.splitterPosition+ " - " + plasmoid.configuration.splitterPosition2);
 
     plasmoid.configuration.appletOrder = ids.join(';');
 }
 
 function saveOptions() {
     saveOption("lockedZoomApplets");
     saveOption("userBlocksColorizingApplets");
 }
 
 function saveOption(option) {
     var ids = new Array();
     for (var i = 0; i < layout.children.length; ++i) {
         var child = layout.children[i];
 
         if (child.applet
                 && (option === "lockedZoomApplets" && child.lockZoom)
                 || (option === "userBlocksColorizingApplets" && child.userBlocksColorizing)) {
             ids.push(child.applet.id);
         }
     }
 
     if (option === "lockedZoomApplets") {
         plasmoid.configuration.lockedZoomApplets = ids.join(';');
     } else if (option === "userBlocksColorizingApplets") {
         plasmoid.configuration.userBlocksColorizingApplets = ids.join(';');
     }
 }
 
 function removeApplet (applet) {
     for (var i = layout.children.length - 1; i >= 0; --i) {
         var child = layout.children[i];
         if (child.applet === applet) {
             child.destroy();
         }
     }
 }
 
 //insert item2 before item1
 function insertBefore(item1, item2) {
     return insertBeforeForLayout(layout, item1, item2);
 }
 
 //insert item2 before item1
 function insertBeforeForLayout(tLayout, item1, item2) {
     if (item1 === item2) {
         return -1;
     }
     var removed = new Array();
 
     var child;
 
     var i;
     for (i = tLayout.children.length - 1; i >= 0; --i) {
         child = tLayout.children[i];
         removed.push(child);
         child.parent = root;
 
         if (child === item1) {
             break;
         }
     }
 
     item2.parent = tLayout;
 
     for (var j = removed.length - 1; j >= 0; --j) {
         removed[j].parent = tLayout;
     }
 
     return i;
 }
 
 
 //insert item2 after item1
 function insertAfter(item1, item2) {
     return insertAfterForLayout(layout, item1, item2);
 }
 
 //insert item2 after item1
 function insertAfterForLayout(tLayout, item1, item2) {
     if (item1 === item2) {
         return -1;
     }
     var removed = new Array();
 
     var child;
 
     var i;
     for (i = tLayout.children.length - 1; i >= 0; --i) {
         child = tLayout.children[i];
         //never ever insert after lastSpacer
         if (child === lastSpacer && item1 === lastSpacer) {
             removed.push(child);
             child.parent = root;
             break;
         } else if (child === item1) {
             //Already in position, do nothing
             if (tLayout.children[i+1] === item2) {
                 return -1;
             }
             break;
         }
 
         removed.push(child);
         child.parent = root;
     }
 
     item2.parent = tLayout;
 
     for (var j = removed.length - 1; j >= 0; --j) {
         removed[j].parent = tLayout;
     }
 
     return i;
 }
 
 
 function insertAtIndex(item, position) {
     var addToEnd = false;
     if (position < 0 || (position > layout.children.length && !item.isInternalViewSplitter)) {
         return;
     } else if (position >= layout.children.length) {
         addToEnd = true;
     }
 
     //never ever insert after lastSpacer
     var firstItem = (layout.children.length === 1) && (layout.children[0] === lastSpacer);
 
     //Important !!! , this is used to add the first item
     if(firstItem){
         lastSpacer.parent = root;
         position = 0;
     }
 
     if (addToEnd){
         item.parent=layout;
         return;
     }
 
     if(layout.children.length > 0){
         if (layout.children[position] === lastSpacer) {
             --position;
         }
     }
 
     var removedItems = new Array();
 
     var totalChildren = layout.children.length;
     for (var i = position; i < totalChildren; ++i) {
         var child = layout.children[position];
         child.parent = root;
         removedItems.push(child);
     }
 
     item.parent = layout;
     for (var i in removedItems) {
         removedItems[i].parent = layout;
     }
 }
 
 function insertAtCoordinates(item, x, y) {
     if (root.isHorizontal) {
         y = layout.height / 2;
     } else {
         x = layout.width / 2;
     }
     var child = layout.childAt(x, y);
 
     //if we got a place inside the space between 2 applets, we have to find it manually
     if (!child) {
         if (root.isHorizontal) {
             for (var i = 0; i < layout.children.length; ++i) {
                 var candidate = layout.children[i];
                 if (x >= candidate.x && x < candidate.x + candidate.width + layout.rowSpacing) {
                     child = candidate;
                     break;
                 }
             }
         } else {
             for (var i = 0; i < layout.children.length; ++i) {
                 var candidate = layout.children[i];
                 if (y >= candidate.x && y < candidate.y + candidate.height + layout.columnSpacing) {
                     child = candidate;
                     break;
                 }
             }
         }
     }
 
     //already in position
     if (child === item) {
         return;
     }
 
     if (!child) {
         // check if dragging takes place after the end of the layout
         if ( ((root.isVertical && y > layout.height)||(root.isHorizontal && x > layout.width))
                 && layout.children.length>0  ){
             child = layout.children[layout.children.length-1];
         } else {
             child = layout.children[0];
         }
     } else {
         item.parent = root;
     }
 
     if ((root.isVertical && y < child.y + child.height/2) ||
             (root.isHorizontal && x < child.x + child.width/2)) {
         return insertBefore(child, item);
     } else {
         return insertAfter(child, item);
     }
 }
 
 //this is used only for the start and end layouts
 function insertAtLayoutCoordinates(tLayout, item, x, y) {
     if (root.isHorizontal) {
         y = tLayout.height / 2;
     } else {
         x = tLayout.width / 2;
     }
     var child = tLayout.childAt(x, y);
 
     //if we got a place inside the space between 2 applets, we have to find it manually
     if (!child) {
         if (root.isHorizontal) {
             for (var i = 0; i < tLayout.children.length; ++i) {
                 var candidate = tLayout.children[i];
                 if (x >= candidate.x && x < candidate.x + candidate.width + tLayout.rowSpacing) {
                     child = candidate;
                     break;
                 }
             }
         } else {
             for (var i = 0; i < tLayout.children.length; ++i) {
                 var candidate = tLayout.children[i];
                 if (y >= candidate.x && y < candidate.y + candidate.height + tLayout.columnSpacing) {
                     child = candidate;
                     break;
                 }
             }
         }
     }
 
     //already in position
     if (child === item) {
         //
         return childFoundId;
     }
 
     if (!child) {
         // check if dragging takes place after the end of the layout
-        var neededSpace = 1.5 * (metrics.iconSize + root.lengthMargin);
+        var neededSpace = 1.5 * (metrics.iconSize + metrics.totals.lengthEdge);
         if ( (((root.isVertical && (y - neededSpace) <= tLayout.height) && y>=0)
               ||(root.isHorizontal && (x - neededSpace) <= tLayout.width) && x>=0)
                 && tLayout.children.length>0  ){
             child = tLayout.children[layout.children.length-1];
             // check if dragging takes place before the start of the layout
         } else if ( ((root.isVertical && (y >= -neededSpace) && (y<=neededSpace))
                      ||(root.isHorizontal && (x >= -neededSpace)  && (x<=neededSpace)))
                    && tLayout.children.length>0  ){
             child = tLayout.children[0];
         } else {
             return -1;
             //child = tLayout.children[0];
         }
     } else {
         item.parent = root;
     }
 
     if ((root.isVertical && y < child.y + child.height/2) ||
             (root.isHorizontal && x < child.x + child.width/2)) {
         return insertBeforeForLayout(tLayout, child, item);
     } else {
         return insertAfterForLayout(tLayout, child, item);
     }
 }
 
 function insertAtCoordinates2(item, x, y) {
     var pos = -1;
 
     if (!root.inConfigureAppletsMode) {
         var layoutPosS = layoutS.mapFromItem(root, x, y);
         pos = insertAtLayoutCoordinates(layoutS, item, layoutPosS.x, layoutPosS.y);
 
         if (pos === -1){
             var layoutPosE = layoutE.mapFromItem(root, x, y);
             pos = insertAtLayoutCoordinates(layoutE, item, layoutPosE.x, layoutPosE.y);
         }
     }
 
     if (pos!==childFoundId && pos === -1) {
         var layoutPos = layout.mapFromItem(root, x, y);
         insertAtCoordinates(item, layoutPos.x, layoutPos.y);
     }
 }
diff --git a/containment/package/contents/ui/DebugWindow.qml b/containment/package/contents/ui/DebugWindow.qml
index 9a5b98a6..d68ad3aa 100644
--- a/containment/package/contents/ui/DebugWindow.qml
+++ b/containment/package/contents/ui/DebugWindow.qml
@@ -1,832 +1,832 @@
 /*
 *  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.1
 import QtQuick.Window 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 
 import org.kde.latte.core 0.2 as LatteCore
 
 Window{
     width: mainGrid.width + 10
     height: Math.min(mainGrid.height+10, Screen.height - visibilityManager.thicknessNormalOriginal)
     visible: true
 
     property string space:" :   "
 
     PlasmaExtras.ScrollArea {
         id: scrollArea
 
         anchors.fill: parent
         verticalScrollBarPolicy: Qt.ScrollBarAsNeeded
         horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
 
         flickableItem.flickableDirection: Flickable.VerticalFlick
 
         Grid{
             id:mainGrid
             columns: 2
 
             Text{
                 text: "Screen id"+space
             }
 
             Text{
                 text: latteView && latteView.positioner ? latteView.positioner.currentScreenName : "___"
             }
 
             Text{
                 text: "Screen Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.screenGeometry){
                         return latteView.screenGeometry.x+","+latteView.screenGeometry.y+ " "+latteView.screenGeometry.width+"x"+latteView.screenGeometry.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Window Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView) {
                         return  latteView.x + "," + latteView.y + " "+latteView.width+ "x"+latteView.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "On Primary"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.onPrimary)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Contents Width"+space
             }
 
             Text{
                 text: layoutsContainer.contentsWidth
             }
 
             Text{
                 text: "Contents Height"+space
             }
 
             Text{
                 text: layoutsContainer.contentsHeight
             }
 
             Text{
                 text: "Max Length"+space
             }
 
             Text{
                 text: root.maxLengthPerCentage +"%"
             }
 
             Text{
                 text: "Max Length (pixels)"+space
             }
 
             Text{
                 text: root.maxLength
             }
 
             Text{
                 text: "Min Length"+space
             }
 
             Text{
                 text: root.minLengthPerCentage +"%"
             }
 
             Text{
                 text: "Min Length (pixels)"+space
             }
 
             Text{
                 text: root.minLength
             }
 
             Text{
                 text: "Offset (pixels)"+space
             }
 
             Text{
                 text: root.offset
             }
 
             Text{
                 text: "Mask"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.effects && latteView.effects.mask) {
                         return latteView.effects.mask.x +", "+ latteView.effects.mask.y+"  "+latteView.effects.mask.width+"x"+latteView.effects.mask.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Absolute Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.absoluteGeometry) {
                         return latteView.absoluteGeometry.x + ", " + latteView.absoluteGeometry.y + "  " + latteView.absoluteGeometry.width + "x" + latteView.absoluteGeometry.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Local Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.localGeometry) {
                         return latteView.localGeometry.x + ", " + latteView.localGeometry.y + "  " + latteView.localGeometry.width + "x" + latteView.localGeometry.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Draw Effects"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.effects && latteView.effects.drawEffects)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Effects Area"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.effects && latteView.effects.rect) {
                         return latteView.effects.rect.x + ", " + latteView.effects.rect.y + "  " +latteView.effects.rect.width + "x" + latteView.effects.rect.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Is Hidden (flag)"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.visibility && latteView.visibility.isHidden)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Contains Mouse (flag)"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.visibility && latteView.visibility.containsMouse)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Edit Mode"+space
             }
 
             Text{
                 text: {
                     if (root.editMode)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Location"+space
             }
 
             Text{
                 text: {
                     switch(plasmoid.location){
                     case PlasmaCore.Types.LeftEdge:
                         return "Left Edge";
                         break;
                     case PlasmaCore.Types.RightEdge:
                         return "Right Edge";
                         break;
                     case PlasmaCore.Types.TopEdge:
                         return "Top Edge";
                         break;
                     case PlasmaCore.Types.BottomEdge:
                         return "Bottom Edge";
                         break;
                     }
 
                     return " <unknown> : " + plasmoid.location;
                 }
             }
 
             Text{
                 text: "Alignment"+space
             }
 
             Text{
                 text: {
                     switch(plasmoid.configuration.alignment){
                     case LatteCore.Types.Left:
                         return "Left";
                         break;
                     case LatteCore.Types.Right:
                         return "Right";
                         break;
                     case LatteCore.Types.Center:
                         return "Center";
                         break;
                     case LatteCore.Types.Top:
                         return "Top";
                         break;
                     case LatteCore.Types.Bottom:
                         return "Bottom";
                         break;
                     case LatteCore.Types.Justify:
                         return "Justify";
                         break;
                     }
 
                     return "<unknown> : " + plasmoid.configuration.alignment;
                 }
             }
 
             Text{
                 text: "Visibility"+space
             }
 
             Text{
                 text: {
                     if (!latteView || !latteView.visibility)
                         return "";
 
                     switch(latteView.visibility.mode){
                     case LatteCore.Types.AlwaysVisible:
                         return "Always Visible";
                         break;
                     case LatteCore.Types.AutoHide:
                         return "Auto Hide";
                         break;
                     case LatteCore.Types.DodgeActive:
                         return "Dodge Active";
                         break;
                     case LatteCore.Types.DodgeMaximized:
                         return "Dodge Maximized";
                         break;
                     case LatteCore.Types.DodgeAllWindows:
                         return "Dodge All Windows";
                         break;
                     case LatteCore.Types.DodgeAllWindows:
                         return "Dodge All Windows";
                         break;
                     case LatteCore.Types.WindowsGoBelow:
                         return "Windows Go Below";
                         break;
                     case LatteCore.Types.WindowsCanCover:
                         return "Windows Can Cover";
                         break;
                     case LatteCore.Types.WindowsAlwaysCover:
                         return "Windows Always Cover";
                         break;
                     case LatteCore.Types.SideBar:
                         return "OnDemand SideBar";
                         break;
                     case LatteCore.Types.NormalWindow:
                         return "Normal Window";
                         break;
                     case LatteCore.Types.None:
                         return "None";
                         break;
                     }
 
                     return "<unknown> : " + latteView.visibility.mode;
                 }
             }
 
             Text{
                 text: "Zoom Factor"+space
             }
 
             Text{
                 text: root.zoomFactor
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Icon Size (current)"+space
             }
 
             Text{
                 text: metrics.iconSize
             }
 
             Text{
                 text: "Icon Size (user)"+space
             }
 
             Text{
                 text: plasmoid.configuration.iconSize
             }
 
             Text{
                 text: "Icon Size (portion)"+space
             }
 
             Text{
                 text: metrics.portionIconSize
             }
 
             Text{
                 text: "Icon Size (auto decrease), Enabled"+space
             }
 
             Text{
                 text: {
                     if (autosize.isActive)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Icon Size (auto decrease)"+space
             }
 
             Text{
                 text: autosize.iconSize
             }
 
             Text{
                 text: "Length Padding (pixels)"+space
             }
 
             Text{
                 text: metrics.padding.length
             }
 
             Text{
-                text: "Length External Margin (pixels)"+space
+                text: "Length Margin (pixels)"+space
             }
 
             Text{
-                text: root.lengthExtMargin
+                text: metrics.margin.length
             }
 
             Text{
                 text: "Thickness Margin"+space
             }
 
             Text{
                 text: metrics.margin.thickness
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Show Panel Background (user)"+space
             }
 
             Text{
                 text: {
                     if (plasmoid.configuration.useThemePanel)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Force Transparent Panel (auto)"+space
             }
 
             Text{
                 text: {
                     if (root.forceTransparentPanel)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Panel Background Length"+space
             }
 
             Text{
                 text: root.realPanelLength
             }
 
             Text{
                 text: "Panel Background Thickness(user)"+space
             }
 
             Text{
                 text: plasmoid.configuration.panelSize + "%"
             }
 
             Text{
                 text: "Panel Background Thickness(automatic)"+space
             }
 
             Text{
                 text: root.realPanelSize
             }
 
             Text{
                 text: "Panel Transparency"+space
             }
 
             Text{
                 text: root.panelTransparency + "%"
             }
 
             Text{
                 text: "Panel Shadows Active"+space
             }
 
             Text{
                 text: {
                     if (root.panelShadowsActive)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Panel Background Shadow"+space
             }
 
             Text{
                 text: root.panelShadow
             }
 
             Text{
                 text: "Panel Thickness Margin High"+space
             }
 
             Text{
                 text: root.panelThickMarginHigh
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Mask - Normal Thickness"+space
             }
 
             Text{
                 text: visibilityManager.thicknessNormal
             }
 
             Text{
                 text: "Thickness Uses Panel Size"+space
             }
 
             Text{
                 text: visibilityManager.panelIsBiggerFromIconSize
             }
 
             Text{
                 text: "Behave As Plasma Panel"+space
             }
 
             Text{
                 text: {
                     if (root.behaveAsPlasmaPanel)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Draw Shadows (external)"+space
             }
 
             Text{
                 text: {
                     if (root.drawShadowsExternal)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Applet Hovered"+space
             }
 
             Text{
                 text: layoutsContainer.hoveredIndex
             }
 
             Text{
                 text: "Task Hovered"+space
             }
 
             Text{
                 text: root.latteAppletHoveredIndex
             }
 
             Text{
                 text: "In Normal State"+space
             }
 
             Text{
                 text: visibilityManager.normalState
             }
 
             Text{
                 text: "Animations Both Axis"+space
             }
 
             Text{
                 text: animations.needBothAxis.count
             }
 
             Text{
                 text: "Animations Only Length"+space
             }
 
             Text{
                 text: animations.needLength.count
             }
 
             Text{
                 text: "Animations Need Thickness"+space
             }
 
             Text{
                 text: animations.needThickness.count
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Start Layout Shown Applets"+space
             }
 
             Text{
                 text: layoutsContainer.startLayout.shownApplets
             }
 
             Text{
                 text: "Start Layout Applets (with fill)"+space
             }
 
             Text{
                 text: layoutsContainer.startLayout.fillApplets
             }
 
             Text{
                 text: "Start Layout Size (no fill applets)"+space
             }
 
             Text{
                 text: layoutsContainer.startLayout.sizeWithNoFillApplets+" px."
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Main Layout Shown Applets"+space
             }
 
             Text{
                 text: layoutsContainer.mainLayout.shownApplets
             }
 
             Text{
                 text: "Main Layout Applets (with fill)"+space
             }
 
             Text{
                 text: layoutsContainer.mainLayout.fillApplets
             }
 
             Text{
                 text: "Main Layout Size (no fill applets)"+space
             }
 
             Text{
                 text: layoutsContainer.mainLayout.sizeWithNoFillApplets+" px."
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "End Layout Shown Applets"+space
             }
 
             Text{
                 text: layoutsContainer.endLayout.shownApplets
             }
 
             Text{
                 text: "End Layout Applets (with fill)"+space
             }
 
             Text{
                 text: layoutsContainer.endLayout.fillApplets
             }
 
             Text{
                 text: "End Layout Size (no fill applets)"+space
             }
 
             Text{
                 text: layoutsContainer.endLayout.sizeWithNoFillApplets+" px."
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Applets need Windows Tracking"+space
             }
 
             Text{
                 text: appletsRecords.windowsTrackingCount
             }
 
             Text{
                 text: "Last Active Window Current Screen (id)"+space
             }
 
             Text{
                 text: latteView && latteView.windowsTracker && latteView.windowsTracker.currentScreen.lastActiveWindow.isValid ?
                           latteView.windowsTracker.currentScreen.lastActiveWindow.winId : "--"
             }
 
             Text{
                 text: "Last Active Window Current Screen (title)"+space
             }
 
             Text{
                 text: latteView && latteView.windowsTracker && latteView.windowsTracker.currentScreen.lastActiveWindow.isValid ?
                           latteView.windowsTracker.currentScreen.lastActiveWindow.display : "--"
                 elide: Text.ElideRight
             }
 
             Text{
                 text: "Last Active Window All Screens (id)"+space
             }
 
             Text{
                 text: latteView && latteView.windowsTracker && latteView.windowsTracker.allScreens.lastActiveWindow.isValid ?
                           latteView.windowsTracker.allScreens.lastActiveWindow.winId : "--"
             }
 
             Text{
                 text: "Last Active Window All Screens (title)"+space
             }
 
             Text{
                 text: latteView && latteView.windowsTracker && latteView.windowsTracker.allScreens.lastActiveWindow.isValid ?
                           latteView.windowsTracker.allScreens.lastActiveWindow.display : "--"
                 elide: Text.ElideRight
             }
         }
 
     }
 }
diff --git a/containment/package/contents/ui/abilities/AutoSize.qml b/containment/package/contents/ui/abilities/AutoSize.qml
index 21d5031d..68179aeb 100644
--- a/containment/package/contents/ui/abilities/AutoSize.qml
+++ b/containment/package/contents/ui/abilities/AutoSize.qml
@@ -1,248 +1,248 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.8
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 
 Item {
     id: sizer
 
     // when there are only plasma style task managers OR any applets that fill width or height
     // the automatic icon size algorithm should better be disabled
     readonly property bool isActive: plasmoid.configuration.autoSizeEnabled
                                      && !root.containsOnlyPlasmaTasks
                                      && layouts.fillApplets<=0
                                      && latteView && latteView.visibility.mode !== LatteCore.Types.SideBar
     property int iconSize: -1 //it is not set, this is the default
 
     readonly property bool inCalculatedIconSize: ((metrics.iconSize === sizer.iconSize) || (metrics.iconSize === metrics.maxIconSize))
     readonly property bool inAutoSizeAnimation: !inCalculatedIconSize
 
     readonly property int automaticStep: 8
     readonly property int historyMaxSize: 10
     readonly property int historyMinSize: 4
 
 
     //! Prediction History of the algorithm in order to track cases where the algorithm produces
     //! grows and shrinks endlessly
     property variant history: []
 
     //! required elements
     property Item layouts
     property Item metrics
     property Item visibility
 
     onInAutoSizeAnimationChanged: {
         if (inAutoSizeAnimation) {
             animations.needBothAxis.addEvent(sizer);
         } else {
             animations.needBothAxis.removeEvent(sizer);
         }
     }
 
     onIsActiveChanged: clearHistory();
 
     Connections {
         target: root
 
         onContainsOnlyPlasmaTasksChanged: sizer.updateIconSize();
         onEditModeChanged: sizer.updateIconSize();
         onMaxLengthChanged: {
             if (root.editMode) {
                 sizer.updateIconSize();
             }
         }
     }
 
     Connections {
         target: metrics
 
         onPortionIconSizeChanged: {
             if (metrics.portionIconSize!==-1) {
                 sizer.updateIconSize();
             }
         }
     }
 
     Connections {
         target: latteView
         onWidthChanged:{
             if (root.isHorizontal && metrics.portionIconSize!==-1) {
                 sizer.updateIconSize();
             }
         }
 
         onHeightChanged:{
             if (root.isVertical && metrics.portionIconSize!==-1) {
                 sizer.updateIconSize();
             }
         }
     }
 
     //! Prediction History Functions
     function clearHistory() {
         history.length = 0;
     }
 
     function addPrediction(currentLength, prediction) {
         history.unshift({current: currentLength, predicted: prediction});
 
        /* console.log(" -- PREDICTION ARRAY -- ");
         for(var i=0; i<history.length; ++i) {
             console.log( i + ". " + history[i].current + " : " + history[i].predicted);
         }*/
 
         if (history.length > historyMaxSize) {
             history.splice(historyMinSize, history.length - historyMinSize);
         }
     }
 
     function producesEndlessLoop(currentLength, prediction) {
         if (history.length < 2) {
             return false;
         }
 
         if (history[1].current === currentLength
                 && history[1].predicted === prediction) {
             //! the current prediction is the same like two steps before in prediction history
 
             if(history[0].current > history[0].predicted && history[1].current < history[1].predicted) {
                 //! case2: the algorithm that is trying to SHRINK has already produced same results subsequently
                 console.log(" AUTOMATIC ITEM SIZE PROTECTOR, :: ENDLESS AUTOMATIC SIZE LOOP DETECTED");
                 return true;
             }
         }
 
         return false;
     }
 
 
     function updateIconSize() {
 
         if ( !doubleCallAutomaticUpdateIconSize.running && !visibility.inTempHiding
                 && ((visibility.normalState || root.editMode)
                     && (sizer.isActive || (!sizer.isActive && metrics.iconSize!==metrics.maxIconSize)))
                 && (metrics.iconSize===metrics.maxIconSize || metrics.iconSize === sizer.iconSize) ) {
 
             //!doubler timer
             if (!doubleCallAutomaticUpdateIconSize.secondTimeCallApplied) {
                 doubleCallAutomaticUpdateIconSize.start();
             } else {
                 doubleCallAutomaticUpdateIconSize.secondTimeCallApplied = false;
             }
 
             var layoutLength;
             var maxLength = root.maxLength;
 
             //console.log("------Entered check-----");
             //console.log("max length: "+ maxLength);
 
             if (root.isVertical) {
                 layoutLength = (plasmoid.configuration.alignment === LatteCore.Types.Justify) ?
                             layouts.startLayout.height+layouts.mainLayout.height+layouts.endLayout.height : layouts.mainLayout.height
             } else {
                 layoutLength = (plasmoid.configuration.alignment === LatteCore.Types.Justify) ?
                             layouts.startLayout.width+layouts.mainLayout.width+layouts.endLayout.width : layouts.mainLayout.width
             }
 
-            var itemLength = metrics.iconSize + lengthMargins;
+            var itemLength = metrics.totals.length;
 
             var toShrinkLimit = maxLength - (root.zoomFactor * itemLength);
             //! to grow limit must be a little less than the shrink one in order to be more robust and
             //! not create endless loops from early calculations
             var toGrowLimit = maxLength - (1.2 * root.zoomFactor * itemLength);
 
             //console.log("toShrinkLimit: "+ toShrinkLimit);
             //console.log("toGrowLimit: "+ toGrowLimit);
 
             var newIconSizeFound = false;
             if (layoutLength > toShrinkLimit) { //must shrink
                 // console.log("step3");
                 var nextIconSize = metrics.maxIconSize;
 
                 do {
                     nextIconSize = nextIconSize - automaticStep;
                     var factor = nextIconSize / metrics.iconSize;
                     var nextLength = factor * layoutLength;
 
                 } while ( (nextLength>toShrinkLimit) && (nextIconSize !== 16));
 
                 var intLength = Math.round(layoutLength);
                 var intNextLength = Math.round(nextLength);
 
                 iconSize = nextIconSize;
                 newIconSizeFound = true;
 
                 addPrediction(intLength, intNextLength);
                 // console.log("Step 3 - found:"+iconSize);
             } else if ((layoutLength<toGrowLimit
                         && (metrics.iconSize === iconSize)) ) { //must grow probably
                 // console.log("step4");
                 var nextIconSize2 = iconSize;
                 var foundGoodSize = -1;
 
                 do {
                     nextIconSize2 = nextIconSize2 + automaticStep;
                     var factor2 = nextIconSize2 / iconSize;
                     var nextLength2 = factor2 * layoutLength;
 
                     if (nextLength2 < toGrowLimit) {
                         foundGoodSize = nextIconSize2;
                     }
                 } while ( (nextLength2<toGrowLimit) && (nextIconSize2 !== metrics.maxIconSize ));
 
                 var intLength2 = Math.round(layoutLength);
                 var intNextLength2 = Math.round(nextLength2);
 
                 if (foundGoodSize > 0 && !producesEndlessLoop(intLength2, intNextLength2)) {
                     if (foundGoodSize === metrics.maxIconSize) {
                         iconSize = -1;
                     } else {
                         iconSize = foundGoodSize;
                     }
                     newIconSizeFound = true
 
                     addPrediction(intLength2, intNextLength2);
                     //        console.log("Step 4 - found:"+iconSize);
                 } else {
                     //       console.log("Step 4 - did not found...");
                 }
             }
         }
     }
 
     //! This functions makes sure to call the updateIconSize(); function which is costly
     //! one more time after its last call to confirm the applied icon size found
     Timer{
         id:doubleCallAutomaticUpdateIconSize
         interval: 1000
         property bool secondTimeCallApplied: false
 
         onTriggered: {
             if (!secondTimeCallApplied) {
                 secondTimeCallApplied = true;
                 sizer.updateIconSize();
             }
         }
     }
 }
diff --git a/containment/package/contents/ui/abilities/Metrics.qml b/containment/package/contents/ui/abilities/Metrics.qml
index c3d42bb6..e3c0b1bc 100644
--- a/containment/package/contents/ui/abilities/Metrics.qml
+++ b/containment/package/contents/ui/abilities/Metrics.qml
@@ -1,38 +1,39 @@
 /*
 *  Copyright 2020 Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 import org.kde.plasma.plasmoid 2.0
 
 import "./privates" as AbilityPrivate
 
 AbilityPrivate.MetricsPrivate {
     //! Signals
     signal iconSizeAnimationEnded();
 
     //! Public Properties
     iconSize: autosizeEnabled && autosize.iconSize > 0 ? Math.min(autosize.iconSize, maxIconSize) : maxIconSize
     maxIconSize: portionIconSize!==-1 ? portionIconSize : plasmoid.configuration.iconSize
 
+    margin.length: fraction.lengthMargin * iconSize
     margin.thickness: fraction.thicknessMargin * iconSize
     margin.maxThickness: fraction.thicknessMargin * maxIconSize
 
     padding.length: fraction.lengthPadding * iconSize
     padding.lengthApplet: fraction.lengthAppletPadding * iconSize
 }
diff --git a/containment/package/contents/ui/abilities/privates/MetricsPrivate.qml b/containment/package/contents/ui/abilities/privates/MetricsPrivate.qml
index 54ad4985..29005f31 100644
--- a/containment/package/contents/ui/abilities/privates/MetricsPrivate.qml
+++ b/containment/package/contents/ui/abilities/privates/MetricsPrivate.qml
@@ -1,85 +1,92 @@
 /*
 *  Copyright 2020 Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.abilities.containers 0.1 as ContainerAbility
 
 import "./metrics" as MetricsPrivateTypes
 
 ContainerAbility.Metrics {
     id: mets
     property Item animations: null
     property Item autosize: null
     property Item indicators: null
 
     //! Private Properties
     readonly property int portionIconSize: { //icon size based on screen height
         if ((plasmoid.configuration.proportionIconSize===-1) || !latteView)
             return -1;
 
         return Math.max(16,Math.round(latteView.screenGeometry.height * plasmoid.configuration.proportionIconSize/100/8)*8);
     }
 
     readonly property bool autosizeEnabled: autosize !== undefined && autosize.isActive
 
     readonly property MetricsPrivateTypes.Fraction fraction: MetricsPrivateTypes.Fraction{
         thicknessMargin: root.shrinkThickMargins ? indicators.info.minThicknessPadding :
                                                    Math.max(indicators.info.minThicknessPadding, plasmoid.configuration.thickMargin / 100)
 
         lengthMargin: plasmoid.configuration.lengthExtMargin / 100
         lengthPadding: indicators.isEnabled ? indicators.padding : 0
         lengthAppletPadding: indicators.infoLoaded ? indicators.info.appletLengthPadding : -1
     }
 
 
 
     //! BEHAVIORS
     Behavior on iconSize {
         enabled: !(root.editMode && root.behaveAsPlasmaPanel)
         NumberAnimation {
             duration: 0.8 * animations.duration.proposed
 
             onRunningChanged: {
                 if (!running) {
                     mets.iconSizeAnimationEnded();
                 }
             }
         }
     }
 
     margin {
+        Behavior on length {
+            NumberAnimation {
+                duration: 0.8 * animations.duration.proposed
+                easing.type: Easing.OutCubic
+            }
+        }
+
         Behavior on thickness {
             NumberAnimation {
                 duration: 0.8 * animations.duration.proposed
                 easing.type: Easing.OutCubic
             }
         }
     }
 
     padding {
         Behavior on length {
             NumberAnimation {
                 duration: 0.8 * animations.duration.proposed
                 easing.type: Easing.OutCubic
             }
         }
     }
 }
diff --git a/containment/package/contents/ui/applet/AppletItem.qml b/containment/package/contents/ui/applet/AppletItem.qml
index 5090f168..9c4346e4 100644
--- a/containment/package/contents/ui/applet/AppletItem.qml
+++ b/containment/package/contents/ui/applet/AppletItem.qml
@@ -1,1195 +1,1195 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "colorizer" as Colorizer
 import "communicator" as Communicator
 import "indicator" as Indicator
 
 Item {
     id: appletItem
 
     visible: false
     width: isInternalViewSplitter && !root.inConfigureAppletsMode ? 0 : computeWidth
     height: isInternalViewSplitter && !root.inConfigureAppletsMode ? 0 : computeHeight
 
     signal mousePressed(int x, int y, int button);
     signal mouseReleased(int x, int y, int button);
 
     property bool animationsEnabled: true
     property bool canBeHovered: true
     property bool canShowAppletNumberBadge: !isSeparator && !isHidden && !isLattePlasmoid
                                             && !isSpacer && !isInternalViewSplitter
     property bool inFillCalculations: false //temp record, is used in calculations for fillWidth,fillHeight applets
     property bool needsFillSpace: { //fill flag, it is used in calculations for fillWidth,fillHeight applets
         if (!applet || !applet.Layout)
             return false;
 
         if (((root.isHorizontal && applet.Layout.fillWidth===true)
              || (root.isVertical && applet.Layout.fillHeight===true))
                 && (applet.status !== PlasmaCore.Types.HiddenStatus))
             return true;
         else
             return false;
     }
 
     property bool userBlocksColorizing: false
     property bool appletBlocksColorizing: !communicator.requires.latteSideColoringEnabled
     property bool appletBlocksParabolicEffect: communicator.requires.parabolicEffectLocked
     property bool lockZoom: false
 
     property bool isActive: (isExpanded
                              && applet.pluginName !== root.plasmoidName
                              && applet.pluginName !== "org.kde.activeWindowControl"
                              && applet.pluginName !== "org.kde.plasma.appmenu")
 
     property bool isExpanded: false
 
     property bool isHidden: applet && applet.status === PlasmaCore.Types.HiddenStatus ? true : false
     property bool isInternalViewSplitter: (internalSplitterId > 0)
     property bool isLattePlasmoid: latteApplet !== null
     property bool isZoomed: false
     property bool isSeparator: applet && (applet.pluginName === "audoban.applet.separator"
                                           || applet.pluginName === "org.kde.latte.separator")
     property bool isSpacer: applet && (applet.pluginName === "org.kde.latte.spacer")
     property bool isSystray: applet && (applet.pluginName === "org.kde.plasma.systemtray" || applet.pluginName === "org.nomad.systemtray" )
 
     property bool firstChildOfStartLayout: index === layoutsContainer.startLayout.firstVisibleIndex
     property bool firstChildOfMainLayout: index === layoutsContainer.mainLayout.firstVisibleIndex
     property bool lastChildOfMainLayout: index === layoutsContainer.mainLayout.lastVisibleIndex
     property bool lastChildOfEndLayout: index === layoutsContainer.endLayout.lastVisibleIndex
 
     readonly property bool atScreenEdge: {
         if (root.panelAlignment !== LatteCore.Types.Justify || root.inConfigureAppletsMode || plasmoid.configuration.offset!==0) {
             return false;
         }
 
         if (root.panelAlignment === LatteCore.Types.Justify) {
             //! Justify case
             if (root.maxLengthPerCentage!==100) {
                 return false;
             }
 
             if (root.isHorizontal) {
                 if (firstChildOfStartLayout) {
                     return latteView && latteView.x === latteView.screenGeometry.x;
                 } else if (lastChildOfEndLayout) {
                     return latteView && ((latteView.x + latteView.width) === (latteView.screenGeometry.x + latteView.screenGeometry.width));
                 }
             } else {
                 if (firstChildOfStartLayout) {
                     return latteView && latteView.y === latteView.screenGeometry.y;
                 } else if (lastChildOfEndLayout) {
                     return latteView && ((latteView.y + latteView.height) === (latteView.screenGeometry.y + latteView.screenGeometry.height));
                 }
             }
 
             return false;
         }
 
         //! [disabled] because it is probably not needed at all. If in the future there is a report
         //! describing a case that this would be useful this disablement choice can be rethought
         /*if (root.panelAlignment === LatteCore.Types.Left) {
             //! Left case
             return firstChildOfMainLayout;
         } else if (root.panelAlignment === LatteCore.Types.Right) {
             //! Right case
             return lastChildOfMainLayout
         }
 
         if (root.panelAlignment === LatteCore.Types.Top) {
             return firstChildOfMainLayout && latteView && latteView.y === latteView.screenGeometry.y;
         } else if (root.panelAlignment === LatteCore.Types.Bottom) {
             return lastChildOfMainLayout && latteView && ((latteView.y + latteView.height) === (latteView.screenGeometry.y + latteView.screenGeometry.height));
         }*/
 
         return false;
     }
 
     //applet is in starting edge
     property bool firstAppletInContainer: (index >=0) &&
                                           ((index === layoutsContainer.startLayout.firstVisibleIndex)
                                            || (index === layoutsContainer.mainLayout.firstVisibleIndex)
                                            || (index === layoutsContainer.endLayout.firstVisibleIndex))
     //applet is in ending edge
     property bool lastAppletInContainer: (index >=0) &&
                                          ((index === layoutsContainer.startLayout.lastVisibleIndex)
                                           || (index === layoutsContainer.mainLayout.lastVisibleIndex)
                                           || (index === layoutsContainer.endLayout.lastVisibleIndex))
 
     readonly property bool acceptMouseEvents: applet && !isLattePlasmoid && !originalAppletBehavior && !appletItem.isSeparator && !communicator.requires.parabolicEffectLocked
     readonly property bool originalAppletBehavior: (root.zoomFactor === 1 && !lockZoom /*hacky flag to keep Latte behavior*/)
                                                    || (root.zoomFactor>1 && !canBeHovered)
                                                    || (root.zoomFactor>1 && canBeHovered && lockZoom)
 
     readonly property bool isSquare: communicator.overlayLatteIconIsActive
     readonly property bool screenEdgeMarginSupported: communicator.requires.screenEdgeMarginSupported
 
     property int animationTime: appletItem.animations.speedFactor.normal * (1.2*appletItem.animations.duration.small)
     property int hoveredIndex: layoutsContainer.hoveredIndex
     property int index: -1
     property int maxWidth: root.isHorizontal ? root.height : root.width
     property int maxHeight: root.isHorizontal ? root.height : root.width
     property int internalSplitterId: 0
 
     property int previousIndex: -1
     property int sizeForFill: -1 //it is used in calculations for fillWidth,fillHeight applets
-    property int spacersMaxSize: Math.max(0,Math.ceil(0.55 * metrics.iconSize) - root.lengthMargins)
+    property int spacersMaxSize: Math.max(0,Math.ceil(0.55 * metrics.iconSize) - metrics.totals.lengthEdges)
     property int status: applet ? applet.status : -1
 
     //! local margins
     readonly property bool parabolicEffectMarginsEnabled: root.zoomFactor>1 && !originalAppletBehavior
 
     property int lengthAppletPadding: metrics.fraction.lengthAppletPadding === -1 || parabolicEffectMarginsEnabled ?
                                           metrics.padding.length : metrics.padding.lengthApplet
 
-    property int lengthAppletFullMargin: lengthAppletPadding + root.lengthExtMargin
+    property int lengthAppletFullMargin: lengthAppletPadding + metrics.margin.length
     property int lengthAppletFullMargins: 2 * lengthAppletFullMargin
 
     property int internalWidthMargins: {
         if (root.isVertical) {
             return metrics.totals.thicknessEdges;
         }
 
         /*TODO, Fitt's case: is temporary until the atScreenEdge applets are aligned properly to the corner and the wrapper
           is taking all the space needed in order to fill right. For atScreenEdge appplets that should be: applet size + lengthAppletPadding + lengthAppletExtMargin.
           The indicator should follow also the applet alignment in this in order to feel right
           */
         return 2 * lengthAppletPadding;
     }
 
     property int internalHeightMargins: {
         if (root.isHorizontal) {
             return root.metrics.totals.thicknessEdges;
         }
 
         /*TODO,Fitt's case: is temporary until the atScreenEdge applets are aligned properly to the corner and the wrapper
           is taking all the space needed in order to fill right. For atScreenEdge appplets that should be: applet size + lengthAppletPadding + lengthAppletExtMargin.
           The indicator should follow also the applet alignment in this in order to feel right
           */
         return 2 * lengthAppletPadding;
     }
 
     //! are set by the indicator
     property int iconOffsetX: 0
     property int iconOffsetY: 0
 
     property real computeWidth: root.isVertical ? wrapper.width :
                                                   hiddenSpacerLeft.width+wrapper.width+hiddenSpacerRight.width
 
     property real computeHeight: root.isVertical ? hiddenSpacerLeft.height + wrapper.height + hiddenSpacerRight.height :
                                                    wrapper.height
 
     property string title: isInternalViewSplitter ? "Now Dock Splitter" : ""
 
     property Item applet: null
     property Item latteApplet: applet && (applet.pluginName === root.plasmoidName) ?
                                    (applet.children[0] ? applet.children[0] : null) : null
     property Item latteStyleApplet: applet && ((applet.pluginName === "org.kde.latte.spacer") || (applet.pluginName === "org.kde.latte.separator")) ?
                                         (applet.children[0] ? applet.children[0] : null) : null
 
     property Item appletWrapper: applet && (applet.pluginName === root.plasmoidName )? wrapper : wrapper.wrapperContainer
 
     property Item tooltipVisualParent: titleTooltipParent
 
     property Item communicatorAlias: communicator
     property Item wrapperAlias: wrapper
 
     property Item animations: null
     property Item appletsRecords: null
     property Item metrics: null
 
     property bool containsMouse: appletMouseArea.containsMouse /*|| appletMouseAreaBottom.containsMouse*/
     property bool pressed: viewSignalsConnector.pressed || clickedAnimation.running
 
 
     //// BEGIN :: Animate Applet when a new applet is dragged in the view
 
     //when the applet moves caused by its resize, don't animate.
     //this is completely heuristic, but looks way less "jumpy"
     property bool movingForResize: false
     property int oldX: x
     property int oldY: y
 
     onXChanged: {
         if (!foreDropArea.visible || movingForResize || !root.dragInfo.entered) {
             movingForResize = false;
             return;
         }
 
         if (!root.isVertical) {
             translation.x = oldX - x;
             translation.y = 0;
         } else {
             translation.y = oldY - y;
             translation.x = 0;
         }
 
         translAnim.running = true
 
         if (!root.isVertical) {
             oldX = x;
             oldY = 0;
         } else {
             oldY = y;
             oldX = 0;
         }
     }
 
     onYChanged: {
         if (!foreDropArea.visible || movingForResize || !root.dragInfo.entered) {
             movingForResize = false;
             return;
         }
 
         if (!root.isVertical) {
             translation.x = oldX - x;
             translation.y = 0;
         } else {
             translation.y = oldY - y;
             translation.x = 0;
         }
 
         translAnim.running = true;
 
         if (!root.isVertical) {
             oldX = x;
             oldY = 0;
         } else {
             oldY = y;
             oldX = 0;
         }
     }
 
     transform: Translate {
         id: translation
     }
 
     NumberAnimation {
         id: translAnim
         duration: appletItem.animations.duration.large
         easing.type: Easing.InOutQuad
         target: translation
         properties: "x,y"
         to: 0
     }
 
     Behavior on lengthAppletPadding {
         NumberAnimation {
             duration: 0.8 * appletItem.animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
 
     //// END :: Animate Applet when a new applet is dragged in the view
 
     /// BEGIN functions
     function activateAppletForNeutralAreas(mouse){
         //if the event is at the active indicator or spacers area then try to expand the applet,
         //unfortunately for other applets there is no other way to activate them yet
         //for example the icon-only applets
         var choords = mapToItem(appletItem.appletWrapper, mouse.x, mouse.y);
 
         var wrapperContainsMouse = choords.x>=0 && choords.y>=0 && choords.x<appletItem.appletWrapper.width && choords.y<appletItem.appletWrapper.height;
         var appletItemContainsMouse = mouse.x>=0 && mouse.y>=0 && mouse.x<width && mouse.y<height;
 
         //console.log(" APPLET :: " + mouse.x +  " _ " + mouse.y);
         //console.log(" WRAPPER :: " + choords.x + " _ " + choords.y);
 
         var inThicknessNeutralArea = !wrapperContainsMouse && (root.localScreenEdgeMargin>0);
         var appletNeutralAreaEnabled = !(inThicknessNeutralArea && root.dragActiveWindowEnabled);
 
         if (appletItemContainsMouse && !wrapperContainsMouse && appletNeutralAreaEnabled) {
             //console.log("PASSED");
             latteView.extendedInterface.toggleAppletExpanded(applet.id);
         } else {
             //console.log("REJECTED");
         }
     }
 
     function checkIndex(){
         index = -1;
 
         for(var i=0; i<layoutsContainer.startLayout.count; ++i){
             var child = layoutsContainer.startLayout.children[i];
             if (child === appletItem){
                 index = layoutsContainer.startLayout.beginIndex + i;
                 break;
             }
         }
 
         for(var i=0; i<layoutsContainer.mainLayout.count; ++i){
             var child = layoutsContainer.mainLayout.children[i];
             if (child === appletItem){
                 index = layoutsContainer.mainLayout.beginIndex + i;
                 break;
             }
         }
 
         for(var i=0; i<layoutsContainer.endLayout.count; ++i){
             var child = layoutsContainer.endLayout.children[i];
             if (child === appletItem){
                 //create a very high index in order to not need to exchange hovering messages
                 //between layoutsContainer.mainLayout and layoutsContainer.endLayout
                 index = layoutsContainer.endLayout.beginIndex + i;
                 break;
             }
         }
 
         if(appletItem.latteApplet){
             if(index===layoutsContainer.startLayout.beginIndex || index===layoutsContainer.mainLayout.beginIndex || index===layoutsContainer.endLayout.beginIndex)
                 latteApplet.disableLeftSpacer = false;
             else
                 latteApplet.disableLeftSpacer = true;
 
             if( index === layoutsContainer.startLayout.beginIndex + layoutsContainer.startLayout.count - 1
                     || index===layoutsContainer.mainLayout.beginIndex + layoutsContainer.mainLayout.count - 1
                     || index === layoutsContainer.endLayout.beginIndex + layoutsContainer.endLayout.count - 1)
                 latteApplet.disableRightSpacer = false;
             else
                 latteApplet.disableRightSpacer = true;
         }
     }
 
     //this functions gets the signal from the plasmoid, it can be used for signal items
     //outside the LatteApplet Plasmoid
     //property int debCounter: 0;
     function clearZoom(){
         if (layoutsContainer.hoveredIndex === -1 && root.latteAppletHoveredIndex === -1) {
             restoreAnimation.start();
         }
     }
 
     function checkCanBeHovered(){
         canBeHoveredTimer.start();
     }
 
     //! Reduce calculations and give the time to applet to adjust to prevent binding loops
     Timer{
         id: canBeHoveredTimer
         interval: 100
         onTriggered: {
             if (wrapper.zoomScale !== 1) {
                 return;
             }
 
             var maxSize = appletItem.metrics.iconSize + metrics.totals.thicknessEdges;
             var maxForMinimumSize = appletItem.metrics.iconSize + metrics.totals.thicknessEdges;
 
             if ( isSystray
                     || appletItem.needsFillSpace
                     || (((applet && root.isHorizontal && (applet.width > maxSize || applet.Layout.minimumWidth > maxForMinimumSize))
                          || (applet && root.isVertical && (applet.height > maxSize || applet.Layout.minimumHeight > maxForMinimumSize)))
                         && !appletItem.isSpacer
                         && !communicator.canShowOverlaiedLatteIcon) ) {
                 appletItem.canBeHovered = false;
             } else {
                 appletItem.canBeHovered = true;
             }
         }
     }
 
     function slotDestroyInternalViewSplitters() {
         if (isInternalViewSplitter) {
             destroy();
         }
     }
 
     //! pos in global root positioning
     function containsPos(pos) {
         var relPos = root.mapToItem(appletItem,pos.x, pos.y);
 
         if (relPos.x>=0 && relPos.x<=width && relPos.y>=0 && relPos.y<=height)
             return true;
 
         return false;
     }
 
     function refersEntryIndex(entryIndex) {
         return (entryIndex === parabolicManager.pseudoAppletIndex(appletItem.index));
     }
 
     ///END functions
 
     //BEGIN connections
     onAppletChanged: {
         if (!applet) {
             destroy();
         }
     }
 
     onIndexChanged: {
         if (appletItem.latteApplet) {
             root.latteAppletPos = index;
         }
 
         if (isHidden) {
             parabolicManager.setHidden(previousIndex, index);
         }
 
         if (isSeparator) {
             parabolicManager.setSeparator(previousIndex, index);
         }
 
         if (index>-1) {
             previousIndex = index;
         }
     }
 
     onIsExpandedChanged: {
         if (isExpanded) {
             root.hideTooltipLabel();
         }
     }
 
     onIsHiddenChanged: {
         if (isHidden) {
             parabolicManager.setHidden(-1, index);
         } else {
             parabolicManager.setHidden(index, -1);
         }
     }
 
     onIsSeparatorChanged: {
         if (isSeparator) {
             parabolicManager.setSeparator(-1, index);
         } else {
             parabolicManager.setSeparator(index, -1);
         }
 
     }
 
     onIsSystrayChanged: {
         checkCanBeHovered();
     }
 
     onLatteAppletChanged: {
         if(appletItem.latteApplet){
             root.latteApplet = appletItem.latteApplet;
             root.latteAppletContainer = appletItem;
             root.latteAppletPos = index;
             appletItem.latteApplet.latteView = root;
             appletItem.latteApplet.forceHidePanel = true;
 
             appletItem.latteApplet.signalPreviewsShown.connect(slotPreviewsShown);
             appletItem.latteApplet.clearZoomSignal.connect(titleTooltipDialog.hide);
         }
     }
 
     onNeedsFillSpaceChanged: checkCanBeHovered();
 
     Component.onCompleted: {
         checkIndex();
         root.updateIndexes.connect(checkIndex);
         root.clearZoomSignal.connect(clearZoom);
         root.destroyInternalViewSplitters.connect(slotDestroyInternalViewSplitters);
     }
 
     Component.onDestruction: {
         appletItem.animations.needBothAxis.removeEvent(appletItem);
         appletItem.appletsRecords.removeApplet(appletItem);
 
         if (isSeparator){
             parabolicManager.setSeparator(previousIndex, -1);
         }
 
         if (isHidden) {
             parabolicManager.setHidden(previousIndex, -1);
         }
 
         if(root.latteAppletPos>=0 && root.latteAppletPos === index){
             root.latteApplet = null;
             root.latteAppletContainer = null;
             root.latteAppletPos = -1;
         }
 
         root.updateIndexes.disconnect(checkIndex);
         root.clearZoomSignal.disconnect(clearZoom);
         root.destroyInternalViewSplitters.disconnect(slotDestroyInternalViewSplitters);
 
         if (appletItem.latteApplet) {
             appletItem.latteApplet.signalPreviewsShown.disconnect(slotPreviewsShown);
             appletItem.latteApplet.clearZoomSignal.disconnect(titleTooltipDialog.hide);
         }
     }
 
     Connections{
         target: root
 
         /* onGlobalDirectRenderChanged:{
             if (root.globalDirectRender && restoreAnimation.running) {
                 // console.log("CLEAR APPLET SCALE !!!!");
                 //restoreAnimation.stop();
                 //wrapper.zoomScale = 1;
             }
         }*/
 
         onLatteAppletHoveredIndexChanged: {
             if ( (root.zoomFactor>1) && (root.latteAppletHoveredIndex >= 0) ){
                 var distance = 2;
                 //for Tasks plasmoid distance of 2 is not always safe there are
                 //cases that needs to be 3, when an internal separator there is
                 //between the hovered task and the current applet
                 if (root.hasInternalSeparator) {
                     if (index < root.latteAppletPos) {
                         var firstTaskIndex = root.latteApplet.parabolicManager.availableHigherIndex(0);
 
                         distance = firstTaskIndex+2;
                     } else if (index > root.latteAppletPos) {
                         var lastTaskIndex = root.latteApplet.parabolicManager.availableLowerIndex(root.tasksCount-1);
 
                         distance = root.tasksCount-1-lastTaskIndex+2;
                     }
                 }
 
                 if(Math.abs(index-root.latteAppletPos+root.latteAppletHoveredIndex)>=Math.max(2,distance)) {
                     appletItem.clearZoom();
                 }
             }
         }
 
         onSignalActivateEntryAtIndex: {
             if (parabolicManager.pseudoIndexBelongsToLatteApplet(entryIndex) && appletItem.isLattePlasmoid) {
                 latteApplet.activateTaskAtIndex(entryIndex - latteApplet.tasksBaseIndex);
             } else if (root.unifiedGlobalShortcuts && refersEntryIndex(entryIndex)) {
                 latteView.extendedInterface.toggleAppletExpanded(applet.id);
             }
         }
 
         onSignalNewInstanceForEntryAtIndex: {
             if (parabolicManager.pseudoIndexBelongsToLatteApplet(entryIndex) && appletItem.isLattePlasmoid) {
                 latteApplet.newInstanceForTaskAtIndex(entryIndex - latteApplet.tasksBaseIndex);
             } else if (root.unifiedGlobalShortcuts && refersEntryIndex(entryIndex)) {
                 latteView.extendedInterface.toggleAppletExpanded(applet.id);
             }
         }
     }
 
     Connections{
         target: layoutsContainer
         onHoveredIndexChanged:{
             //for applets it is safe to consider that a distance of 2
             //is enough to clearZoom
             if ( (root.zoomFactor>1) && (layoutsContainer.hoveredIndex>=0)
                     && (Math.abs(index-layoutsContainer.hoveredIndex)>=2))
                 appletItem.clearZoom();
 
             if ((restoreAnimation.running) && (layoutsContainer.hoveredIndex !== -1)) {
                 restoreAnimation.stop();
             }
         }
     }
 
     Connections{
         target: root
         onLatteAppletHoveredIndexChanged: {
             if ((restoreAnimation.running) && (root.latteAppletHoveredIndex !== -1)) {
                 restoreAnimation.stop();
             }
         }
     }
 
     Connections {
         id: viewSignalsConnector
         target: root.latteView ? root.latteView : null
         enabled: !appletItem.isLattePlasmoid && !appletItem.isSeparator && !appletItem.isSpacer && !appletItem.isHidden
 
         property bool pressed: false
         property bool blockWheel: false
 
         onMousePressed: {
             if (appletItem.containsPos(pos)) {
                 viewSignalsConnector.pressed = true;
                 var local = appletItem.mapFromItem(root, pos.x, pos.y);
 
                 appletItem.mousePressed(local.x, local.y, button);
 
                 if (button === Qt.LeftButton) {
                     appletItem.activateAppletForNeutralAreas(local);
                 }
             }
         }
 
         onMouseReleased: {
             if (appletItem.containsPos(pos)) {
                 viewSignalsConnector.pressed = false;
                 var local = appletItem.mapFromItem(root, pos.x, pos.y);
                 appletItem.mouseReleased(local.x, local.y, button);
             }
         }
 
         onWheelScrolled: {
             if (!appletItem.applet || !root.mouseWheelActions || viewSignalsConnector.blockWheel
                     || (root.latteViewIsHidden || root.inSlidingIn || root.inSlidingOut)) {
                 return;
             }
 
             blockWheel = true;
             scrollDelayer.start();
 
             if (appletItem.containsPos(pos) && root.latteView.extendedInterface.appletIsExpandable(applet.id)) {
                 var angle = angleDelta.y / 8;
                 var expanded = root.latteView.extendedInterface.appletIsExpanded(applet.id);
 
                 if ((angle > 12 && !expanded) /*positive direction*/
                         || (angle < -12 && expanded) /*negative direction*/) {
                     latteView.extendedInterface.toggleAppletExpanded(applet.id);
                 }
             }
         }
     }
 
     Connections {
         target: root.latteView ? root.latteView.extendedInterface : null
         enabled: !appletItem.isLattePlasmoid && !appletItem.isSeparator && !appletItem.isSpacer && !appletItem.isHidden
 
         onExpandedAppletStateChanged: {
             if (latteView.extendedInterface.hasExpandedApplet && appletItem.applet) {
                 appletItem.isExpanded = latteView.extendedInterface.appletIsExpandable(appletItem.applet.id)
                         && latteView.extendedInterface.appletIsExpanded(appletItem.applet.id);
             } else {
                 appletItem.isExpanded = false;
             }
         }
     }
 
     ///END connections
 
     //! It is used for any communication needed with the underlying applet
     Communicator.Engine{
         id: communicator
 
         //set up the overlayed appletItems and properties for when a overlaiedIconItem must be presented to the user
         //because the plasma widgets specific implementation breaks the Latte experience
         onOverlayLatteIconIsActiveChanged:{
             if (!overlayLatteIconIsActive && applet.opacity===0) {
                 applet.opacity = 1;
 
                 wrapper.disableScaleWidth = false;
                 wrapper.disableScaleHeight = false;
 
                 wrapper.updateLayoutWidth();
                 wrapper.updateLayoutHeight();
             } else if (overlayLatteIconIsActive && applet.opacity>0) {
                 applet.opacity = 0;
 
                 if (applet.pluginName === "org.kde.plasma.folder") {
                     applet.parent =  wrapper.containerForOverlayIcon;
                     applet.anchors.fill = wrapper.containerForOverlayIcon;
                 }
 
                 wrapper.disableScaleWidth = false;
                 wrapper.disableScaleHeight = false;
 
                 wrapper.updateLayoutWidth();
                 wrapper.updateLayoutHeight();
             }
         }
     }
 
     /*  Rectangle{
         anchors.fill: parent
         color: "transparent"
         border.color: "green"
         border.width: 1
     }*/
 
 
     /* DEPRECATED in favor of VIEW::MouseSignalsTracking
     MouseArea{
         id: appletMouseAreaBottom
         anchors.fill: parent
         propagateComposedEvents: true
         visible: (!appletMouseArea.visible || !appletMouseArea.enabled) && !root.editMode && !originalAppletBehavior
 
         onPressed: {
             appletItem.activateAppletForNeutralAreas(mouse);
             mouse.accepted = false;
         }
 
         onReleased: {
             mouse.accepted = false;
         }
     }*/
 
     //! Main Applet Shown Area
     Flow{
         id: appletFlow
         width: appletItem.computeWidth
         height: appletItem.computeHeight
 
         // a hidden spacer for the first element to add stability
         // IMPORTANT: hidden spacers must be tested on vertical !!!
         HiddenSpacer{id: hiddenSpacerLeft}
 
         Item {
             width: wrapper.width
             height: wrapper.height
 
             Indicator.Bridge{
                 id: indicatorBridge
             }
 
             //! Indicator Back Layer
             Indicator.Loader{
                 id: indicatorBackLayer
                 level: Indicator.LevelOptions {
                     id: backLevelOptions
                     isBackground: true
                     bridge: indicatorBridge
 
                     Binding {
                         target: appletItem
                         property: "iconOffsetX"
                         value: backLevelOptions.requested.iconOffsetX
                     }
 
                     Binding {
                         target: appletItem
                         property: "iconOffsetY"
                         value: backLevelOptions.requested.iconOffsetY
                     }
                 }
             }
 
             ItemWrapper{
                 id: wrapper
 
                 TitleTooltipParent{
                     id: titleTooltipParent
                     metrics: appletItem.metrics
                 }
             }
 
             //! The Applet Colorizer
             Colorizer.Applet {
                 id: appletColorizer
                 anchors.fill: parent
                 opacity: mustBeShown ? 1 : 0
 
                 readonly property bool mustBeShown: colorizerManager.mustBeShown
                                                     && !appletItem.userBlocksColorizing
                                                     && !appletItem.appletBlocksColorizing
                                                     && !appletItem.isInternalViewSplitter
 
                 Behavior on opacity {
                     NumberAnimation {
                         duration: 1.2 * appletItem.animations.duration.proposed
                         easing.type: Easing.OutCubic
                     }
                 }
             }
 
             //! Indicator Front Layer
             Indicator.Loader{
                 id: indicatorFrontLayer
                 level: Indicator.LevelOptions {
                     isForeground: true
                     bridge: indicatorBridge
                 }
             }
 
             //! Applet Shortcut Visual Badge
             Item {
                 id: shortcutBadgeContainer
 
                 width: {
                     if (root.isHorizontal) {
                         return appletItem.metrics.iconSize * wrapper.zoomScale
                     } else {
                         return badgeThickness;
                     }
                 }
 
                 height: {
                     if (root.isHorizontal) {
                         return badgeThickness;
                     } else {
                         return appletItem.metrics.iconSize * wrapper.zoomScale
                     }
                 }
 
                 readonly property int badgeThickness: {
                     if (plasmoid.location === PlasmaCore.Types.BottomEdge
                             || plasmoid.location === PlasmaCore.Types.RightEdge) {
                         return ((appletItem.metrics.iconSize + appletItem.metrics.margin.thickness) * wrapper.zoomScale) + root.localScreenEdgeMargin;
                     }
 
                     return ((appletItem.metrics.iconSize + appletItem.metrics.margin.thickness) * wrapper.zoomScale);
                 }
 
                 ShortcutBadge{
                     anchors.fill: parent
                 }
 
                 states:[
                     State{
                         name: "horizontal"
                         when: plasmoid.formFactor === PlasmaCore.Types.Horizontal
 
                         AnchorChanges{
                             target: shortcutBadgeContainer;
                             anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                             anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                         }
                     },
                     State{
                         name: "vertical"
                         when: plasmoid.formFactor === PlasmaCore.Types.Vertical
 
                         AnchorChanges{
                             target: shortcutBadgeContainer;
                             anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                             anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                         }
                     }
                 ]
             }
         }
 
         // a hidden spacer on the right for the last item to add stability
         HiddenSpacer{id: hiddenSpacerRight; rightSpacer: true}
     }// Flow with hidden spacers inside
 
     //Busy Indicator
     PlasmaComponents.BusyIndicator {
         z: 1000
         visible: applet && applet.busy
         running: visible
         anchors.centerIn: parent
         width: Math.min(parent.width, parent.height)
         height: width
     }
 
     Loader {
         id: addingAreaLoader
         width: root.isHorizontal ? parent.width : parent.width - root.localScreenEdgeMargin
         height: root.isHorizontal ? parent.height - root.localScreenEdgeMargin : parent.height
 
         active: isLattePlasmoid
 
         sourceComponent: LatteComponents.AddingArea{
             id: addingAreaItem
             anchors.fill: parent
             // width: root.isHorizontal ? parent.width : parent.width - root.localScreenEdgeMargin
             // height: root.isHorizontal ? parent.height - root.localScreenEdgeMargin : parent.height
 
             radius: appletItem.metrics.iconSize/10
             opacity: root.addLaunchersMessage ? 1 : 0
             backgroundOpacity: 0.75
             duration: appletItem.animations.speedFactor.current
 
             title: i18n("Tasks Area")
         }
 
         //! AddingAreaItem States
         states:[
             State{
                 name: "bottom"
                 when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: root.localScreenEdgeMargin;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "top"
                 when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: root.localScreenEdgeMargin;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "left"
                 when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: root.localScreenEdgeMargin;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "right"
                 when: plasmoid.location === PlasmaCore.Types.RightEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: root.localScreenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             }
         ]
     }
 
     MouseArea{
         id: appletMouseArea
 
         anchors.fill: parent
         enabled: visible
         hoverEnabled: latteApplet ? false : true
         propagateComposedEvents: true
 
         //! a way must be found in order for this be enabled
         //! only to support springloading for plasma 5.10
         //! also on this is based the tooltips behavior by enabling it
         //! plasma tooltips are disabled
         visible: acceptMouseEvents
 
         property bool blockWheel: false
 
         onEntered: {
             if (containsMouse && !originalAppletBehavior && !communicator.requires.parabolicEffectLocked && appletItem.canBeHovered){
                 root.stopCheckRestoreZoomTimer();
             }
 
             if (restoreAnimation.running) {
                 restoreAnimation.stop();
             }
 
             if (!(isSeparator || isSpacer)) {
                 root.showTooltipLabel(appletItem, applet.title);
             }
 
             //console.log("entered applet:" + layoutsContainer.hoveredIndex);
 
 
             if (layoutsContainer.hoveredIndex === -1 && root.latteAppletHoveredIndex===-1) {
                 root.startDirectRenderDelayerDuringEntering();
             }
 
             if (!(root.latteViewIsHidden || root.inSlidingIn || root.inSlidingOut)){
                 layoutsContainer.hoveredIndex = index;
             }
 
             if (originalAppletBehavior || communicator.requires.parabolicEffectLocked || !canBeHovered) {
                 return;
             }
 
             if (root.isHalfShown || (root.latteApplet
                                      && (root.latteApplet.noTasksInAnimation>0 || root.latteApplet.contextMenu))) {
                 return;
             }
 
             if (root.isHorizontal){
                 layoutsContainer.currentSpot = mouseX;
                 wrapper.calculateScales(mouseX);
             }
             else{
                 layoutsContainer.currentSpot = mouseY;
                 wrapper.calculateScales(mouseY);
             }
         }
 
         onExited:{
             if (communicator.appletIconItemIsShown()) {
                 communicator.setAppletIconItemActive(false);
             }
 
             root.hideTooltipLabel();
 
             if (root.zoomFactor>1){
                 root.startCheckRestoreZoomTimer();
             }
         }
 
         onPositionChanged: {
             if (originalAppletBehavior || !canBeHovered) {
                 mouse.accepted = false;
                 return;
             }
 
             if (root.isHalfShown || (root.latteApplet
                                      && (root.latteApplet.noTasksInAnimation>0 || root.latteApplet.contextMenu))) {
                 return;
             }
 
             if (layoutsContainer.hoveredIndex === -1 && root.latteAppletHoveredIndex===-1) {
                 root.startDirectRenderDelayerDuringEntering();
             }
 
             if (!(root.latteViewIsHidden || root.inSlidingIn || root.inSlidingOut)){
                 layoutsContainer.hoveredIndex = index;
             }
 
             if (!root.globalDirectRender && !root.directRenderDelayerIsRunning) {
                 root.setGlobalDirectRender(true);
             }
 
             if( ((wrapper.zoomScale == 1 || wrapper.zoomScale === root.zoomFactor) && !root.globalDirectRender) || root.globalDirectRender) {
                 if (root.isHorizontal){
                     var step = Math.abs(layoutsContainer.currentSpot-mouse.x);
                     if (step >= appletItem.animations.hoverPixelSensitivity){
                         layoutsContainer.currentSpot = mouse.x;
 
                         wrapper.calculateScales(mouse.x);
                     }
                 }
                 else{
                     var step = Math.abs(layoutsContainer.currentSpot-mouse.y);
                     if (step >= appletItem.animations.hoverPixelSensitivity){
                         layoutsContainer.currentSpot = mouse.y;
 
                         wrapper.calculateScales(mouse.y);
                     }
                 }
             }
 
             mouse.accepted = false;
         }
 
         //! these are needed in order for these events to be really forwarded underneath
         //! otherwise there were applets that did not receive them e.g. lock/logout applet
         //! when parabolic effect was used
         onPressed: mouse.accepted = false;
         onReleased: mouse.accepted = false;
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
         interval: 500
 
         onTriggered: viewSignalsConnector.blockWheel = false;
     }
 
     //BEGIN states
     states: [
         State {
             name: "left"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined;}
             }
         },
         State {
             name: "right"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right;}
             }
         },
         State {
             name: "bottom"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined;}
             }
         },
         State {
             name: "top"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined;}
             }
         }
     ]
     //END states
 
     //BEGIN animations
     ///////Restore Zoom Animation/////
     ParallelAnimation{
         id: restoreAnimation
 
         PropertyAnimation {
             target: wrapper
             property: "zoomScale"
             to: 1
             duration: 4 * appletItem.animationTime
             easing.type: Easing.InCubic
         }
     }
 
 
     /////Clicked Animation/////
     SequentialAnimation{
         id: clickedAnimation
         alwaysRunToEnd: true
         running: appletItem.isSquare && !originalAppletBehavior && appletItem.pressed
                  && (appletItem.animations.speedFactor.current > 0) && !indicators.info.providesClickedAnimation
 
         ParallelAnimation{
             PropertyAnimation {
                 target: wrapper.clickedEffect
                 property: "brightness"
                 to: -0.35
                 duration: appletItem.animations.duration.large
                 easing.type: Easing.OutQuad
             }
         }
         ParallelAnimation{
             PropertyAnimation {
                 target: wrapper.clickedEffect
                 property: "brightness"
                 to: 0
                 duration: appletItem.animations.duration.large
                 easing.type: Easing.OutQuad
             }
         }
     }
     //END animations
 }
diff --git a/containment/package/contents/ui/applet/HiddenSpacer.qml b/containment/package/contents/ui/applet/HiddenSpacer.qml
index f7cde432..bf575c00 100644
--- a/containment/package/contents/ui/applet/HiddenSpacer.qml
+++ b/containment/package/contents/ui/applet/HiddenSpacer.qml
@@ -1,106 +1,106 @@
 /*
 *  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.1
 
 import org.kde.latte.core 0.2 as LatteCore
 
 Item{
     id: hiddenSpacer
 
     //we add one missing pixel from calculations
     width: root.isHorizontal ? nHiddenSize : wrapper.width
     height: root.isHorizontal ? wrapper.height : nHiddenSize
 
     ///check also if this is the first/last plasmoid in anylayout
     visible: (rightSpacer ? appletItem.lastAppletInContainer : appletItem.firstAppletInContainer) || separatorSpace>0
 
     property bool neighbourSeparator: false;
 
     property int separatorSpace: neighbourSeparator && !appletItem.isSeparator && root.parabolicEffectEnabled
-                                 && !appletItem.latteApplet ? ((LatteCore.Environment.separatorLength/2)+root.lengthExtMargin) : subtrackedMargins
+                                 && !appletItem.latteApplet ? ((LatteCore.Environment.separatorLength/2)+appletItem.metrics.margin.length) : subtrackedMargins
 
     property real nHiddenSize: {
         if (isSeparator || !communicator.requires.lengthMarginsEnabled) {
             return 0;
         }
 
         return (nScale > 0) ? (appletItem.spacersMaxSize * nScale) + separatorSpace : separatorSpace
     }
 
     property bool rightSpacer: false
 
     readonly property bool atEdgeForcingFittsLaw: !isSeparator && !parabolicEffectMarginsEnabled && atScreenEdge
     readonly property int subtrackedMargins: {
         if (atEdgeForcingFittsLaw && ((firstAppletInContainer && rightSpacer) || (lastAppletInContainer && !rightSpacer ))) {
-            return (wrapperAlias.edgeLengthMarginsDisabled ? root.lengthExtMargin + appletItem.lengthAppletPadding : root.lengthExtMargin);
+            return (wrapperAlias.edgeLengthMarginsDisabled ? appletItem.metrics.margin.length + appletItem.lengthAppletPadding : appletItem.metrics.margin.length);
         }
 
         return 0;
     }
 
     property real nScale: 0
 
     Behavior on nHiddenSize {
         id: animatedBehavior
         enabled: !root.globalDirectRender || restoreAnimation.running
         NumberAnimation { duration: 3 * appletItem.animationTime }
     }
 
     Behavior on nHiddenSize {
         id: directBehavior
         enabled: !animatedBehavior.running
         NumberAnimation { duration: root.directRenderAnimationTime }
     }
 
     Connections{
         target: root
         onSeparatorsUpdated: updateNeighbour();
     }
 
     Connections{
         target: appletItem
         onContainsMouseChanged: {
             if (!appletItem.containsMouse) {
                 hiddenSpacer.nScale = 0;
             }
         }
     }
 
     function updateNeighbour() {
         hiddenSpacer.neighbourSeparator = hiddenSpacer.rightSpacer ?
                     parabolicManager.isSeparator(index+1) : parabolicManager.isSeparator(index-1)
     }
 
     Loader{
         active: root.debugModeSpacers
 
         sourceComponent: Rectangle{
             width: !root.isVertical ? hiddenSpacer.width : 1
             height: !root.isVertical ? 1 : hiddenSpacer.height
             x: root.isVertical ? hiddenSpacer.width/2 : 0
             y: !root.isVertical ? hiddenSpacer.height/2 : 0
 
             border.width: 1
             border.color: "red"
             color: "transparent"
         }
     }
 }
diff --git a/containment/package/contents/ui/applet/ItemWrapper.qml b/containment/package/contents/ui/applet/ItemWrapper.qml
index f9bbc03e..16d800b3 100644
--- a/containment/package/contents/ui/applet/ItemWrapper.qml
+++ b/containment/package/contents/ui/applet/ItemWrapper.qml
@@ -1,783 +1,783 @@
 /*
 *  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.1
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 
 import org.kde.latte.core 0.2 as LatteCore
 
 import "../../code/MathTools.js" as MathTools
 
 Item{
     id: wrapper
 
     width: {
         if (appletItem.isInternalViewSplitter && !root.inConfigureAppletsMode)
             return 0;
 
         if (isSeparator && root.parabolicEffectEnabled && root.isHorizontal) {
             return -1;
         }
 
         //! width for applets that use fillWidth/fillHeight such plasma taskmanagers and AWC
         if (appletItem.needsFillSpace && root.isHorizontal) {
             if (root.panelAlignment !== LatteCore.Types.Justify) {
                 var maximumValue = (applet.Layout.maximumWidth === Infinity) || applet.Layout.maximumWidth === -1 ?
                             appletItem.sizeForFill : Math.min(appletItem.sizeForFill, applet.Layout.maximumWidth);
 
                 var constrainedWidth = MathTools.bound(applet.Layout.minimumWidth, applet.Layout.preferredWidth, maximumValue);
 
                 return root.inConfigureAppletsMode ? Math.max(constrainedWidth, appletItem.metrics.iconSize) : constrainedWidth;
             }
 
             if(appletItem.sizeForFill>-1){
                 return appletItem.sizeForFill;
             }
         }
 
         if (appletItem.latteApplet) {
             return latteApplet.tasksWidth;
         } else {
             if (root.isHorizontal && root.inConfigureAppletsMode) {
                 return Math.max(Math.min(appletItem.metrics.iconSize, root.minAppletLengthInConfigure), scaledWidth);
             }
 
             return root.isVertical ? scaledWidth + root.localScreenEdgeMargin : scaledWidth;
         }
     }
 
     height: {
         if (appletItem.isInternalViewSplitter && !root.inConfigureAppletsMode)
             return 0;
 
         if (isSeparator && root.parabolicEffectEnabled && root.isVertical) {
             return -1;
         }
 
         //! height for applets that use fillWidth/fillHeight such plasma taskmanagers and AWC
         if (appletItem.needsFillSpace && root.isVertical) {
             if (root.panelAlignment !== LatteCore.Types.Justify) {
                 var maximumValue = (applet.Layout.maximumHeight === Infinity) || applet.Layout.maximumHeight === -1 ?
                             appletItem.sizeForFill : Math.min(appletItem.sizeForFill, applet.Layout.maximumHeight);
 
                 var constrainedHeight = MathTools.bound(applet.Layout.minimumHeight, applet.Layout.preferredHeight, maximumValue);
 
                 return root.inConfigureAppletsMode ? Math.max(constrainedHeight, appletItem.metrics.iconSize) : constrainedHeight;
             }
 
             if (appletItem.sizeForFill>-1){
                 return appletItem.sizeForFill;
             }
         }
 
         if (appletItem.latteApplet) {
             return latteApplet.tasksHeight;
         } else {
             if (root.isVertical && root.inConfigureAppletsMode) {
                 return Math.max(Math.min(appletItem.metrics.iconSize, root.minAppletLengthInConfigure), scaledHeight);
             }
 
             return root.isHorizontal ? scaledHeight + root.localScreenEdgeMargin : scaledHeight;
         }
     }
 
     opacity: appletColorizer.mustBeShown && graphicsSystem.isAccelerated ? 0 : 1
 
     property bool disableScaleWidth: false
     property bool disableScaleHeight: false
     property bool editMode: root.inConfigureAppletsMode
 
     property bool edgeLengthMarginsDisabled: isSeparator || !communicator.requires.lengthMarginsEnabled || !canBeHovered
 
     property int appletWidth: applet ?  applet.width : -1
     property int appletHeight: applet ?  applet.height : -1
 
     property int appletMinimumWidth: applet && applet.Layout ?  applet.Layout.minimumWidth : -1
     property int appletMinimumHeight: applet && applet.Layout ? applet.Layout.minimumHeight : -1
 
     property int appletPreferredWidth: applet && applet.Layout ?  applet.Layout.preferredWidth : -1
     property int appletPreferredHeight: applet && applet.Layout ?  applet.Layout.preferredHeight : -1
 
     property int appletMaximumWidth: applet && applet.Layout ?  applet.Layout.maximumWidth : -1
     property int appletMaximumHeight: applet && applet.Layout ?  applet.Layout.maximumHeight : -1
 
     property int iconSize: appletItem.metrics.iconSize
 
     property int marginWidth: root.isVertical ?
                                   appletItem.metrics.totals.thicknessEdges :
                                   (root.inFullJustify && atScreenEdge && !parabolicEffectMarginsEnabled ? edgeLengthMargins : localLengthMargins)  //Fitt's Law
     property int marginHeight: root.isHorizontal ?
                                    appletItem.metrics.totals.thicknessEdges :
                                    (root.inFullJustify && atScreenEdge && !parabolicEffectMarginsEnabled ? edgeLengthMargins : localLengthMargins)  //Fitt's Law
 
     property int localLengthMargins: isSeparator || !communicator.requires.lengthMarginsEnabled || isInternalViewSplitter ? 0 : appletItem.lengthAppletFullMargins
     property int edgeLengthMargins: edgeLengthMarginsDisabled ? 0 : appletItem.lengthAppletPadding * 2
 
     property real scaledWidth: zoomScaleWidth * (layoutWidth + marginWidth)
     property real scaledHeight: zoomScaleHeight * (layoutHeight + marginHeight)
     property real zoomScaleWidth: disableScaleWidth ? 1 : zoomScale
     property real zoomScaleHeight: disableScaleHeight ? 1 : zoomScale
 
     property int layoutWidthResult: 0
 
     property int layoutWidth
     property int layoutHeight
 
     property real center:root.isHorizontal ?
                              (width + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2 :
                              (height + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2
 
     property real zoomScale: 1
 
     property int index: appletItem.index
 
     property Item wrapperContainer: _wrapperContainer
     property Item clickedEffect: _clickedEffect
     property Item containerForOverlayIcon: _containerForOverlayIcon
     property Item overlayIconLoader: _overlayIconLoader
 
     Behavior on opacity {
         NumberAnimation {
             duration: 0.8 * appletItem.animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
 
     // property int pHeight: applet ? applet.Layout.preferredHeight : -10
 
     /*function debugLayouts(){
         if(applet){
             console.log("---------- "+ applet.pluginName +" ----------");
             console.log("MinW "+applet.Layout.minimumWidth);
             console.log("PW "+applet.Layout.preferredWidth);
             console.log("MaxW "+applet.Layout.maximumWidth);
             console.log("FillW "+applet.Layout.fillWidth);
             console.log("-----");
             console.log("MinH "+applet.Layout.minimumHeight);
             console.log("PH "+applet.Layout.preferredHeight);
             console.log("MaxH "+applet.Layout.maximumHeight);
             console.log("FillH "+applet.Layout.fillHeight);
             console.log("-----");
             console.log("Real Applet Width: "+applet.width);
             console.log("Real Applet Height: "+applet.height);
             console.log("-----");
             console.log("Real Wrapper Width: "+wrapper.width);
             console.log("Real Wrapper Height: "+wrapper.height);
             console.log("-----");
             console.log("Can be hovered: " + canBeHovered);
             console.log("Icon size: " + appletItem.metrics.iconSize);
             console.log("Thick Margins: " + appletItem.metrics.totals.thicknessEdges);
             console.log("Intern. Margins: " + (appletItem.metrics.padding.length * 2));
-            console.log("Intern. Margins: " + (root.lengthExtMargin * 2));
+            console.log("Intern. Margins: " + (appletItem.metrics.margin.length * 2));
             console.log("Max hovered criteria: " + (appletItem.metrics.iconSize + metrics.totals.thicknessEdges));
             console.log("-----");
             console.log("LayoutW: " + layoutWidth);
             console.log("LayoutH: " + layoutHeight);
         }
     }
 
     onLayoutWidthChanged: {
         debugLayouts();
     }
 
     onLayoutHeightChanged: {
         debugLayouts();
     }*/
 
     onAppletWidthChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
     }
 
     onAppletHeightChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
     }
 
     onAppletMinimumWidthChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
 
         updateLayoutWidth();
     }
     onAppletMinimumHeightChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
 
         updateLayoutHeight();
     }
 
     onAppletPreferredWidthChanged: updateLayoutWidth();
     onAppletPreferredHeightChanged: updateLayoutHeight();
 
     onAppletMaximumWidthChanged: updateLayoutWidth();
     onAppletMaximumHeightChanged: updateLayoutHeight();
 
     Connections {
         target: appletItem
         onCanBeHoveredChanged: {
             updateLayoutWidth();
             updateLayoutHeight();
         }
     }
 
     onIconSizeChanged: {
         updateLayoutWidth();
         updateLayoutHeight();
     }
 
     onEditModeChanged: {
         updateLayoutWidth();
         updateLayoutHeight();
     }
 
     onZoomScaleChanged: {
         if ((zoomScale === root.zoomFactor) && !root.globalDirectRender) {
             root.setGlobalDirectRender(true);
         }
 
         if ((zoomScale > 1) && !appletItem.isZoomed) {
             appletItem.isZoomed = true;
             appletItem.animations.needBothAxis.addEvent(appletItem);
         } else if (zoomScale == 1) {
             appletItem.isZoomed = false;
             appletItem.animations.needBothAxis.removeEvent(appletItem);
         }
     }
 
     Connections {
         target: root
         onIsVerticalChanged: {
             if (appletItem.latteApplet) {
                 return;
             }
 
             wrapper.disableScaleWidth = false;
             wrapper.disableScaleHeight = false;
 
             if (root.isVertical)  {
                 wrapper.updateLayoutHeight();
                 wrapper.updateLayoutWidth();
             } else {
                 wrapper.updateLayoutWidth();
                 wrapper.updateLayoutHeight();
             }
         }
     }
 
     function updateLayoutHeight(){
         appletItem.movingForResize = true;
 
         if (appletItem.needsFillSpace && root.isVertical) {
             layoutsContainer.updateSizeForAppletsInFill();
             return;
         }
 
         var blockParabolicEffect = false;
 
         if (isLattePlasmoid) {
             return;
         } else if (appletItem.isInternalViewSplitter){
             if(!root.inConfigureAppletsMode) {
                 layoutHeight = 0;
             } else {
                 layoutHeight = (root.isHorizontal ? appletItem.metrics.iconSize : Math.min(appletItem.metrics.iconSize, root.maxJustifySplitterSize));
             }
         }
         else if(appletItem.isSystray && root.isHorizontal){
             layoutHeight = appletItem.metrics.iconSize;
         }
         else{
             if(applet && (applet.Layout.minimumHeight > appletItem.metrics.iconSize) && root.isVertical && !canBeHovered && !communicator.overlayLatteIconIsActive){
                 blockParabolicEffect = true;
                 layoutHeight = applet.Layout.minimumHeight;
             } //it is used for plasmoids that need to scale only one axis... e.g. the Weather Plasmoid
             else if(applet
                     && ( applet.Layout.maximumHeight < appletItem.metrics.iconSize
                         || applet.Layout.preferredHeight > appletItem.metrics.iconSize
                         || appletItem.originalAppletBehavior)
                     && root.isVertical
                     && !disableScaleWidth
                     && !communicator.overlayLatteIconIsActive) {
                 //this way improves performance, probably because during animation the preferred sizes update a lot
                 if((applet.Layout.maximumHeight < appletItem.metrics.iconSize)){
                     layoutHeight = applet.Layout.maximumHeight;
                 } else if (applet.Layout.minimumHeight > appletItem.metrics.iconSize){
                     blockParabolicEffect = true;
                     layoutHeight = applet.Layout.minimumHeight;
                 } else if ((applet.Layout.preferredHeight > appletItem.metrics.iconSize)
                            || (appletItem.originalAppletBehavior && applet.Layout.preferredHeight > 0 )){
                     blockParabolicEffect = true;
                     layoutHeight = applet.Layout.preferredHeight;
                 } else{
                     layoutHeight = appletItem.metrics.iconSize;
                 }
             } else {
                 layoutHeight = appletItem.metrics.iconSize;
             }
         }
 
         if (wrapper.zoomScale === 1) {
             if (blockParabolicEffect) {
                 disableScaleHeight = true;
             } else {
                 disableScaleHeight = false;
             }
         }
     }
 
     function updateLayoutWidth(){
         appletItem.movingForResize = true;
 
         if (appletItem.needsFillSpace && root.isHorizontal) {
             layoutsContainer.updateSizeForAppletsInFill();
             return;
         }
 
         var blockParabolicEffect = false;
 
         if (isLattePlasmoid) {
             return;
         } else if (appletItem.isInternalViewSplitter){
             if(!root.inConfigureAppletsMode) {
                 layoutWidth = 0;
             } else {
                 layoutWidth = (root.isVertical ? appletItem.metrics.iconSize : Math.min(appletItem.metrics.iconSize, root.maxJustifySplitterSize));
             }
         }
         else if(appletItem.isSystray && root.isVertical){
             layoutWidth = appletItem.metrics.iconSize;
         }
         else{
             if(applet && (applet.Layout.minimumWidth > appletItem.metrics.iconSize) && root.isHorizontal && !canBeHovered && !communicator.overlayLatteIconIsActive){
                 blockParabolicEffect = true;
                 layoutWidth = applet.Layout.minimumWidth;
             } //it is used for plasmoids that need to scale only one axis... e.g. the Weather Plasmoid
             else if(applet
                     && ( applet.Layout.maximumWidth < appletItem.metrics.iconSize
                         || applet.Layout.preferredWidth > appletItem.metrics.iconSize
                         || appletItem.originalAppletBehavior)
                     && root.isHorizontal
                     && !disableScaleHeight
                     && !communicator.overlayLatteIconIsActive){
 
                 //this way improves performance, probably because during animation the preferred sizes update a lot
                 if((applet.Layout.maximumWidth < appletItem.metrics.iconSize)){
                     //   return applet.Layout.maximumWidth;
                     layoutWidth = applet.Layout.maximumWidth;
                 } else if (applet.Layout.minimumWidth > appletItem.metrics.iconSize){
                     blockParabolicEffect = true;
                     layoutWidth = applet.Layout.minimumWidth;
                 } else if ((applet.Layout.preferredWidth > appletItem.metrics.iconSize)
                            || (appletItem.originalAppletBehavior && applet.Layout.preferredWidth > 0 )){
                     blockParabolicEffect = true;
                     layoutWidth = applet.Layout.preferredWidth;
                 } else{
                     layoutWidth = appletItem.metrics.iconSize;
                 }
             } else{
                 layoutWidth = appletItem.metrics.iconSize;
             }
         }
 
         if (wrapper.zoomScale === 1) {
             if (blockParabolicEffect) {
                 disableScaleWidth = true;
             } else {
                 disableScaleWidth = false;
             }
         }
     }
 
     Item{
         id:_wrapperContainer
 
         width:{
             if (appletItem.needsFillSpace && (appletItem.sizeForFill>-1) && root.isHorizontal){
                 return wrapper.width;
             }
 
             if (appletItem.isInternalViewSplitter) {
                 return wrapper.layoutWidth;
             } else {
                 if (plasmoid.formFactor === PlasmaCore.Types.Vertical) {
                     var wrapperContainerThickness = parent.zoomScaleWidth * (appletItem.metrics.totals.thickness);
                     return appletItem.screenEdgeMarginSupported ? wrapperContainerThickness + root.localScreenEdgeMargin : wrapperContainerThickness;
                 } else {
                     return parent.zoomScaleWidth * wrapper.layoutWidth;
                 }
             }
         }
 
         height:{
             if (appletItem.needsFillSpace && (appletItem.sizeForFill>-1) && root.isVertical){
                 return wrapper.height;
             }
 
             if (appletItem.isInternalViewSplitter) {
                 return wrapper.layoutHeight;
             } else {
                 if (plasmoid.formFactor === PlasmaCore.Types.Horizontal) {
                     var wrapperContainerThickness = parent.zoomScaleHeight * (appletItem.metrics.totals.thickness);
                     return appletItem.screenEdgeMarginSupported ? wrapperContainerThickness + root.localScreenEdgeMargin : wrapperContainerThickness;
                 } else {
                     return parent.zoomScaleHeight * wrapper.layoutHeight;
                 }
             }
 
         }
 
         opacity: appletShadow.active ? 0 : 1
 
         readonly property int appliedEdgeMargin: {
             if (appletItem.isInternalViewSplitter) {
                 return root.localScreenEdgeMargin + appletItem.metrics.margin.thickness;
             }
 
             return appletItem.screenEdgeMarginSupported ? 0 : root.localScreenEdgeMargin;
         }
 
         ///Secret MouseArea to be used by the folder widget
         Loader{
             anchors.fill: parent
             active: communicator.overlayLatteIconIsActive
                     && applet.pluginName === "org.kde.plasma.folder"
                     && !appletItem.acceptMouseEvents
 
             sourceComponent: MouseArea{
                 onClicked: latteView.extendedInterface.toggleAppletExpanded(applet.id);
             }
         }
 
         Item{
             id: _containerForOverlayIcon
             anchors.fill: parent
         }
 
         Loader{
             id: _overlayIconLoader
             anchors.fill: parent
             active: communicator.overlayLatteIconIsActive
 
             property color backgroundColor: "black"
             property color glowColor: "white"
 
             sourceComponent: LatteCore.IconItem{
                 id: overlayIconItem
                 anchors.fill: parent
                 source: {
                     if (communicator.appletIconItemIsShown())
                         return communicator.appletIconItem.source;
                     else if (communicator.appletImageItemIsShown())
                         return communicator.appletImageItem.source;
 
                     return "";
                 }
 
                 providesColors: indicators.info.needsIconColors && source != ""
                 usesPlasmaTheme: communicator.appletIconItemIsShown() ? communicator.appletIconItem.usesPlasmaTheme : false
 
                 Binding{
                     target: _overlayIconLoader
                     property: "backgroundColor"
                     when: overlayIconItem.providesColors
                     value: overlayIconItem.backgroundColor
                 }
 
                 Binding{
                     target: _overlayIconLoader
                     property: "glowColor"
                     when: overlayIconItem.providesColors
                     value: overlayIconItem.glowColor
                 }
 
                 Loader{
                     anchors.centerIn: parent
                     active: root.debugModeOverloadedIcons
                     sourceComponent: Rectangle{
                         width: 30
                         height: 30
                         color: "green"
                         opacity: 0.65
                     }
                 }
             }
         }
 
         //! WrapperContainer States
         states:[
             State{
                 name: "bottom"
                 when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                 AnchorChanges{
                     target: _wrapperContainer;
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                 }
                 PropertyChanges{
                     target: _wrapperContainer;
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: _wrapperContainer.appliedEdgeMargin;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "top"
                 when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                 AnchorChanges{
                     target:_wrapperContainer;
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: _wrapperContainer;
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: _wrapperContainer.appliedEdgeMargin;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "left"
                 when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                 AnchorChanges{
                     target: _wrapperContainer;
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: _wrapperContainer;
                     anchors.leftMargin: _wrapperContainer.appliedEdgeMargin;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "right"
                 when: plasmoid.location === PlasmaCore.Types.RightEdge
 
                 AnchorChanges{
                     target: _wrapperContainer;
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: _wrapperContainer;
                     anchors.leftMargin: 0;    anchors.rightMargin: _wrapperContainer.appliedEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             }
         ]
     }
 
     Loader{
         anchors.fill: _wrapperContainer
         active: appletItem.isInternalViewSplitter && root.inConfigureAppletsMode
 
         sourceComponent: Item {
             anchors.fill: parent
 
             PlasmaCore.SvgItem{
                 id:splitterImage
                 anchors.centerIn: parent
                 width: Math.min(root.maxJustifySplitterSize, appletItem.metrics.iconSize)
                 height: width
                 rotation: root.isVertical ? 90 : 0
 
                 svg: PlasmaCore.Svg{
                     imagePath: root.universalSettings.splitterIconPath()
                 }
 
                 layer.enabled: graphicsSystem.isAccelerated
                 layer.effect: DropShadow {
                     radius: root.appShadowSize
                     fast: true
                     samples: 2 * radius
                     color: root.appShadowColor
 
                     verticalOffset: 2
                 }
             }
         }
     }
 
     ///Shadow in applets
     Loader{
         id: appletShadow
         anchors.fill: appletItem.appletWrapper
 
         active: appletItem.applet
                 && graphicsSystem.isAccelerated
                 && !appletColorizer.mustBeShown
                 && (root.enableShadows && applet.pluginName !== root.plasmoidName)
 
         onActiveChanged: {
             if (active && !isSeparator && graphicsSystem.isAccelerated) {
                 wrapperContainer.opacity = 0;
             } else {
                 wrapperContainer.opacity = 1;
             }
         }
 
         opacity: isSeparator ? 0.4 : 1
 
         sourceComponent: DropShadow{
             anchors.fill: parent
             color: root.appShadowColor //"#ff080808"
             fast: true
             samples: 2 * radius
             source: communicator.overlayLatteIconIsActive ? _wrapperContainer : appletItem.applet
             radius: shadowSize
             verticalOffset: root.forceTransparentPanel || root.forcePanelForBusyBackground ? 0 : 2
 
             property int shadowSize : root.appShadowSize
         }
     }
 
     BrightnessContrast{
         id:hoveredImage
         anchors.fill: _wrapperContainer
         source: _wrapperContainer
 
         enabled: appletItem.isSquare && !originalAppletBehavior && !indicators.info.providesHoveredAnimation && opacity != 0 ? true : false
         opacity: appletMouseArea.containsMouse ? 1 : 0
         brightness: 0.25
         contrast: 0.15
         visible: !indicators.info.providesHoveredAnimation
 
         Behavior on opacity {
             NumberAnimation { duration: appletItem.animations.speedFactor.current*appletItem.animations.duration.large }
         }
     }
 
     BrightnessContrast {
         id: _clickedEffect
         anchors.fill: _wrapperContainer
         source: _wrapperContainer
 
         visible: clickedAnimation.running && !indicators.info.providesClickedAnimation
     }
 
     /*   onHeightChanged: {
         if ((index == 1)|| (index==3)){
             console.log("H: "+index+" ("+zoomScale+"). "+currentLayout.children[1].height+" - "+currentLayout.children[3].height+" - "+(currentLayout.children[1].height+currentLayout.children[3].height));
         }
     }
 
     onZoomScaleChanged:{
         if ((index == 1)|| (index==3)){
             console.log(index+" ("+zoomScale+"). "+currentLayout.children[1].height+" - "+currentLayout.children[3].height+" - "+(currentLayout.children[1].height+currentLayout.children[3].height));
         }
     }*/
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             color: "transparent"
             //! red visualizer, in debug mode for the applets that use fillWidth or fillHeight
             //! green, for the rest
             border.color:  (appletItem.needsFillSpace && (appletItem.sizeForFill>-1) && root.isHorizontal) ? "red" : "green"
             border.width: 1
         }
     }
 
     Behavior on zoomScale {
         enabled: !root.globalDirectRender
         NumberAnimation {
             duration: 3 * appletItem.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on zoomScale {
         enabled: root.globalDirectRender && !restoreAnimation.running
         NumberAnimation { duration: root.directRenderAnimationTime }
     }
 
     function calculateScales( currentMousePosition ){
         if (root.zoomFactor===1) {
             return;
         }
 
         var distanceFromHovered = Math.abs(index - layoutsContainer.hoveredIndex);
 
         // A new algorithm trying to make the zoom calculation only once
         // and at the same time fixing glitches
         if ((distanceFromHovered == 0)&&
                 (currentMousePosition  > 0) ){
 
             //use the new parabolicManager in order to handle all parabolic effect messages
             var scales = parabolicManager.applyParabolicEffect(index, currentMousePosition, center);
 
             /*if (root.latteApplet && Math.abs(index - root.latteAppletPos) > 2){
                 root.latteApplet.clearZoom();
             }*/
 
             //Left hiddenSpacer
             if(appletItem.firstAppletInContainer){
                 hiddenSpacerLeft.nScale = scales.leftScale - 1;
             }
 
             //Right hiddenSpacer  ///there is one more item in the currentLayout ????
             if(appletItem.lastAppletInContainer){
                 hiddenSpacerRight.nScale =  scales.rightScale - 1;
             }
 
             zoomScale = root.zoomFactor;
         }
 
     } //scale
 
 
     function signalUpdateScale(nIndex, nScale, step){
         if(appletItem && !appletItem.containsMouse && (appletItem.index === nIndex)){
             if ( ((canBeHovered && !appletItem.originalAppletBehavior) || appletItem.latteApplet)
                     && (applet && applet.status !== PlasmaCore.Types.HiddenStatus)
                     //&& (index != currentLayout.hoveredIndex)
                     ){
                 if(!appletItem.latteApplet){
                     if(nScale >= 0)
                         zoomScale = nScale + step;
                     else
                         zoomScale = zoomScale + step;
                 }
             }
         }
     }
 
     Component.onCompleted: {
         root.updateScale.connect(signalUpdateScale);
     }
 
     Component.onDestruction: {
         root.updateScale.disconnect(signalUpdateScale);
     }
 }// Main task area // id:wrapper
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index 20d72570..4254b645 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1793 +1,1781 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.8
 import QtQuick.Layouts 1.1
 import QtQuick.Window 2.2
 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.kquickcontrolsaddons 2.0
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 import org.kde.latte.private.app 0.1 as LatteApp
 import org.kde.latte.private.containment 0.1 as LatteContainment
 
 
 import "abilities" as Ability
 import "applet" as Applet
 import "colorizer" as Colorizer
 import "editmode" as EditMode
 import "indicators" as Indicators
 import "layouts" as Layouts
 import "../code/LayoutManager.js" as LayoutManager
 
 Item {
     id: root
     objectName: "containmentViewLayout"
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.isVertical
     LayoutMirroring.childrenInherit: true
 
     //// BEGIN SIGNALS
     signal clearZoomSignal();
     signal destroyInternalViewSplitters();
     signal emptyAreasWheel(QtObject wheel);
     signal separatorsUpdated();
     signal signalActivateEntryAtIndex(int entryIndex);
     signal signalNewInstanceForEntryAtIndex(int entryIndex);
     signal updateEffectsArea();
     signal updateIndexes();
     signal updateScale(int delegateIndex, real newScale, real step);
 
     signal broadcastedToApplet(string pluginName, string action, variant value);
     //// END SIGNALS
 
     ////BEGIN properties
     property bool debugMode: Qt.application.arguments.indexOf("--graphics")>=0
     property bool debugModeLocalGeometry: Qt.application.arguments.indexOf("--localgeometry")>=0
     property bool debugModeSpacers: Qt.application.arguments.indexOf("--spacers")>=0
     property bool debugModeTimers: Qt.application.arguments.indexOf("--timers")>=0
     property bool debugModeWindow: Qt.application.arguments.indexOf("--with-window")>=0
     property bool debugModeOverloadedIcons: Qt.application.arguments.indexOf("--overloaded-icons")>=0
 
     readonly property int version: LatteCore.Environment.makeVersion(0,9,4)
 
     property bool globalDirectRender: false //it is used as a globalDirectRender for all elements in the dock
 
     property int directRenderAnimationTime: 0
 
     property bool addLaunchersMessage: false
     property bool addLaunchersInTaskManager: plasmoid.configuration.addLaunchersInTaskManager
     property bool backgroundOnlyOnMaximized: plasmoid.configuration.backgroundOnlyOnMaximized
     property bool behaveAsPlasmaPanel: {
         if (!LatteCore.WindowSystem.compositingActive) {
             //! In NOCOMPOSITING mode VIEWS should behave as real windows and that way
             //! we gain also the snapping features from KWin
             return true;
         }
 
         if (!latteView || !latteView.visibility) {
             return false;
         }
 
         if (screenEdgeMarginEnabled && plasmoid.configuration.fittsLawIsRequested) {
             //! dont use when floating views are requesting Fitt's Law
             return false;
         }
 
         var staticLayout = (plasmoid.configuration.minLength === plasmoid.configuration.maxLength);
 
         return (visibilityManager.panelIsBiggerFromIconSize
                 && (maxZoomFactor === 1.0)
                 && (plasmoid.configuration.alignment === LatteCore.Types.Justify || staticLayout)
                 && !root.editMode
                 && !visibilityManager.inLocationAnimation);
     }
 
     property int viewType: {
         var staticLayout = (plasmoid.configuration.minLength === plasmoid.configuration.maxLength);
 
         if ((plasmoid.configuration.alignment === LatteCore.Types.Justify || staticLayout)
                 && (plasmoid.configuration.useThemePanel)
                 && (plasmoid.configuration.panelSize === 100)
                 && (maxZoomFactor === 1.0)) {
             return LatteCore.Types.PanelView;
         }
 
         return LatteCore.Types.DockView;
     }
 
     property bool blurEnabled: plasmoid.configuration.blurEnabled && (!forceTransparentPanel || forcePanelForBusyBackground)
 
     readonly property bool ignoreRegularFilesDragging: !root.editMode
                                                        && (dragInfo.computationsAreValid || foreDropArea.dragInfo.computationsAreValid)
                                                        && !root.dragInfo.isPlasmoid
                                                        && !root.dragInfo.onlyLaunchers
     readonly property Item dragInfo: Item {
         property bool entered: backDropArea.dragInfo.entered || foreDropArea.dragInfo.entered
         property bool isTask: backDropArea.dragInfo.isTask || foreDropArea.dragInfo.isTask
         property bool isPlasmoid: backDropArea.dragInfo.isPlasmoid || foreDropArea.dragInfo.isPlasmoid
         property bool isSeparator: backDropArea.dragInfo.isSeparator || foreDropArea.dragInfo.isSeparator
         property bool isLatteTasks: backDropArea.dragInfo.isLatteTasks || foreDropArea.dragInfo.isLatteTasks
         property bool onlyLaunchers: backDropArea.dragInfo.onlyLaunchers || foreDropArea.dragInfo.onlyLaunchers
 
         //  onIsPlasmoidChanged: console.log("isPlasmoid :: " + backDropArea.dragInfo.isPlasmoid + " _ " + foreDropArea.dragInfo.isPlasmoid );
         //  onEnteredChanged: console.log("entered :: " + backDropArea.dragInfo.entered + " _ " + foreDropArea.dragInfo.entered );
     }
 
     property bool containsOnlyPlasmaTasks: false //this is flag to indicate when from tasks only a plasma based one is found
     property bool dockContainsMouse: latteView && latteView.visibility ? latteView.visibility.containsMouse : false
 
     property bool disablePanelShadowMaximized: plasmoid.configuration.disablePanelShadowForMaximized && LatteCore.WindowSystem.compositingActive
     property bool drawShadowsExternal: panelShadowsActive && behaveAsPlasmaPanel && !visibilityManager.inTempHiding
     property bool editMode: editModeVisual.inEditMode
     property bool windowIsTouching: latteView && latteView.windowsTracker
                                     && (latteView.windowsTracker.currentScreen.activeWindowTouching || hasExpandedApplet)
 
     property bool forceSolidPanel: (latteView && latteView.visibility
                                     && LatteCore.WindowSystem.compositingActive
                                     && !inConfigureAppletsMode
                                     && userShowPanelBackground
                                     && ( (plasmoid.configuration.solidBackgroundForMaximized
                                           && !(hasExpandedApplet && !plasmaBackgroundForPopups)
                                           && latteView.windowsTracker.currentScreen.existsWindowTouching)
                                         || (hasExpandedApplet && plasmaBackgroundForPopups) ))
                                    || solidBusyForTouchingBusyVerticalView
                                    || plasmaStyleBusyForTouchingBusyVerticalView
                                    || !LatteCore.WindowSystem.compositingActive
 
     property bool forceTransparentPanel: root.backgroundOnlyOnMaximized
                                          && latteView && latteView.visibility
                                          && LatteCore.WindowSystem.compositingActive
                                          && !inConfigureAppletsMode
                                          && !forceSolidPanel
                                          && !latteView.windowsTracker.currentScreen.existsWindowTouching
                                          && !(windowColors === LatteContainment.Types.ActiveWindowColors && selectedWindowsTracker.existsWindowActive)
 
     property bool forcePanelForBusyBackground: userShowPanelBackground && (root.themeColors === LatteContainment.Types.SmartThemeColors)
                                                && ( (root.forceTransparentPanel && colorizerManager.backgroundIsBusy)
                                                    || normalBusyForTouchingBusyVerticalView )
 
     property bool normalBusyForTouchingBusyVerticalView: (latteView && latteView.windowsTracker /*is touching a vertical view that is in busy state and the user prefers isBusy transparency*/
                                                           && latteView.windowsTracker.currentScreen.isTouchingBusyVerticalView
                                                           && root.themeColors === LatteContainment.Types.SmartThemeColors
                                                           && plasmoid.configuration.backgroundOnlyOnMaximized
                                                           /*&& !plasmoid.configuration.solidBackgroundForMaximized
                                                           && !plasmaBackgroundForPopups*/)
 
     property bool solidBusyForTouchingBusyVerticalView: false //DISABLED, until to check if the normalBusyForTouchingBusyVerticalView is enough to catch and handle the case
     /*(latteView && latteView.windowsTracker /*is touching a vertical view that is in busy state and the user prefers solidness*/
     /* && latteView.windowsTracker.currentScreen.isTouchingBusyVerticalView
                                                          && root.themeColors === LatteContainment.Types.SmartThemeColors
                                                          && plasmoid.configuration.backgroundOnlyOnMaximized
                                                          && plasmoid.configuration.solidBackgroundForMaximized
                                                          && !plasmaBackgroundForPopups)*/
 
     property bool plasmaStyleBusyForTouchingBusyVerticalView: false //DISABLED, until to check if the normalBusyForTouchingBusyVerticalView is enough to catch and handle the case
     //(latteView && latteView.windowsTracker /*is touching a vertical view that is in busy state and the user prefers solidness*/
     /* && latteView.windowsTracker.currentScreen.isTouchingBusyVerticalView
                                                                && root.themeColors === LatteContainment.Types.SmartThemeColors
                                                                && plasmoid.configuration.backgroundOnlyOnMaximized
                                                                && plasmaBackgroundForPopups)*/
 
     property bool hideThickScreenGap: screenEdgeMarginEnabled
                                       && plasmoid.configuration.hideScreenGapForMaximized
                                       && latteView && latteView.windowsTracker
                                       && latteView.windowsTracker.currentScreen.existsWindowMaximized
 
     property bool hideLengthScreenGaps: hideThickScreenGap
                                         && (latteView.visibility.mode === LatteCore.Types.AlwaysVisible
                                             || latteView.visibility.mode === LatteCore.Types.WindowsGoBelow)
                                         && (plasmoid.configuration.alignment === LatteCore.Types.Justify)
                                         && plasmoid.configuration.maxLength>85
                                         && !root.editMode
 
 
 
     property int themeColors: plasmoid.configuration.themeColors
     property int windowColors: plasmoid.configuration.windowColors
 
     property bool colorizerEnabled: themeColors !== LatteContainment.Types.PlasmaThemeColors || windowColors !== LatteContainment.Types.NoneWindowColors
 
     property bool plasmaBackgroundForPopups: plasmoid.configuration.plasmaBackgroundForPopups
 
     readonly property bool hasExpandedApplet: latteView && latteView.extendedInterface.hasExpandedApplet;
     readonly property bool hasUserSpecifiedBackground: (latteView && latteView.layout && latteView.layout.background.startsWith("/")) ?
                                                            true : false
 
     readonly property bool inConfigureAppletsMode: root.editMode && (plasmoid.configuration.inConfigureAppletsMode || !LatteCore.WindowSystem.compositingActive)
     readonly property bool parabolicEffectEnabled: zoomFactor>1 && !inConfigureAppletsMode
 
     property bool dockIsShownCompletely: !(dockIsHidden || inSlidingIn || inSlidingOut) && !root.editMode
     property bool closeActiveWindowEnabled: plasmoid.configuration.closeActiveWindowEnabled
     property bool dragActiveWindowEnabled: plasmoid.configuration.dragActiveWindowEnabled
     property bool immutable: plasmoid.immutable
     property bool inFullJustify: (plasmoid.configuration.alignment === LatteCore.Types.Justify) && (maxLengthPerCentage===100)
     property bool inSlidingIn: visibilityManager ? visibilityManager.inSlidingIn : false
     property bool inSlidingOut: visibilityManager ? visibilityManager.inSlidingOut : false
     property bool inStartup: true
     property bool isHalfShown: false //is used to disable the zoom hovering effect at sliding in-out the dock
     property bool isHorizontal: plasmoid.formFactor === PlasmaCore.Types.Horizontal
     property bool isReady: !(dockIsHidden || inSlidingIn || inSlidingOut)
     property bool isVertical: !isHorizontal
     property bool isHovered: latteApplet ? ((latteAppletHoveredIndex !== -1) || (layoutsContainer.hoveredIndex !== -1)) //|| wholeArea.containsMouse
                                          : (layoutsContainer.hoveredIndex !== -1) //|| wholeArea.containsMouse
     property bool mouseWheelActions: plasmoid.configuration.mouseWheelActions
     property bool onlyAddingStarup: true //is used for the initialization phase in startup where there aren't removals, this variable provides a way to grow icon size
     property bool shrinkThickMargins: plasmoid.configuration.shrinkThickMargins
     property bool showLatteShortcutBadges: false
     property bool showAppletShortcutBadges: false
     property bool showMetaBadge: false
     property int applicationLauncherId: -1
 
     //FIXME: possibly this is going to be the default behavior, this user choice
     //has been dropped from the Dock Configuration Window
     //property bool smallAutomaticIconJumps: plasmoid.configuration.smallAutomaticIconJumps
     property bool smallAutomaticIconJumps: true
 
     property bool userShowPanelBackground: LatteCore.WindowSystem.compositingActive ? plasmoid.configuration.useThemePanel : true
     property bool useThemePanel: noApplets === 0 || !LatteCore.WindowSystem.compositingActive ?
                                      true : (plasmoid.configuration.useThemePanel || plasmoid.configuration.solidBackgroundForMaximized)
 
     property bool plasma515: LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,15,0)
     property bool plasma518: LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,18,0)
 
     property alias hoveredIndex: layoutsContainer.hoveredIndex
     property alias directRenderDelayerIsRunning: directRenderDelayerForEnteringTimer.running
 
     readonly property int minAppletLengthInConfigure: 64
     readonly property int maxJustifySplitterSize: 96
 
     property int latteAppletPos: -1
     property real minLengthPerCentage: plasmoid.configuration.minLength
     property real maxLengthPerCentage: hideLengthScreenGaps ? 100 : plasmoid.configuration.maxLength
 
     property int minLength: {
         if (root.isHorizontal) {
             return behaveAsPlasmaPanel && LatteCore.WindowSystem.compositingActive ? width : width * (minLengthPerCentage/100)
         } else {
             return behaveAsPlasmaPanel && LatteCore.WindowSystem.compositingActive ? height : height * (minLengthPerCentage/100)
         }
     }
 
     property int maxLength: {
         if (root.isHorizontal) {
             return behaveAsPlasmaPanel ? width : width * (maxLengthPerCentage/100)
         } else {
             return behaveAsPlasmaPanel ? height : height * (maxLengthPerCentage/100)
         }
     }
 
     property int scrollAction: plasmoid.configuration.scrollAction
 
     property bool panelOutline: plasmoid.configuration.panelOutline
     property int panelEdgeSpacing: Math.max(panelBoxBackground.lengthMargins, 1.5*appShadowSize)
     property int panelTransparency: plasmoid.configuration.panelTransparency //user set
     property int currentPanelTransparency: 0 //application override
 
     readonly property real currentPanelOpacity: currentPanelTransparency/100
 
     property bool panelShadowsActive: {
         if (!userShowPanelBackground) {
             return false;
         }
 
         if (inConfigureAppletsMode) {
             return plasmoid.configuration.panelShadows;
         }
 
         var forcedNoShadows = (plasmoid.configuration.panelShadows && disablePanelShadowMaximized
                                && latteView && latteView.windowsTracker && latteView.windowsTracker.currentScreen.activeWindowMaximized);
 
         if (forcedNoShadows) {
             return false;
         }
 
         var transparencyCheck = (blurEnabled || (!blurEnabled && currentPanelTransparency>20));
 
         //! Draw shadows for isBusy state only when current panelTransparency is greater than 10%
         if (plasmoid.configuration.panelShadows && root.forcePanelForBusyBackground && transparencyCheck) {
             return true;
         }
 
         if (( (plasmoid.configuration.panelShadows && !root.backgroundOnlyOnMaximized)
              || (plasmoid.configuration.panelShadows && root.backgroundOnlyOnMaximized && !root.forceTransparentPanel))
                 && !forcedNoShadows) {
             return true;
         }
 
         if (hasExpandedApplet && plasmaBackgroundForPopups) {
             return true;
         }
 
         return false;
     }
 
     property int appShadowOpacity: (plasmoid.configuration.shadowOpacity/100) * 255
     property int appShadowSize: enableShadows ? (0.5*metrics.iconSize) * (plasmoid.configuration.shadowSize/100) : 0
     property int appShadowSizeOriginal: enableShadows ? (0.5*metrics.maxIconSize) * (plasmoid.configuration.shadowSize/100) : 0
 
     property string appChosenShadowColor: {
         if (plasmoid.configuration.shadowColorType === LatteContainment.Types.ThemeColorShadow) {
             var strC = String(theme.textColor);
             return strC.indexOf("#") === 0 ? strC.substr(1) : strC;
         } else if (plasmoid.configuration.shadowColorType === LatteContainment.Types.UserColorShadow) {
             return plasmoid.configuration.shadowColor;
         }
 
         // default shadow color
         return "080808";
     }
 
     property string appShadowColor: "#" + decimalToHex(appShadowOpacity) + appChosenShadowColor
     property string appShadowColorSolid: "#" + appChosenShadowColor
 
     property int totalPanelEdgeSpacing: 0 //this is set by PanelBox
     property int offset: {
         if (behaveAsPlasmaPanel) {
             return 0;
         }
 
         if (root.isHorizontal) {
             return width * (plasmoid.configuration.offset/100);
         } else {
             height * (plasmoid.configuration.offset/100)
         }
     }
 
     //center the layout correctly when the user uses an offset
     property int offsetFixed: (offset===0 || panelAlignment === LatteCore.Types.Center || plasmoid.configuration.alignment === LatteCore.Types.Justify)?
                                   offset : offset+panelMarginLength/2+totalPanelEdgeSpacing/2
 
     property int realPanelSize: 0
     property int realPanelLength: 0
     property int realPanelThickness: 0
     //this is set by the PanelBox
     property int panelThickMarginBase: 0
     property int panelThickMarginHigh: 0
     property int panelMarginLength: 0
     property int panelShadow: 0 //shadowsSize
     property int editShadow: {
         if (!LatteCore.WindowSystem.compositingActive) {
             return 0;
         } else if (latteView && latteView.screenGeometry) {
             return latteView.screenGeometry.height/90;
         } else {
             return 7;
         }
     }
 
     property int themePanelThickness: {
         var panelBase = root.panelThickMarginHigh + root.panelThickMarginBase;
         var margin = shrinkThickMargins ? 0 : metrics.totals.thicknessEdges + localScreenEdgeMargin;
         var maxPanelSize = (metrics.iconSize + margin) - panelBase;
         var percentage = LatteCore.WindowSystem.compositingActive ? plasmoid.configuration.panelSize/100 : 1;
         return Math.max(panelBase, panelBase + percentage*maxPanelSize);
     }
 
-    property int lengthExtMargin: metrics.fraction.lengthMargin * metrics.iconSize
-
     property bool screenEdgeMarginEnabled: plasmoid.configuration.screenEdgeMargin >= 0 && !plasmoid.configuration.shrinkThickMargins
     property int screenEdgeMargin: {
         //! is used for window geometry calculations
         if (!screenEdgeMarginEnabled
                 || (hideThickScreenGap && localScreenEdgeMargin === 0)) {
                 /*window geometry is updated after the local screen margin animation was zeroed*/
             return 0;
         }
 
         return plasmoid.configuration.screenEdgeMargin;
     }
     property int localScreenEdgeMargin: (screenEdgeMarginEnabled && behaveAsPlasmaPanel && !root.editMode)
                                         || !screenEdgeMarginEnabled
                                         || hideThickScreenGap ? 0 : plasmoid.configuration.screenEdgeMargin
 
-    property int lengthMargin: metrics.padding.length + lengthExtMargin
-    property int lengthMargins: 2 * lengthMargin
-
-    property int widthMargins: root.isVertical ? metrics.totals.thicknessEdges : lengthMargins
-    property int heightMargins: root.isHorizontal ? metrics.totals.thicknessEdges : lengthMargins
+    property int widthMargins: root.isVertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
+    property int heightMargins: root.isHorizontal ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
 
     ///FIXME: <delete both> I can't remember why this is needed, maybe for the anchorings!!! In order for the Double Layout to not mess the anchorings...
     //property int layoutsContainer.mainLayoutPosition: !plasmoid.immutable ? LatteCore.Types.Center : (root.isVertical ? LatteCore.Types.Top : LatteCore.Types.Left)
     //property int panelAlignment: plasmoid.configuration.alignment !== LatteCore.Types.Justify ? plasmoid.configuration.alignment : layoutsContainer.mainLayoutPosition
 
     property int panelAlignment: !root.inConfigureAppletsMode ? plasmoid.configuration.alignment :
                                                                 ( plasmoid.configuration.alignment === LatteCore.Types.Justify ?
                                                                      LatteCore.Types.Center : plasmoid.configuration.alignment )
 
     property int panelUserSetAlignment: plasmoid.configuration.alignment
 
     property real zoomFactor: LatteCore.WindowSystem.compositingActive && animations.active ? ( 1 + (plasmoid.configuration.zoomLevel / 20) ) : 1
 
     readonly property string plasmoidName: "org.kde.latte.plasmoid"
 
     property var badgesForActivate: {
         if (!shortcutsEngine) {
             return ['1','2','3','4','5','6','7','8','9','0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.'];
         }
 
         return shortcutsEngine.badgesForActivate;
     }
 
     property var iconsArray: [16, 22, 32, 48, 64, 96, 128, 256]
 
     property Item dragOverlay
     property Item toolBox
     property Item latteAppletContainer
     property Item latteApplet
 
     readonly property alias animations: _animations
     readonly property alias appletsRecords: _appletsRecords
     readonly property alias autosize: _autosize
     readonly property alias indicatorsManager: indicators
     readonly property alias metrics: _metrics
     readonly property alias parabolicManager: _parabolicManager
 
     readonly property alias maskManager: visibilityManager
     readonly property alias layoutsContainerItem: layoutsContainer
 
     property QtObject latteView: null
     property QtObject shortcutsEngine: null
     property QtObject themeExtended: null
     property QtObject universalSettings: null
     property QtObject layoutsManager: null
     property QtObject viewLayout: latteView && latteView.layout ? latteView.layout : null
     property QtObject selectedWindowsTracker: {
         if (latteView && latteView.windowsTracker) {
             switch(plasmoid.configuration.activeWindowFilter) {
             case LatteContainment.Types.ActiveInCurrentScreen:
                 return latteView.windowsTracker.currentScreen;
             case LatteContainment.Types.ActiveFromAllScreens:
                 return latteView.windowsTracker.allScreens;
             }
         }
 
         return null;
     }
 
     // TO BE DELETED, if not needed: property int counter:0;
 
     ///BEGIN properties provided to Latte Plasmoid
     //shadows for applets, it should be removed as the appleitems don't need it any more
     property bool badges3DStyle: universalSettings ? universalSettings.badges3DStyle : true
     property bool enableShadows: plasmoid.configuration.appletShadowsEnabled
     property bool dockIsHidden: latteView ? latteView.visibility.isHidden : true
 
     property bool titleTooltips: plasmoid.configuration.titleTooltips
     property bool unifiedGlobalShortcuts: true
 
     readonly property bool hasInternalSeparator: latteApplet ? latteApplet.hasInternalSeparator : false
 
     property int latteAppletHoveredIndex: latteApplet ? latteApplet.hoveredIndex : -1
     property int tasksCount: latteApplet ? latteApplet.tasksCount : 0
 
 
     property real maxZoomFactor: Math.max(zoomFactor, _appletsRecords.maxInnerZoomFactor)
 
     property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property color minimizedDotColor: colorizerManager.minimizedDotColor
     ///END properties from latteApplet
 
 
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     //// BEGIN properties in functions
     property int noApplets: {
         var count1 = 0;
         var count2 = 0;
 
         count1 = layoutsContainer.mainLayout.children.length;
         var tempLength = layoutsContainer.mainLayout.children.length;
 
         for (var i=tempLength-1; i>=0; --i) {
             var applet = layoutsContainer.mainLayout.children[i];
             if (applet && (applet === dndSpacer || applet === lastSpacer ||  applet.isInternalViewSplitter))
                 count1--;
         }
 
         count2 = layoutsContainer.endLayout.children.length;
         tempLength = layoutsContainer.endLayout.children.length;
 
         for (var i=tempLength-1; i>=0; --i) {
             var applet = layoutsContainer.endLayout.children[i];
             if (applet && (applet === dndSpacer || applet === lastSpacer  || applet.isInternalViewSplitter))
                 count2--;
         }
 
         return (count1 + count2);
     }
 
     ///The index of user's current icon size
     property int currentIconIndex:{
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === metrics.iconSize){
                 return i;
             }
         }
         return 3;
     }
 
     //// END properties in functions
 
     ////////////////END properties
 
     //// BEGIN OF Behaviors
-    Behavior on lengthExtMargin {
-        NumberAnimation {
-            duration: 0.8 * animations.duration.proposed
-            easing.type: Easing.OutCubic
-        }
-    }
-
     Behavior on localScreenEdgeMargin {
         enabled: !root.behaveAsPlasmaPanel
                  && !editModeVisual.editAnimationRunning /*avoid slide-out animation when from editMode we change to real floating*/
 
         NumberAnimation {
             duration: 0.8 * animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on offset {
         enabled: editModeVisual.editAnimationInFullThickness
         NumberAnimation {
             id: offsetAnimation
 
             duration: 0.8 * animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
     //// END OF Behaviors
 
     //////////////START OF CONNECTIONS
     onEditModeChanged: {
         if (editMode) {
             visibilityManager.updateMaskArea();
             clearZoom();
         } else {
             layoutsContainer.updateSizeForAppletsInFill();
         }
 
         //! This is used in case the dndspacer has been left behind
         //! e.g. the user drops a folder and a context menu is appearing
         //! but the user decides to not make a choice for the applet type
         if (dndSpacer.parent !== root) {
             dndSpacer.parent = root;
         }
     }
 
     onInConfigureAppletsModeChanged: {
         if (inConfigureAppletsMode && panelUserSetAlignment===LatteCore.Types.Justify) {
             joinLayoutsToMainLayout();
         } else if (!inConfigureAppletsMode) {
             splitMainLayoutToLayouts();
         }
 
         updateIndexes();
     }
 
     //! It is used only when the user chooses different alignment types
     //! and not during startup
     onPanelUserSetAlignmentChanged: {
         if (!root.editMode) {
             return;
         }
 
         if (!inConfigureAppletsMode){
             if (panelUserSetAlignment===LatteCore.Types.Justify) {
                 addInternalViewSplitters();
                 splitMainLayoutToLayouts();
             } else {
                 joinLayoutsToMainLayout();
                 root.destroyInternalViewSplitters();
             }
         } else {
             if (panelUserSetAlignment===LatteCore.Types.Justify) {
                 addInternalViewSplitters();
             } else {
                 root.destroyInternalViewSplitters();
             }
         }
 
         LayoutManager.save();
         updateIndexes();
     }
 
     onLatteViewChanged: {
         if (latteView) {
             latteView.onXChanged.connect(visibilityManager.updateMaskArea);
             latteView.onYChanged.connect(visibilityManager.updateMaskArea);
             latteView.onWidthChanged.connect(visibilityManager.updateMaskArea);
             latteView.onHeightChanged.connect(visibilityManager.updateMaskArea);
 
             latteView.positioner.hideDockDuringLocationChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
 
 
             latteView.visibility.onContainsMouseChanged.connect(visibilityManager.slotContainsMouseChanged);
             latteView.visibility.onMustBeHide.connect(visibilityManager.slotMustBeHide);
             latteView.visibility.onMustBeShown.connect(visibilityManager.slotMustBeShown);
 
             updateContainsOnlyPlasmaTasks();
         }
     }
 
     onDockContainsMouseChanged: {
         if (!dockContainsMouse) {
             initializeHoveredIndexes();
         }
     }
 
     onMaxLengthChanged: {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     onToolBoxChanged: {
         if (toolBox) {
             toolBox.visible = false;
         }
     }
 
     onIsReadyChanged: {
         if (isReady && !titleTooltipDialog.visible && titleTooltipDialog.activeItemHovered){
             titleTooltipDialog.show(titleTooltipDialog.activeItem, titleTooltipDialog.activeItemText);
         }
     }
 
     onIsVerticalChanged: {
         if (isVertical) {
             if (plasmoid.configuration.alignment === LatteCore.Types.Left)
                 plasmoid.configuration.alignment = LatteCore.Types.Top;
             else if (plasmoid.configuration.alignment === LatteCore.Types.Right)
                 plasmoid.configuration.alignment = LatteCore.Types.Bottom;
         } else {
             if (plasmoid.configuration.alignment === LatteCore.Types.Top)
                 plasmoid.configuration.alignment = LatteCore.Types.Left;
             else if (plasmoid.configuration.alignment === LatteCore.Types.Bottom)
                 plasmoid.configuration.alignment = LatteCore.Types.Right;
         }
     }
 
     Component.onCompleted: {
         //  currentLayout.isLayoutHorizontal = isHorizontal
         LayoutManager.plasmoid = plasmoid;
         LayoutManager.root = root;
         LayoutManager.layout = layoutsContainer.mainLayout;
         LayoutManager.layoutS = layoutsContainer.startLayout;
         LayoutManager.layoutE = layoutsContainer.endLayout;
         LayoutManager.lastSpacer = lastSpacer;
         LayoutManager.metrics = metrics;
 
         upgrader_v010_alignment();
 
         LayoutManager.restore();
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         inStartupTimer.start();
     }
 
     Component.onDestruction: {
         console.debug("Destroying Latte Dock Containment ui...");
 
         if (latteView) {
             latteView.onXChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onYChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onWidthChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onHeightChanged.disconnect(visibilityManager.updateMaskArea);
 
             latteView.positioner.hideDockDuringLocationChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
 
             if (latteView.visibility) {
                 latteView.visibility.onContainsMouseChanged.disconnect(visibilityManager.slotContainsMouseChanged);
                 latteView.visibility.onMustBeHide.disconnect(visibilityManager.slotMustBeHide);
                 latteView.visibility.onMustBeShown.disconnect(visibilityManager.slotMustBeShown);
             }
         }
     }
 
     Containment.onAppletAdded: {
         addApplet(applet, x, y);
         console.log(applet.pluginName);
         LayoutManager.save();
         updateIndexes();
     }
 
     Containment.onAppletRemoved: {
         LayoutManager.removeApplet(applet);
         var flexibleFound = false;
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var applet = layoutsContainer.mainLayout.children[i].applet;
             if (applet && ((root.isHorizontal && applet.Layout.fillWidth) ||
                            (!root.isHorizontal && applet.Layout.fillHeight)) &&
                     applet.visible) {
                 flexibleFound = true;
                 break
             }
         }
         if (!flexibleFound) {
             lastSpacer.parent = layoutsContainer.mainLayout;
         }
 
         console.log(applet.pluginName);
         LayoutManager.save();
 
         updateIndexes();
         updateContainsOnlyPlasmaTasks();
     }
 
     Plasmoid.onUserConfiguringChanged: {
         if (plasmoid.immutable) {
             if (dragOverlay) {
                 dragOverlay.destroy();
             }
             return;
         }
 
         // console.debug("user configuring", plasmoid.userConfiguring)
 
         if (plasmoid.userConfiguring) {
             //  console.log("applets------");
             for (var i = 0; i < plasmoid.applets.length; ++i) {
                 //    console.log("applet:"+i);
                 plasmoid.applets[i].expanded = false;
             }
             if (!dragOverlay) {
                 var component = Qt.createComponent("editmode/ConfigOverlay.qml");
                 if (component.status == Component.Ready) {
                     dragOverlay = component.createObject(root);
                 } else {
                     console.log("Could not create ConfigOverlay");
                     console.log(component.errorString());
                 }
                 component.destroy();
             } else {
                 dragOverlay.visible = true;
             }
         } else {
             if (dragOverlay) {
                 dragOverlay.visible = false;
                 dragOverlay.destroy();
             }
         }
     }
 
     Plasmoid.onImmutableChanged: {
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         ///Set Preferred Sizes///
         ///Notice: they are set here because if they are set with a binding
         ///they break the !immutable experience, the latteView becomes too small
         ///to add applets
         /*   if (plasmoid.immutable) {
             if(root.isHorizontal) {
                 root.Layout.preferredWidth = (plasmoid.configuration.alignment === LatteCore.Types.Justify ?
                                                   layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin);
             } else {
                 root.Layout.preferredHeight = (plasmoid.configuration.alignment === LatteCore.Types.Justify ?
                                                    layoutsContainer.height + 0.5*iconMargin : layoutsContainer.mainLayout.height + iconMargin);
             }
         } else {
             if (root.isHorizontal) {
                 root.Layout.preferredWidth = Screen.width;
             } else {
                 root.Layout.preferredHeight = Screen.height;
             }
         }*/
 
         visibilityManager.updateMaskArea();
     }
     //////////////END OF CONNECTIONS
 
     //////////////START OF FUNCTIONS
     function addApplet(applet, x, y) {
         var container = appletContainerComponent.createObject(dndSpacer.parent)
 
         container.applet = applet;
         applet.parent = container.appletWrapper;
 
         applet.anchors.fill = container.appletWrapper;
 
         applet.visible = true;
 
 
         // don't show applet if it chooses to be hidden but still make it
         // accessible in the panelcontroller
         container.visible = Qt.binding(function() {
             return applet.status !== PlasmaCore.Types.HiddenStatus || (!plasmoid.immutable && root.inConfigureAppletsMode)
         })
 
         addContainerInLayout(container, applet, x, y);
 
         updateContainsOnlyPlasmaTasks();
     }
 
     function addContainerInLayout(container, applet, x, y){
         // Is there a DND placeholder? Replace it!
         if ( (dndSpacer.parent === layoutsContainer.mainLayout)
                 || (dndSpacer.parent === layoutsContainer.startLayout)
                 || (dndSpacer.parent===layoutsContainer.endLayout)) {
             LayoutManager.insertBeforeForLayout(dndSpacer.parent, dndSpacer, container);
             dndSpacer.parent = root;
             return;
             // If the provided position is valid, use it.
         } else if (x >= 0 && y >= 0) {
             var index = LayoutManager.insertAtCoordinates2(container, x , y);
 
             // Fall through to determining an appropriate insert position.
         } else {
             var before = null;
             container.animationsEnabled = false;
 
             if (lastSpacer.parent === layoutsContainer.mainLayout) {
                 before = lastSpacer;
             }
 
             // Insert icons to the left of whatever is at the center (usually a Task Manager),
             // if it exists.
             // FIXME TODO: This is a real-world fix to produce a sensible initial position for
             // launcher icons added by launcher menu applets. The basic approach has been used
             // since Plasma 1. However, "add launcher to X" is a generic-enough concept and
             // frequent-enough occurrence that we'd like to abstract it further in the future
             // and get rid of the ugliness of parties external to the containment adding applets
             // of a specific type, and the containment caring about the applet type. In a better
             // system the containment would be informed of requested launchers, and determine by
             // itself what it wants to do with that information.
             if (applet.pluginName == "org.kde.plasma.icon") {
                 var middle = layoutsContainer.mainLayout.childAt(root.width / 2, root.height / 2);
 
                 if (middle) {
                     before = middle;
                 }
 
                 // Otherwise if lastSpacer is here, enqueue before it.
             }
 
             if (before) {
                 LayoutManager.insertBefore(before, container);
 
                 // Fall through to adding at the end.
             } else {
                 container.parent = layoutsContainer.mainLayout;
             }
         }
 
         //Important, removes the first children of the layoutsContainer.mainLayout after the first
         //applet has been added
         lastSpacer.parent = root;
 
         updateIndexes();
     }
 
     function addInternalViewSplitters(){
         if (internalViewSplittersCount() === 0) {
             addInternalViewSplitter(plasmoid.configuration.splitterPosition);
             addInternalViewSplitter(plasmoid.configuration.splitterPosition2);
         }
     }
 
     function addInternalViewSplitter(pos){
         var splittersCount = internalViewSplittersCount();
         if(splittersCount<2){
             var container = appletContainerComponent.createObject(root);
 
             container.internalSplitterId = splittersCount+1;
             container.visible = true;
 
             if(pos>=0 ){
                 LayoutManager.insertAtIndex(container, pos);
             } else {
                 LayoutManager.insertAtIndex(container, Math.floor(layoutsContainer.mainLayout.count / 2));
             }
         }
     }
 
     //! it is used in order to check the right click position
     //! the only way to take into account the visual appearance
     //! of the applet (including its spacers)
     function appletContainsPos(appletId, pos){
         for (var i = 0; i < layoutsContainer.startLayout.children.length; ++i) {
             var child = layoutsContainer.startLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var child = layoutsContainer.mainLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.endLayout.children.length; ++i) {
             var child = layoutsContainer.endLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         return false;
     }
 
     function checkLastSpacer() {
         lastSpacer.parent = root
 
         var expands = false;
 
         if (isHorizontal) {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillWidth) {
                     expands = true;
                 }
             }
         } else {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillHeight) {
                     expands = true;
                 }
             }
         }
         if (!expands) {
             lastSpacer.parent = layoutsContainer.mainLayout
         }
     }
 
     function clearZoom(){
         if (latteApplet){
             latteApplet.clearZoom();
         }
 
         root.clearZoomSignal();
     }
 
     function containmentActions(){
         return latteView.containmentActions();
     }
 
     function decimalToHex(d, padding) {
         var hex = Number(d).toString(16);
         padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
 
         while (hex.length < padding) {
             hex = "0" + hex;
         }
 
         return hex;
     }
 
 
     function disableDirectRender(){
         //  root.globalDirectRender = false;
     }
 
     function internalViewSplittersCount(){
         var splitters = 0;
         for (var container in layoutsContainer.startLayout.children) {
             var item = layoutsContainer.startLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.mainLayout.children) {
             var item = layoutsContainer.mainLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.endLayout.children) {
             var item = layoutsContainer.endLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         return splitters;
     }
 
     function initializeHoveredIndexes() {
         layoutsContainer.hoveredIndex = -1;
         layoutsContainer.currentSpot = -1000;
         if (latteApplet) {
             latteApplet.initializeHoveredIndex();
         }
     }
 
     function layoutManager() {
         return LayoutManager;
     }
 
     function layoutManagerInsertBefore(place, item) {
         LayoutManager.insertBefore(place, item);
     }
 
     function layoutManagerInsertAfter(place, item) {
         LayoutManager.insertAfter(place, item);
     }
 
     function layoutManagerSave() {
         LayoutManager.save();
     }
 
     function layoutManagerSaveOptions() {
         LayoutManager.saveOptions();
     }
 
     function mouseInCanBeHoveredApplet(){
         if (latteApplet && latteApplet.containsMouse())
             return true;
 
         var applets = layoutsContainer.startLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         applets = layoutsContainer.mainLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         ///check second layout also
         applets = layoutsContainer.endLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         return false;
     }
 
     function mouseInHoverableArea() {
         return (latteView.visibility.containsMouse && !rootMouseArea.containsMouse && mouseInCanBeHoveredApplet());
     }
 
     function setHoveredIndex(ind) {
         layoutsContainer.hoveredIndex = ind;
     }
 
     function hideTooltipLabel(debug){
         titleTooltipDialog.hide(debug);
     }
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletShortcutBadges(showLatteShortcuts, showShortcuts, showMeta, applicationLauncher){
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.setShowTaskShortcutBadges(showLatteShortcuts);
         }
 
         showLatteShortcutBadges = showLatteShortcuts;
         showAppletShortcutBadges = showShortcuts;
         showMetaBadge = showMeta;
         applicationLauncherId = applicationLauncher;
 
         if (latteApplet) {
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function activateEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalActivateEntryAtIndex(index);
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function newInstanceForEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalNewInstanceForEntryAtIndex(index);
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function appletIdForIndex(index) {
         if (!root.unifiedGlobalShortcuts || parabolicManager.pseudoIndexBelongsToLatteApplet(index)) {
             return -1;
         }
 
         for (var i=0; i<layoutsContainer.startLayout.children.length; ++i){
             var appletItem = layoutsContainer.startLayout.children[i];
 
             if (appletItem && appletItem.refersEntryIndex(index)) {
                 return appletItem.applet.id;
             }
         }
 
         for (var j=0; j<layoutsContainer.mainLayout.children.length; ++j){
             var appletItem2 = layoutsContainer.mainLayout.children[j];
 
             if (appletItem2 && appletItem2.refersEntryIndex(index)) {
                 return appletItem2.applet.id;
             }
         }
 
         for (var k=0; j<layoutsContainer.endLayout.children.length; ++k){
             var appletItem3 = layoutsContainer.endLayout.children[k];
 
             if (appletItem3 && appletItem3.refersEntryIndex(index)) {
                 return appletItem3.applet.id;
             }
         }
 
         return -1;
     }
 
 
     function showTooltipLabel(taskItem, text){
         titleTooltipDialog.show(taskItem, text);
     }
 
     function sizeIsFromAutomaticMode(size){
 
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === size){
                 return true;
             }
         }
 
         return false;
     }
 
     function slotPreviewsShown(){
         if (latteView) {
             latteView.extendedInterface.deactivateApplets();
         }
     }
 
     function startCheckRestoreZoomTimer(){
         checkRestoreZoom.start();
     }
 
     function stopCheckRestoreZoomTimer(){
         checkRestoreZoom.stop();
     }
 
     function startDirectRenderDelayerDuringEntering(){
         directRenderDelayerForEnteringTimer.start();
     }
 
     function setGlobalDirectRender(value) {
         if (latteApplet && latteApplet.tasksExtendedManager.waitingLaunchersLength() > 0)
             return;
 
         if (value === true) {
             if (mouseInCanBeHoveredApplet()) {
                 root.globalDirectRender = true;
             } else {
                 //    console.log("direct render true ignored...");
             }
         } else {
             root.globalDirectRender = false;
         }
     }
 
     function updateContainsOnlyPlasmaTasks() {
         if (latteView) {
             root.containsOnlyPlasmaTasks = (latteView.tasksPresent() && !latteApplet);
         } else {
             root.containsOnlyPlasmaTasks = false;
         }
     }
 
     function updateSizeForAppletsInFill() {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     function splitMainLayoutToLayouts() {
         if (internalViewSplittersCount() === 2) {
             console.log("LAYOUTS: Moving applets from MAIN to THREE Layouts mode...");
             var splitter = -1;
             var splitter2 = -1;
 
             var totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=0; i<totalChildren; ++i) {
                 var item = layoutsContainer.mainLayout.children[i];
 
                 if(item.isInternalViewSplitter && splitter === -1) {
                     splitter = i;
                 } else if (item.isInternalViewSplitter && splitter>=0 && splitter2 === -1) {
                     splitter2 = i;
                 }
             }
 
             // console.log("update layouts 1:"+splitter + " - "+splitter2);
             for (var i=0; i<=splitter; ++i){
                 var item = layoutsContainer.mainLayout.children[0];
                 item.parent = layoutsContainer.startLayout;
             }
 
             splitter2 = splitter2 - splitter - 1;
             // console.log("update layouts 2:"+splitter + " - "+splitter2);
 
             totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=splitter2+1; i<totalChildren; ++i){
                 var item = layoutsContainer.mainLayout.children[splitter2+1];
                 item.parent = layoutsContainer.endLayout;
             }
         }
     }
 
     function joinLayoutsToMainLayout() {
         console.log("LAYOUTS: Moving applets from THREE to MAIN Layout mode...");
         var totalChildren1 = layoutsContainer.mainLayout.children.length;
         for (var i=totalChildren1-1; i>=0; --i) {
             var item1 = layoutsContainer.mainLayout.children[0];
             item1.parent = layoutsContainer.startLayout;
         }
 
         var totalChildren2 = layoutsContainer.endLayout.children.length;
 
         for (var i=totalChildren2-1; i>=0; --i) {
             var item2 = layoutsContainer.endLayout.children[0];
             item2.parent = layoutsContainer.startLayout;
         }
 
         var totalChildrenL = layoutsContainer.startLayout.children.length;
         for (var i=totalChildrenL-1; i>=0; --i) {
             var itemL = layoutsContainer.startLayout.children[0];
             itemL.parent = layoutsContainer.mainLayout;
         }
     }
 
     function upgrader_v010_alignment() {
         //! IMPORTANT, special case because it needs to be loaded on Component constructor
         if (!plasmoid.configuration.alignmentUpgraded) {
             plasmoid.configuration.alignment = plasmoid.configuration.panelPosition;
             plasmoid.configuration.alignmentUpgraded = true;
         }
     }
     //END functions
 
 
     ////BEGIN interfaces
 
     Connections {
         target: LatteCore.WindowSystem
 
         onCompositingActiveChanged: {
             visibilityManager.updateMaskArea();
         }
     }
 
     Connections {
         target: latteView
 
         onContextMenuIsShownChanged: {
             if (!latteView.contextMenuIsShown) {
                 checkRestoreZoom.start();
             } else {
                 root.setGlobalDirectRender(false);
             }
         }
     }
 
     Connections{
         target: latteView && latteView.visibility ? latteView.visibility : root
 
         ignoreUnknownSignals : true
 
         onContainsMouseChanged: {
             if (mouseInHoverableArea()) {
                 stopCheckRestoreZoomTimer();
             } else {
                 startCheckRestoreZoomTimer();
             }
         }
     }
 
     Connections{
         target: layoutsContainer
 
         onHoveredIndexChanged: {
             if (latteApplet && layoutsContainer.hoveredIndex>-1){
                 latteApplet.setHoveredIndex(-1);
             }
 
             if (latteApplet && latteApplet.windowPreviewIsShown && layoutsContainer.hoveredIndex>-1) {
                 latteApplet.hidePreview();
             }
         }
     }
 
     ////END interfaces
 
     /////BEGIN: Title Tooltip///////////
     PlasmaCore.Dialog{
         id: titleTooltipDialog
 
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: plasmoid.location
         mainItem: RowLayout{
             Layout.fillWidth: true
             Layout.fillHeight: true
             PlasmaComponents.Label{
                 id:titleLbl
                 Layout.leftMargin: 4
                 Layout.rightMargin: 4
                 Layout.topMargin: 2
                 Layout.bottomMargin: 2
                 text: titleTooltipDialog.title
             }
         }
 
         visible: false
 
         property string title: ""
 
         property bool activeItemHovered: false
         property Item activeItem: null
         property Item activeItemTooltipParent: null
         property string activeItemText: ""
 
 
         Component.onCompleted: {
             root.clearZoomSignal.connect(titleTooltipDialog.hide);
         }
 
         Component.onDestruction: {
             root.clearZoomSignal.disconnect(titleTooltipDialog.hide);
         }
 
         function hide(debug){
             if (!root.titleTooltips)
                 return;
 
             activeItemHovered = false;
             hideTitleTooltipTimer.start();
         }
 
         function show(taskItem, text){
             if (!root.titleTooltips || (latteApplet && latteApplet.contextMenu)){
                 return;
             }
 
             activeItemHovered = true;
 
             if (activeItem !== taskItem) {
                 activeItem = taskItem;
                 activeItemTooltipParent = taskItem.tooltipVisualParent;
                 activeItemText = text;
             }
 
             if (isReady) {
                 showTitleTooltipTimer.start();
             }
 
         }
 
         function update() {
             activeItemHovered = true
             title = activeItemText;
             visualParent = activeItemTooltipParent;
             if (latteApplet && latteApplet.windowPreviewIsShown) {
                 latteApplet.hidePreview();
             }
 
             visible = true;
         }
     }
 
     Timer {
         id: showTitleTooltipTimer
         interval: 100
         onTriggered: {
             if (latteView && latteView.visibility && latteView.visibility.containsMouse) {
                 titleTooltipDialog.update();
             }
 
             if (titleTooltipDialog.visible) {
                 titleTooltipCheckerToNotShowTimer.start();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: showTitleTooltipTimer called...");
             }
         }
     }
 
     Timer {
         id: hideTitleTooltipTimer
         interval: 200
         onTriggered: {
             if (!titleTooltipDialog.activeItemHovered) {
                 titleTooltipDialog.visible = false;
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: hideTitleTooltipTimer called...");
             }
 
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown
     Timer {
         id: titleTooltipCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (titleTooltipDialog.visible && latteApplet && (latteApplet.contextMenu || latteApplet.windowPreviewIsShown)) {
                 titleTooltipDialog.visible = false;
             }
         }
     }
     /////END: Title Tooltip///////////
 
     ///////////////BEGIN components
     Component {
         id: appletContainerComponent
         Applet.AppletItem{
             animations: _animations
             appletsRecords: _appletsRecords
             metrics: _metrics
         }
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     Indicators.Manager{
         id: indicators
     }
 
     Item {
         id: graphicsSystem
         readonly property bool isAccelerated: (GraphicsInfo.api !== GraphicsInfo.Software)
                                               && (GraphicsInfo.api !== GraphicsInfo.Unknown)
     }
 
     Upgrader {
         id: upgrader
     }
 
     ///////////////END components
 
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
 
     ///////////////BEGIN UI elements
 
     //it is used to check if the mouse is outside the layoutsContainer borders,
     //so in that case the onLeave event behavior should be trigerred
     RootMouseArea{
         id: rootMouseArea
     }
 
     Loader{
         active: root.debugModeWindow
         sourceComponent: DebugWindow{}
     }
 
     EditMode.Visual{
         id:editModeVisual
         //   z: root.behaveAsPlasmaPanel ? 1 : 0
     }
 
     Item {
         id: lastSpacer
         parent: layoutsContainer.mainLayout
 
         Layout.fillWidth: true
         Layout.fillHeight: true
         z:10
 
         Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.color: "yellow"
             border.width: 1
         }
     }
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
         z:10
 
         sourceComponent: Item{
             Rectangle{
                 anchors.fill: parent
                 color: "yellow"
                 opacity: 0.06
             }
         }
     }
 
     VisibilityManager{ id: visibilityManager }
 
     DragDropArea {
         id: backDropArea
         anchors.fill: parent
         readonly property bool higherPriority: latteView && latteView.containsDrag
                                                && ((root.dragInfo.isPlasmoid && root.dragInfo.isSeparator)
                                                    || (foreDropArea.dragInfo.computationsAreValid && !root.dragInfo.isPlasmoid && !root.dragInfo.onlyLaunchers))
 
         Item{
             id: panelBox
             anchors.fill: layoutsContainer
 
             PanelBox{
                 id: panelBoxBackground
             }
         }
 
         Layouts.LayoutsContainer {
             id: layoutsContainer
         }
 
         DragDropArea {
             id: foreDropArea
             anchors.fill: parent
             visible: !backDropArea.higherPriority
             isForeground: true
 
             /* Rectangle {
                 anchors.fill: parent
                 color: "blue"
                 opacity: 0.5
             }*/
         }
     }
 
     Colorizer.Manager {
         id: colorizerManager
     }
 
     Item {
         id: dndSpacer
 
         width: root.isHorizontal ? length : thickness
         height: root.isHorizontal ? thickness : length
 
-        readonly property int length: metrics.iconSize + root.lengthMargins
-        readonly property int thickness: metrics.iconSize + metrics.totals.thicknessEdges + root.localScreenEdgeMargin
+        readonly property int length: metrics.totals.length
+        readonly property int thickness: metrics.totals.thickness + root.localScreenEdgeMargin
 
         Layout.preferredWidth: width
         Layout.preferredHeight: height
         opacity: 0
         z:1500
 
         LatteComponents.AddItem{
             id: dndSpacerAddItem
             width: root.isHorizontal ? parent.width : parent.width - root.localScreenEdgeMargin
             height: root.isHorizontal ? parent.height - root.localScreenEdgeMargin : parent.height
 
             states:[
                 State{
                     name: "bottom"
                     when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                         anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: root.localScreenEdgeMargin;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "top"
                     when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                         anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: root.localScreenEdgeMargin;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "left"
                     when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                         anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: root.localScreenEdgeMargin;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "right"
                     when: plasmoid.location === PlasmaCore.Types.RightEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                         anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: root.localScreenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 }
             ]
         }
     }
 
     ///////////////END UI elements
 
     ///////////////BEGIN ABILITIES
 
     Ability.Animations {
         id: _animations
         metrics: _metrics
         settings: universalSettings
     }
 
     Ability.AppletsRecords {
         id: _appletsRecords
     }
 
     Ability.AutoSize {
         id: _autosize
         layouts: layoutsContainer
         metrics: _metrics
         visibility: visibilityManager
     }
 
     Ability.Metrics {
         id: _metrics
         animations: _animations
         autosize: _autosize
         indicators: indicatorsManager
     }
 
     ///////////////END ABILITIES
 
     ///////////////BEGIN TIMER elements
 
 
     //Timer to check if the mouse is still outside the latteView in order to restore zooms to 1.0
     Timer{
         id:checkRestoreZoom
         interval: 90
 
         onTriggered: {
             if (latteApplet && (latteApplet.previewContainsMouse() || latteApplet.contextMenu)) {
                 return;
             }
 
             if (latteView.contextMenuIsShown) {
                 return;
             }
 
             if (!mouseInHoverableArea()) {
                 setGlobalDirectRender(false);
                 root.initializeHoveredIndexes();
                 root.clearZoom();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: checkRestoreZoom called...");
             }
         }
     }
 
     //! 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 * animations.speedFactor.current * animations.duration.small
     }
 
     //! It is used in order to slide-in the latteView on startup
     Timer{
         id: inStartupTimer
         interval: 1500
         repeat: false
         onTriggered: {
             if (inStartup) {
                 visibilityManager.slotMustBeShown();
             }
         }
     }
 
     ///////////////END TIMER elements
 
     Loader{
         anchors.fill: parent
         active: root.debugModeLocalGeometry
         sourceComponent: Rectangle{
             x: latteView.localGeometry.x
             y: latteView.localGeometry.y
             width: latteView.localGeometry.width
             height: latteView.localGeometry.height
 
             color: "blue"
             border.width: 2
             border.color: "red"
 
             opacity: 0.35
         }
     }
 }
diff --git a/plasmoid/package/contents/code/tools.js b/plasmoid/package/contents/code/tools.js
index 838f5700..a74e7ed8 100644
--- a/plasmoid/package/contents/code/tools.js
+++ b/plasmoid/package/contents/code/tools.js
@@ -1,136 +1,136 @@
 /*
 *  Copyright 2016       Smith AR <audoban@openmailbox.org>
 *            2016-2018  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 function wheelActivateNextPrevTask(wheelDelta, eventDelta) {
     // magic number 120 for common "one click"
     // See: http://qt-project.org/doc/qt-5/qml-qtquick-wheelevent.html#angleDelta-prop
     wheelDelta += eventDelta;
     var increment = 0;
     while (wheelDelta >= 120) {
         wheelDelta -= 120;
         increment++;
     }
     while (wheelDelta <= -120) {
         wheelDelta += 120;
         increment--;
     }
     while (increment != 0) {
         activateNextPrevTask(increment < 0)
         increment += (increment < 0) ? 1 : -1;
     }
 
     return wheelDelta;
 }
 
 function activateTask(index, model, modifiers, task) {
     if (modifiers & Qt.ControlModifier) {
         tasksModel.requestNewInstance(index);
     } else if (task.isGroupParent) {
         task.activateNextTask();
        // if (backend.canPresentWindows()) {
             //task.toolTipAreaItem.hideToolTip();
         //    backend.presentWindows(model.LegacyWinIdList);
        // }
         /*} else if (groupDialog.visible) {
             groupDialog.visible = false;
         } else {
             groupDialog.visualParent = task;
             groupDialog.visible = true;
         }*/
     } else {
         if (model.IsMinimized === true) {
             tasksModel.requestToggleMinimized(index);
             tasksModel.requestActivate(index);
         } else if (model.IsActive === true) {
             tasksModel.requestToggleMinimized(index);
         } else {
             tasksModel.requestActivate(index);
         }
     }
 }
 
 
 function activateNextPrevTask(next) {
     // FIXME TODO: Unnecessarily convoluted and costly; optimize.
 
     var taskIndexList = [];
     var activeTaskIndex = tasksModel.activeTask;
 
     for (var i = 0; i < taskList.children.length - 1; ++i) {
         var task = taskList.children[i];
         var modelIndex = task.modelIndex(i);
 
         if (task !== undefined){
             if (task.IsLauncher !== true && task.IsStartup !== true) {
                 if (task.m.IsGroupParent === true) {
                     for (var j = 0; j < tasksModel.rowCount(modelIndex); ++j) {
                         taskIndexList.push(tasksModel.makeModelIndex(i, j));
                     }
                 } else {
                     taskIndexList.push(modelIndex);
                 }
             }
         }
     }
 
     if (!taskIndexList.length) {
         return;
     }
 
     var target = taskIndexList[0];
 
     for (var i = 0; i < taskIndexList.length; ++i) {
         if (taskIndexList[i] === activeTaskIndex)
         {
             if (next && i < (taskIndexList.length - 1)) {
                 target = taskIndexList[i + 1];
             } else if (!next) {
                 if (i) {
                     target = taskIndexList[i - 1];
                 } else {
                     target = taskIndexList[taskIndexList.length - 1];
                 }
             }
 
             break;
         }
     }
 
     tasksModel.requestActivate(target);
 }
 
 function insertIndexAt(above, x, y) {
     if (above && above.itemIndex) {
         return above.itemIndex;
     } else {
         var distance = root.vertical ? y : x;
         //var step = root.vertical ? LayoutManager.taskWidth() : LayoutManager.taskHeight();
-        var step = metrics.iconSize + root.lengthMargins;
+        var step = metrics.totals.length;
         var stripe = Math.ceil(distance / step);
 
         /* if (stripe === LayoutManager.calculateStripes()) {
             return tasksModel.count - 1;
         } else {
             return stripe * LayoutManager.tasksPerStripe();
         }*/
 
         return stripe-1;
     }
 }
diff --git a/plasmoid/package/contents/ui/abilities/Metrics.qml b/plasmoid/package/contents/ui/abilities/Metrics.qml
index 02b99c1b..d2f386db 100644
--- a/plasmoid/package/contents/ui/abilities/Metrics.qml
+++ b/plasmoid/package/contents/ui/abilities/Metrics.qml
@@ -1,32 +1,33 @@
 /*
 *  Copyright 2020 Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.abilities.applets 0.1 as AppletAbility
 
 AppletAbility.Metrics {
     //! Public Local Properties
     local.iconSize: Math.max(plasmoid.configuration.iconSize, 16)
 
+    local.margin.length: 0.1 * iconSize
     local.margin.thickness: 0.16 * iconSize
     local.padding.length: 0.04 * iconSize
 }
diff --git a/plasmoid/package/contents/ui/main.qml b/plasmoid/package/contents/ui/main.qml
index 68fcd5c5..4f804a78 100644
--- a/plasmoid/package/contents/ui/main.qml
+++ b/plasmoid/package/contents/ui/main.qml
@@ -1,2131 +1,2127 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.8
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.taskmanager 0.1 as TaskManager
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.activities 0.1 as Activities
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import org.kde.latte.abilities.applets 0.1 as AppletAbility
 
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "abilities" as Ability
 import "previews" as Previews
 import "task" as Task
 import "taskslayout" as TasksLayout
 import "../code/tools.js" as TaskTools
 import "../code/activitiesTools.js" as ActivitiesTools
 import "../code/ColorizerTools.js" as ColorizerTools
 
 Item {
     id:root
 
     Layout.fillWidth: scrollingEnabled && !root.vertical
     Layout.fillHeight: scrollingEnabled && root.vertical
 
     Layout.minimumWidth: -1
     Layout.minimumHeight: -1
     Layout.preferredWidth: tasksWidth
     Layout.preferredHeight: tasksHeight
     Layout.maximumWidth: -1
     Layout.maximumHeight: -1
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.vertical
     LayoutMirroring.childrenInherit: true
 
     //it is used to check both the applet and the containment for direct render
     property bool globalDirectRender: latteView ? latteView.globalDirectRender : icList.directRender
 
     property bool plasma515: latteView ? latteView.plasma515 : LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,15,0)
     property bool plasma518: latteView ? latteView.plasma518 : LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,18,0)
 
     property bool editMode: latteView ? latteView.editMode : plasmoid.userConfiguring
     property bool inConfigureAppletsMode: latteView ? latteView.inConfigureAppletsMode : true
     property bool disableRestoreZoom: false //blocks restore animation in rightClick
     property bool disableAllWindowsFunctionality: root.showWindowsOnlyFromLaunchers && !indicators.isEnabled
     property bool dropNewLauncher: false
     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 showTaskShortcutBadges: false
     property int tasksBaseIndex: 0
     property bool useThemePanel: plasmoid.configuration.useThemePanel
     property bool taskInAnimation: noTasksInAnimation > 0 ? true : false
     property bool transparentPanel: plasmoid.configuration.transparentPanel
     property bool vertical: plasmoid.formFactor === PlasmaCore.Types.Vertical ? true : false
 
     property int clearWidth
     property int clearHeight
 
     property int newDroppedPosition: -1
     property int noInitCreatedBuffers: 0
     property int noTasksInAnimation: 0
     property int themePanelSize: plasmoid.configuration.panelSize
 
     property int location : {
         if (plasmoid.location === PlasmaCore.Types.LeftEdge
                 || plasmoid.location === PlasmaCore.Types.RightEdge
                 || plasmoid.location === PlasmaCore.Types.TopEdge) {
             return plasmoid.location;
         }
 
         return PlasmaCore.Types.BottomEdge;
     }
 
     property int tasksStarting: 0
 
     ///Don't use Math.floor it adds one pixel in animations and creates glitches
-    property int widthMargins: root.vertical ? metrics.totals.thicknessEdges : lengthMargins
-    property int heightMargins: !root.vertical ? metrics.totals.thicknessEdges : lengthMargins
+    property int widthMargins: root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
+    property int heightMargins: !root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
 
     property int internalWidthMargins: root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthPaddings
     property int internalHeightMargins: !root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthPaddings
 
     property real textColorBrightness: ColorizerTools.colorBrightness(themeTextColor)
     property color minimizedDotColor: {
         if (latteView) {
             return latteView.minimizedDotColor;
         }
 
         return textColorBrightness > 127.5 ? Qt.darker(themeTextColor, 1.7) : Qt.lighter(themeBackgroundColor, 7)
     }
 
     property color themeTextColor: theme.textColor
     property color themeBackgroundColor: theme.backgroundColor
 
     property color lightTextColor: textColorBrightness > 127.5 ? themeTextColor : themeBackgroundColor
 
     //a small badgers record (id,value)
     //in order to track badgers when there are changes
     //in launcher reference from libtaskmanager
     property variant badgers:[]
     property variant launchersOnActivities: []
 
     //global plasmoid reference to the context menu
     property QtObject contextMenu: null
     property QtObject contextMenuComponent: Qt.createComponent("ContextMenu.qml");
     property Item dragSource: null
     property Item parabolicManager: _parabolicManager
     property Item tasksExtendedManager: _tasksExtendedManager
     readonly property alias animations: _animations
     readonly property alias metrics: _metrics
 
     readonly property alias containsDrag: mouseHandler.containsDrag
     readonly property bool dragAreaEnabled: latteView ? (root.dragSource !== null
                                                          || latteView.dragInfo.isSeparator
                                                          || latteView.dragInfo.isTask
                                                          || !latteView.dragInfo.isPlasmoid)
                                                       : true
 
     //! it is used to play the animation correct when the user removes a launcher
     property string launcherForRemoval: ""
 
     //BEGIN Latte Dock properties
     property bool badges3DStyle: latteView ? latteView.badges3DStyle : true
     property bool dockIsShownCompletely: latteView ? latteView.dockIsShownCompletely : true
     property bool enableShadows: latteView ? latteView.enableShadows > 0 : plasmoid.configuration.showShadows
     property bool forceHidePanel: false
     property bool directRenderDelayerIsRunning: latteView ? latteView.directRenderDelayerIsRunning : directRenderDelayerForEnteringTimer.running
     property bool disableLeftSpacer: false
     property bool disableRightSpacer: false
     property bool dockIsHidden: latteView ? latteView.dockIsHidden : false
     property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
     property bool highlightWindows: hoverAction === LatteTasks.Types.HighlightWindows || hoverAction === LatteTasks.Types.PreviewAndHighlightWindows
     property bool parabolicEffectEnabled: latteView ? latteView.parabolicEffectEnabled : zoomFactor>1 && !root.editMode
 
     property bool scrollingEnabled: plasmoid.configuration.scrollTasksEnabled
     property bool autoScrollTasksEnabled: scrollingEnabled && plasmoid.configuration.autoScrollTasksEnabled
     property bool manualScrollTasksEnabled: scrollingEnabled &&  manualScrollTasksType !== LatteTasks.Types.ManualScrollDisabled
     property int manualScrollTasksType: plasmoid.configuration.manualScrollTasksType
 
     property bool showInfoBadge: plasmoid.configuration.showInfoBadge
     property bool showProgressBadge: plasmoid.configuration.showInfoBadge
     property bool showAudioBadge: plasmoid.configuration.showAudioBadge
     property bool infoBadgeProminentColorEnabled: plasmoid.configuration.infoBadgeProminentColorEnabled
     property bool audioBadgeActionsEnabled: plasmoid.configuration.audioBadgeActionsEnabled
     property bool showOnlyCurrentScreen: plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: plasmoid.configuration.showOnlyCurrentActivity
     property bool showPreviews:  hoverAction === LatteTasks.Types.PreviewWindows || hoverAction === LatteTasks.Types.PreviewAndHighlightWindows
     property bool showWindowActions: plasmoid.configuration.showWindowActions
     property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers
 
     property bool titleTooltips: latteView ? latteView.titleTooltips : false
     property alias windowPreviewIsShown: windowsPreviewDlg.visible
 
     property int directRenderAnimationTime: latteView ? latteView.directRenderAnimationTime : 0
     property int dockHoveredIndex : latteView ? latteView.hoveredIndex : -1
 
     property int launchersGroup: plasmoid.configuration.launchersGroup
 
     property int leftClickAction: plasmoid.configuration.leftClickAction
     property int middleClickAction: plasmoid.configuration.middleClickAction
     property int hoverAction: plasmoid.configuration.hoverAction
     property int modifier: plasmoid.configuration.modifier
     property int modifierClickAction: plasmoid.configuration.modifierClickAction
     property int modifierClick: plasmoid.configuration.modifierClick
     property int modifierQt:{
         if (modifier === LatteTasks.Types.Shift)
             return Qt.ShiftModifier;
         else if (modifier === LatteTasks.Types.Ctrl)
             return Qt.ControlModifier;
         else if (modifier === LatteTasks.Types.Alt)
             return Qt.AltModifier;
         else if (modifier === LatteTasks.Types.Meta)
             return Qt.MetaModifier;
         else return -1;
     }
     property int taskScrollAction: plasmoid.configuration.taskScrollAction
 
     onTaskScrollActionChanged: {
         if (taskScrollAction > LatteTasks.Types.ScrollToggleMinimized) {
             //! migrating scroll action to LatteTasks.Types.ScrollAction
             plasmoid.configuration.taskScrollAction = plasmoid.configuration.taskScrollAction-LatteTasks.Types.ScrollToggleMinimized;
         }
     }
 
-    property int lengthExtMargin: latteView ? latteView.lengthExtMargin : 0.1 * metrics.iconSize
-    property int lengthMargin: metrics.padding.length + lengthExtMargin
-    property int lengthMargins: 2 * lengthMargin
-
     property int tasksHeight: mouseHandler.height
     property int tasksWidth: mouseHandler.width
     //updated from Binding
     property int alignment
 
     readonly property real currentPanelOpacity: latteView ? latteView.currentPanelTransparency / 100 : 1
 
     property real maxZoomFactor: latteView ? latteView.maxZoomFactor : Math.max(zoomFactor, animations.maxZoomFactor)
 
     property real zoomFactor: latteView ? latteView.zoomFactor : ( 1 + (plasmoid.configuration.zoomLevel / 20) )
 
     property int appShadowSize: latteView ? latteView.appShadowSize : Math.ceil(0.12*metrics.iconSize)
     property string appShadowColor: latteView ? latteView.appShadowColor : "#ff080808"
     property string appShadowColorSolid: latteView ? latteView.appShadowColorSolid : "#ff080808"
 
     property alias tasksCount: tasksModel.count
     property alias hoveredIndex: icList.hoveredIndex
 
     readonly property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property bool viewLayoutIsCurrent: latteView && viewLayout && latteView.layoutsManager
                                                 && viewLayout.name === latteView.layoutsManager.currentLayoutName
     readonly property string viewLayoutName: viewLayout ? viewLayout.name : ""
     readonly property QtObject viewLayout : latteView && latteView.viewLayout ? latteView.viewLayout : null
 
     property var badgesForActivate: latteView ? latteView.badgesForActivate : []
 
 
     property Item latteView: null
     readonly property Item indicators: latteView ? latteView.indicatorsManager : indicatorsStandaloneLoader.item
     //END Latte Dock Panel properties
 
     //BEGIN Latte Dock Communicator
     property QtObject latteBridge: null
 
     readonly property bool enforceLattePalette: latteBridge && latteBridge.applyPalette && latteBridge.palette
     readonly property bool latteInEditMode: latteBridge && latteBridge.inEditMode
     readonly property int screenEdgeMargin: latteBridge ? latteBridge.screenEdgeMargin : 0
     //END  Latte Dock Communicator
 
     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 signalPreviewsShown();
     //signal signalDraggingState(bool value);
     signal showPreviewForTasks(QtObject group);
     //trigger updating scaling of neighbour delegates of zoomed delegate
     signal updateScale(int delegateIndex, real newScale, real step)
     signal mimicEnterForParabolic();
     signal publishTasksGeometries();
     signal windowsHovered(variant winIds, bool hovered)
 
     //onAnimationsChanged: console.log(animations);
     /* Rectangle{
                 anchors.fill: parent
                 border.width: 1
                 border.color: "red"
                 color: "white"
             } */
     onLatteViewChanged: {
         if (latteView) {
             plasmoid.action("configure").visible = false;
             plasmoid.configuration.isInLatteDock = true;
 
             if (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                     || root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                 tasksModel.updateLaunchersList();
             }
         } else {
             plasmoid.configuration.isInLatteDock = false;
         }
     }
 
     onLaunchersGroupChanged:{
         if(latteView) {
             tasksModel.updateLaunchersList();
         }
     }
 
     Connections {
         target: plasmoid
         onLocationChanged: {
             iconGeometryTimer.start();
         }
     }
 
     Connections {
         target: plasmoid.configuration
 
         // onLaunchersChanged: tasksModel.launcherList = plasmoid.configuration.launchers
         onGroupingAppIdBlacklistChanged: tasksModel.groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
         onGroupingLauncherUrlBlacklistChanged: tasksModel.groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
     }
 
 
     Connections{
         target: latteView
         onDockIsHiddenChanged:{
             if (latteView.dockIsHidden) {
                 windowsPreviewDlg.hide("3.3");
             }
         }
     }
 
 
     Connections{
         target: latteView && latteView.layoutsManager ? latteView.layoutsManager : null
 
         onCurrentLayoutNameChanged: root.publishTasksGeometries();
     }
 
     Connections{
         target: icList
 
         onHoveredIndexChanged:{
             if (latteView && icList.hoveredIndex>-1){
                 latteView.setHoveredIndex(-1);
             }
         }
     }
 
     Binding {
         target: plasmoid
         property: "status"
         value: (tasksModel.anyTaskDemandsAttentionInValidTime || root.dragSource ?
                     PlasmaCore.Types.NeedsAttentionStatus : PlasmaCore.Types.PassiveStatus);
     }
 
     /////
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
     //!
     Item {
         id: graphicsSystem
         readonly property bool isAccelerated: (GraphicsInfo.api !== GraphicsInfo.Software)
                                               && (GraphicsInfo.api !== GraphicsInfo.Unknown)
     }
 
     Loader {
         id: indicatorsStandaloneLoader
         active: !latteView && !plasmoid.configuration.isInLatteDock
         source: "indicators/Manager.qml"
     }
 
     Binding {
         target: root
         property: "alignment"
         value: {
             if (latteView) {
                 if (latteView.panelUserSetAlignment === -1) {
                     return;
                 }
 
                 if (inConfigureAppletsMode) {
                     return LatteCore.Types.Center;
                 } else if (latteView.panelUserSetAlignment === LatteCore.Types.Justify) {
                     if (latteView.latteAppletPos>=0 && latteView.latteAppletPos<100) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? LatteCore.Types.Left : LatteCore.Types.Top;
                     } else if (latteView.latteAppletPos>=100 && latteView.latteAppletPos<200) {
                         return LatteCore.Types.Center;
                     } else if (latteView.latteAppletPos>=200) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? LatteCore.Types.Right : LatteCore.Types.Bottom;
                     }
 
                     return LatteCore.Types.Center;
                 }
 
                 return latteView.panelUserSetAlignment;
             }
 
             return LatteCore.Types.Center;
         }
     }
 
     /////
 
     function initializeHoveredIndex() {
         icList.hoveredIndex = -1;
         icList.currentSpot = -1000;
     }
 
     function launchersDropped(urls){
         mouseHandler.urlsDropped(urls);
     }
 
     ///UPDATE
     function launcherExists(url) {
         return (ActivitiesTools.getIndex(url, tasksModel.launcherList)>=0);
     }
 
     function taskExists(url) {
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.launcherUrl===url && task.isWindow) {
                 return true;
             }
         }
         return false;
     }
 
     function launchersDrop(event) {
         var createLaunchers = false;
 
         if (event.mimeData.hasUrls) {
             createLaunchers = event.mimeData.urls.every(function (item) {
                 return backend.isApplication(item)
             });
         }
 
         return createLaunchers;
     }
 
     function currentLauncherList() {
         var launch = [];
         var launchersList = [];
 
         if (viewLayout) {
             if (latteView && latteView.layoutsManager
                     && latteView.viewLayout && latteView.universalSettings
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     launchersList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     launchersList = latteView.universalSettings.launchers;
                 }
             }
         } else {
             launchersList = plasmoid.configuration.launchers59;
         }
 
 
         for(var i=0; i<launchersList.length; ++i){
             var launcherRecord = launchersList[i];
 
             if (launcherRecord.indexOf("[") === -1) {
                 //global launcher
                 launch.push(launcherRecord);
             } else {
                 //launcher assigned to activities
                 var end = launcherRecord.indexOf("\n");
                 var explicitLauncher = launcherRecord.substring(end+1,launcherRecord.length);
                 if (explicitLauncher !== "" && launcherRecord.indexOf(activityInfo.currentActivity) > -1) {
                     launch.push(explicitLauncher);
                 }
             }
         }
 
         return launch;
     }
 
     function currentListViewLauncherList() {
         var launch = [];
 
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = icList.childAtIndex(i);
 
             if (task!==undefined && task.launcherUrl!=="" && tasksModel.launcherInCurrentActivity(task.launcherUrl)) {
                 launch.push(task.launcherUrl);
             }
         }
 
         return launch;
     }
 
     function forcePreviewsHiding(debug) {
         //console.log("   Tasks: Force hide previews event called: "+debug);
         windowsPreviewDlg.visible = false;
         windowsPreviewDlg.mainItem.visible = false;
         windowsPreviewDlg.activeItem = null;
     }
 
     function hidePreview(){
         windowsPreviewDlg.hide(11);
     }
 
     onDragSourceChanged: {
         if (dragSource == null) {
             root.draggingFinished();
             tasksModel.syncLaunchers();
 
             restoreDraggingPhaseTimer.start();
         } else {
             inDraggingPhase = true;
         }
     }
 
     /////Window previews///////////
 
     Previews.ToolTipDelegate2 {
         id: toolTipDelegate
         visible: false
     }
 
     ////BEGIN interfaces
 
     LatteTasks.Dialog{
         id: windowsPreviewDlg
         // hideOnWindowDeactivate: false
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: root.location
         mainItem: toolTipDelegate
         visible: false
 
         property bool signalSent: false
         property Item activeItem: null
 
         Component.onCompleted: mainItem.visible = true;
 
         onContainsMouseChanged: {
             //! Orchestrate restore zoom and previews window hiding. Both should be
             //! triggered together.
             if (containsMouse) {
                 stopCheckRestoreZoomTimer();
                 hidePreviewWinTimer.stop();
             } else {
                 hide(7.3);
             }
         }
 
         function hide(debug){
             //console.log("   Tasks: hide previews event called: "+debug);
             if (containsMouse || !visible) {
                 return;
             }
 
             if (latteView && signalSent) {
                 //it is used to unblock dock hiding
                 signalSent = false;
             }
 
             if (!root.contextMenu) {
                 root.disableRestoreZoom = false;
             }
 
             hidePreviewWinTimer.start();
         }
 
         function show(taskItem){
             if (root.disableAllWindowsFunctionality) {
                 return;
             }
 
             hidePreviewWinTimer.stop();
 
             // console.log("preview show called...");
             if ((!activeItem || (activeItem !== taskItem)) && !root.contextMenu) {
                 //console.log("preview show called: accepted...");
 
                 //this can be used from others to hide their appearance
                 //e.g but applets from the dock to hide themselves
                 if (!visible) {
                     root.signalPreviewsShown();
                 }
 
                 activeItem = taskItem;
                 toolTipDelegate.parentTask = taskItem;
 
                 if (latteView && !signalSent) {
                     //it is used to block dock hiding
                     signalSent = true;
                 }
 
                 //! Workaround in order to update properly the previews thumbnails
                 //! when switching between single thumbnail to another single thumbnail
                 mainItem.visible = false;
                 visible = true;
                 mainItem.visible = true;
             }
         }
     }
 
     //! Delay windows previews hiding
     Timer {
         id: hidePreviewWinTimer
         interval: 300
         onTriggered: {
             //! Orchestrate restore zoom and previews window hiding. Both should be
             //! triggered together.
             var contains = (windowsPreviewDlg.containsMouse
                             || (windowsPreviewDlg.activeItem && windowsPreviewDlg.activeItem.containsMouse) /*main task*/
                             || (windowsPreviewDlg.activeItem /*dragging file(s) from outside*/
                                 && mouseHandler.hoveredItem
                                 && !root.dragSource
                                 && mouseHandler.hoveredItem === windowsPreviewDlg.activeItem));
 
             if (!contains) {
                 root.forcePreviewsHiding();
                 startCheckRestoreZoomTimer();
             }
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown. It is mostly used under wayland in order to avoid crashes. When the context
     //! menu will be shown there is a chance that previews window has already appeared in that
     //! case the previews window must become hidden
     Timer {
         id: windowsPreviewCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (windowsPreviewDlg.visible && root.contextMenu) {
                 windowsPreviewDlg.hide("8.2");
             }
         }
     }
 
     //! Timer to delay the removal of the window through the context menu in case the
     //! the window is zoomed
     Timer{
         id: delayWindowRemovalTimer
         //this is the animation time needed in order for tasks to restore their zoom first
         interval: 7 * (animations.speedFactor.current * animations.duration.small)
 
         property var modelIndex
 
         onTriggered: {
             tasksModel.requestClose(delayWindowRemovalTimer.modelIndex)
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: delayWindowRemovalTimer called...");
             }
         }
     }
 
     Timer {
         id: activityChangeDelayer
         interval: 150
         onTriggered: {
             root.inActivityChange = false;
             activityInfo.previousActivity = activityInfo.currentActivity;
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: activityChangeDelayer called...");
             }
         }
     }
 
     /////Window Previews/////////
 
 
     property bool loadLaunchersFirstTime: false;
 
     onViewLayoutChanged: {
         if (viewLayout && !loadLaunchersFirstTime) {
             tasksModel.updateLaunchersList();
             loadLaunchersFirstTime = true;
         }
     }
 
     TaskManager.TasksModel {
         id: tasksModel
 
         virtualDesktop: virtualDesktopInfo.currentDesktop
         screenGeometry: root.screenGeometry
         // comment in order to support LTS Plasma 5.8
         // screen: plasmoid.screen
         activity: viewLayout ? viewLayout.lastUsedActivity : activityInfo.currentActivity
 
         filterByVirtualDesktop: root.showOnlyCurrentDesktop
         filterByScreen: root.showOnlyCurrentScreen
         filterByActivity: root.showOnlyCurrentActivity
 
         launchInPlace: true
         separateLaunchers: true
         groupInline: false
 
         groupMode: groupTasksByDefault ? TaskManager.TasksModel.GroupApplications : TaskManager.TasksModel.GroupDisabled
         sortMode: TaskManager.TasksModel.SortManual
 
         property bool anyTaskDemandsAttentionInValidTime: false
 
         function updateLaunchersList(){
             if (latteView
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     console.log("Tasks: Applying LAYOUT Launchers List...");
                     tasksModel.launcherList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     console.log("Tasks: Applying GLOBAL Launchers List...");
                     tasksModel.launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 console.log("Tasks: Applying UNIQUE Launchers List...");
                 tasksModel.launcherList = plasmoid.configuration.launchers59;
             }
         }
 
         function launcherInCurrentActivity(url) {
             var activities = tasksModel.launcherActivities(url);
 
             var NULL_UUID = "00000000-0000-0000-0000-000000000000";
 
             if (activities.indexOf(NULL_UUID) !== -1 || activities.indexOf(activityInfo.currentActivity) !== -1)
                 return true;
 
             return false;
         }
 
         onActivityChanged: {
             ActivitiesTools.currentActivity = String(activity);
         }
 
         onLauncherListChanged: {
             if (viewLayout) {
                 if (latteView && latteView.layoutsManager
                         && latteView.viewLayout && latteView.universalSettings
                         && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                             || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                     if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                         latteView.viewLayout.launchers = launcherList;
                     } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                         latteView.universalSettings.launchers = launcherList;
                     }
 
                     if (inDraggingPhase) {
                         if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                             latteView.layoutsManager.launchersSignals.validateLaunchersOrder(root.viewLayoutName,
                                                                                              plasmoid.id,
                                                                                              root.launchersGroup,
                                                                                              currentLauncherList());
                         }
                     }
                 } else {
                     plasmoid.configuration.launchers59 = launcherList;
                 }
             } else {
                 plasmoid.configuration.launchers59 = launcherList;
             }
         }
 
         onGroupingAppIdBlacklistChanged: {
             plasmoid.configuration.groupingAppIdBlacklist = groupingAppIdBlacklist;
         }
 
         onGroupingLauncherUrlBlacklistChanged: {
             plasmoid.configuration.groupingLauncherUrlBlacklist = groupingLauncherUrlBlacklist;
         }
 
         onAnyTaskDemandsAttentionChanged: {
             if (anyTaskDemandsAttention){
                 anyTaskDemandsAttentionInValidTime = true;
                 attentionTimerComponent.createObject(root);
             }
         }
 
 
         Component.onCompleted: {
             ActivitiesTools.launchersOnActivities = root.launchersOnActivities
             ActivitiesTools.currentActivity = String(activityInfo.currentActivity);
             ActivitiesTools.plasmoid = plasmoid;
 
             //var loadedLaunchers = ActivitiesTools.restoreLaunchers();
             ActivitiesTools.importLaunchersToNewArchitecture();
 
             if (viewLayout && latteView.universalSettings
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     launcherList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 launcherList = plasmoid.configuration.launchers59;
             }
 
             groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
             groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
 
             icList.model = tasksModel;
             tasksStarting = count;
 
             ///Plasma 5.9 enforce grouping at all cases
             if (LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,9,0)) {
                 groupingWindowTasksThreshold = -1;
             }
         }
     }
 
     //! TaskManagerBackend required a groupDialog setting otherwise it crashes. This patch
     //! sets one just in order not to crash TaskManagerBackend
     PlasmaCore.Dialog {
         //ghost group Dialog to not crash TaskManagerBackend
         id: groupDialogGhost
         visible: false
 
         type: PlasmaCore.Dialog.PopupMenu
         flags: Qt.WindowStaysOnTopHint
         hideOnWindowDeactivate: true
         location: root.location
     }
 
 
     TaskManagerApplet.Backend {
         id: backend
 
         taskManagerItem: root
         toolTipItem: toolTipDelegate
         highlightWindows: root.highlightWindows
 
         onAddLauncher: {
             tasksModel.requestAddLauncher(url);
         }
 
         Component.onCompleted: {
             //! In Plasma 5.9 TaskManagerBackend required a groupDialog setting
             //! otherwise it crashes.
             //! frameworks 5.29.0 provide id 335104
             //! work only after Plasma 5.9 and frameworks 5.29
             //! + added a check for groupDialog also when it is present
             //!   in plasma 5.8 (that was introduced after 5.8.5)
             if (LatteCore.Environment.frameworksVersion >= 335104 || (groupDialog !== undefined)) {
                 groupDialog = groupDialogGhost;
             }
         }
     }
 
     TaskManagerApplet.DragHelper {
         id: dragHelper
 
         dragIconSize: units.iconSizes.medium
     }
 
     TaskManager.VirtualDesktopInfo {
         id: virtualDesktopInfo
     }
 
     TaskManager.ActivityInfo {
         id: activityInfo
 
         property string previousActivity: ""
         onCurrentActivityChanged: {
             root.inActivityChange = true;
             activityChangeDelayer.start();
         }
 
         Component.onCompleted: previousActivity = currentActivity;
     }
 
     PlasmaCore.DataSource {
         id: mpris2Source
         engine: "mpris2"
         connectedSources: sources
         function sourceNameForLauncherUrl(launcherUrl, pid) {
             if (!launcherUrl || launcherUrl === "") {
                 return "";
             }
 
             // MPRIS spec explicitly mentions that "DesktopEntry" is with .desktop extension trimmed
             // Moreover, remove URL parameters, like wmClass (part after the question mark)
             var desktopFileName = launcherUrl.toString().split('/').pop().split('?')[0].replace(".desktop", "")
             if (desktopFileName.indexOf("applications:") === 0) {
                 desktopFileName = desktopFileName.substr(13)
             }
 
             for (var i = 0, length = connectedSources.length; i < length; ++i) {
                 var source = connectedSources[i];
                 // we intend to connect directly, otherwise the multiplexer steals the connection away
                 if (source === "@multiplex") {
                     continue;
                 }
 
                 var sourceData = data[source];
                 if (!sourceData) {
                     continue;
                 }
 
                 if (sourceData.DesktopEntry === desktopFileName || (pid && sourceData.InstancePid === pid)) {
                     return source;
                 }
 
                 var metadata = sourceData.Metadata;
                 if (metadata) {
                     var kdePid = metadata["kde:pid"];
                     if (kdePid && pid === kdePid) {
                         return source;
                     }
                 }
             }
 
             return ""
         }
 
         function startOperation(source, op) {
             var service = serviceForSource(source)
             var operation = service.operationDescription(op)
             return service.startOperationCall(operation)
         }
 
         function goPrevious(source) {
             startOperation(source, "Previous");
         }
         function goNext(source) {
             startOperation(source, "Next");
         }
         function play(source) {
             startOperation(source, "Play");
         }
         function pause(source) {
             startOperation(source, "Pause");
         }
         function playPause(source) {
             startOperation(source, "PlayPause");
         }
         function stop(source) {
             startOperation(source, "Stop");
         }
         function raise(source) {
             startOperation(source, "Raise");
         }
         function quit(source) {
             startOperation(source, "Quit");
         }
     }
 
     Loader {
         id: pulseAudio
         source: "PulseAudio.qml"
         active: root.showAudioBadge
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     TasksExtendedManager {
         id: _tasksExtendedManager
     }
 
     Ability.Animations {
         id: _animations
         bridge: latteBridge
     }
 
     Ability.Metrics {
         id: _metrics
         bridge: latteBridge
     }
 
     AppletAbility.Requirements{
         id: _requires
         bridge: latteBridge
 
         latteSideColoringEnabled: false
         screenEdgeMarginSupported: true        
         innerZoomFactor: {
             if (!_animations.active || !LatteCore.WindowSystem.compositingActive) {
                 return 1;
             }
 
             var hasHighThicknessAnimation = _animations.launcherBouncingEnabled || _animations.windowInAttentionEnabled || _animations.windowAddedInGroupEnabled;
 
             return hasHighThicknessAnimation ? 1.65 : 1.0;
         }
     }
 
     Component{
         id: attentionTimerComponent
         Timer{
             id: attentionTimer
             interval:8500
             onTriggered: {
                 tasksModel.anyTaskDemandsAttentionInValidTime = false;
                 destroy();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: attentionTimer called...");
                 }
             }
             Component.onCompleted: {
                 start();
             }
         }
     }
 
     //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 * (animations.speedFactor.current * 1.2 * animations.duration.small) + 50)
 
         onTriggered: {
             if(root.latteView)
                 console.log("Plasmoid, checkListHoveredTimer was called, even though it shouldn't...");
 
             if (!root.containsMouse()) {
 
                 icList.directRender = false;
 
                 root.clearZoom();
             }
 
             interval = normalInterval;
 
             if (latteView && latteView.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 * animations.speedFactor.current * animations.duration.small
     }
 
     //this timer restores the draggingPhase flag to false
     //after a dragging has finished... This delay is needed
     //in order to not animate any tasks are added after a
     //dragging
     Timer {
         id: restoreDraggingPhaseTimer
         interval: 150
         onTriggered: inDraggingPhase = false;
     }
 
     ///Red Liner!!! show the upper needed limit for animations
     Rectangle{
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: root.vertical ? 1 : 2 * metrics.iconSize
         height: root.vertical ? 2 * metrics.iconSize : 1
         color: "red"
         x: (root.location === PlasmaCore.Types.LeftEdge) ? neededSpace : parent.width - neededSpace
         y: (root.location === PlasmaCore.Types.TopEdge) ? neededSpace : parent.height - neededSpace
 
         visible: plasmoid.configuration.zoomHelper
 
-        property int neededSpace: zoomFactor*(metrics.iconSize+lengthMargins)
+        property int neededSpace: zoomFactor*metrics.totals.length
     }
 
     Item{
         id:barLine
         anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
         anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
         anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
         anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: ( icList.orientation === Qt.Horizontal ) ? icList.width + spacing : smallSize
         height: ( icList.orientation === Qt.Vertical ) ? icList.height + spacing : smallSize
 
         property int spacing: latteView ? 0 : metrics.iconSize / 2
         property int smallSize: Math.max(0.10 * metrics.iconSize, 16)
 
         Behavior on opacity{
             NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
         }
 
         /// plasmoid's default panel
         BorderImage{
             anchors.fill:parent
             source: "../images/panel-west.png"
             border { left:8; right:8; top:8; bottom:8 }
 
             opacity: (plasmoid.configuration.showBarLine && !plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
 
             visible: (opacity == 0) ? false : true
 
             horizontalTileMode: BorderImage.Stretch
             verticalTileMode: BorderImage.Stretch
 
             Behavior on opacity{
                 NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
             }
         }
 
 
         /// item which is used as anchors for the plasma's theme
         Item{
             id:belower
 
             width: (root.location === PlasmaCore.Types.LeftEdge) ? shadowsSvgItem.margins.left : shadowsSvgItem.margins.right
             height: (root.location === PlasmaCore.Types.BottomEdge)? shadowsSvgItem.margins.bottom : shadowsSvgItem.margins.top
 
             anchors.top: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
             anchors.bottom: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
             anchors.right: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
             anchors.left: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
         }
 
 
         /// the current theme's panel
         PlasmaCore.FrameSvgItem{
             id: shadowsSvgItem
 
             anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? belower.bottom : undefined
             anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? belower.top : undefined
             anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? belower.left : undefined
             anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? belower.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
             width: root.vertical ? panelSize + margins.left + margins.right: parent.width
             height: root.vertical ? parent.height : panelSize + margins.top + margins.bottom
 
             imagePath: "translucent/widgets/panel-background"
             prefix:"shadow"
 
             opacity: (plasmoid.configuration.showBarLine && plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
             visible: (opacity == 0) ? false : true
 
             property int panelSize: ((root.location === PlasmaCore.Types.BottomEdge) ||
                                      (root.location === PlasmaCore.Types.TopEdge)) ?
                                         plasmoid.configuration.panelSize + belower.height:
                                         plasmoid.configuration.panelSize + belower.width
 
             Behavior on opacity{
                 NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
             }
 
 
             PlasmaCore.FrameSvgItem{
                 anchors.margins: belower.width-1
                 anchors.fill:parent
                 imagePath: plasmoid.configuration.transparentPanel ? "translucent/widgets/panel-background" :
                                                                      "widgets/panel-background"
             }
         }
 
 
         TasksLayout.MouseHandler {
             id: mouseHandler
             anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? scrollableList.bottom : undefined
             anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? scrollableList.top : undefined
             anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? scrollableList.left : undefined
             anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? scrollableList.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? scrollableList.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? scrollableList.verticalCenter : undefined
 
             width: root.vertical ? maxSize : icList.width
             height: root.vertical ? icList.height : maxSize
 
             target: icList
 
             visible: root.dragAreaEnabled
 
             property int maxSize: (((root.hoveredIndex>=0 || dockHoveredIndex>=0 ) || windowPreviewIsShown) && !root.dragSource) ?
                                       (root.zoomFactor * metrics.totals.thickness) + root.screenEdgeMargin :
                                       metrics.totals.thickness + root.screenEdgeMargin
 
             function onlyLaunchersInList(list){
                 return list.every(function (item) {
                     return backend.isApplication(item)
                 });
             }
 
             function urlsDroppedOnArea(urls){
                 // If all dropped URLs point to application desktop files, we'll add a launcher for each of them.
                 if (onlyLaunchersInList(urls)) {
                     urls.forEach(function (item) {
                         addLauncher(item);
                     });
                     return;
                 }
 
                 if (!hoveredItem) {
                     return;
                 }
 
                 // DeclarativeMimeData urls is a QJsonArray but requestOpenUrls expects a proper QList<QUrl>.
                 var urlsList = backend.jsonArrayToUrlList(urls);
 
                 // Otherwise we'll just start a new instance of the application with the URLs as argument,
                 // as you probably don't expect some of your files to open in the app and others to spawn launchers.
                 tasksModel.requestOpenUrls(hoveredItem.modelIndex(), urlsList);
             }
 
             onUrlsDropped: {               
                 //! inform synced docks for new dropped launchers
                 if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers && onlyLaunchersInList(urls)) {
                     latteView.layoutsManager.launchersSignals.urlsDropped(root.viewLayoutName,
                                                                           root.launchersGroup, urls);
                     return;
                 }
 
                 //! if the list does not contain only launchers then just open the corresponding
                 //! urls with the relevant app
                 urlsDroppedOnArea(urls);
             }
         }
 
         /* Rectangle {
             anchors.fill: scrollableList
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
         TasksLayout.ScrollableList {
             id: scrollableList
             width: !root.vertical ? Math.min(root.width, icList.width) : thickness
             height: root.vertical ? Math.min(root.height, icList.height) : thickness
             contentWidth: icList.width
             contentHeight: icList.height
 
             property int thickness: {
                 if (latteView) {
                     return animations.hasThicknessAnimation ? latteView.maskManager.thicknessNormal : latteView.maskManager.thicknessZoom;
                 }
 
                 return metrics.totals.thickness * root.zoomFactor;
             }
 
             //onCurrentPosChanged: console.log("CP :: "+ currentPos + " icW:"+icList.width + " rw: "+root.width + " w:" +width);
 
             layer.enabled: contentsExceed && root.scrollingEnabled
             layer.effect: OpacityMask {
                 maskSource: TasksLayout.ScrollOpacityMask{
                     width: scrollableList.width
                     height: scrollableList.height
                 }
             }
 
             TasksLayout.ScrollPositioner {
                 id: listViewBase
 
                 ListView {
                     id:icList
                     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
                     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
                     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
                     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
                     anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
                     anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
                     width: !root.vertical ? contentWidth : mouseHandler.maxSize
                     height: root.vertical ? contentHeight : mouseHandler.maxSize
                     boundsBehavior: Flickable.StopAtBounds
                     orientation: plasmoid.formFactor === PlasmaCore.Types.Vertical ? Qt.Vertical : Qt.Horizontal
                     delegate: Task.TaskItem{
                         animations: _animations
                         metrics: _metrics
                         requires: _requires
                     }
 
                     property int currentSpot : -1000
                     property int hoveredIndex : -1
                     property int previousCount : 0
 
                     property int tasksCount: tasksModel.count
 
                     property bool directRender: false
 
                     //the duration of this animation should be as small as possible
                     //it fixes a small issue with the dragging an item to change it's
                     //position, if the duration is too big there is a point in the
                     //list that an item is going back and forth too fast
 
                     //more of a trouble
                     moveDisplaced: Transition {
                         NumberAnimation { properties: "x,y"; duration: animations.speedFactor.current*animations.duration.large; easing.type: Easing.Linear }
                     }
 
                     ///this transition can not be used with dragging !!!! I breaks
                     ///the lists indexes !!!!!
                     ///move: Transition {
                     ///    NumberAnimation { properties: "x,y"; duration: 400; easing.type: Easing.Linear }
                     ///}
 
                     function childAtPos(x, y){
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             var choords = mapFromItem(task,0, 0);
 
                             if( (task.objectName==="TaskItem") && (x>=choords.x) && (x<=choords.x+task.width)
                                     && (y>=choords.y) && (y<=choords.y+task.height)){
                                 return task;
                             }
                         }
 
                         return null;
                     }
 
                     function childAtIndex(position) {
                         var tasks = icList.contentItem.children;
 
                         if (position < 0)
                             return;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task.lastValidIndex === position
                                     || (task.lastValidIndex === -1 && task.itemIndex === position )) {
                                 return task;
                             }
                         }
 
                         return undefined;
                     }
 
                     function launcherModelIndex(url) {
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task && (task.launcherUrl===url)) {
                                 return task.itemIndex;
                             }
                         }
 
                         return -1;
                     }
                 }
             } // ScrollPositioner
         } // ScrollableList
 
         TasksLayout.ScrollEdgeShadows {
             id: scrollShadows
             width: !root.vertical ? scrollableList.width : thickness
             height: !root.vertical ? thickness : scrollableList.height
             visible: scrollableList.contentsExceed
 
             flickable: scrollableList
         } // ScrollEdgeShadows
 
         LatteComponents.AddingArea {
             id: newDroppedLauncherVisual
             anchors.fill: parent
             visible: backgroundOpacity > 0
             radius: metrics.iconSize/10
             backgroundOpacity: root.dropNewLauncher && mouseHandler.onlyLaunchers && (root.dragSource == null)? 0.75 : 0
             duration: animations.speedFactor.current
 
             title: i18n("Tasks Area")
         }
     }
 
     //// helpers
 
     Timer {
         id: iconGeometryTimer
         // INVESTIGATE: such big interval but unfortunately it does not work otherwise
         interval: 500
         repeat: false
 
         onTriggered: {
             root.publishTasksGeometries();
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: iconGeometryTimer called...");
             }
         }
     }
 
 
     ///REMOVE
     ////Activities List
     ////it can be used to cleanup the launchers from garbage-deleted activities....
     Item{
         id: activityModelInstance
         property int count: activityModelRepeater.count
 
         Repeater {
             id:activityModelRepeater
             model: Activities.ActivityModel {
                 id: activityModel
                 //  shownStates: "Running"
             }
             delegate: Item {
                 visible: false
                 property string activityId: model.id
                 property string activityName: model.name
             }
         }
 
         function activities(){
             var activitiesResult = [];
 
             for(var i=0; i<activityModelInstance.count; ++i){
                 console.log(children[i].activityId);
                 activitiesResult.push(children[i].activityId);
             }
 
             return activitiesResult;
         }
 
         ///REMOVE
         onCountChanged: {
             /*  if(activityInfo.currentActivity != "00000000-0000-0000-0000-000000000000"){
                 console.log("----------- Latte Plasmoid Signal: Activities number was changed ---------");
                 var allActivities = activities();
                 ActivitiesTools.cleanupRecords(allActivities);
                 console.log("----------- Latte Plasmoid Signal End ---------");
             }*/
         }
     }
 
     Timer{
         id:launchersOrderValidatorTimer
         interval: 400
 
         property var launchers: []
 
         function launchersAreInSync() {
             return arraysAreEqual(currentListViewLauncherList(), launchers);
         }
 
         function launcherValidPos(url) {
             for (var i=0; i<launchers.length; ++i) {
                 if (launchers[i] === url) {
                     return i;
                 }
             }
 
             return -1;
         }
 
         function arraysAreEqual(list1, list2) {
             if (list1.length !== list2.length) {
                 console.log("  arrays have different size...")
                 return false;
             }
 
             for (var i=0; i<list1.length; ++i) {
                 if (list1[i] !== list2[i]) {
                     return false;
                 }
             }
 
             return true;
         }
 
         //! true if upward is the best way to iterate through current
         //! in order to make it equal with goal
         function upwardIsBetter(current, goal)
         {
             var tCurrent = current.slice();
 
             if (!arraysAreEqual(tCurrent, goal)) {
                 for (var i=0; i<tCurrent.length; ++i) {
                     if (tCurrent[i] !== goal[i]) {
                         var val = tCurrent[i];
                         tCurrent.splice(i, 1);
                         tCurrent.splice(goal.indexOf(val), 0, val);
 
                         if (arraysAreEqual(tCurrent, goal)){
                             return true;
                         } else {
                             return false;
                         }
                     }
                 }
             }
 
             return false;
         }
 
 
         onTriggered: {
             if (launchersAreInSync()) {
                 stop();
                 console.log("launchers synced at:" + launchers);
                 launchers.length = 0;
                 parabolicManager.updateTasksEdgesIndexes();
                 root.separatorsUpdated();
                 tasksModel.syncLaunchers();
             } else {
                 var currentLaunchers = currentListViewLauncherList();
 
                 if (upwardIsBetter(currentLaunchers, launchers)) {
                     console.log("UPWARD....");
                     for (var i=0; i<currentLaunchers.length; ++i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 } else {
                     console.log("DOWNWARD....");
                     for (var i=currentLaunchers.length-1; i>=0; --i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 }
 
                 console.log("why we reached ??? ");
                 console.log("CURRENT ::: " + currentLaunchers);
                 console.log("VALID   ::: " + launchers);
             }
         }
     }
 
     /////////
 
     //// functions
     function addInternalSeparatorAtPos(pos) {
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.viewLayoutName,
                                                                       root.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     // This is called by dockcorona in response to a Meta+number shortcut.
     function activateTaskAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         var tasks = icList.contentItem.children;
 
         //! this is used to bypass the internal separators if they exist
         var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.itemIndex === confirmedIndex) {
                 if (task.isGroupParent) {
                     task.activateNextTask();
                 } else {
                     task.activateTask();
                 }
                 break;
             }
         }
     }
 
     // This is called 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 getBadger(identifier) {
         var ident1 = identifier;
         var n = ident1.lastIndexOf('/');
 
         var result = n>=0 ? ident1.substring(n + 1) : identifier;
 
         for(var i=0; i<badgers.length; ++i) {
             if (result.indexOf(badgers[i].id) >= 0) {
                 return badgers[i];
             }
         }
     }
 
     function updateBadge(identifier, value) {
         var tasks = icList.contentItem.children;
         var identifierF = identifier.concat(".desktop");
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task && task.launcherUrl && task.launcherUrl.indexOf(identifierF) >= 0) {
                 task.badgeIndicator = value === "" ? 0 : Number(value);
                 var badge = getBadger(identifierF);
                 if (badge) {
                     badge.value = value;
                 } else {
                     badgers.push({id: identifierF, value: value});
                 }
             }
         }
     }
 
     function getLauncherList() {
         return plasmoid.configuration.launchers59;
     }
 
     //! BEGIN ::: external launchers signals in order to update the tasks model
     function extSignalAddLauncher(group, launcher) {
         if (group === root.launchersGroup) {
             tasksModel.requestAddLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncher(group, launcher) {
         if (group === root.launchersGroup) {
             root.launcherForRemoval = launcher;
             tasksModel.requestRemoveLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalAddLauncherToActivity(group, launcher, activity) {
         if (group === root.launchersGroup) {
             var launcherActivities = tasksModel.launcherActivities(launcher);
 
             if (activity !== tasksModel.activity && (launcherActivities[0] === "00000000-0000-0000-0000-000000000000")) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestAddLauncherToActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncherFromActivity(group, launcher, activity) {
         if (group === root.launchersGroup) {
             if (activity === tasksModel.activity) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestRemoveLauncherFromActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalUrlsDropped(group, urls) {
         if (group === root.launchersGroup) {
             mouseHandler.urlsDroppedOnArea(urls);
         }
     }
 
     function extSignalMoveTask(group, from, to) {
         if (group === root.launchersGroup && !root.dragSource) {
             tasksModel.move(from, to);
             parabolicManager.updateTasksEdgesIndexes();
             root.separatorsUpdated();
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalValidateLaunchersOrder(group, launchers) {
         if (group === root.launchersGroup && !root.dragSource) {
             launchersOrderValidatorTimer.stop();
             launchersOrderValidatorTimer.launchers = launchers;
             launchersOrderValidatorTimer.start();
         }
     }
 
     //! END ::: external launchers signals in order to update the tasks model
 
 
     //! it is used to add the fake desktop file which represents
     //! the separator (fake launcher)
     function addSeparator(pos){
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     function removeLastSeparator(){
         var separatorName = parabolicManager.lastPresentSeparatorName();
 
         if (separatorName !== "") {
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.removeLauncher(root.viewLayoutName,
                                                                          root.launchersGroup, separatorName);
             } else {
                 root.launcherForRemoval = separatorName;
                 tasksModel.requestRemoveLauncher(separatorName);
             }
         }
     }
 
     //! show/hide tasks numbered badges e.g. from global shortcuts
     function setShowTaskShortcutBadges(showBadges){
         showTaskShortcutBadges = showBadges;
     }
 
     //! setup the tasks first index based on the fact that this is a plasmoid
     //! and applets could exist before it
     function setTasksBaseIndex(base){
         tasksBaseIndex = base;
     }
 
     function previewContainsMouse() {
         return windowsPreviewDlg.containsMouse;
     }
 
     function containsMouse(){
         //console.log("s1...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         //if (previewContainsMouse())
         //  windowsPreviewDlg.hide(4);
 
         if (previewContainsMouse())
             return true;
 
         //console.log("s3...");
         var tasks = icList.contentItem.children;
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if(task && task.containsMouse){
                 // console.log("Checking "+i+" - "+task.index+" - "+task.containsMouse);
                 return true;
             }
         }
 
         return false;
     }
 
     function clearZoom(){
         //console.log("Plasmoid clear...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         if (!previewContainsMouse()) {
             windowsPreviewDlg.hide(4.2);
         }
 
         if (!latteView) {
             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=" ) );
         }
 
         var path = url;
         var filename = path.split("/").pop();
         tasksExtendedManager.addToBeAddedLauncher(filename);
 
         tasksModel.requestAddLauncher(url);
         launchersUpdatedFor(url);
         tasksModel.syncLaunchers();
     }
 
     function resetDragSource() {
         dragSource.z = 0;
         dragSource = null;
     }
 
     function setGlobalDirectRender(value) {
         if (tasksExtendedManager.waitingLaunchersLength() > 0)
             return;
 
         if (latteView) {
             latteView.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 (latteView) {
 
             latteView.startCheckRestoreZoomTimer();
         } else {
             if (duration > 0) {
                 checkListHovered.startDuration(duration);
             } else {
                 checkListHovered.startNormal();
             }
         }
     }
 
     function stopCheckRestoreZoomTimer() {
         if (latteView) {
             latteView.stopCheckRestoreZoomTimer();
         } else {
             checkListHovered.stop();
         }
     }
 
     function startDirectRenderDelayerDuringEntering(){
         if (latteView) {
             latteView.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:  {
         root.presentWindows.connect(backend.presentWindows);
         root.windowsHovered.connect(backend.windowsHovered);
         dragHelper.dropped.connect(resetDragSource);
     }
 
     Component.onDestruction: {
         root.presentWindows.disconnect(backend.presentWindows);
         root.windowsHovered.disconnect(backend.windowsHovered);
         dragHelper.dropped.disconnect(resetDragSource);
     }
 
     //BEGIN states
     // Alignments
     // 0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Bottom Edge
         State {
             name: "bottomCenter"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomLeft"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomRight"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Top Edge
         State {
             name: "topCenter"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "topLeft"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "topRight"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ////Left Edge
         State {
             name: "leftCenter"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "leftTop"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "leftBottom"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Right Edge
         State {
             name: "rightCenter"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "rightTop"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "rightBottom"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         }
 
     ]
     //END states
 
 }
diff --git a/plasmoid/package/contents/ui/task/HiddenSpacer.qml b/plasmoid/package/contents/ui/task/HiddenSpacer.qml
index 1c54b16b..fc9396f2 100644
--- a/plasmoid/package/contents/ui/task/HiddenSpacer.qml
+++ b/plasmoid/package/contents/ui/task/HiddenSpacer.qml
@@ -1,174 +1,174 @@
 /*
 *  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.latte.core 0.2 as LatteCore
 
 Item{
     id: hiddenSpacer
     //we add one missing pixel from calculations
     width: root.vertical ? wrapper.width : nHiddenSize
     height: root.vertical ? nHiddenSize : wrapper.height
 
     visible: (rightSpacer ? index === parabolicManager.lastRealTaskIndex : index === parabolicManager.firstRealTaskIndex)
              || (separatorSpace > 0) || taskItem.inAttentionAnimation
              || taskItem.inFastRestoreAnimation || taskItem.inMimicParabolicAnimation
 
     property bool neighbourSeparator: false
     //in case there is a neighbour separator, lastValidIndex is used in order to protect from false
     //when the task is removed
     property int indexUsed: index === -1 ? lastValidIndex : index
 
     //fix #846,empty tasks after activity changes
     //in some cases after activity changes some tasks
     //are shown empty because some ghost tasks are created.
     //This was tracked down to hidden TaskItems spacers.
     //the flag !root.inActivityChange protects from this
     //and it is used later on Behaviors in order to not break
     //the activity change animations from removal/additions of tasks
     //! && !root.inActivityChange (deprecated) in order to check if it is fixed
     property int separatorSpace: neighbourSeparator && !isSeparator && root.parabolicEffectEnabled
                                  && !(parabolicManager.hasInternalSeparator && root.dragSource) ?
-                                     ((LatteCore.Environment.separatorLength/2)+root.lengthExtMargin) : 0
+                                     ((LatteCore.Environment.separatorLength/2)+taskItem.metrics.margin.length) : 0
 
     property bool rightSpacer: false
 
     property real nScale: 0
     property real nHiddenSize: 0
 
     Binding{
         target: hiddenSpacer
         property: "nHiddenSize"
         value: {
             if (isForcedHidden) {
                 return 0;
             } else if (!inAttentionAnimation && !inMimicParabolicAnimation && !inFastRestoreAnimation) {
                 return (nScale > 0) ? (taskItem.spacersMaxSize * nScale) + separatorSpace : separatorSpace;
             } else {
                 return (nScale > 0) ? (taskItem.metrics.iconSize * nScale) + separatorSpace : separatorSpace;
             }
         }
     }
 
     function updateNeighbour() {
         //index===-1 indicates that this item is removed
         if (taskItem.inBouncingAnimation) {
             return;
         }
 
         if (root.editMode && root.inConfigureAppletsMode) {
             neighbourSeparator = false;
         } else if (latteView && index!==-1) {
             if (!rightSpacer) {
                 neighbourSeparator = (taskItem.hasNeighbourSeparator(itemIndex-1, false) && !isSeparator && itemIndex!==parabolicManager.firstRealTaskIndex)
                         || (latteView.parabolicManager.isSeparator(latteView.latteAppletPos-1) && parabolicManager.firstRealTaskIndex === itemIndex);
             } else {
                 if (itemIndex >= root.tasksCount) {
                     return;
                 }
 
                 neighbourSeparator = (taskItem.hasNeighbourSeparator(itemIndex+1,true) && !isSeparator && itemIndex!==parabolicManager.lastRealTaskIndex)
                         || (latteView.parabolicManager.isSeparator(latteView.latteAppletPos+1) && parabolicManager.lastRealTaskIndex === itemIndex );
             }
 
             /* if (launcherUrl.indexOf("kwrite") > -1 || launcherUrl.indexOf("dolphin") > -1 ) {
                 var spacerName = "left";
                 if (rightSpacer)
                     spacerName = "right";
 
                 console.log(launcherUrl +":" + itemIndex +"," + spacerName + " _-_- " +neighbourSeparator);
             }*/
         }
     }
 
     Connections{
         target: root
         onEditModeChanged: hiddenSpacer.updateNeighbour();
         onInConfigureAppletsModeChanged: hiddenSpacer.updateNeighbour();
         onLatteViewChanged: hiddenSpacer.updateNeighbour();
         // onInternalSeparatorHiddenChanged: hiddenSpacer.updateNeighbour();
         onSeparatorsUpdated: hiddenSpacer.updateNeighbour();
     }
 
     Connections{
         target: taskItem
         onContainsMouseChanged: {
             if (!taskItem.containsMouse && !inAttentionAnimation && !inFastRestoreAnimation && !inMimicParabolicAnimation) {
                 hiddenSpacer.nScale = 0;
             }
         }
     }
 
     Connections{
         target: latteView
         onSeparatorsUpdated: hiddenSpacer.updateNeighbour();
         onLatteAppletPosChanged: hiddenSpacer.updateNeighbour();
     }
 
     Connections{
         target: parabolicManager
         onFirstRealTaskIndexChanged: hiddenSpacer.updateNeighbour();
         onLastRealTaskIndexChanged: hiddenSpacer.updateNeighbour();
     }
 
     Connections{
         target: taskItem
         onItemIndexChanged: hiddenSpacer.updateNeighbour();
     }
 
     Component.onCompleted: {
         root.hiddenTasksUpdated.connect(updateNeighbour);
         hiddenSpacer.updateNeighbour();
     }
 
     Component.onDestruction: {
         root.hiddenTasksUpdated.disconnect(updateNeighbour);
     }
 
     Behavior on nHiddenSize {
         id: animatedBehavior
         enabled: (taskItem.inFastRestoreAnimation || showWindowAnimation.running || restoreAnimation.running
                   || root.inActivityChange || taskItem.inRemoveStage)
                  || (taskItem.containsMouse && inAttentionAnimation && wrapper.mScale!==root.zoomFactor)
         NumberAnimation{ duration: 3 * taskItem.animationTime }
     }
 
     Behavior on nHiddenSize {
         id: directBehavior
         enabled: !animatedBehavior.running
         NumberAnimation { duration: root.directRenderAnimationTime }
     }
 
     Loader{
         active: latteView && latteView.debugModeSpacers
 
         sourceComponent: Rectangle{
             width: !root.vertical ? hiddenSpacer.width : 1
             height: !root.vertical ? 1 : hiddenSpacer.height
             x: root.vertical ? hiddenSpacer.width/2 : 0
             y: !root.vertical ? hiddenSpacer.height/2 : 0
 
             border.width: 1
             border.color: "red"
             color: "transparent"
         }
     }
 }
diff --git a/plasmoid/package/contents/ui/task/IconItem.qml b/plasmoid/package/contents/ui/task/IconItem.qml
index a0ae3311..ffa8f5d2 100644
--- a/plasmoid/package/contents/ui/task/IconItem.qml
+++ b/plasmoid/package/contents/ui/task/IconItem.qml
@@ -1,799 +1,799 @@
 /*
 *  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.4
 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.kquickcontrolsaddons 2.0 as KQuickControlAddons
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "animations" as TaskAnimations
 
 //I am using  KQuickControlAddons.QIconItem even though onExit it triggers the following error
 //QObject::~QObject: Timers cannot be stopped from another thread
 //but it increases performance almost to double during animation
 
 Item{
     id: taskIcon
 
    // width: wrapper.regulatorWidth
    // height: wrapper.regulatorHeight
 
     //big interval to show shadows only after all the crappy adds and removes of tasks
     //have happened
     property bool firstDrawed: true
     property bool toBeDestroyed: false
 
     // three intervals in order to create the necessary buffers from the
     // PlasmaCore.IconItem, one big interval for the first creation of the
     // plasmoid, a second one for the first creation of a task and a small one
     // for simple updates.
     // This is done before especially on initialization stage some visuals
     // are not ready and empty buffers are created
 
     //property int firstDrawedInterval: root.initializationStep ? 2000 : 1000
     // property int shadowInterval: firstDrawed ? firstDrawedInterval : 250
     property int shadowInterval: firstDrawed ? 1000 : 250
 
     property int shadowSize : root.appShadowSize
 
     readonly property bool smartLauncherEnabled: ((taskItem.isStartup === false) && (root.showInfoBadge || root.showProgressBadge))
     readonly property variant iconDecoration: decoration
 
     readonly property color backgroundColor: iconImageBuffer.backgroundColor
     readonly property color glowColor: iconImageBuffer.glowColor
     readonly property bool progressVisible: smartLauncherItem && smartLauncherItem.progressVisible
     readonly property real progress: smartLauncherItem && smartLauncherItem.progress ? smartLauncherItem.progress : 0
 
     property QtObject buffers: null
     property QtObject smartLauncherItem: null
 
     property Item visualIconItem: iconImageBuffer
     property Item titleTooltipVisualParent: titleTooltipParent
     property Item previewsTootipVisualParent: previewsTooltipParent
 
     /* Rectangle{
         anchors.fill: parent
         border.width: 1
         border.color: "green"
         color: "transparent"
     } */
 
     onSmartLauncherEnabledChanged: {
         if (smartLauncherEnabled && !smartLauncherItem) {
             var smartLauncher = Qt.createQmlObject(
                         " import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet; TaskManagerApplet.SmartLauncherItem { }",
                         taskIcon);
 
             smartLauncher.launcherUrl = Qt.binding(function() { return taskItem.launcherUrlWithIcon; });
 
             smartLauncherItem = smartLauncher;
         } else if (!smartLauncherEnabled && smartLauncherItem) {
             smartLauncherItem.destroy();
             smartLauncherItem = null;
         }
     }
 
     Rectangle{
         id: draggedRectangle
         width: taskItem.isSeparator ? parent.width + 1 : iconImageBuffer.width+1
         height: taskItem.isSeparator ? parent.height + 1 : iconImageBuffer.height+1
         anchors.centerIn: iconGraphic
         opacity: 0
         radius: 3
         anchors.margins: 5
 
         property color tempColor: theme.highlightColor
         color: tempColor
         border.width: 1
         border.color: theme.highlightColor
 
         onTempColorChanged: tempColor.a = 0.35;
     }
 
     TitleTooltipParent{
         id: titleTooltipParent
         thickness: root.zoomFactor * taskItem.metrics.totals.thickness
     }
 
     TitleTooltipParent{
         id: previewsTooltipParent
         thickness: (root.zoomFactor * taskItem.metrics.totals.thickness) + 1
     }
 
     //!
 
     // KQuickControlAddons.QIconItem{
     Item{
         id: iconGraphic
         width: parent.width
         height: parent.height
 
         //fix bug #478, when changing form factor sometimes the tasks are not positioned
         //correctly, in such case we make a fast reinitialization for the sizes
         Connections {
             target: plasmoid
 
             onFormFactorChanged:{
                 taskItem.inAddRemoveAnimation = false;
 
                 wrapper.mScale = 1.01;
                 wrapper.tempScaleWidth = 1.01;
                 wrapper.tempScaleHeight = 1.01;
 
                 wrapper.mScale = 1;
                 wrapper.tempScaleWidth = 1;
                 wrapper.tempScaleHeight = 1;
             }
         }
 
         LatteCore.IconItem{
             id: iconImageBuffer
 
             anchors.centerIn: parent
 
             width: Math.round(newTempSize)
             height: Math.round(width)
             source: decoration
             smooth: root.zoomFactor === 1 ? true : false
             providesColors: indicators ? indicators.info.needsIconColors : false
 
             opacity: root.enableShadows
                      && taskWithShadow.active
                      && graphicsSystem.isAccelerated ? 0 : 1
             visible: !taskItem.isSeparator && (!badgesLoader.active || !graphicsSystem.isAccelerated)
 
             onValidChanged: {
                 if (!valid && (source === decoration || source === "unknown")) {
                     source = "application-x-executable";
                 }
             }
 
             //! try to show the correct icon when a window is removed... libtaskmanager when a window is removed
             //! sends an unknown pixmap as icon
             Connections {
                 target: taskItem
                 onInRemoveStageChanged: {
                     if (taskItem.inRemoveStage && iconImageBuffer.lastValidSourceName !== "") {
                         iconImageBuffer.source = iconImageBuffer.lastValidSourceName;
                     }
                 }
             }
 
             property int zoomedSize: root.zoomFactor * taskItem.metrics.iconSize
 
             property real basicScalingWidth : wrapper.inTempScaling ? (taskItem.metrics.iconSize * wrapper.scaleWidth) :
                                                                       taskItem.metrics.iconSize * wrapper.mScale
             property real basicScalingHeight : wrapper.inTempScaling ? (taskItem.metrics.iconSize * wrapper.scaleHeight) :
                                                                        taskItem.metrics.iconSize * wrapper.mScale
 
             property real newTempSize: {
                 if (wrapper.opacity === 1 ) {
                     return Math.min(basicScalingWidth, basicScalingHeight);
                 } else {
                     return Math.max(basicScalingWidth, basicScalingHeight);
                 }
             }
 
             //! Latte Side Painting-style if the user chose it
             Loader{
                 anchors.fill: iconImageBuffer
                 active: plasmoid.configuration.forceMonochromaticIcons
 
                 sourceComponent: ColorOverlay {
                     anchors.fill: parent
                     color: latteBridge ? latteBridge.palette.textColor : "transparent"
                     source: iconImageBuffer
                 }
             }
             //! Latte Side Painting-style if the user chose it
 
             ///states for launcher animation
             states: [
                 State{
                     name: "*"
                     //! since qt 5.14 default state can not use "when" property
                     //! it breaks restoring transitions otherwise
 
                     AnchorChanges{
                         target:iconImageBuffer;
                         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined;
                         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined;
                         anchors.right: root.location === PlasmaCore.Types.RightEdge ? parent.right : undefined;
                         anchors.left: root.location === PlasmaCore.Types.LeftEdge ? parent.left : undefined;
                         anchors.top: root.location === PlasmaCore.Types.TopEdge ? parent.top : undefined;
                         anchors.bottom: root.location === PlasmaCore.Types.BottomEdge ? parent.bottom : undefined;
                     }
                 },
 
                 State{
                     name: "animating"
                     when: !taskItem.inAddRemoveAnimation && (launcherAnimation.running || newWindowAnimation.running || fastRestoreAnimation.running)
 
                     AnchorChanges{
                         target:iconImageBuffer;
                         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined;
                         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined;
                         anchors.right: root.location === PlasmaCore.Types.LeftEdge ? parent.right : undefined;
                         anchors.left: root.location === PlasmaCore.Types.RightEdge ? parent.left : undefined;
                         anchors.top: root.location === PlasmaCore.Types.BottomEdge ? parent.top : undefined;
                         anchors.bottom: root.location === PlasmaCore.Types.TopEdge ? parent.bottom : undefined;
                     }
                 }
             ]
 
             ///transitions, basic for the anchor changes
             transitions: [
                 Transition{
                     from: "animating"
                     to: "*"
                     enabled: !fastRestoreAnimation.running && !taskItem.inMimicParabolicAnimation
 
                     AnchorAnimation { duration: 1.5 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
                 }
             ]
         } //IconImageBuffer
 
         //! Shadows
         Loader{
             id: taskWithShadow
             anchors.fill: iconImageBuffer
             active: root.enableShadows && !taskItem.isSeparator && graphicsSystem.isAccelerated
 
             sourceComponent: DropShadow{
                 anchors.fill: parent
                 color: root.appShadowColor
                 fast: true
                 samples: 2 * radius
                 source: badgesLoader.active ? badgesLoader.item : iconImageBuffer
                 radius: root.appShadowSize
                 verticalOffset: 2
             }
         }
         //! Shadows
 
         //! Combined Loader for Progress and Audio badges masks
         Loader{
             id: badgesLoader
             anchors.fill: iconImageBuffer
             active: (activateProgress > 0) && graphicsSystem.isAccelerated
             asynchronous: true
             opacity: stateColorizer.opacity > 0 ? 0 : 1
 
             property real activateProgress: showInfo || showProgress || showAudio ? 1 : 0
 
             property bool showInfo: (root.showInfoBadge && taskIcon.smartLauncherItem && !taskItem.isSeparator
                                      && (taskIcon.smartLauncherItem.countVisible || taskItem.badgeIndicator > 0) && !taskIcon.smartLauncherItem.progressVisible)
 
             property bool showProgress: root.showProgressBadge && taskIcon.smartLauncherItem && !taskItem.isSeparator
                                         && taskIcon.smartLauncherItem.progressVisible
 
             property bool showAudio: (root.showAudioBadge && taskItem.hasAudioStream && taskItem.playingAudio && !taskItem.isSeparator) && !shortcutBadge.active
 
             Behavior on activateProgress {
                 NumberAnimation { duration: 2 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
             }
 
             sourceComponent: Item{
                 ShaderEffect {
                     id: iconOverlay
                     enabled: false
                     anchors.fill: parent
                     property var source: ShaderEffectSource {
                         sourceItem: LatteCore.IconItem{
                             width: iconImageBuffer.width
                             height: iconImageBuffer.height
                             source: iconImageBuffer.source
 
                             Loader{
                                 anchors.fill: parent
                                 active: plasmoid.configuration.forceMonochromaticIcons
 
                                 sourceComponent: ColorOverlay {
                                     anchors.fill: parent
                                     color: latteBridge ? latteBridge.palette.textColor : "transparent"
                                     source: iconImageBuffer
                                 }
                             }
                         }
                     }
                     property var mask: ShaderEffectSource {
                         sourceItem: Item{
                             LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.vertical
                             LayoutMirroring.childrenInherit: true
 
                             width: iconImageBuffer.width
                             height: iconImageBuffer.height
 
                             Rectangle{
                                 id: maskRect
                                 width: Math.max(badgeVisualsLoader.infoBadgeWidth, parent.width / 2)
                                 height: parent.height / 2
                                 radius: parent.height
                                 visible: badgesLoader.showInfo || badgesLoader.showProgress
 
                                 //! Removes any remainings from the icon around the roundness at the corner
                                 Rectangle{
                                     id: maskCorner
                                     width: parent.width/2
                                     height: parent.height/2
                                 }
 
                                 states: [
                                     State {
                                         name: "default"
                                         when: (root.location !== PlasmaCore.Types.RightEdge)
 
                                         AnchorChanges {
                                             target: maskRect
                                             anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right;}
                                         }
                                         AnchorChanges {
                                             target: maskCorner
                                             anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right;}
                                         }
                                     },
                                     State {
                                         name: "right"
                                         when: (root.location === PlasmaCore.Types.RightEdge)
 
                                         AnchorChanges {
                                             target: maskRect
                                             anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined;}
                                         }
                                         AnchorChanges {
                                             target: maskCorner
                                             anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined;}
                                         }
                                     }
                                 ]
                             } // progressMask
 
                             Rectangle{
                                 id: maskRect2
                                 width: parent.width/2
                                 height: width
                                 radius: width
                                 visible: badgesLoader.showAudio
 
                                 Rectangle{
                                     id: maskCorner2
                                     width:parent.width/2
                                     height:parent.height/2
                                 }
 
                                 states: [
                                     State {
                                         name: "default"
                                         when: (root.location !== PlasmaCore.Types.RightEdge)
 
                                         AnchorChanges {
                                             target: maskRect2
                                             anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined;}
                                         }
                                         AnchorChanges {
                                             target: maskCorner2
                                             anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined;}
                                         }
                                     },
                                     State {
                                         name: "right"
                                         when: (root.location === PlasmaCore.Types.RightEdge)
 
                                         AnchorChanges {
                                             target: maskRect2
                                             anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right;}
                                         }
                                         AnchorChanges {
                                             target: maskCorner2
                                             anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right;}
                                         }
                                     }
                                 ]
                             } // audio mask
                         }
                         hideSource: true
                         live: true
                     } //end of mask
 
                     supportsAtlasTextures: true
 
                     fragmentShader: "
             varying highp vec2 qt_TexCoord0;
             uniform highp float qt_Opacity;
             uniform lowp sampler2D source;
             uniform lowp sampler2D mask;
             void main() {
                 gl_FragColor = texture2D(source, qt_TexCoord0.st) * (1.0 - (texture2D(mask, qt_TexCoord0.st).a)) * qt_Opacity;
             }
         "
                 } //end of sourceComponent
             }
         }
         ////!
 
         //! START: Badges Visuals
         //! the badges visual get out from iconGraphic in order to be able to draw shadows that
         //! extend beyond the iconGraphic boundaries
         Loader {
             id: badgeVisualsLoader
             anchors.fill: iconImageBuffer
             active: (badgesLoader.activateProgress > 0)
 
             readonly property int infoBadgeWidth: active ? publishedInfoBadgeWidth : 0
             property int publishedInfoBadgeWidth: 0
 
             sourceComponent: Item {
                 ProgressOverlay{
                     id: infoBadge
                     anchors.right: parent.right
                     anchors.top: parent.top
                     width: Math.max(parent.width, contentWidth)
                     height: parent.height
 
                     opacity: badgesLoader.activateProgress
                     visible: badgesLoader.showInfo || badgesLoader.showProgress
 
                     layer.enabled: root.enableShadows && graphicsSystem.isAccelerated
                     layer.effect: DropShadow {
                         color: root.appShadowColor
                         fast: true
                         samples: 2 * radius
                         source: infoBadge
                         radius: root.appShadowSize
                         verticalOffset: 2
                     }
                 }
 
                 AudioStream{
                     id: audioStreamBadge
                     anchors.fill: parent
                     opacity: badgesLoader.activateProgress
                     visible: badgesLoader.showAudio
 
                     layer.enabled: root.enableShadows && graphicsSystem.isAccelerated
                     layer.effect: DropShadow {
                         color: root.appShadowColor
                         fast: true
                         samples: 2 * radius
                         source: audioStreamBadge
                         radius: root.appShadowSize
                         verticalOffset: 2
                     }
                 }
 
                 Binding {
                     target: badgeVisualsLoader
                     property: "publishedInfoBadgeWidth"
                     value: infoBadge.contentWidth
                 }
             }
         }
 
         //! GREY-ing the information badges when the task is dragged
         //! moved out of badgeVisualsLoader in order to avoid crashes
         //! when the latte view is removed
         Loader {
             width: iconImageBuffer.width
             height: iconImageBuffer.height
             anchors.centerIn: iconImageBuffer
 
             active: badgeVisualsLoader.active && graphicsSystem.isAccelerated
             sourceComponent: Colorize{
                 source: badgeVisualsLoader.item
 
                 //! HACK TO AVOID PIXELIZATION
                 //! WORKAROUND: When Effects are enabled e.g. BrightnessContrast, Colorize etc.
                 //! the icon appears pixelated. It is even most notable when zoomFactor === 1
                 //! I don't know enabling cached=true helps, but it does.
                 cached: true
 
                 opacity: stateColorizer.opacity
                 hue: stateColorizer.hue
                 saturation: stateColorizer.saturation
                 lightness: stateColorizer.lightness
             }
         }
         //! END: Badges Visuals
 
         //! Effects
         Colorize{
             id: stateColorizer
             anchors.centerIn: iconImageBuffer
             width: iconImageBuffer.width
             height: iconImageBuffer.height
 
             //! HACK TO AVOID PIXELIZATION
             //! WORKAROUND: When Effects are enabled e.g. BrightnessContrast, Colorize etc.
             //! the icon appears pixelated. It is even most notable when zoomFactor === 1
             //! I don't know enabling cached=true helps, but it does.
             cached: true
 
             source: badgesLoader.active ? badgesLoader : iconImageBuffer
             visible: !isSeparator
 
             opacity:0
 
             hue:0
             saturation:0
             lightness:0
         }
 
         BrightnessContrast{
             id:hoveredImage
             anchors.centerIn: iconImageBuffer
             width: iconImageBuffer.width
             height: iconImageBuffer.height
 
             //! HACK TO AVOID PIXELIZATION
             //! WORKAROUND: When Effects are enabled e.g. BrightnessContrast, Colorize etc.
             //! the icon appears pixelated. It is even most notable when zoomFactor === 1
             //! I don't know enabling cached=true helps, but it does.
             cached: true
 
             source: badgesLoader.active ? badgesLoader : iconImageBuffer
             visible: !isSeparator
 
             opacity: taskItem.containsMouse && !clickedAnimation.running && !indicators.info.providesHoveredAnimation ? 1 : 0
             brightness: 0.30
             contrast: 0.1
 
             Behavior on opacity {
                 NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
             }
         }
 
         BrightnessContrast {
             id: brightnessTaskEffect
             anchors.centerIn: iconImageBuffer
             width: iconImageBuffer.width
             height: iconImageBuffer.height
 
             //! HACK TO AVOID PIXELIZATION
             //! WORKAROUND: When Effects are enabled e.g. BrightnessContrast, Colorize etc.
             //! the icon appears pixelated. It is even most notable when zoomFactor === 1
             //! I don't know enabling cached=true helps, but it does.
             cached: true
 
             source: badgesLoader.active ? badgesLoader : iconImageBuffer
 
             visible: clickedAnimation.running && !isSeparator
         }
         //! Effects
 
         ShortcutBadge{
             id: shortcutBadge
         }
     }
 
     Loader {
         id: dropFilesVisual
         active: applyOpacity>0
 
         width: !root.vertical ? length : thickness
         height: !root.vertical ? thickness : length
         anchors.centerIn: parent
 
-        readonly property int length: taskItem.metrics.iconSize + root.lengthMargins
+        readonly property int length: taskItem.metrics.totals.length
         readonly property int thickness: taskItem.metrics.totals.thickness
 
         readonly property real applyOpacity: root.dropNewLauncher && !mouseHandler.onlyLaunchers
                                              && (root.dragSource == null) && (mouseHandler.hoveredItem === taskItem) ? 0.7 : 0
 
         sourceComponent: LatteComponents.AddItem {
             anchors.fill: parent
             backgroundOpacity: dropFilesVisual.applyOpacity
         }
     }
 
     Component.onDestruction: {
         taskIcon.toBeDestroyed = true;
 
         if(removingAnimation.removingItem)
             removingAnimation.removingItem.destroy();
     }
 
     Connections{
         target: taskItem
 
         onInAttentionChanged:{
             if (!taskItem.inAttention && newWindowAnimation.running && taskItem.inAttentionAnimation) {
                 newWindowAnimation.pause();
                 fastRestoreAnimation.start();
             }
         }
     }
 
     ///// Animations /////
 
     TaskAnimations.ClickedAnimation { id: clickedAnimation }
 
     TaskAnimations.LauncherAnimation { id:launcherAnimation }
 
     TaskAnimations.NewWindowAnimation { id: newWindowAnimation }
 
     TaskAnimations.RemoveWindowFromGroupAnimation { id: removingAnimation }
 
     TaskAnimations.FastRestoreAnimation { id: fastRestoreAnimation }
 
     //////////// States ////////////////////
     states: [
         State{
             name: "*"
             //! since qt 5.14 default state can not use "when" property
             //! it breaks restoring transitions otherwise
         },
 
         State{
             name: "isDragged"
             when: ( (taskItem.isDragged) && (!root.inConfigureAppletsMode) )
         }
     ]
 
     //////////// Transitions //////////////
 
     transitions: [
         Transition{
             id: isDraggedTransition
             to: "isDragged"
             property int speed: taskItem.animations.speedFactor.current * taskItem.animations.duration.large
 
             SequentialAnimation{
                 ScriptAction{
                     script: {
                         icList.directRender = false;
                         if(latteView) {
                             latteView.globalDirectRender=false;
                         }
 
                         taskItem.inBlockingAnimation = true;
                         root.clearZoom();
                     }
                 }
 
                 PropertyAnimation {
                     target: wrapper
                     property: "mScale"
                     to: 1 + ((root.zoomFactor - 1) / 3)
                     duration: isDraggedTransition.speed / 2
                     easing.type: Easing.OutQuad
                 }
 
                 ParallelAnimation{
                     PropertyAnimation {
                         target: draggedRectangle
                         property: "opacity"
                         to: 1
                         duration: isDraggedTransition.speed
                         easing.type: Easing.OutQuad
                     }
 
                     PropertyAnimation {
                         target: iconImageBuffer
                         property: "opacity"
                         to: 0
                         duration: isDraggedTransition.speed
                         easing.type: Easing.OutQuad
                     }
 
                     PropertyAnimation {
                         target: stateColorizer
                         property: "opacity"
                         to: taskItem.isSeparator ? 0 : 1
                         duration: isDraggedTransition.speed
                         easing.type: Easing.OutQuad
                     }
                 }
             }
 
             onRunningChanged: {
                 if(running){
                     taskItem.animationStarted();
                     //root.animations++;
 
                     parabolicManager.clearTasksGreaterThan(index);
                     parabolicManager.clearTasksLowerThan(index);
 
                     if (latteView){
                         latteView.parabolicManager.clearAppletsGreaterThan(latteView.latteAppletPos);
                         latteView.parabolicManager.clearAppletsLowerThan(latteView.latteAppletPos);
                     }
                 }
             }
         },
         Transition{
             id: defaultTransition
             from: "isDragged"
             to: "*"
             property int speed: taskItem.animations.speedFactor.current * taskItem.animations.duration.large
 
             SequentialAnimation{
                 ScriptAction{
                     script: {
                         icList.directRender = false;
                         if(latteView) {
                             latteView.globalDirectRender=false;
                         }
                     }
                 }
 
                 ParallelAnimation{
                     PropertyAnimation {
                         target: draggedRectangle
                         property: "opacity"
                         to: 0
                         duration: defaultTransition.speed
                         easing.type: Easing.OutQuad
                     }
 
                     PropertyAnimation {
                         target: iconImageBuffer
                         property: "opacity"
                         to: 1
                         duration: defaultTransition.speed
                         easing.type: Easing.OutQuad
                     }
 
                     PropertyAnimation {
                         target: stateColorizer
                         property: "opacity"
                         to: 0
                         duration: isDraggedTransition.speed
                         easing.type: Easing.OutQuad
                     }
                 }
 
                 /*  PropertyAnimation {
                     target: wrapper
                     property: "mScale"
                     to: 1;
                     duration: isDraggedTransition.speed
                     easing.type: Easing.OutQuad
                 }*/
 
                 ScriptAction{
                     script: {
                         taskItem.inBlockingAnimation = false;
                     }
                 }
             }
 
             onRunningChanged: {
                 if(!running){
                     var halfZoom = 1 + ((root.zoomFactor - 1) / 2);
 
                     wrapper.calculateScales(taskItem.metrics.totals.thickness/2);
 
                     taskItem.animationEnded();
                     //   root.animations--;
                 }
             }
         }
     ]
 
 }// Icon Item
diff --git a/plasmoid/package/contents/ui/task/TaskItem.qml b/plasmoid/package/contents/ui/task/TaskItem.qml
index 6a54fe4d..f5871e32 100644
--- a/plasmoid/package/contents/ui/task/TaskItem.qml
+++ b/plasmoid/package/contents/ui/task/TaskItem.qml
@@ -1,1712 +1,1712 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.0
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.latte.core 0.2 as LatteCore
 
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "animations" as TaskAnimations
 import "indicator" as Indicator
 
 MouseArea{
     id: taskItem
 
     visible: false //true//(isStartup && animations.speedFactor.current !== 0) ? false : true
 
     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
     objectName: "TaskItem"
 
     width: {
         if (!visible)
             return 0;
 
         if (isSeparator) {
             if (root.vertical) {
                 return taskItem.metrics.totals.thickness + root.screenEdgeMargin;
             } else {
                 if (root.dragSource || !root.parabolicEffectEnabled) {
-                    return LatteCore.Environment.separatorLength+2*root.lengthExtMargin;
+                    return LatteCore.Environment.separatorLength+2*taskItem.metrics.margin.length;
                 }
             }
 
             return 0;
         }
 
         if (root.vertical) {
             return wrapper.width;
         } else {
             return hiddenSpacerLeft.width+wrapper.width+hiddenSpacerRight.width;
         }
     }
 
     /*onWidthChanged: {
         console.log("T: " + itemIndex + " - " + launcherUrl + " - " + width + " _ "+ hiddenSpacerLeft.width + " _ " + wrapper.width + " _ " + hiddenSpacerRight.width);
     }*/
 
     height: {
         if (!visible)
             return 0;
 
         if (isSeparator) {
             if (!root.vertical) {
                 return taskItem.metrics.totals.thickness + root.screenEdgeMargin;
             } else {
                 if (root.dragSource || !root.parabolicEffectEnabled) {
-                    return LatteCore.Environment.separatorLength+2*root.lengthExtMargin;
+                    return LatteCore.Environment.separatorLength+2*taskItem.metrics.margin.length;
                 }
             }
 
             return 0;
         }
 
         if (root.vertical) {
             return hiddenSpacerLeft.height + wrapper.height + hiddenSpacerRight.height;
         } else {
             return wrapper.height;
         }
     }
 
     acceptedButtons: Qt.LeftButton | Qt.MidButton | Qt.RightButton
     hoverEnabled: visible && (!inAnimation) && (!IsStartup) && (!root.taskInAnimation)
                   &&(!inBouncingAnimation) && !isSeparator
     // hoverEnabled: false
     //opacity : isSeparator && (hiddenSpacerLeft.neighbourSeparator || hiddenSpacerRight.neighbourSeparator) ? 0 : 1
 
     property bool buffersAreReady: false
     property bool delayingRemove: ListView.delayRemove
     property bool scalesUpdatedOnce: false
     //states that exist in windows in a Group of windows
     property bool hasActive: isActive
     property bool hasMinimized: (IsGroupParent === true) ? subWindows.hasMinimized : isMinimized
     property bool hasShown: (IsGroupParent === true) ? subWindows.hasShown : !isMinimized && isWindow
     property bool inAttention: isDemandingAttention && plasmoid.status === PlasmaCore.Types.RequiresAttentionStatus ? true : false
     /*animations flags*/
     property bool inAnimation: true
     property bool inAddRemoveAnimation: true
     property bool inAttentionAnimation: false
     property bool inBlockingAnimation: false
     property bool inBouncingAnimation: false
     property bool inFastRestoreAnimation: false
     property bool inMimicParabolicAnimation: false
     property bool inNewWindowAnimation: false
     property real mimicParabolicScale: -1
     property bool inPopup: false
     property bool inRemoveStage: false
 
     property bool isAbleToShowPreview: true
     property bool isActive: (IsActive === true) ? true : false
     property bool isDemandingAttention: (IsDemandingAttention === true) ? true : false
     property bool isDragged: false
     property bool isGroupable: (IsGroupable === true) ? true : false
     property bool isGroupParent: (IsGroupParent === true) ? true : false
     property bool isForcedHidden: false
     property bool isLauncher: (IsLauncher === true) ? true : false
     property bool isMinimized: (IsMinimized === true) ? true : false
     property bool isSeparator: false
     property bool isStartup: (IsStartup === true) ? true : false
     property bool isWindow: (IsWindow === true) ? true : false
     property bool isZoomed: false
 
     property bool canPublishGeometries: (isWindow || isStartup || isGroupParent) && visible && width>=taskItem.metrics.iconSize && height>=taskItem.metrics.iconSize
                                         && !taskItem.delayingRemove
                                         && (wrapper.mScale===1 || wrapper.mScale===root.zoomFactor) //don't publish during zoomFactor
 
     property bool pressed: false
     property bool wheelIsBlocked: false
 
     property int animationTime: (taskItem.animations.active ? taskItem.animations.speedFactor.current : 2) * (1.2 *taskItem.animations.duration.small)
     property int badgeIndicator: 0 //it is used from external apps
     property int 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*taskItem.metrics.iconSize) - root.lengthMargins)
+    property int spacersMaxSize: Math.max(0,Math.ceil(0.55*taskItem.metrics.iconSize) - taskItem.metrics.totals.lengthEdges)
     property int windowsCount: subWindows.windowsCount
     property int windowsMinimizedCount: subWindows.windowsMinimized
 
     //! are set by the indicator
     property int iconOffsetX: 0
     property int iconOffsetY: 0
 
     property string activity: tasksModel.activity
 
     readonly property var m: model
     readonly property int pid: model && model.AppPid ? model.AppPid : -1
     readonly property string appName: model && model.AppName ? model.AppName : ""
 
     property string modelLauncherUrl: (LauncherUrlWithoutIcon && LauncherUrlWithoutIcon !== null) ? LauncherUrlWithoutIcon : ""
     property string modelLauncherUrlWithIcon: (LauncherUrl && LauncherUrl !== null) ? LauncherUrl : ""
     property string launcherUrl: ""
     property string launcherUrlWithIcon: ""
     property string launcherName: ""
 
     property Item tooltipVisualParent: wrapper.titleTooltipVisualParent
     property Item previewsVisualParent: wrapper.previewsTooltipVisualParent
     property Item wrapperAlias: wrapper
 
     //abilities
     property Item animations: null
     property Item metrics: null
     property Item requires: null
 
     onModelLauncherUrlChanged: {
         if (modelLauncherUrl !== ""){
             launcherUrl = modelLauncherUrl;
 
             //!extract the launcherName if possible
             var nameStarts = launcherUrl.lastIndexOf("/");
             if (nameStarts === -1){
                 nameStarts = launcherUrl.lastIndexOf(":");
             }
 
             var nameEnds = launcherUrl.lastIndexOf(".desktop");
 
             if (nameStarts!==-1 && nameEnds!==-1 && nameStarts<nameEnds) {
                 launcherName = launcherUrl.substring(nameStarts+1,nameEnds);
             }
         }
 
         if (parabolicManager.isSeparator(modelLauncherUrl)){
             isSeparator = true;
         } else {
             isSeparator = false;
         }
     }
 
     onModelLauncherUrlWithIconChanged: {
         if (modelLauncherUrlWithIcon !== ""){
             launcherUrlWithIcon = modelLauncherUrlWithIcon;
         }
     }
 
     ////// Audio streams //////
     property Item audioStreamOverlay
     property var audioStreams: []
     readonly property bool hasAudioStream: root.showAudioBadge && audioStreams.length > 0 && !isLauncher
     readonly property bool playingAudio: hasAudioStream && audioStreams.some(function (item) {
         return !item.corked
     })
 
     readonly property bool muted: hasAudioStream && audioStreams.every(function (item) {
         return item.muted
     })
 
     readonly property int volume: {
         if (!hasAudioStream){
             return 0;
         }
 
         var maxVolume = 0;
         for (var i=0; i<audioStreams.length; ++i){
             if (audioStreams[i].volume > maxVolume)
                 maxVolume = audioStreams[i].volume;
         }
 
         return maxVolume;
     }
 
     //////
 
     property QtObject contextMenu: null
     property QtObject draggingResistaner: null
     property QtObject hoveredTimerObj: null
 
     signal groupWindowAdded();
     signal groupWindowRemoved();
     signal checkWindowsStates();
 
     Behavior on opacity {
         // NumberAnimation { duration: (IsStartup || (IsLauncher) ) ? 0 : 400 }
         NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
     }
 
     Loader{
         anchors.fill: parent
         active: latteView && latteView.debugMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.color:  "blue"
             border.width: 1
         }
     }
 
 
     SubWindows{
         id: subWindows
 
         property int previousCount: 0
 
         onWindowsCountChanged: {
             if (root.showWindowsOnlyFromLaunchers && !root.indicatorsEnabled) {
                 return;
             }
 
             if ((windowsCount >= 2) && (windowsCount > previousCount)
                     && !(taskItem.containsMouse || parabolicManager.neighbourIsHovered(itemIndex)) ){
                 if(root.dragSource == null)
                     taskItem.groupWindowAdded();
             }
             else if ((windowsCount >=1) &&(windowsCount < previousCount)){
                 //sometimes this is triggered in dragging with no reason
                 if(root.dragSource == null && !taskItem.delayingRemove)
                     taskItem.groupWindowRemoved();
             }
 
             if (windowsCount>=1) {
                 taskItem.slotPublishGeometries();
             }
 
             //! workaround in order to update correctly the previousCount
             //! windowsCount can not return to zero because is such case
             //! the window task is removed and the launcher is added from
             //! libtaskmanager
             if (windowsCount>=1) {
                 previousCount = windowsCount;
             }
         }
     }
 
     Loader {
         id: isSeparatorRectangle
         active: (opacityN>0)
 
         width: taskItem.width
         height: taskItem.height
         anchors.centerIn: separatorItem
 
         property real opacityN: isSeparator && root.contextMenu && root.contextMenu.visualParent === taskItem ? 1 : 0
 
         Behavior on opacityN {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             opacity: isSeparatorRectangle.opacityN
             radius: 3
 
             property color tempColor: theme.highlightColor
             color: tempColor
             border.width: 1
             border.color: theme.highlightColor
 
             onTempColorChanged: tempColor.a = 0.35;
 
         }
     }
 
     Item{
         id:separatorItem
 
         anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
         anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
         anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
         anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         anchors.bottomMargin: (root.location === PlasmaCore.Types.BottomEdge) ? margin : 0
         anchors.topMargin: (root.location === PlasmaCore.Types.TopEdge) ? margin : 0
         anchors.leftMargin: (root.location === PlasmaCore.Types.LeftEdge) ? margin : 0
         anchors.rightMargin: (root.location === PlasmaCore.Types.RightEdge) ? margin : 0
 
         opacity: (separatorShadow.active) || forceHiddenState ? 0 : 0.4
         visible: taskItem.isSeparator
 
-        width: root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+root.lengthMargins: 1)
-        height: !root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+root.lengthMargins: 1)
+        width: root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+taskItem.metrics.totals.lengthEdges: 1)
+        height: !root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+taskItem.metrics.totals.lengthEdges: 1)
 
         property bool forceHiddenState: false
 
         readonly property int margin: root.screenEdgeMargin + metrics.margin.thickness
 
         Behavior on opacity {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         function updateForceHiddenState() {
             if (!isSeparator || root.editMode || root.dragSource) {
                 forceHiddenState = false;
             } else {
                 var firstPosition = (index>=0) && (index < parabolicManager.firstRealTaskIndex);
                 var sepNeighbour = taskItem.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 && taskItem.containsMouse) {
                     if (root.vertical) {
                         taskItem.mousePosChanged(taskItem.mouseY);
                     } else {
                         taskItem.mousePosChanged(taskItem.mouseX);
                     }
                 }
             }
 
             onGlobalDirectRenderChanged:{
                 if (root.globalDirectRender && restoreAnimation.running) {
                     // console.log("Cleat Task Scale !!!!");
                     restoreAnimation.stop();
                 }
             }
 
             onShowWindowsOnlyFromLaunchersChanged: {
                 if (!root.editMode) {
                     return;
                 }
 
                 taskItem.updateVisibilityBasedOnLaunchers();
             }
 
             onInActivityChangeChanged: {
                 if (root.showWindowsOnlyFromLaunchers && !root.inActivityChange) {
                     taskItem.updateVisibilityBasedOnLaunchers();
                 }
             }
         }
 
         Rectangle {
             anchors.centerIn: parent
 
             width: root.vertical ? taskItem.metrics.iconSize - 4  : 1
             height: !root.vertical ? taskItem.metrics.iconSize - 4 : 1
             color: enforceLattePalette ? latteBridge.palette.textColor : theme.textColor
         }
 
 
     }
 
     ///Shadow in tasks
     Loader{
         id: separatorShadow
         anchors.fill: separatorItem
         active: root.enableShadows && isSeparator && graphicsSystem.isAccelerated
         opacity: separatorItem.forceHiddenState ? 0 : 0.4
 
         Behavior on opacity {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         sourceComponent: DropShadow{
             anchors.fill: parent
             color: root.appShadowColor
             fast: true
             samples: 2 * radius
             source: separatorItem
             radius: root.appShadowSize
             verticalOffset: 2
         }
     }
 
     /* Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
     Flow{
         id: taskFlow
         width: parent.width
         height: parent.height
 
         // a hidden spacer for the first element to add stability
         // IMPORTANT: hidden spacers must be tested on vertical !!!
         HiddenSpacer{ id:hiddenSpacerLeft;}
 
         Item{
             width: wrapper.width
             height: wrapper.height
 
             Indicator.Bridge{
                 id: indicatorBridge
             }
 
             Indicator.Loader{
                 id: indicatorBackLayer
                 level: Indicator.LevelOptions {
                     id: backLevelOptions
                     isBackground: true
                     bridge: indicatorBridge
 
                     Binding {
                         target: taskItem
                         property: "iconOffsetX"
                         value: backLevelOptions.requested.iconOffsetX
                     }
 
                     Binding {
                         target: taskItem
                         property: "iconOffsetY"
                         value: backLevelOptions.requested.iconOffsetY
                     }
                 }
             }
 
             Wrapper{id: wrapper}
 
             Indicator.Loader{
                 id: indicatorFrontLayer
                 level: Indicator.LevelOptions {
                     isForeground: true
                     bridge: indicatorBridge
                 }
             }
         }
 
         // a hidden spacer on the right for the last item to add stability
         HiddenSpacer{ id:hiddenSpacerRight; rightSpacer: true }
     }// Flow with hidden spacers inside   
 
     Component {
         id: taskInitComponent
         Timer {
             id: timer
 
             interval: 800
             repeat: false
 
             onTriggered: {
                 //      taskItem.hoverEnabled = true;
                 slotPublishGeometries();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: taskInitComponentTimer called...");
                 }
 
                 timer.destroy();
             }
 
             Component.onCompleted: timer.start()
         }
     }
 
     ////// Values Changes /////
     //restore scales when there is no zoom factor for that item or
     //the mouse is out of the ListView
     // onItemIndexChanged: {
     //  }
 
     onAppNameChanged: updateAudioStreams()
     onPidChanged: updateAudioStreams()
     onHasAudioStreamChanged: updateAudioStreams()
 
     onCanPublishGeometriesChanged: {
         if (canPublishGeometries) {
             slotPublishGeometries();
             taskInitComponent.createObject(taskItem);
         }
     }
 
     onItemIndexChanged: {
         if (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.inConfigureAppletsMode)){
             root.dragSource = taskItem;
             dragHelper.startDrag(taskItem, model.MimeType, model.MimeData,
                                  model.LauncherUrlWithoutIcon, model.decoration);
             pressX = -1;
             pressY = -1;
         }
     }
 
     onIsMinimizedChanged: {
         checkWindowsStates();
     }
 
     onIsActiveChanged: {
         checkWindowsStates();
         if (isActive) {
             scrollableList.focusOn(taskItem);
         }
     }
 
     onIsForcedHiddenChanged: root.hiddenTasksUpdated();
 
     onIsSeparatorChanged: {
         if (isSeparator) {
             root.separatorsUpdated();
 
             if (tasksExtendedManager.isLauncherToBeMoved(launcherUrl) && itemIndex>=0) {
                 tasksExtendedManager.moveLauncherToCorrectPos(launcherUrl, itemIndex);
             }
         } else {
             root.separatorsUpdated();
         }
     }
 
     onLauncherUrlChanged: updateBadge();
 
     ////// End of Values Changes /////
 
 
     ///////////////// Mouse Area Events ///////////////////
     onEntered: {
         root.stopCheckRestoreZoomTimer();
 
         if (restoreAnimation.running) {
             restoreAnimation.stop();
         }
 
         if (icList.hoveredIndex === -1 && root.dockHoveredIndex ===-1) {
             root.startDirectRenderDelayerDuringEntering();
         }
 
         if ((icList.hoveredIndex !== itemIndex) && isLauncher && windowsPreviewDlg.visible) {
             windowsPreviewDlg.hide(1);
         }
 
         if (!latteView || (latteView && !(latteView.dockIsHidden || latteView.inSlidingIn || latteView.inSlidingOut))){
             icList.hoveredIndex = index;
         }
 
         if (root.latteView && !root.showPreviews && root.titleTooltips){
             showTitleTooltip();
         }
 
         //! show previews if enabled
         if(isAbleToShowPreview && ((root.showPreviews && windowsPreviewDlg.activeItem !== taskItem) || root.highlightWindows)){
             if (hoveredTimerObj) {
                 //! don't delay showing preview in normal states,
                 //! that is when the dock wasn't hidden
                 if (!hoveredTimerObj.running) {
                     hoveredTimerObj.start();
                 }
             } else {
                 if (!root.disableAllWindowsFunctionality) {
                     hoveredTimerObj = hoveredTimerComponent.createObject(taskItem);
                 }
             }
         }
 
         if (root.autoScrollTasksEnabled) {
             scrollableList.autoScrollFor(taskItem);
         }
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
     }
 
     // IMPORTANT: This must be improved ! even for small milliseconds  it reduces performance
     onExited: {
         scalesUpdatedOnce = false;
         isAbleToShowPreview = true;
 
         if (root.latteView && (!root.showPreviews || (root.showPreviews && isLauncher))){
             root.latteView.hideTooltipLabel();
         }
 
         if(taskItem.contextMenu && taskItem.contextMenu.status == PlasmaComponents.DialogStatus.Open){
             ///don't 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 don't delay at all
     //! when mouseX-Y is updated based on the plasmoid formFactor
     function mousePosChanged(mousePos) {
         if (mousePos<0 ||
                 (inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         root.stopCheckRestoreZoomTimer();
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             if (icList.hoveredIndex === -1 && root.dockHoveredIndex ===-1) {
                 root.startDirectRenderDelayerDuringEntering();
             }
 
             if (!latteView || (latteView && !(latteView.dockIsHidden || latteView.inSlidingIn || latteView.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 >= taskItem.animations.hoverPixelSensitivity){
                         icList.currentSpot = mousePos;
 
                         wrapper.calculateScales(mousePos);
                     }
                 }
             }
         }
     }
 
     onMouseXChanged: {
         if (!root.vertical) {
             mousePosChanged(mouseX);
         }
     }
 
     onMouseYChanged: {
         if (root.vertical) {
             mousePosChanged(mouseY);
         }
     }
 
 
 
     onPositionChanged: {
         if ((inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             // mouse.button is always 0 here, hence checking with mouse.buttons
             if (pressX != -1 && mouse.buttons == Qt.LeftButton
                     && isDragged
                     && dragHelper.isDrag(pressX, pressY, mouse.x, mouse.y) ) {
                 root.dragSource = taskItem;
                 dragHelper.startDrag(taskItem, model.MimeType, model.MimeData,
                                      model.LauncherUrlWithoutIcon, model.decoration);
                 pressX = -1;
                 pressY = -1;
             }
         }
     }
 
     onContainsMouseChanged:{
         if(!containsMouse && !inAnimation) {
             pressed=false;
         }
 
         ////disable hover effect///
         if (isWindow && root.highlightWindows && !containsMouse) {
             root.windowsHovered( root.plasma515 ? model.WinIdList : model.LegacyWinIdList , false);
         }
     }
 
     onPressed: {
         //console.log("Pressed Task Delegate..");
         if (LatteCore.WindowSystem.compositingActive && !LatteCore.WindowSystem.isPlatformWayland) {
             if(root.leftClickAction !== LatteTasks.Types.PreviewWindows) {
                 isAbleToShowPreview = false;
                 windowsPreviewDlg.hide(2);
             }
         }
 
         slotPublishGeometries();
 
         var modAccepted = modifierAccepted(mouse);
 
         if ((mouse.button == Qt.LeftButton)||(mouse.button == Qt.MidButton) || modAccepted) {
             lastButtonClicked = mouse.button;
             pressed = true;
             pressX = mouse.x;
             pressY = mouse.y;
 
             if(draggingResistaner == null && !modAccepted)
                 draggingResistaner = resistanerTimerComponent.createObject(taskItem);
         }
         else if (mouse.button == Qt.RightButton && !modAccepted){
             // When we're a launcher, there's no window controls, so we can show all
             // places without the menu getting super huge.
             if (model.IsLauncher === true && !isSeparator) {
                 showContextMenu({showAllPlaces: true})
             } else {
                 showContextMenu();
             }
         }
     }
 
     onReleased: {
         //console.log("Released Task Delegate...");
         if (draggingResistaner != null){
             draggingResistaner.destroy();
             draggingResistaner = null;
         }
 
         if(pressed && (!inBlockingAnimation || inAttentionAnimation) && !isSeparator){
 
             if (modifierAccepted(mouse) && !root.disableAllWindowsFunctionality){
                 if( !taskItem.isLauncher ){
                     if (root.modifierClickAction == LatteTasks.Types.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.modifierClickAction == LatteTasks.Types.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.modifierClickAction == LatteTasks.Types.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.modifierClickAction == LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.modifierClickAction == LatteTasks.Types.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.MidButton && !root.disableAllWindowsFunctionality){
                 if( !taskItem.isLauncher ){
                     if (root.middleClickAction == LatteTasks.Types.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.middleClickAction == LatteTasks.Types.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.middleClickAction == LatteTasks.Types.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.middleClickAction == LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.middleClickAction == LatteTasks.Types.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.LeftButton){
                 if( !taskItem.isLauncher ){
                     if ( (root.leftClickAction === LatteTasks.Types.PreviewWindows && isGroupParent)
                             || ( (LatteCore.WindowSystem.isPlatformWayland || !LatteCore.WindowSystem.compositingActive)
                                 && root.leftClickAction === LatteTasks.Types.PresentWindows
                                 && isGroupParent) ) {
                         if(windowsPreviewDlg.activeItem !== taskItem || !windowsPreviewDlg.visible){
                             showPreviewWindow();
                         } else {
                             root.forcePreviewsHiding(21.1);
                         }
                     } else if ( (root.leftClickAction === LatteTasks.Types.PresentWindows && !(isGroupParent && !LatteCore.WindowSystem.compositingActive))
                                || ((root.leftClickAction === LatteTasks.Types.PreviewWindows && !isGroupParent)) ) {
                         activateTask();
                     } else if (root.leftClickAction === LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     }
                 } else {
                     activateTask();
                 }
             }
 
             backend.cancelHighlightWindows();
         }
 
         pressed = false;
 
         if(!inAnimation) {
             startCheckRestoreZoomTimer(3 * taskItem.animations.duration.large);
         }
     }
 
     onWheel: {
         var wheelActionsEnabled = (root.taskScrollAction !== LatteTasks.Types.ScrollNone || manualScrollTasksEnabled);
 
         if (isSeparator
                 || wheelIsBlocked
                 || !wheelActionsEnabled
                 || inBouncingAnimation
                 || (latteView && (latteView.dockIsHidden || latteView.inSlidingIn || latteView.inSlidingOut))){
 
             return;
         }
 
         var angleVertical = wheel.angleDelta.y / 8;
         var angleHorizontal = wheel.angleDelta.x / 8;
 
         wheelIsBlocked = true;
         scrollDelayer.start();
 
         var verticalDirection = (Math.abs(angleVertical) > Math.abs(angleHorizontal));
         var mainAngle = verticalDirection ? angleVertical : angleHorizontal;
 
         var positiveDirection = (mainAngle > 12);
         var negativeDirection = (mainAngle < -12);
 
         var parallelScrolling = (verticalDirection && plasmoid.formFactor === PlasmaCore.Types.Vertical)
                 || (!verticalDirection && plasmoid.formFactor === PlasmaCore.Types.Horizontal);
 
         if (positiveDirection) {
             slotPublishGeometries();
 
             var overflowScrollingAccepted = (root.manualScrollTasksEnabled
                                              && scrollableList.contentsExceed
                                              && (root.manualScrollTasksType === LatteTasks.Types.ManualScrollVerticalHorizontal
                                                  || (root.manualScrollTasksType === LatteTasks.Types.ManualScrollOnlyParallel && parallelScrolling)) );
 
 
             if (overflowScrollingAccepted) {
                 scrollableList.increasePos();
             } else {
                 if (isLauncher || root.disableAllWindowsFunctionality) {
                     wrapper.runLauncherAnimation();
                 } else if (isGroupParent) {
                     subWindows.activateNextTask();
                 } else {
                     var taskIndex = modelIndex();
 
                     if (isMinimized) {
                         tasksModel.requestToggleMinimized(taskIndex);
                     }
 
                     tasksModel.requestActivate(taskIndex);
                 }
 
                // hidePreviewWindow();
             }
         } else if (negativeDirection) {
             slotPublishGeometries();
 
             var overflowScrollingAccepted = (root.manualScrollTasksEnabled
                                              && scrollableList.contentsExceed
                                              && (root.manualScrollTasksType === LatteTasks.Types.ManualScrollVerticalHorizontal
                                                  || (root.manualScrollTasksType === LatteTasks.Types.ManualScrollOnlyParallel && parallelScrolling)) );
 
 
             if (overflowScrollingAccepted) {
                 scrollableList.decreasePos();
             } else {
                 if (isLauncher || root.disableAllWindowsFunctionality) {
                     // do nothing
                 } else if (isGroupParent) {
                     if (root.taskScrollAction === LatteTasks.Types.ScrollToggleMinimized) {
                         subWindows.minimizeTask();
                     } else {
                         subWindows.activatePreviousTask();
                     }
                 } else {
                     var taskIndex = modelIndex();
 
                     var hidingTask = (!isMinimized && root.taskScrollAction === LatteTasks.Types.ScrollToggleMinimized);
 
                     if (isMinimized || hidingTask) {
                         tasksModel.requestToggleMinimized(taskIndex);
                     }
 
                     if (!hidingTask) {
                         tasksModel.requestActivate(taskIndex);
                     }
                 }
 
                // hidePreviewWindow();
             }
         }
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
 
         interval: 400
 
         onTriggered: taskItem.wheelIsBlocked = false;
     }
 
     ///////////////// End Of Mouse Area Events ///////////////////
 
     ///// Handlers for Signals /////
     function animationStarted(){
         //    console.log("Animation started: " + index);
         inAnimation = true;
     }
 
     function animationEnded(){
         //   console.log("Animation ended: " + index);
         inAnimation = false;
     }
 
     function clearZoom(){
         if(!root)
             return;
 
         if (root.hoveredIndex === -1 && root.dockHoveredIndex === -1) {
             restoreAnimation.start();
         }
     }
 
     function handlerDraggingFinished(){
         isDragged = false;
     }
     ///// End of Handlers //////
 
 
 
     ///// Helper functions /////
     function activateNextTask() {
         subWindows.activateNextTask();
     }
 
     function activateTask() {
         if( taskItem.isLauncher || root.disableAllWindowsFunctionality){
             if (LatteCore.WindowSystem.compositingActive) {
                 wrapper.runLauncherAnimation();
             } else {
                 launcherAction();
             }
         }
         else{
             if (model.IsGroupParent) {
                 if (LatteCore.WindowSystem.compositingActive && backend.canPresentWindows()) {
                     root.presentWindows(root.plasma515 ? model.WinIdList: model.LegacyWinIdList );
                 }
             } else {
                 if (isMinimized) {
                     var i = modelIndex();
                     tasksModel.requestToggleMinimized(i);
                     tasksModel.requestActivate(i);
                 } else if (isActive) {
                     tasksModel.requestToggleMinimized(modelIndex());
                 } else {
                     tasksModel.requestActivate(modelIndex());
                 }
             }
         }
     }
 
     function 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 showPreviewWindow() {
         if (root.disableAllWindowsFunctionality || !isAbleToShowPreview) {
             return;
         }
 
         if(windowsPreviewDlg.activeItem !== taskItem){
             if (!root.latteView
                     || (root.latteView && !root.latteView.isHalfShown && !root.latteView.inSlidingIn && !root.latteView.inSlidingOut)) {
                 if (root.latteView && root.titleTooltips) {
                     root.latteView.hideTooltipLabel();
                 }
 
                 taskItem.preparePreviewWindow(false);
                 windowsPreviewDlg.show(taskItem);
             }
         }
     }
 
     function showTitleTooltip() {
         if (root.latteView && root.titleTooltips){
             var displayText = isWindow ? model.display : model.AppName;
             var maxCharacters = 80;
 
             var fixedDisplayText = displayText.length>maxCharacters ? displayText.substring(0,maxCharacters-1) + "..." : displayText;
 
             root.latteView.showTooltipLabel(taskItem, fixedDisplayText);
         }
     }
 
     function hidePreviewWindow() {
         if(windowsPreviewDlg.activeItem === taskItem){
             windowsPreviewDlg.hide("14.1");
 
             if (root.latteView && root.titleTooltips && containsMouse) {
                 showTitleTooltip();
             }
         }
     }
 
     function preparePreviewWindow(hideClose){
         windowsPreviewDlg.visualParent = previewsVisualParent;
 
         toolTipDelegate.parentTask = taskItem;
 
         //! WORKAROUND, in order for toolTipDelegate to re-instantiate the previews model when
         //! previews are changing from single instance preview to another single instance
         toolTipDelegate.rootIndex = undefined;
         toolTipDelegate.rootIndex = tasksModel.makeModelIndex(itemIndex, -1);
 
         toolTipDelegate.hideCloseButtons = hideClose;
 
         toolTipDelegate.appName = Qt.binding(function() {
             return model.AppName;
         });
 
         if (!isLauncher) {
             toolTipDelegate.pidParent = Qt.binding(function() {
                 return model.AppPid;
             });
         } else {
             toolTipDelegate.pidParent = -1;
         }
 
         toolTipDelegate.windows = Qt.binding(function() {
             return root.plasma515 ? model.WinIdList : model.LegacyWinIdList ;
         });
         toolTipDelegate.isGroup = Qt.binding(function() {
             return model.IsGroupParent == true;
         });
         toolTipDelegate.icon = Qt.binding(function() {
             return model.decoration;
         });
         toolTipDelegate.launcherUrl = Qt.binding(function() {
             return model.LauncherUrlWithoutIcon;
         });
         toolTipDelegate.isLauncher = Qt.binding(function() {
             return model.IsLauncher == true;
         });
         toolTipDelegate.isMinimizedParent = Qt.binding(function() {
             return model.IsMinimized == true;
         });
         toolTipDelegate.displayParent = Qt.binding(function() {
             return model.display;
         });
         toolTipDelegate.genericName = Qt.binding(function() {
             return model.GenericName;
         });
         toolTipDelegate.virtualDesktopParent = Qt.binding(function() {
             return (model.VirtualDesktops !== undefined && model.VirtualDesktops.length > 0) ? model.VirtualDesktops : [0];
         });
         toolTipDelegate.isOnAllVirtualDesktopsParent = Qt.binding(function() {
             return model.IsOnAllVirtualDesktops == true;
         });
         toolTipDelegate.activitiesParent = Qt.binding(function() {
             return model.Activities;
         });
     }
 
 
     function launcherAction(){
         // if ((lastButtonClicked == Qt.LeftButton)||(lastButtonClicked == Qt.MidButton)){
         if (LatteCore.WindowSystem.compositingActive) {
             inBouncingAnimation = true;
             tasksExtendedManager.addWaitingLauncher(taskItem.launcherUrl);
         }
 
         if (root.disableAllWindowsFunctionality) {
             tasksModel.requestNewInstance(modelIndex());
         } else {
             tasksModel.requestActivate(modelIndex());
         }
     }
 
     ///window previews///
     function generateSubText(task) {
         var subTextEntries = new Array();
 
         if (!plasmoid.configuration.showOnlyCurrentDesktop
                 && virtualDesktopInfo.numberOfDesktops > 1
                 && model.IsOnAllVirtualDesktops !== true
                 && model.VirtualDesktop != -1
                 && model.VirtualDesktop != undefined) {
             subTextEntries.push(i18n("On %1", virtualDesktopInfo.desktopNames[model.VirtualDesktop - 1]));
         }
 
         if (model.Activities == undefined) {
             return subTextEntries.join("\n");
         }
 
         if (model.Activities.length == 0 && activityInfo.numberOfRunningActivities > 1) {
             subTextEntries.push(i18nc("Which virtual desktop a window is currently on",
                                       "Available on all activities"));
         } else if (model.Activities.length > 0) {
             var activityNames = new Array();
 
             for (var i = 0; i < model.Activities.length; i++) {
                 var activity = model.Activities[i];
 
                 if (plasmoid.configuration.showOnlyCurrentActivity) {
                     if (activity != activityInfo.currentActivity) {
                         activityNames.push(activityInfo.activityName(model.Activities[i]));
                     }
                 } else if (activity != activityInfo.currentActivity) {
                     activityNames.push(activityInfo.activityName(model.Activities[i]));
                 }
             }
 
             if (plasmoid.configuration.showOnlyCurrentActivity) {
                 if (activityNames.length > 0) {
                     subTextEntries.push(i18nc("Activities a window is currently on (apart from the current one)",
                                               "Also available on %1", activityNames.join(", ")));
                 }
             } else if (activityNames.length > 0) {
                 subTextEntries.push(i18nc("Which activities a window is currently on",
                                           "Available on %1", activityNames.join(", ")));
             }
         }
 
         return subTextEntries.join("\n");
     }
     ///window previews////
 
     function modelIndex(){
         return tasksModel.makeModelIndex(index);
     }
 
     function showContextMenu(args) {
         if (isSeparator && !root.editMode)
             return;
 
         if (!root.contextMenu) {
             contextMenu = root.createContextMenu(taskItem, modelIndex(), args);
             contextMenu.show();
         } else {
             //! make sure that context menu isnt deleted multiple times and creates a crash
             //! bug case: 397635
             var cMenu = root.contextMenu;
             root.contextMenu = null;
             cMenu.destroy();
         }
     }
 
     function modifierAccepted(mouse){
         if (mouse.modifiers & root.modifierQt){
             if ((mouse.button === Qt.LeftButton && root.modifierClick === LatteTasks.Types.LeftClick)
                     || (mouse.button === Qt.MiddleButton && root.modifierClick === LatteTasks.Types.MiddleClick)
                     || (mouse.button === Qt.RightButton && root.modifierClick === LatteTasks.Types.RightClick))
                 return true;
         }
 
         return false;
     }
 
     function setBlockingAnimation(value){
         inBlockingAnimation = value;
     }
 
     function slotMimicEnterForParabolic(){
         if (containsMouse) {
             if (inMimicParabolicAnimation) {
                 mimicParabolicScale = root.zoomFactor;
             }
 
             wrapper.calculateScales(icList.currentSpot);
         }
     }
 
     function slotShowPreviewForTasks(group) {
         if (group === taskItem && !windowsPreviewDlg.visible) {
             preparePreviewWindow(true);
             windowsPreviewDlg.show(taskItem);
         }
     }
 
     function slotPublishGeometries() {
         //! this way we make sure that layouts that are in different activities that the current layout
         //! don't publish their geometries
         if ( canPublishGeometries && (!latteView || root.viewLayoutIsCurrent)) {
             var globalChoords = backend.globalRect(wrapper.visualIconItem);
             var limits = backend.globalRect(scrollableList);
 
             //! Limit the published geometries boundaries at scrolling area boundaries
             var adjX = Math.min(limits.x+limits.width, Math.max(limits.x, globalChoords.x));
             var adjY = Math.min(limits.y+limits.height, Math.max(limits.y, globalChoords.y));
 
             var length = taskItem.metrics.iconSize * wrapper.mScale;
             var thickness = length;
 
             //! Magic Lamp effect doesn't like coordinates outside the screen and
             //! width,heights of zero value... So we now normalize the geometries
             //! sent in order to avoid such circumstances
             if (root.vertical) {
                 if (adjY !== globalChoords.y) {
                     if (((globalChoords.y+globalChoords.height) < limits.y) || (globalChoords.y)>(limits.y+limits.height)) {
                         //! totally out of boundaries
                         length = 4;
                     } else {
                         //! semi-part out of boundaries
                         length = Math.max(4, Math.abs(adjY - globalChoords.y));
                     }
 
                     globalChoords.height = length;
                 }
             } else {
                 if (adjX !== globalChoords.x) {
                     if (((globalChoords.x+globalChoords.width) < limits.x) || (globalChoords.x)>(limits.x+limits.width)) {
                         //! totally out of boundaries
                         length = 4;
                     } else {
                         //! semi-part out of boundaries
                         length = Math.max(4, Math.abs(adjX - globalChoords.x));
                     }
 
                     globalChoords.width = length;
                 }                
             }
 
             globalChoords.x = adjX;
             globalChoords.y = adjY;
 
             if (latteView && latteView.dockIsHidden) {
                 if (root.location === PlasmaCore.Types.BottomEdge) {
                     globalChoords.y = root.screenGeometry.y+root.screenGeometry.height-1;
                     globalChoords.height = 1;
                 } else if (root.location === PlasmaCore.Types.TopEdge) {
                     globalChoords.y = root.screenGeometry.y+1;
                     globalChoords.height = 1;
                 } else if (root.location === PlasmaCore.Types.LeftEdge) {
                     globalChoords.x = root.screenGeometry.x+1;
                     globalChoords.width = 1;
                 } else if (root.location === PlasmaCore.Types.RightEdge) {
                     globalChoords.x = root.screenGeometry.x+root.screenGeometry.width - 1;
                     globalChoords.width = 1;
                 }
             }
 
             tasksModel.requestPublishDelegateGeometry(taskItem.modelIndex(), globalChoords, taskItem);
         }
     }
 
     function slotWaitingLauncherRemoved(launch) {
         if ((isWindow || isStartup || isLauncher) && !visible && launch === launcherUrl) {
             wrapper.mScale = 1;
             visible = true;
         }
     }
 
 
     function updateAudioStreams() {
         if (root.dragSource !== null) {
             audioStreams = [];
             return;
         }
 
         var pa = pulseAudio.item;
         if (!pa) {
             audioStreams = [];
             return;
         }
 
         var streams = pa.streamsForPid(taskItem.pid);
         if (streams.length) {
             pa.registerPidMatch(taskItem.appName);
         } else {
             // We only want to fall back to appName matching if we never managed to map
             // a PID to an audio stream window. Otherwise if you have two instances of
             // an application, one playing and the other not, it will look up appName
             // for the non-playing instance and erroneously show an indicator on both.
             if (!pa.hasPidMatch(taskItem.appName)) {
                 var streams_result;
                 streams_result = pa.streamsForAppName(taskItem.appName);
                 if (streams_result.length===0 && launcherName !== "") {
                     streams_result = pa.streamsForAppName(launcherName);
                 }
                 streams = streams_result;
             }
         }
 
         // fix a binding loop concerning audiostreams, the audiostreams
         // should be updated only when they have changed
         var changed = false;
 
         if (streams.length !== audioStreams.length) {
             changed = true;
         } else {
             for(var i=0; i<streams.length; ++i) {
                 if (streams[i] !== audioStreams[i]) {
                     changed = true;
                     break;
                 }
             }
         }
 
         if (changed) {
             taskItem.audioStreams = streams;
         }
     }
 
     function slotLaunchersChangedFor(launcher) {
         if (root.showWindowsOnlyFromLaunchers && launcher === launcherUrl) {
             updateVisibilityBasedOnLaunchers()
         }
     }
 
     function updateVisibilityBasedOnLaunchers(){
         var launcherExists = !(((tasksModel.launcherPosition(taskItem.launcherUrl) == -1)
                                 && (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) == -1) )
                                || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl));
 
         if (root.showWindowsOnlyFromLaunchers) {
             var hideWindow =  !launcherExists && taskItem.isWindow;
 
             if (hideWindow) {
                 isForcedHidden = true;
                 taskRealRemovalAnimation.start();
             } else if (launcherExists && taskItem.isWindow && !taskItem.isVisible) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         } else {
             var showWindow =  !launcherExists && taskItem.isWindow;
 
             if (showWindow) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         }
     }
 
     function toggleMuted() {
         if (muted) {
             taskItem.audioStreams.forEach(function (item) { item.unmute(); });
         } else {
             taskItem.audioStreams.forEach(function (item) { item.mute(); });
         }
     }
 
     function increaseVolume() {
         taskItem.audioStreams.forEach(function (item) { item.increaseVolume(); });
     }
 
     function decreaseVolume() {
         taskItem.audioStreams.forEach(function (item) { item.decreaseVolume(); });
     }
 
     function updateBadge() {
         var badger = root.getBadger(launcherUrl);
 
         if (badger) {
             badgeIndicator = parseInt(badger.value);
         } else {
             badgeIndicator = 0;
         }
     }
 
     Connections {
         target: pulseAudio.item
         ignoreUnknownSignals: true // Plasma-PA might not be available
         onStreamsChanged: taskItem.updateAudioStreams()
     }
 
     Connections {
         target: root
         //trying to fix #440, showing the audio icon indicator to irrelevant tasks
         //after dragging an existent task with audio
         onDragSourceChanged: taskItem.updateAudioStreams()
         onShowAudioBadgeChanged: taskItem.updateAudioStreams()
     }
 
     Connections {
         target: root
         onHoveredIndexChanged: {
             if ((restoreAnimation.running) && (root.hoveredIndex !== -1)) {
                 restoreAnimation.stop();
             }
         }
 
         onDockHoveredIndexChanged: {
             if ((restoreAnimation.running) && (root.dockHoveredIndex !== -1)) {
                 restoreAnimation.stop();
             }
         }
     }
 
     Connections {
         target: scrollableList
         onAnimationsFinishedChanged: {
             if (scrollableList.animationsFinished) {
                 taskItem.slotPublishGeometries();
             }
         }
     }
 
     Connections {
         target: latteView
         onDockIsHiddenChanged: {
             if (dockIsHidden) {
                 taskItem.slotPublishGeometries();
             }
         }
 
         onDockIsShownCompletelyChanged: {
             if (dockIsShownCompletely) {
                 taskItem.slotPublishGeometries();
             }
         }
     }
 
 
     ///// 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(taskItem.launcherUrl) !== -1)
                                 || (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) !== -1) );
 
         //startup without launcher
         var hideStartup =  ((!hasShownLauncher || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl))
                             && taskItem.isStartup);
 
         if (!LatteCore.WindowSystem.compositingActive) {
             visible = true;
         } else if ( (isWindow || isStartup || isLauncher) && tasksExtendedManager.waitingLauncherExists(launcherUrl)) {
             tasksExtendedManager.waitingLauncherRemoved.connect(slotWaitingLauncherRemoved);
             visible = false;
         } else if (hideStartup){
             visible = false;
         } else {
             visible = true;
         }
 
         showWindowAnimation.showWindow();
         updateAudioStreams();
     }
 
     Component.onDestruction: {
         root.draggingFinished.disconnect(handlerDraggingFinished);
         root.clearZoomSignal.disconnect(clearZoom);
         root.publishTasksGeometries.disconnect(slotPublishGeometries);
         root.showPreviewForTasks.disconnect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.disconnect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.disconnect(slotLaunchersChangedFor);
 
         tasksExtendedManager.waitingLauncherRemoved.disconnect(slotWaitingLauncherRemoved);
 
         wrapper.sendEndOfNeedBothAxisAnimation();
     }
 
     /////Animations
 
     TaskAnimations.ShowWindowAnimation{ id: showWindowAnimation }
 
     TaskAnimations.RestoreAnimation{ id: restoreAnimation }
 
     //A Timer to check how much time the task is hovered in order to check if we must
     //show window previews
     Component {
         id: hoveredTimerComponent
         Timer {
             id: hoveredTimer
 
             interval: Math.max(150,plasmoid.configuration.previewsDelay)
 
             repeat: false
 
             onTriggered: {
                 if (root.disableAllWindowsFunctionality || !isAbleToShowPreview) {
                     return;
                 }
 
                 if (taskItem.containsMouse) {
                     if (root.showPreviews) {
                         showPreviewWindow();
                     }
 
                     if (taskItem.isWindow && root.highlightWindows) {
                         root.windowsHovered( root.plasma515 ? model.WinIdList : model.LegacyWinIdList , taskItem.containsMouse);
                     }
                 }
 
                 hoveredTimer.destroy();
             }
 
             Component.onCompleted: hoveredTimer.start()
         }
     }
 
 
     //A Timer to help in resist a bit to dragging, the user must try
     //to press a little first before dragging Started
     Component {
         id: resistanerTimerComponent
         Timer {
             id: resistanerTimer
             interval: taskItem.resistanceDelay
             repeat: false
 
             onTriggered: {
                 if (!taskItem.inBlockingAnimation){
                     taskItem.isDragged = true;
                 }
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: resistanerTimer called...");
                 }
 
                 resistanerTimer.destroy();
             }
 
             Component.onCompleted: resistanerTimer.start()
         }
     }
 
     ///trying to compete with the crazy situation in the tasksModel
     ///with launchers and startups... There are windows that stay
     ///startup mode e.g. chrome, libreoffice... not showing startups
     ///the user can lose windows...
     ///Based on the animations, windows are shown directly, startups
     ///are shown after 5secs of existence, and launchers after 200ms
     ///for launchers this is set in order to give to a window the time
     ///to disappear and then show the launcher...
 
 
     //   property int mainDelay: IsLauncher ? 800 : 400
     //   property int mainDelay: icList.delayingRemoval ? 2*showWindowAnimation.speed : 450
 
     //BE CAREFUL: this interval (e.g. 700ms) must be lower from the removal animation
     //duration e.g.(800ms) because there are situations that because of this some
     //launchers delay A LOT to reappear, e.g google-chrome
     //I will blacklist google-chrome as I have not found any other case for this bug
     //to appear, but even this way there are cases that still appears...
     property int mainDelay: (AppId == "google-chrome") ? 0 : 2 * taskItem.animations.speedFactor.current * showWindowAnimation.speed
     property int windowDelay: taskItem.isStartup ? 3 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large : mainDelay
 
     Component {
         id: delayShowWindow
         Timer {
             id: timerWindow
 
             interval: windowDelay
 
             repeat: false
 
             onTriggered: {
                 //console.log("I am in here: "+taskItem.windowDelay);
                 // showWindowAnimation.execute();
                 if(!taskItem.buffersAreReady)
                     showWindowAnimation.showWindow();
                 else
                     showWindowAnimation.execute();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: timerWindow called...");
                 }
 
                 timerWindow.destroy();
             }
 
             Component.onCompleted: timerWindow.start()
         }
     }
 
     // when changing activities and desktops the index of the tasks
     // is updated immediately to -1, this timer protects this indexing
     // change in order to provide a beautiful removal tasks animation
     Timer {
         id: lastValidTimer
         interval: 100 ///the interval does not follow the animations timing
         repeat: false
 
         onTriggered: {
             if (taskItem.itemIndex >= 0){
                 taskItem.lastValidIndex = taskItem.itemIndex;
 
                 if (root.showWindowsOnlyFromLaunchers) {
                     parabolicManager.updateTasksEdgesIndexes();
                 }
             }
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: lastValidTimer called...");
             }
         }
     }
 
     ///Item's Removal Animation
     ListView.onRemove: TaskAnimations.RealRemovalAnimation{ id: taskRealRemovalAnimation }
 
 }// main Item
 
diff --git a/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml b/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml
index 74f12158..523b4af4 100644
--- a/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml
+++ b/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml
@@ -1,203 +1,203 @@
 /*
 *  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.latte.core 0.2 as LatteCore
 
 SequentialAnimation {
     id: taskRealRemovalAnimation
     PropertyAction { target: taskItem; property: "ListView.delayRemove"; value: true }
     PropertyAction { target: taskItem; property: "inAnimation"; value: true }
     PropertyAction { target: taskItem; property: "inAddRemoveAnimation"; value: true }
     PropertyAction { target: taskItem; property: "inRemoveStage"; value: true }
 
     //Animation Add/Remove (1) - when is window with no launcher, animations enabled
     //Animation Add/Remove (4) - the user removes a launcher, animation enabled
     property bool animation1: ((((tasksModel.launcherPosition(taskItem.launcherUrl) === -1)
                                  && (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) === -1) )
                                 || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl))
                                && !taskItem.isStartup && LatteCore.WindowSystem.compositingActive)
 
     property bool animation4: ((taskItem.launcherUrl===root.launcherForRemoval
                                 || taskItem.launcherUrlWithIcon===root.launcherForRemoval )
                                && !taskItem.isStartup && LatteCore.WindowSystem.compositingActive)
 
     property bool enabledAnimation: (animation1 || animation4) && (taskItem.animations.newWindowSlidingEnabled)
                                     && !taskItem.inBouncingAnimation
                                     && !taskItem.isSeparator
                                     && taskItem.visible;
 
     readonly property string needLengthEvent: taskRealRemovalAnimation + "_realremoval"
 
     ScriptAction{
         script:{
             //! When a window is removed and afterwards its launcher must be shown immediately!
             if (!enabledAnimation && taskItem.isWindow && !taskItem.isSeparator
                     && tasksModel.launcherPosition(taskItem.launcherUrl) !== -1
                     && !tasksExtendedManager.immediateLauncherExists(taskItem.launcherUrl)){
                 tasksExtendedManager.addImmediateLauncher(taskItem.launcherUrl);
             }
 
             //trying to fix the ListView nasty behavior
             //during the removal the anchoring for ListView children changes a lot
             var previousTask = icList.childAtIndex(taskItem.lastValidIndex-1);
 
             if (previousTask !== undefined && !previousTask.isStartup && !previousTask.inBouncingAnimation){
                 //! When removing a task and there are surrounding separators then the hidden spacers
                 //! are updated immediately for the neighbour tasks. In such case in order to not break
                 //! the removal animation a small margin must applied
                 var nextTaskIsSeparator = (lastValidIndex !== -1) && enabledAnimation &&
                         ((taskItem.hasNeighbourSeparator(lastValidIndex+1,true) && !taskItem.isSeparator && lastValidIndex<parabolicManager.lastRealTaskIndex)
                          || (latteView && latteView.parabolicManager.isSeparator(latteView.latteAppletPos+1) && lastValidIndex>parabolicManager.lastRealTaskIndex));
 
                 var previousTaskIsSeparator = (lastValidIndex !== -1) && enabledAnimation &&
                         ((taskItem.hasNeighbourSeparator(lastValidIndex-1,false) && !taskItem.isSeparator && lastValidIndex>parabolicManager.firstRealTaskIndex)
                          || (latteView && latteView.parabolicManager.isSeparator(latteView.latteAppletPos-1) && lastValidIndex<=parabolicManager.firstRealTaskIndex));
 
-                var spacer = nextTaskIsSeparator ? -(2+root.lengthMargin) : ( previousTaskIsSeparator ? (2+root.lengthMargin)/2 : 0);
+                var spacer = nextTaskIsSeparator ? -(2+taskItem.metrics.totals.lengthEdge) : ( previousTaskIsSeparator ? (2+taskItem.metrics.totals.lengthEdge)/2 : 0);
 
                 //console.log("EDGES ::: " + parabolicManager.firstRealTaskIndex + " _ " + parabolicManager.lastRealTaskIndex);
                 //console.log("Removing ::: " + lastValidIndex + " _ " + launcherUrl + " _ " + previousTaskIsSeparator + " _ " + nextTaskIsSeparator);
 
                 if (root.vertical) {
                     taskItem.anchors.top = previousTask.bottom;
                     taskItem.anchors.topMargin = spacer;
                 } else {
                     taskItem.anchors.left = previousTask.right;
                     taskItem.anchors.leftMargin = spacer;
                 }
             }
 
             // console.log("1." + taskItem.launcherUrl + " - " + taskRealRemovalAnimation.enabledAnimation);
             // console.log("2." + root.launcherForRemoval + " - " + taskItem.isLauncher);
 
             taskItem.animations.needLength.addEvent(needLengthEvent);
 
             if (wrapper.mScale > 1 && !taskRealRemovalAnimation.enabledAnimation
                     && !taskItem.inBouncingAnimation && LatteCore.WindowSystem.compositingActive) {
                 tasksExtendedManager.setFrozenTask(taskItem.launcherUrl, wrapper.mScale);
             }
         }
     }
 
     //Ghost animation that acts as a delayer in case there is a bouncing animation
     //taking place
     PropertyAnimation {
         target: wrapper
         property: "opacity"
         to: 1
 
         //this duration must be a bit less than the bouncing animation. Otherwise the
         //smooth transition between removals is breaking
         duration:  taskItem.inBouncingAnimation  && !taskItem.isSeparator? 4*launcherSpeedStep + 50 : 0
         easing.type: Easing.InQuad
 
         property int launcherSpeedStep: 0.8 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large
     }
     //end of ghost animation
 
     PropertyAnimation {
         target: wrapper
         property: "mScale"
         to: 1
         duration:  taskRealRemovalAnimation.enabledAnimation ? showWindowAnimation.speed : 0
         easing.type: Easing.InQuad
     }
 
     //PropertyAction { target: wrapper; property: "opacity"; value: isWindow ? 0 : 1 }
     //animation mainly for launchers removal and startups
     ParallelAnimation{
         id: removalAnimation
 
         // property int speed: (IsStartup && !taskItem.visible)? 0 : 400
         //property int speed: 400
         NumberAnimation {
             target: wrapper;
             property: "opacity";
             to: 0;
             duration: taskRealRemovalAnimation.enabledAnimation ? 1.35*showWindowAnimation.speed : 0
             easing.type: Easing.InQuad
         }
 
         PropertyAnimation {
             target: wrapper
             property: (icList.orientation === Qt.Vertical) ? "tempScaleWidth" : "tempScaleHeight"
             to: 0
             duration:  taskRealRemovalAnimation.enabledAnimation ? 1.35*showWindowAnimation.speed : 0
             easing.type: Easing.InQuad
         }
     }
 
     //smooth move into place the surrounding tasks
     PropertyAnimation {
         target: wrapper
         property: (icList.orientation === Qt.Vertical) ? "tempScaleHeight" : "tempScaleWidth"
         to: 0
         duration:  taskRealRemovalAnimation.enabledAnimation ? 1.35*showWindowAnimation.speed : 0
         easing.type: Easing.InQuad
     }
 
     ScriptAction{
         script:{
             if (showWindowAnimation.animationSent){
                 //console.log("SAFETY REMOVAL 1: animation removing ended");
                 showWindowAnimation.animationSent = false;
                 taskItem.animations.needLength.removeEvent(showWindowAnimation.needLengthEvent);
             }
 
             taskItem.animations.needLength.removeEvent(needLengthEvent);
 
             if(taskItem.launcherUrl===root.launcherForRemoval && taskItem.isLauncher)
                 root.launcherForRemoval="";
 
             if (windowsPreviewDlg.visible && windowsPreviewDlg.mainItem.parentTask === taskItem
                     && isWindow && !isGroupParent){
                 hidePreview();
             }
 
             if (root.showWindowsOnlyFromLaunchers) {
                 if (root.vertical) {
                     taskItem.anchors.top = undefined;
                     taskItem.anchors.topMargin = 0;
                 } else {
                     taskItem.anchors.left = undefined;
                     taskItem.anchors.leftMargin = 0;
                 }
             }
 
             taskItem.visible = false;
 
             //send signal that the launcher is really removing
             if (taskItem.inBouncingAnimation) {
                 tasksExtendedManager.removeWaitingLauncher(taskItem.launcherUrl);
                 root.setGlobalDirectRender(false);
             }
         }
     }
 
     PropertyAction { target: taskItem; property: "inAnimation"; value: false }
     PropertyAction { target: taskItem; property: "inAddRemoveAnimation"; value: false }
     PropertyAction { target: taskItem; property: "inRemoveStage"; value: false }
 
     PropertyAction { target: taskItem; property: "ListView.delayRemove"; value: false }
 }
diff --git a/plasmoid/package/contents/ui/task/indicator/Loader.qml b/plasmoid/package/contents/ui/task/indicator/Loader.qml
index b2d4cb95..199b4d44 100644
--- a/plasmoid/package/contents/ui/task/indicator/Loader.qml
+++ b/plasmoid/package/contents/ui/task/indicator/Loader.qml
@@ -1,82 +1,82 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 Loader {
     id: indicatorLoader
     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
     anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
     anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
     active: level.bridge && level.bridge.active && (level.isBackground || (level.isForeground && indicators.info.providesFrontLayer))
     sourceComponent: {
         if (!indicators) {
             return;
         }
         return indicators.indicatorComponent;
     }
 
     width: {
         if (locked) {
             return visualLockedWidth;
         }
 
-        return !root.vertical ? taskItem.wrapperAlias.width - 2*taskItem.wrapperAlias.mScale*root.lengthExtMargin : taskItem.wrapperAlias.width;
+        return !root.vertical ? taskItem.wrapperAlias.width - 2*taskItem.wrapperAlias.mScale*taskItem.metrics.margin.length: taskItem.wrapperAlias.width;
     }
 
     height: {
         if (locked) {
             return visualLockedHeight;
         }
 
-        return root.vertical ? taskItem.wrapperAlias.height - 2*taskItem.wrapperAlias.mScale*root.lengthExtMargin : taskItem.wrapperAlias.height;
+        return root.vertical ? taskItem.wrapperAlias.height - 2*taskItem.wrapperAlias.mScale*taskItem.metrics.margin.length : taskItem.wrapperAlias.height;
     }
 
     readonly property bool locked: inAttentionAnimation || inNewWindowAnimation || inBouncingAnimation
 
     property real visualLockedWidth: root.vertical ? root.screenEdgeMargin + taskItem.metrics.iconSize + root.internalWidthMargins :
                                                      taskItem.metrics.iconSize + root.internalWidthMargins
     property real visualLockedHeight: !root.vertical ? root.screenEdgeMargin + taskItem.metrics.iconSize + root.internalHeightMargins :
                                                        taskItem.metrics.iconSize + root.internalHeightMargins
 
     //! Connections !//
 
     property Item level
 
     Connections {
         target: taskItem
         enabled: indicators ? indicators.info.needsMouseEventCoordinates : false
         onPressed: {
             var fixedPos = indicatorLoader.mapFromItem(taskItem, mouse.x, mouse.y);
             level.mousePressed(Math.round(fixedPos.x), Math.round(fixedPos.y), mouse.button);
         }
         onReleased: {
             var fixedPos = indicatorLoader.mapFromItem(taskItem, mouse.x, mouse.y);
             level.mousePressed(Math.round(fixedPos.x), Math.round(fixedPos.y), mouse.button);
         }
     }
 }
diff --git a/plasmoid/package/contents/ui/taskslayout/ScrollableList.qml b/plasmoid/package/contents/ui/taskslayout/ScrollableList.qml
index 54c81641..75b94ada 100644
--- a/plasmoid/package/contents/ui/taskslayout/ScrollableList.qml
+++ b/plasmoid/package/contents/ui/taskslayout/ScrollableList.qml
@@ -1,402 +1,402 @@
 /*
  * Copyright 2019 Michail Vourlakos <mvourlakos@gmail.com>
  *
  * This program 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.
  *
  * 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 General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 import QtQuick 2.7
 import QtQuick.Controls 1.4
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 import org.kde.latte.core 0.2 as LatteCore
 
 Flickable{
     id: flickableContainer
     clip: false
     flickableDirection: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? Flickable.HorizontalFlick : Flickable.VerticalFlick
     interactive: false
 
     property int offset: 0
 
     readonly property bool animationsFinished: !horizontalAnimation.running && !verticalAnimation.running
     readonly property bool centered: root.alignment === LatteCore.Types.Center
     readonly property bool reversed: Qt.application.layoutDirection === Qt.RightToLeft
 
     readonly property bool contentsExceed:  {
         if (root.scrollingEnabled) {
             return (!root.vertical ? Math.floor(contentWidth) > width : Math.floor(contentHeight) > height);
         }
 
         return false;
     }
     readonly property int contentsExtraSpace: {
         if (contentsExceed) {
             if (!root.vertical) {
                 return contentWidth - width;
             } else {
                 return contentHeight - height;
             }
         }
 
         return 0;
     }
 
     readonly property int scrollFirstPos: 0
     readonly property int scrollLastPos: contentsExtraSpace
     readonly property int scrollStep: metrics.iconSize * 1.5
     readonly property int currentPos: !root.vertical ? contentX : contentY
 
-    readonly property int autoScrollTriggerLength: metrics.iconSize + root.lengthMargins/2
+    readonly property int autoScrollTriggerLength: metrics.iconSize + metrics.totals.lengthEdge
 
     readonly property int alignment: {
         if (root.location === PlasmaCore.Types.LeftEdge) {
             if (centered) return LatteCore.Types.LeftEdgeCenterAlign;
             if (root.alignment === LatteCore.Types.Top) return LatteCore.Types.LeftEdgeTopAlign;
             if (root.alignment === LatteCore.Types.Bottom) return LatteCore.Types.LeftEdgeBottomAlign;
         }
 
         if (root.location === PlasmaCore.Types.RightEdge) {
             if (centered) return LatteCore.Types.RightEdgeCenterAlign;
             if (root.alignment === LatteCore.Types.Top) return LatteCore.Types.RightEdgeTopAlign;
             if (root.alignment === LatteCore.Types.Bottom) return LatteCore.Types.RightEdgeBottomAlign;
         }
 
         if (root.location === PlasmaCore.Types.BottomEdge) {
             if (centered) return LatteCore.Types.BottomEdgeCenterAlign;
 
             if ((root.alignment === LatteCore.Types.Left && !reversed)
                     || (root.alignment === LatteCore.Types.Right && reversed)) {
                 return LatteCore.Types.BottomEdgeLeftAlign;
             }
 
             if ((root.alignment === LatteCore.Types.Right && !reversed)
                     || (root.alignment === LatteCore.Types.Left && reversed)) {
                 return LatteCore.Types.BottomEdgeRightAlign;
             }
         }
 
         if (root.location === PlasmaCore.Types.TopEdge) {
             if (centered) return LatteCore.Types.TopEdgeCenterAlign;
 
             if ((root.alignment === LatteCore.Types.Left && !reversed)
                     || (root.alignment === LatteCore.Types.Right && reversed)) {
                 return LatteCore.Types.TopEdgeLeftAlign;
             }
 
             if ((root.alignment === LatteCore.Types.Right && !reversed)
                     || (root.alignment === LatteCore.Types.Left && reversed)) {
                 return LatteCore.Types.TopEdgeRightAlign;
             }
         }
 
         return LatteCore.Types.BottomEdgeCenterAlign;
     }
 
     function increasePos() {
         increasePosWithStep(scrollStep);
     }
 
     function decreasePos() {
         decreasePosWithStep(scrollStep);
     }
 
     function increasePosWithStep(step) {
         if (!root.vertical) {
             contentX = Math.min(scrollLastPos, contentX + step);
         } else {
             contentY = Math.min(scrollLastPos, contentY + step);
         }
 
     }
 
     function decreasePosWithStep(step) {
         if (!root.vertical) {
             contentX = Math.max(scrollFirstPos, contentX - step);
         } else {
             contentY = Math.max(scrollFirstPos, contentY - step);
         }
     }
 
     function focusOn(task) {
         if (!contentsExceed) {
             return;
         }
 
         var cP = task.mapToItem(scrollableList, 0, 0);
         var distance = 0;
 
         if (!root.vertical) {
             if (cP.x < 0) {
                 distance = Math.abs(cP.x - metrics.iconSize);
                 decreasePosWithStep(distance);
             } else if ((cP.x+task.width) > scrollableList.width) {
                 distance = Math.abs(cP.x - scrollableList.width + task.width + metrics.iconSize);
                 increasePosWithStep(distance);
             }
         } else {
             if (cP.y < 0) {
                 distance = Math.abs(cP.y - metrics.iconSize);
                 decreasePosWithStep(distance);
             } else if ((cP.y+task.height) > scrollableList.height) {
                 distance = Math.abs(cP.y - scrollableList.height + task.height + metrics.iconSize);
                 increasePosWithStep(distance);
             }
         }
     }
 
     function autoScrollFor(task) {
         //! It has TWO IN-QUESTION issues that may have been solved by the
         //! initial checks
         //! 1. when the user uses the mouse wheel at the first or the last task
         //!    the autoscrolling forcefully returns the view to boundaries
         //! 2. when parabolic effect is activated the experience is not that smooth
         //!    at the view boundaries, parabolic effect AND autoscroll at the
         //!    boundaries create animation breakage
 
         if (!root.autoScrollTasksEnabled || !contentsExceed || root.tasksCount < 3
                 || (task.itemIndex===parabolicManager.lastRealTaskIndex && root.zoomFactor>1)) {
             //last task with parabolic effect breaks the autoscolling behavior
             return;
         }
 
         var cP = task.mapToItem(scrollableList, 0, 0);
 
         if (!root.vertical) {
             if (currentPos !== scrollFirstPos && cP.x < autoScrollTriggerLength) {
                 decreasePosWithStep(metrics.iconSize*1.5);
             } else if (currentPos !== scrollLastPos && (cP.x+task.width > (scrollableList.width-autoScrollTriggerLength))) {
                 increasePosWithStep(metrics.iconSize*1.5);
             }
         } else {
             if (currentPos !== scrollFirstPos && cP.y < autoScrollTriggerLength) {
                 decreasePosWithStep(metrics.iconSize*1.5);
             } else if (currentPos !== scrollLastPos && (cP.y+task.height > (scrollableList.height-autoScrollTriggerLength))) {
                 increasePosWithStep(metrics.iconSize*1.5);
             }
         }
 
     }
 
     onContentsExtraSpaceChanged: {
         if (!root.vertical) {
             if (contentX < scrollFirstPos) {
                 contentX = scrollFirstPos;
             } else if (contentX > scrollLastPos) {
                 contentX = scrollLastPos;
             }
         } else {
             if (contentY < scrollFirstPos) {
                 contentY = scrollFirstPos;
             } else if (contentY > scrollLastPos) {
                 contentY = scrollLastPos;
             }
         }
     }
 
     Behavior on contentX {
         NumberAnimation {
             id: horizontalAnimation
             duration: animations.speedFactor.current*1.7*animations.duration.large
             easing.type: Easing.OutQuad
         }
     }
 
     Behavior on contentY {
         NumberAnimation {
             id: verticalAnimation
             duration: animations.speedFactor.current*1.7*animations.duration.large
             easing.type: Easing.OutQuad
         }
     }
 
     //////////////////////////BEGIN states
     // Alignment
     // 0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Left Edge
         State {
             name: "leftCenter"
             when: flickableContainer.alignment === LatteCore.Types.LeftEdgeCenterAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: flickableContainer.offset;
             }
         },
         State {
             name: "leftTop"
             when: flickableContainer.alignment === LatteCore.Types.LeftEdgeTopAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:flickableContainer.offset;    anchors.bottomMargin:flickableContainer.lastMargin;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "leftBottom"
             when: flickableContainer.alignment === LatteCore.Types.LeftEdgeBottomAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:flickableContainer.lastMargin;    anchors.bottomMargin:flickableContainer.offset;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Right Edge
         State {
             name: "rightCenter"
             when: flickableContainer.alignment === LatteCore.Types.RightEdgeCenterAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: flickableContainer.offset;
             }
         },
         State {
             name: "rightTop"
             when: flickableContainer.alignment === LatteCore.Types.RightEdgeTopAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:flickableContainer.offset;    anchors.bottomMargin:flickableContainer.lastMargin;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "rightBottom"
             when: flickableContainer.alignment === LatteCore.Types.RightEdgeBottomAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:flickableContainer.lastMargin;    anchors.bottomMargin:flickableContainer.offset;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Bottom Edge
         State {
             name: "bottomCenter"
             when: flickableContainer.alignment === LatteCore.Types.BottomEdgeCenterAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: flickableContainer.offset; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "bottomLeft"
             when: flickableContainer.alignment === LatteCore.Types.BottomEdgeLeftAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: flickableContainer.offset;    anchors.rightMargin:flickableContainer.lastMargin;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "bottomRight"
             when: flickableContainer.alignment === LatteCore.Types.BottomEdgeRightAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: flickableContainer.lastMargin;    anchors.rightMargin:flickableContainer.offset;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Top Edge
         State {
             name: "topCenter"
             when: flickableContainer.alignment === LatteCore.Types.TopEdgeCenterAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: flickableContainer.offset; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "topLeft"
             when: flickableContainer.alignment === LatteCore.Types.TopEdgeLeftAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: flickableContainer.offset;    anchors.rightMargin:flickableContainer.lastMargin;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "topRight"
             when: flickableContainer.alignment === LatteCore.Types.TopEdgeRightAlign
 
             AnchorChanges {
                 target: flickableContainer
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: flickableContainer;
                 anchors.leftMargin: flickableContainer.lastMargin;    anchors.rightMargin:flickableContainer.offset;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         }
     ]
 }