diff --git a/containment/package/contents/ui/abilities/Layouter.qml b/containment/package/contents/ui/abilities/Layouter.qml
index 8da4621d..a564e83b 100644
--- a/containment/package/contents/ui/abilities/Layouter.qml
+++ b/containment/package/contents/ui/abilities/Layouter.qml
@@ -1,63 +1,67 @@
 /*
 *  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 Ability
 
 Ability.LayouterPrivate {
     id: _layouter
 
     property bool appletsInParentChange: false
 
     readonly property bool inNormalFillCalculationsState: animations.needBothAxis.count === 0
                                                           && animations.needThickness.count === 0
                                                           && ((animations.needLength.count === 0)
                                                               || (animations.needLength.count===1 && editModeVisual.inEditMode))
                                                           && (!dragOverlay || (dragOverlay && !dragOverlay.pressed)) /*do not update during moving/dragging applets*/
                                                           && !appletsInParentChange
 
 
     function updateSizeForAppletsInFill() {
         if (!updateSizeForAppletsInFillTimer.running) {
             _layouter._updateSizeForAppletsInFill();
             updateSizeForAppletsInFillTimer.start();
         }
     }
 
     onInNormalFillCalculationsStateChanged: {
         if (inNormalFillCalculationsState) {
             _layouter.updateSizeForAppletsInFill();
         }
     }
 
+    onMaxLengthChanged: {
+        _layouter.updateSizeForAppletsInFill();
+    }
+
     Connections {
         target: layouts
         onContentsLengthChanged: _layouter.updateSizeForAppletsInFill();
     }
 
     //! This timer is needed in order to reduce the calls to heavy cpu function
     //! updateSizeForAppletsInFill()
     Timer{
         id: updateSizeForAppletsInFillTimer
         interval: 75
         onTriggered: _layouter._updateSizeForAppletsInFill();
     }
 }
diff --git a/containment/package/contents/ui/abilities/privates/LayouterPrivate.qml b/containment/package/contents/ui/abilities/privates/LayouterPrivate.qml
index ccd75d1d..66b1e9f2 100644
--- a/containment/package/contents/ui/abilities/privates/LayouterPrivate.qml
+++ b/containment/package/contents/ui/abilities/privates/LayouterPrivate.qml
@@ -1,383 +1,383 @@
 /*
 *  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.core 0.2 as LatteCore
 
 import "./layouter" as LayouterElements
 
 Item {
     property Item layouts: null
     property Item animations: null
     property Item indexer: null
 
     readonly property int fillApplets: startLayout.fillApplets + mainLayout.fillApplets + endLayout.fillApplets
 
-    readonly property int maxLength: root.maxLength
+    readonly property int maxLength: root.panelAlignment === LatteCore.Types.Justify ? root.maxLength : Math.min(root.minLength, root.maxLength)
 
     readonly property Item startLayout: LayouterElements.AppletsContainer {
         grid: layouts.startLayout
     }
 
     readonly property Item mainLayout: LayouterElements.AppletsContainer {
         grid: layouts.mainLayout
     }
 
     readonly property Item endLayout: LayouterElements.AppletsContainer {
         grid: layouts.endLayout
     }
 
     //!         FILLWIDTH/FILLHEIGHT COMPUTATIONS
     //! Computations in order to calculate correctly the sizes for applets
     //! that are requesting fillWidth or fillHeight
 
     //! qBound style function that is specialized in Layouts
     //! meaning that -1 values are ignored for fillWidth(s)/Height(s)
     function layoutBound(min, pref, max){
-        if (max === -1) {
+      /*  if (max === -1) {
             max = pref === -1 ? min : pref;
         }
 
         if (pref === -1) {
             pref = max === -1 ? min : pref;
-        }
+        }*/
 
-        return Math.min(Math.max(min,pref),max);
+        return Math.max(min, pref, max);//  Math.min(Math.max(min,pref),max);
     }
 
 
     //! initialize AppletItems flag "inFillCalculations" in order
     //! to inform them that new calculations are taking place
     function initLayoutForFillsCalculations(layout) {
         for(var i=0; i<layout.children.length; ++i) {
             var curApplet = layout.children[i];
             if (curApplet.needsFillSpace) {
                 curApplet.inFillCalculations = true;
             }
         }
     }
 
     //! during step1/pass1 all applets that provide valid metrics (minimum/preferred/maximum values)
     //! they gain a valid space in order to draw themeselves
     function computeStep1ForLayout(layout, availableSpace, sizePerApplet, noOfApplets) {
         for(var i=0; i<layout.children.length; ++i) {
             var curApplet = layout.children[i];
 
             if (curApplet.needsFillSpace) {
                 if (curApplet && curApplet.applet && curApplet.applet.Layout) {
                     var minSize = root.isVertical ? curApplet.applet.Layout.minimumHeight : curApplet.applet.Layout.minimumWidth;
                     var prefSize = root.isVertical ? curApplet.applet.Layout.preferredHeight : curApplet.applet.Layout.preferredWidth;
                     var maxSize = root.isVertical ? curApplet.applet.Layout.maximumHeight : curApplet.applet.Layout.maximumWidth;
 
                     // console.log( " s3_0 " + curApplet.applet.pluginName + " : (" +minSize+","+prefSize+","+maxSize+") ");
 
                     minSize = minSize>=0 && minSize!==Infinity ? minSize : -1;
                     prefSize = minSize>=0 && prefSize!==Infinity ? prefSize : -1;
                     maxSize = maxSize>=0 && maxSize!== Infinity ? maxSize : -1;
 
                     var appliedSize = -1;
 
                     //! check if the applet does not provide any valid metrics and for that case
                     //! the system must decide what space to be given after the applets that provide
                     //! nice metrics are assigned their sizes
                     var systemDecide = ((minSize<0) && (prefSize<0) && (maxSize<0));
 
                     if (!systemDecide) {
                         if (noOfApplets>1) {
                             appliedSize = layoutBound(minSize, prefSize, maxSize);
 
                             // console.log( " s3_1 " + curApplet.applet.pluginName + " : (" +minSize+","+prefSize+","+maxSize+") -> " + appliedSize);
                         } else if (noOfApplets===1) {
                             //! at this step if only one applet has remained for which the max size is not null,
                             //! then for this applet we make sure the maximum size does not exceed the available space
                             //! in order for the applet to not be drawn outside the boundaries
                             appliedSize = layoutBound(minSize, prefSize, Math.min(maxSize, sizePerApplet));
 
                             // console.log( " s3_2 " + curApplet.applet.pluginName + " : (" +minSize+","+prefSize+","+maxSize+") -> " + appliedSize);
                         }
 
                         //! appliedSize is valid and is also lower than the availableSpace, if it is not lower then
                         //! for this applet the needed space will be provided as a second pass in a fair way
                         //! between all remained applets that did not gain a valid fill space
                         if (appliedSize>=0 && appliedSize<=sizePerApplet) {
                             var properSize = Math.min(appliedSize, availableSpace);
                             var thickness = root.isVertical ? root.width : root.height;
                             var adjustedSize = curApplet.isHidden ? 0 : Math.max(thickness, properSize);
 
                             curApplet.sizeForFill = adjustedSize;
                             curApplet.inFillCalculations = false;
                             availableSpace = Math.max(0, availableSpace - curApplet.sizeForFill);
                             noOfApplets = noOfApplets - 1;
                             sizePerApplet = noOfApplets > 1 ? Math.floor(availableSpace / noOfApplets) : availableSpace;
 
                             // console.log( " s3_3 " + curApplet.applet.pluginName + " assigned: " + curApplet.sizeForFill);
                         }
                     }
 
                     // console.log("s3_r " +curApplet.applet.pluginName + " : " + availableSpace + " _ " + sizePerApplet + " _ " + noOfApplets + "\n");
                 }
             }
         }
 
         return [availableSpace, sizePerApplet, noOfApplets];
     }
 
     //! during step2/pass2 all the applets with fills
     //! that remained with no computations from pass1
     //! are updated with the algorithm's proposed size
     function computeStep2ForLayout(layout, sizePerApplet, noOfApplets) {
         if (sizePerApplet>0) {
             if (noOfApplets === 0) {
                 //! when all applets have assigned some size and there is still free space, we must find
                 //! the most demanding space applet and assign the remaining space to it
 
                 var mostDemandingAppletSize = 0;
                 var mostDemandingApplet = undefined;
 
                 //! applets with no strong opinion
                 var neutralAppletsNo = 0;
                 var neutralApplets = [];
 
                 for(var i=0; i<layout.children.length; ++i) {
                     var curApplet = layout.children[i];
 
                     //! the most demanding applet is the one that has maximum size set to Infinity
                     //! AND is not Neutral, meaning that it provided some valid metrics
                     //! AND at the same time gained from step one the biggest space
                     if (curApplet && curApplet.needsFillSpace && curApplet.applet && curApplet.applet.Layout) {
                         var minSize = root.isVertical ? curApplet.applet.Layout.minimumHeight : curApplet.applet.Layout.minimumWidth;
                         var prefSize = root.isVertical ? curApplet.applet.Layout.preferredHeight : curApplet.applet.Layout.preferredWidth;
                         var maxSize = root.isVertical ? curApplet.applet.Layout.maximumHeight : curApplet.applet.Layout.maximumWidth;
 
                         var isNeutral = (minSize<=0 && prefSize<=0);
 
                         // console.log( " s4_0 " + curApplet.applet.pluginName + " : (" +minSize+","+prefSize+","+maxSize+") ");
 
                         if (!isNeutral && maxSize===Infinity && curApplet.sizeForFill>mostDemandingAppletSize) {
                             mostDemandingApplet = curApplet;
                             mostDemandingAppletSize = curApplet.sizeForFill;
                         } else if (isNeutral) {
                             neutralAppletsNo = neutralAppletsNo + 1;
                             neutralApplets.push(curApplet);
                         }
                     }
                 }
 
                 if (mostDemandingApplet) {
                     //! the most demanding applet gains all the remaining space
                     mostDemandingApplet.sizeForFill = mostDemandingApplet.sizeForFill + sizePerApplet;
 
                     // console.log("s4_1  "+ mostDemandingApplet.applet.pluginName + " assigned: "  + mostDemandingApplet.sizeForFill + "\n");
                 } else if (neutralAppletsNo>0) {
                     //! if no demanding applets was found then the available space is splitted equally
                     //! between all neutralApplets
                     var adjustedAppletSize = (sizePerApplet / neutralAppletsNo);
                     for (var j=0; j<neutralApplets.length; ++j) {
                         // console.log("s4_2.0  "+ neutralApplets[j].applet.pluginName + " _ " + neutralApplets[j].sizeForFill + " _ " + adjustedAppletSize);
 
                         neutralApplets[j].sizeForFill = neutralApplets[j].sizeForFill + adjustedAppletSize;
 
                         // console.log("s4_2  "+ neutralApplets[j].applet.pluginName + " assigned: "  + sizePerApplet + "\n");
                     }
                 }
             } else {
                 for(var i=0; i<layout.children.length; ++i) {
                     var curApplet = layout.children[i];
 
                     if (curApplet && curApplet.needsFillSpace && curApplet.inFillCalculations) {
                         curApplet.sizeForFill = sizePerApplet;
                         // console.log("s4_3  "+ curApplet.applet.pluginName + " assigned: "  + sizePerApplet + "\n");
                         curApplet.inFillCalculations = false;
                     }
                 }
             }
         }
     }
 
     //! initialize the three layouts and execute the step1/phase1
     //! it is used when the Centered (Main)Layout is used only or when the Main(Layout)
     //! is empty in Justify mode
     function initializationPhase(availableSpace, sizePerApplet, noOfApplets){
         if (root.panelAlignment === LatteCore.Types.Justify) {
             initLayoutForFillsCalculations(startLayout.grid);
             initLayoutForFillsCalculations(endLayout.grid);
         }
         initLayoutForFillsCalculations(mainLayout.grid);
 
         // console.log("s3...");
 
         //! first pass in order to update sizes for applet that want to fill space
         //! but their maximum metrics are lower than the sizePerApplet
         var res = computeStep1ForLayout(mainLayout.grid, availableSpace, sizePerApplet, noOfApplets);
         availableSpace = res[0]; sizePerApplet = res[1]; noOfApplets = res[2];
 
         // console.log( " i1 : " + availableSpace + " _ " + sizePerApplet + " _ " + noOfApplets );
 
         if (root.panelAlignment === LatteCore.Types.Justify) {
             res = computeStep1ForLayout(startLayout.grid, availableSpace, sizePerApplet, noOfApplets);
             availableSpace = res[0]; sizePerApplet = res[1]; noOfApplets = res[2];
             // console.log( " i2 : " + availableSpace + " _ " + sizePerApplet + " _ " + noOfApplets );
 
             res = computeStep1ForLayout(endLayout.grid, availableSpace, sizePerApplet, noOfApplets);
             availableSpace = res[0]; sizePerApplet = res[1]; noOfApplets = res[2];
             // console.log( " i3 : " + availableSpace + " _ " + sizePerApplet + " _ " + noOfApplets );
         }
 
         return [availableSpace, sizePerApplet, noOfApplets];
     }
 
 
     function _updateSizeForAppletsInFill() {
         if (inNormalFillCalculationsState) {
             // console.log("-------------");
             // console.log("s1...");
             var noA = startLayout.fillApplets + mainLayout.fillApplets + endLayout.fillApplets;
 
             if (noA === 0)
                 return;
 
             // console.log("s2...");
             if (mainLayout.shownApplets === 0 || root.panelAlignment !== LatteCore.Types.Justify) {
                 // console.log("  S2 _ SIZES ::: " + maxLength + " ___ " + startLayout.sizeWithNoFillApplets + " ___ " + mainLayout.sizeWithNoFillApplets + " ___ " + endLayout.sizeWithNoFillApplets);
 
                 var availableSpace = Math.max(0, maxLength - startLayout.sizeWithNoFillApplets - mainLayout.sizeWithNoFillApplets - endLayout.sizeWithNoFillApplets - root.panelEdgeSpacing);
                 var sizePerApplet = availableSpace / noA;
 
                 var res = initializationPhase(availableSpace, sizePerApplet, noA);
                 availableSpace = res[0];  sizePerApplet = res[1]; noA = res[2];
 
                 // console.log("s4...");
 
                 //! after step1 there is a chance that all applets were assigned a valid space
                 //! but at the same time some space remained free. In such case we make sure
                 //! that remained space will be assigned to the most demanding applet.
                 //! This is achieved by <layout>No values. For step2 passing value!=0
                 //! means default step2 behavior BUT value=0 means that remained space
                 //! must be also assigned at the end.
                 var remainedSpace = (noA === 0 && sizePerApplet > 0) ? true : false
 
                 var startNo = -1;
                 var mainNo = -1;
                 var endNo = -1;
 
                 if (remainedSpace) {
                     if (startLayout.fillApplets > 0) {
                         startNo = 0;
                     } else if (lendLayout.fillApplets > 0) {
                         endNo = 0;
                     } else if (mainLayout.fillApplets > 0) {
                         mainNo = 0;
                     }
                 }
 
                 //! second pass in order to update sizes for applet that want to fill space
                 //! these applets get the direct division of the available free space that
                 //! remained from step1 OR the the free available space that no applet requested yet
 
                 computeStep2ForLayout(startLayout.grid, sizePerApplet, startNo); //default behavior
                 computeStep2ForLayout(mainLayout.grid, sizePerApplet, mainNo); //default behavior
                 computeStep2ForLayout(endLayout.grid, sizePerApplet, endNo); //default behavior
 
                 //console.log("s5...");
             } else {
                 //! Justify mode in all remaining cases
 
                 // console.log(" S3 _ SIZES ::: " + root.maxLength + " ___ " + startLayout.sizeWithNoFillApplets + " ___ " + mainLayout.sizeWithNoFillApplets + " ___ " + endLayout.sizeWithNoFillApplets);
 
                 //! compute the two free spaces around the centered layout
                 //! they are called start and end accordingly
                 var halfMainLayout = mainLayout.sizeWithNoFillApplets / 2;
                 var availableSpaceStart = Math.max(0, maxLength/2 - startLayout.sizeWithNoFillApplets - halfMainLayout - root.panelEdgeSpacing/2);
                 var availableSpaceEnd = Math.max(0, maxLength/2 - endLayout.sizeWithNoFillApplets - halfMainLayout - root.panelEdgeSpacing/2);
                 var availableSpace;
 
                 if (mainLayout.fillApplets === 0 || (startLayout.shownApplets ===0 && endLayout.shownApplets===0)){
                     //! no fill applets in main OR we are in alignment that all applets are in main
                     availableSpace = availableSpaceStart + availableSpaceEnd - mainLayout.sizeWithNoFillApplets;
                 } else {
                     //! use the minimum available space in order to avoid overlaps
                     availableSpace = 2 * Math.min(availableSpaceStart, availableSpaceEnd) - mainLayout.sizeWithNoFillApplets;
                 }
 
                 var sizePerAppletMain = mainLayout.fillApplets > 0 ? availableSpace / noA : 0 ;
 
                 var noStart = startLayout.fillApplets;
                 var noMain = mainLayout.fillApplets;
                 var noEnd = endLayout.fillApplets;
 
                 //! initialize the computations
                 initLayoutForFillsCalculations(startLayout.grid);
                 initLayoutForFillsCalculations(mainLayout.grid);
                 initLayoutForFillsCalculations(endLayout.grid);
 
                 var res;
 
                 //! first pass
                 if (mainLayout.fillApplets > 0){
                     res = computeStep1ForLayout(mainLayout.grid, availableSpace, sizePerAppletMain, noMain);
                     sizePerAppletMain = res[1]; noMain = res[2];
                     var dif = (availableSpace - res[0]) / 2;
                     availableSpaceStart = availableSpaceStart - dif;
                     availableSpaceEnd = availableSpaceEnd - dif;
                 }
 
                 var sizePerAppletStart = startLayout.fillApplets > 0 ? availableSpaceStart / noStart : 0 ;
                 var sizePerAppletEnd = endLayout.fillApplets > 0 ? availableSpaceEnd / noEnd : 0 ;
 
                 if (startLayout.fillApplets > 0) {
                     res = computeStep1ForLayout(startLayout.grid, availableSpaceStart, sizePerAppletStart, noStart);
                     availableSpaceStart = res[0]; sizePerAppletStart = res[1]; noStart = res[2];
                 }
                 if (endLayout.fillApplets > 0) {
                     res = computeStep1ForLayout(endLayout.grid, availableSpaceEnd, sizePerAppletEnd, noEnd);
                     availableSpaceEnd = res[0]; sizePerAppletEnd = res[1]; noEnd = res[2];
                 }
 
                 ////
                 //! second pass
 
                 // console.log(" S ::: " +startLayout.fillApplets + " _ " + sizePerAppletStart + " _ " + noStart);
 
                 if (mainLayout.fillApplets > 0) {
                     computeStep2ForLayout(mainLayout.grid, sizePerAppletMain, noMain); //default behavior
                 }
 
                 if (startLayout.fillApplets > 0) {
                     if (mainLayout.fillApplets > 0) {
                         //! adjust final fill applet size in mainlayouts final length
                         sizePerAppletStart = ((maxLength/2) - (mainLayout.grid.length/2) - startLayout.sizeWithNoFillApplets) / noStart;
                     }
 
                     computeStep2ForLayout(startLayout.grid, sizePerAppletStart, noStart);
                 }
 
                 if (endLayout.fillApplets > 0) {
                     if (mainLayout.fillApplets > 0) {
                         //! adjust final fill applet size in mainlayouts final length
                         sizePerAppletEnd = ((maxLength/2) - (mainLayout.grid.length/2) - endLayout.sizeWithNoFillApplets) / noEnd;
                     }
 
                     computeStep2ForLayout(endLayout.grid, sizePerAppletEnd, noEnd);
                 }
             }
         }
     }
 }
diff --git a/containment/package/contents/ui/applet/AppletItem.qml b/containment/package/contents/ui/applet/AppletItem.qml
index 57f62584..3ee2b528 100644
--- a/containment/package/contents/ui/applet/AppletItem.qml
+++ b/containment/package/contents/ui/applet/AppletItem.qml
@@ -1,1188 +1,1188 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.7
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "colorizer" as Colorizer
 import "communicator" as Communicator
 import "indicator" as Indicator
 import "../debug" as Debug
 
 Item {
     id: appletItem
 
     visible: false
     width: isInternalViewSplitter && !root.inConfigureAppletsMode ? 0 : computeWidth
     height: isInternalViewSplitter && !root.inConfigureAppletsMode ? 0 : computeHeight
 
     //any applets that exceed their limits should not take events from their surrounding applets
     clip: true
 
     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)
                             || (isInternalViewSplitter && !root.inConfigureAppletsMode)
     property bool isInternalViewSplitter: (internalSplitterId > 0)
     property bool isLattePlasmoid: latteApplet !== null
     property bool isZoomed: false
     property bool isSeparator: applet && (applet.pluginName === "audoban.applet.separator"
                                           || applet.pluginName === "org.kde.latte.separator")
     property bool isSpacer: applet && (applet.pluginName === "org.kde.latte.spacer")
     property bool isSystray: applet && (applet.pluginName === "org.kde.plasma.systemtray" || applet.pluginName === "org.nomad.systemtray" )
 
     property bool firstChildOfStartLayout: index === appletItem.layouter.startLayout.firstVisibleIndex
     property bool firstChildOfMainLayout: index === appletItem.layouter.mainLayout.firstVisibleIndex
     property bool lastChildOfMainLayout: index === appletItem.layouter.mainLayout.lastVisibleIndex
     property bool lastChildOfEndLayout: index === appletItem.layouter.endLayout.lastVisibleIndex
 
     readonly property bool atScreenEdge: {
         if (root.panelAlignment !== LatteCore.Types.Justify || root.inConfigureAppletsMode || plasmoid.configuration.offset!==0) {
             return false;
         }
 
         if (root.panelAlignment === LatteCore.Types.Justify) {
             //! Justify case
             if (root.maxLengthPerCentage!==100) {
                 return false;
             }
 
             if (root.isHorizontal) {
                 if (firstChildOfStartLayout) {
                     return latteView && latteView.x === latteView.screenGeometry.x;
                 } else if (lastChildOfEndLayout) {
                     return latteView && ((latteView.x + latteView.width) === (latteView.screenGeometry.x + latteView.screenGeometry.width));
                 }
             } else {
                 if (firstChildOfStartLayout) {
                     return latteView && latteView.y === latteView.screenGeometry.y;
                 } else if (lastChildOfEndLayout) {
                     return latteView && ((latteView.y + latteView.height) === (latteView.screenGeometry.y + latteView.screenGeometry.height));
                 }
             }
 
             return false;
         }
 
         //! [disabled] because it is probably not needed at all. If in the future there is a report
         //! describing a case that this would be useful this disablement choice can be rethought
         /*if (root.panelAlignment === LatteCore.Types.Left) {
             //! Left case
             return firstChildOfMainLayout;
         } else if (root.panelAlignment === LatteCore.Types.Right) {
             //! Right case
             return lastChildOfMainLayout
         }
 
         if (root.panelAlignment === LatteCore.Types.Top) {
             return firstChildOfMainLayout && latteView && latteView.y === latteView.screenGeometry.y;
         } else if (root.panelAlignment === LatteCore.Types.Bottom) {
             return lastChildOfMainLayout && latteView && ((latteView.y + latteView.height) === (latteView.screenGeometry.y + latteView.screenGeometry.height));
         }*/
 
         return false;
     }
 
     //applet is in starting edge
     property bool firstAppletInContainer: (index >=0) &&
                                           ((index === layouter.startLayout.firstVisibleIndex)
                                            || (index === layouter.mainLayout.firstVisibleIndex)
                                            || (index === layouter.endLayout.firstVisibleIndex))
     //applet is in ending edge
     property bool lastAppletInContainer: (index >=0) &&
                                          ((index === layouter.startLayout.lastVisibleIndex)
                                           || (index === layouter.mainLayout.lastVisibleIndex)
                                           || (index === layouter.endLayout.lastVisibleIndex))
 
     readonly property bool acceptMouseEvents: applet && !isLattePlasmoid && !originalAppletBehavior && !appletItem.isSeparator && !communicator.requires.parabolicEffectLocked
     readonly property bool originalAppletBehavior: (appletItem.parabolic.factor.zoom === 1 && !lockZoom /*hacky flag to keep Latte behavior*/)
                                                    || (appletItem.parabolic.factor.zoom>1 && !canBeHovered)
                                                    || (appletItem.parabolic.factor.zoom>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 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) - metrics.totals.lengthEdges)
     property int status: applet ? applet.status : -1
 
     //! separators tracking
     readonly property bool tailAppletIsSeparator: {
         if (isSeparator || index<0) {
             return false;
         }
 
         var tail = index - 1;
 
         while(tail>=0 && indexer.hidden.indexOf(tail)>=0) {
             //! when a tail applet contains sub-indexing and does not influence
             //! tracking is considered hidden
             tail = tail - 1;
         }
 
         if (tail >= 0 && indexer.clients.indexOf(tail)>=0) {
             //! tail applet contains items sub-indexing
             var tailBridge = indexer.getClientBridge(tail);
 
             if (tailBridge && tailBridge.client) {
                 return tailBridge.client.lastHeadItemIsSeparator;
             }
         }
 
         // tail applet is normal
         return (indexer.separators.indexOf(tail)>=0);
     }
 
     readonly property bool headAppletIsSeparator: {
         if (isSeparator || index<0) {
             return false;
         }
 
         var head = index + 1;
 
         while(head>=0 && indexer.hidden.indexOf(head)>=0) {
             //! when a head applet contains sub-indexing and does not influence
             //! tracking is considered hidden
             head = head + 1;
         }
 
         if (head >= 0 && indexer.clients.indexOf(head)>=0) {
             //! head applet contains items sub-indexing
             var headBridge = indexer.getClientBridge(head);
 
             if (headBridge && headBridge.client) {
                 return headBridge.client.firstTailItemIsSeparator;
             }
         }
 
         // head applet is normal
         return (indexer.separators.indexOf(head)>=0);
     }
 
     //! local margins
     readonly property bool parabolicEffectMarginsEnabled: appletItem.parabolic.factor.zoom>1 && !originalAppletBehavior
 
     property int lengthAppletPadding: metrics.fraction.lengthAppletPadding === -1 || parabolicEffectMarginsEnabled ?
                                           metrics.padding.length : metrics.padding.lengthApplet
 
     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
 
     readonly property alias communicator: _communicator
     readonly property alias wrapper: _wrapper
 
     property Item animations: null
     property Item indexer: null
     property Item layouter: null
     property Item metrics: null
     property Item parabolic: null
 
     property bool containsMouse: appletMouseArea.containsMouse || (isLattePlasmoid && latteApplet.containsMouse)
     property bool pressed: viewSignalsConnector.pressed || clickedAnimation.running
 
 
     //// BEGIN :: Animate Applet when a new applet is dragged in the view
 
     //when the applet moves caused by its resize, don't animate.
     //this is completely heuristic, but looks way less "jumpy"
     property bool movingForResize: false
     property int oldX: x
     property int oldY: y
 
     onXChanged: {
         if (root.isVertical) {
             return;
         }
 
         if (movingForResize) {
             movingForResize = false;
             return;
         }
 
         var draggingAppletInConfigure = root.dragOverlay && root.dragOverlay.currentApplet;
         var isCurrentAppletInDragging = draggingAppletInConfigure && (root.dragOverlay.currentApplet === appletItem);
         var dropApplet = root.dragInfo.entered && foreDropArea.visible
 
         if (isCurrentAppletInDragging || !draggingAppletInConfigure && !dropApplet) {
             return;
         }
 
         if (!root.isVertical) {
             translation.x = oldX - x;
             translation.y = 0;
         } else {
             translation.y = oldY - y;
             translation.x = 0;
         }
 
         translAnim.running = true
 
         if (!root.isVertical) {
             oldX = x;
             oldY = 0;
         } else {
             oldY = y;
             oldX = 0;
         }
     }
 
     onYChanged: {
         if (root.isHorizontal) {
             return;
         }
 
         if (movingForResize) {
             movingForResize = false;
             return;
         }
 
         var draggingAppletInConfigure = root.dragOverlay && root.dragOverlay.currentApplet;
         var isCurrentAppletInDragging = draggingAppletInConfigure && (root.dragOverlay.currentApplet === appletItem);
         var dropApplet = root.dragInfo.entered && foreDropArea.visible
 
         if (isCurrentAppletInDragging || !draggingAppletInConfigure && !dropApplet) {
             return;
         }
         if (!root.isVertical) {
             translation.x = oldX - x;
             translation.y = 0;
         } else {
             translation.y = oldY - y;
             translation.x = 0;
         }
 
         translAnim.running = true;
 
         if (!root.isVertical) {
             oldX = x;
             oldY = 0;
         } else {
             oldY = y;
             oldX = 0;
         }
     }
 
     transform: Translate {
         id: translation
     }
 
     NumberAnimation {
         id: translAnim
         duration: appletItem.animations.duration.large
         easing.type: Easing.InOutQuad
         target: translation
         properties: "x,y"
         to: 0
     }
 
     Behavior on lengthAppletPadding {
         NumberAnimation {
             duration: 0.8 * appletItem.animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
 
     //// END :: Animate Applet when a new applet is dragged in the view
 
     /// BEGIN functions
     function activateAppletForNeutralAreas(mouse){
         //if the event is at the active indicator or spacers area then try to expand the applet,
         //unfortunately for other applets there is no other way to activate them yet
         //for example the icon-only applets
         var choords = mapToItem(appletItem.appletWrapper, mouse.x, mouse.y);
 
         var wrapperContainsMouse = choords.x>=0 && choords.y>=0 && choords.x<appletItem.appletWrapper.width && choords.y<appletItem.appletWrapper.height;
         var appletItemContainsMouse = mouse.x>=0 && mouse.y>=0 && mouse.x<width && mouse.y<height;
 
         //console.log(" APPLET :: " + mouse.x +  " _ " + mouse.y);
         //console.log(" WRAPPER :: " + choords.x + " _ " + choords.y);
 
         var inThicknessNeutralArea = !wrapperContainsMouse && (appletItem.metrics.margin.screenEdge>0);
         var appletNeutralAreaEnabled = !(inThicknessNeutralArea && root.dragActiveWindowEnabled);
 
         if (appletItemContainsMouse && !wrapperContainsMouse && appletNeutralAreaEnabled) {
             //console.log("PASSED");
             latteView.extendedInterface.toggleAppletExpanded(applet.id);
         } else {
             //console.log("REJECTED");
         }
     }
 
     function checkIndex(){
         index = -1;
 
         for(var i=0; i<appletItem.layouter.startLayout.count; ++i){
             var child = layoutsContainer.startLayout.children[i];
             if (child === appletItem){
                 index = layoutsContainer.startLayout.beginIndex + i;
                 break;
             }
         }
 
         for(var i=0; i<appletItem.layouter.mainLayout.count; ++i){
             var child = layoutsContainer.mainLayout.children[i];
             if (child === appletItem){
                 index = layoutsContainer.mainLayout.beginIndex + i;
                 break;
             }
         }
 
         for(var i=0; i<appletItem.layouter.endLayout.count; ++i){
             var child = layoutsContainer.endLayout.children[i];
             if (child === appletItem){
                 //create a very high index in order to not need to exchange hovering messages
                 //between layoutsContainer.mainLayout and layoutsContainer.endLayout
                 index = layoutsContainer.endLayout.beginIndex + i;
                 break;
             }
         }
 
         if(appletItem.latteApplet){
             if(index===layoutsContainer.startLayout.beginIndex || index===layoutsContainer.mainLayout.beginIndex || index===layoutsContainer.endLayout.beginIndex)
                 latteApplet.disableLeftSpacer = false;
             else
                 latteApplet.disableLeftSpacer = true;
 
             if( index === layoutsContainer.startLayout.beginIndex + appletItem.layouter.startLayout.count - 1
                     || index===layoutsContainer.mainLayout.beginIndex + appletItem.layouter.mainLayout.count - 1
                     || index === layoutsContainer.endLayout.beginIndex + appletItem.layouter.endLayout.count - 1)
                 latteApplet.disableRightSpacer = false;
             else
                 latteApplet.disableRightSpacer = true;
         }
     }
 
     //this functions gets the signal from the plasmoid, it can be used for signal items
     //outside the LatteApplet Plasmoid
     //property int debCounter: 0;
 
     function sltClearZoom(){
         if (communicator.parabolicEffectIsSupported) {
             communicator.bridge.parabolic.client.sglClearZoom();
         } else {
             restoreAnimation.start();
         }
     }
 
     function 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;
             }
 
             if (appletItem.isLattePlasmoid) {
                 appletItem.canBeHovered = true;
                 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 (index>-1) {
             previousIndex = index;
         }
     }
 
     onIsExpandedChanged: {
         if (isExpanded) {
             root.hideTooltipLabel();
         }
     }
 
     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);
         }
     }
 
     onNeedsFillSpaceChanged: checkCanBeHovered();
 
     Component.onCompleted: {
         checkIndex();
         root.updateIndexes.connect(checkIndex);
         root.destroyInternalViewSplitters.connect(slotDestroyInternalViewSplitters);
 
         parabolic.sglClearZoom.connect(sltClearZoom);
     }
 
     Component.onDestruction: {
         appletItem.animations.needBothAxis.removeEvent(appletItem);
 
         if(root.latteAppletPos>=0 && root.latteAppletPos === index){
             root.latteApplet = null;
             root.latteAppletContainer = null;
             root.latteAppletPos = -1;
         }
 
         root.updateIndexes.disconnect(checkIndex);
         root.destroyInternalViewSplitters.disconnect(slotDestroyInternalViewSplitters);
 
         parabolic.sglClearZoom.disconnect(sltClearZoom);
 
         if (appletItem.latteApplet) {
             appletItem.latteApplet.signalPreviewsShown.disconnect(slotPreviewsShown);
         }
     }
 
     Connections{
         target: root
 
         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 {
         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
                     parabolic: appletItem.parabolic
                 }
             }
 
             //! The Applet Colorizer
             Colorizer.Applet {
                 id: appletColorizer
                 anchors.fill: parent
                 opacity: mustBeShown ? 1 : 0
 
                 readonly property bool mustBeShown: colorizerManager.mustBeShown
                                                     && !appletItem.userBlocksColorizing
                                                     && !appletItem.appletBlocksColorizing
                                                     && !appletItem.isInternalViewSplitter
 
                 Behavior on opacity {
                     NumberAnimation {
                         duration: 1.2 * appletItem.animations.duration.proposed
                         easing.type: Easing.OutCubic
                     }
                 }
             }
 
             //! Indicator Front Layer
             Indicator.Loader{
                 id: indicatorFrontLayer
                 level: Indicator.LevelOptions {
                     isForeground: true
                     bridge: indicatorBridge
                 }
             }
 
             //! Applet Shortcut Visual Badge
             Item {
                 id: shortcutBadgeContainer
 
                 width: {
                     if (root.isHorizontal) {
                         return appletItem.metrics.iconSize * wrapper.zoomScale
                     } else {
                         return badgeThickness;
                     }
                 }
 
                 height: {
                     if (root.isHorizontal) {
                         return badgeThickness;
                     } else {
                         return appletItem.metrics.iconSize * wrapper.zoomScale
                     }
                 }
 
                 readonly property int badgeThickness: {
                     if (plasmoid.location === PlasmaCore.Types.BottomEdge
                             || plasmoid.location === PlasmaCore.Types.RightEdge) {
                         return ((appletItem.metrics.iconSize + appletItem.metrics.margin.thickness) * wrapper.zoomScale) + appletItem.metrics.margin.screenEdge;
                     }
 
                     return ((appletItem.metrics.iconSize + appletItem.metrics.margin.thickness) * wrapper.zoomScale);
                 }
 
                 ShortcutBadge{
                     anchors.fill: parent
                 }
 
                 states:[
                     State{
                         name: "horizontal"
                         when: plasmoid.formFactor === PlasmaCore.Types.Horizontal
 
                         AnchorChanges{
                             target: shortcutBadgeContainer;
                             anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                             anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                         }
                     },
                     State{
                         name: "vertical"
                         when: plasmoid.formFactor === PlasmaCore.Types.Vertical
 
                         AnchorChanges{
                             target: shortcutBadgeContainer;
                             anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                             anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                         }
                     }
                 ]
             }
         }
 
         // a hidden spacer on the right for the last item to add stability
         HiddenSpacer{id: hiddenSpacerRight; rightSpacer: true}
     }// Flow with hidden spacers inside
 
     //Busy Indicator
     PlasmaComponents.BusyIndicator {
         z: 1000
         visible: applet && applet.busy
         running: visible
         anchors.centerIn: parent
         width: Math.min(parent.width, parent.height)
         height: width
     }
 
     Loader {
         id: addingAreaLoader
         width: root.isHorizontal ? parent.width : parent.width - appletItem.metrics.margin.screenEdge
         height: root.isHorizontal ? parent.height - appletItem.metrics.margin.screenEdge : parent.height
 
         active: isLattePlasmoid
 
         sourceComponent: LatteComponents.AddingArea{
             id: addingAreaItem
             anchors.fill: parent
             // width: root.isHorizontal ? parent.width : parent.width - appletItem.metrics.margin.screenEdge
             // height: root.isHorizontal ? parent.height - appletItem.metrics.margin.screenEdge : parent.height
 
             radius: appletItem.metrics.iconSize/10
             opacity: root.addLaunchersMessage ? 1 : 0
             backgroundOpacity: 0.75
             duration: appletItem.animations.speedFactor.current
 
             title: i18n("Tasks Area")
         }
 
         //! AddingAreaItem States
         states:[
             State{
                 name: "bottom"
                 when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: appletItem.metrics.margin.screenEdge;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "top"
                 when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                     anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: appletItem.metrics.margin.screenEdge;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "left"
                 when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: appletItem.metrics.margin.screenEdge;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             },
             State{
                 name: "right"
                 when: plasmoid.location === PlasmaCore.Types.RightEdge
 
                 AnchorChanges{
                     target: addingAreaLoader
                     anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                     anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                 }
                 PropertyChanges{
                     target: addingAreaLoader
                     anchors.leftMargin: 0;    anchors.rightMargin: appletItem.metrics.margin.screenEdge;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                     anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                 }
             }
         ]
     }
 
     MouseArea{
         id: appletMouseArea
 
         anchors.fill: parent
         enabled: visible
         hoverEnabled: latteApplet ? false : true
         propagateComposedEvents: true
 
         //! a way must be found in order for this be enabled
         //! only to support springloading for plasma 5.10
         //! also on this is based the tooltips behavior by enabling it
         //! plasma tooltips are disabled
         visible: acceptMouseEvents
 
         property bool blockWheel: false
 
         onEntered: {
             appletItem.parabolic.stopRestoreZoomTimer();
 
             if (restoreAnimation.running) {
                 restoreAnimation.stop();
             }
 
             if (!(isSeparator || isSpacer)) {
                 root.showTooltipLabel(appletItem, applet.title);
             }
 
             if (originalAppletBehavior || communicator.requires.parabolicEffectLocked || !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 (appletItem.parabolic.factor.zoom>1){
                 appletItem.parabolic.startRestoreZoomTimer();
             }
         }
 
         onPositionChanged: {
             if (originalAppletBehavior || !canBeHovered) {
                 mouse.accepted = false;
                 return;
             }
 
             if (root.isHalfShown || (root.latteApplet
                                      && (root.latteApplet.noTasksInAnimation>0 || root.latteApplet.contextMenu))) {
                 return;
             }
 
             var rapidMovement = appletItem.parabolic.lastIndex>=0 && Math.abs(appletItem.parabolic.lastIndex-index)>1;
 
             if (rapidMovement) {
                 parabolic.setDirectRenderingEnabled(true);
             }
 
             if( ((wrapper.zoomScale == 1 || wrapper.zoomScale === appletItem.parabolic.factor.zoom) && !parabolic.directRenderingEnabled) || parabolic.directRenderingEnabled) {
                 if (root.isHorizontal){
                     var step = Math.abs(layoutsContainer.currentSpot-mouse.x);
                     if (step >= appletItem.animations.hoverPixelSensitivity){
                         layoutsContainer.currentSpot = mouse.x;
 
                         wrapper.calculateScales(mouse.x);
                     }
                 }
                 else{
                     var step = Math.abs(layoutsContainer.currentSpot-mouse.y);
                     if (step >= appletItem.animations.hoverPixelSensitivity){
                         layoutsContainer.currentSpot = mouse.y;
 
                         wrapper.calculateScales(mouse.y);
                     }
                 }
             }
 
             mouse.accepted = false;
         }
 
         //! these are needed in order for these events to be really forwarded underneath
         //! otherwise there were applets that did not receive them e.g. lock/logout applet
         //! when parabolic effect was used
         onPressed: mouse.accepted = false;
         onReleased: mouse.accepted = false;
     }
 
     //! Debug Elements
     Loader{
         anchors.bottom: parent.bottom
         anchors.left: parent.left
 
         active: root.debugModeLayouter
         sourceComponent: Debug.Tag{
-            label.text: root.isHorizontal ? appletItem.width : appletItem.height
+            label.text: (root.isHorizontal ? appletItem.width : appletItem.height) + " / fill_size:"+appletItem.sizeForFill
             label.color: appletItem.needsFillSpace ? "green" : "white"
         }
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
         interval: 500
 
         onTriggered: viewSignalsConnector.blockWheel = false;
     }
 
     //BEGIN states
     states: [
         State {
             name: "left"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined;}
             }
         },
         State {
             name: "right"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right;}
             }
         },
         State {
             name: "bottom"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined;}
             }
         },
         State {
             name: "top"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
 
             AnchorChanges {
                 target: appletFlow
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined;}
             }
         }
     ]
     //END states
 
     //BEGIN animations
     ///////Restore Zoom Animation/////
     ParallelAnimation{
         id: restoreAnimation
 
         PropertyAnimation {
             target: wrapper
             property: "zoomScale"
             to: 1
             duration: 3 * appletItem.animationTime
             easing.type: Easing.InCubic
         }
     }
 
 
     /////Clicked Animation/////
     SequentialAnimation{
         id: clickedAnimation
         alwaysRunToEnd: true
         running: appletItem.isSquare && !originalAppletBehavior && appletItem.pressed
                  && (appletItem.animations.speedFactor.current > 0) && !indicators.info.providesClickedAnimation
 
         ParallelAnimation{
             PropertyAnimation {
                 target: wrapper.clickedEffect
                 property: "brightness"
                 to: -0.35
                 duration: appletItem.animations.duration.large
                 easing.type: Easing.OutQuad
             }
         }
         ParallelAnimation{
             PropertyAnimation {
                 target: wrapper.clickedEffect
                 property: "brightness"
                 to: 0
                 duration: appletItem.animations.duration.large
                 easing.type: Easing.OutQuad
             }
         }
     }
     //END animations
 }
diff --git a/containment/package/contents/ui/applet/ItemWrapper.qml b/containment/package/contents/ui/applet/ItemWrapper.qml
index cb3cedae..da46e466 100644
--- a/containment/package/contents/ui/applet/ItemWrapper.qml
+++ b/containment/package/contents/ui/applet/ItemWrapper.qml
@@ -1,826 +1,804 @@
 /*
 *  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.needsFillSpace && root.isHorizontal && 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 + appletItem.metrics.margin.screenEdge : 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.needsFillSpace && root.isVertical && 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 + appletItem.metrics.margin.screenEdge : 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: " + (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 === appletItem.parabolic.factor.zoom) && !appletItem.parabolic.directRenderingEnabled) {
             appletItem.parabolic.setDirectRenderingEnabled(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) {
             appletItem.layouter.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) {
             appletItem.layouter.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 + appletItem.metrics.margin.screenEdge : 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 + appletItem.metrics.margin.screenEdge : wrapperContainerThickness;
                 } else {
                     return parent.zoomScaleHeight * wrapper.layoutHeight;
                 }
             }
 
         }
 
         opacity: appletShadow.active ? 0 : 1
 
         readonly property int appliedEdgeMargin: {
             if (appletItem.isInternalViewSplitter) {
                 return appletItem.metrics.margin.screenEdge + appletItem.metrics.margin.thickness;
             }
 
             return appletItem.screenEdgeMarginSupported ? 0 : appletItem.metrics.margin.screenEdge;
         }
 
         ///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 {
         id: animatedScaleBehavior
         enabled: !appletItem.parabolic.directRenderingEnabled || restoreAnimation.running
         NumberAnimation {
             duration: 3 * appletItem.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on zoomScale {
         enabled: !animatedScaleBehavior.enabled
         NumberAnimation { duration: 0 }
     }
 
     function calculateScales( currentMousePosition ){
         if (parabolic.factor.zoom===1) {
             return;
         }
 
         //use the new parabolic effect manager in order to handle all parabolic effect messages
         var scales = parabolic.applyParabolicEffect(index, currentMousePosition, center);
 
         //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 = parabolic.factor.zoom;
     } //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)
                     ){
                 if(!appletItem.latteApplet){
                     if(nScale >= 0)
                         zoomScale = nScale + step;
                     else
                         zoomScale = zoomScale + step;
                 }
             }
         }
     }
 
     function sltUpdateLowerItemScale(delegateIndex, newScale, step) {
         if (delegateIndex === appletItem.index) {
             if (communicator.parabolicEffectIsSupported) {
                 communicator.bridge.parabolic.client.hostRequestUpdateLowerItemScale(newScale, step);
                 return;
             }
 
             if (!appletItem.isSeparator && !appletItem.isHidden) {
                 //! when accepted
                 signalUpdateScale(delegateIndex, newScale, step);
 
                 if (newScale > 1) { // clear lower items
                     parabolic.sglUpdateLowerItemScale(delegateIndex-1, 1, 0);
                 }
             } else {
                 parabolic.sglUpdateLowerItemScale(delegateIndex-1, newScale, step);
             }
         } else if ((newScale === 1) && (appletItem.index < delegateIndex)) {
             //! apply zoom clearing
             if (communicator.parabolicEffectIsSupported) {
                 communicator.bridge.parabolic.client.hostRequestUpdateLowerItemScale(1, step);
             } else {
                 signalUpdateScale(appletItem.index, 1, 0);
             }
         }
     }
 
     function sltUpdateHigherItemScale(delegateIndex, newScale, step) {
         if (delegateIndex === appletItem.index) {          
             if (communicator.parabolicEffectIsSupported) {
                 communicator.bridge.parabolic.client.hostRequestUpdateHigherItemScale(newScale, step);
                 return;
             }
 
             if (!appletItem.isSeparator && !appletItem.isHidden) {
                 //! when accepted
                 signalUpdateScale(delegateIndex, newScale, step);
 
                 if (newScale > 1) { // clear higher items
                     parabolic.sglUpdateHigherItemScale(delegateIndex+1, 1, 0);
                 }
             } else {
                 parabolic.sglUpdateHigherItemScale(delegateIndex+1, newScale, step);
             }
         } else if ((newScale === 1) && (appletItem.index > delegateIndex)) {
             //! apply zoom clearing
             if (communicator.parabolicEffectIsSupported) {
                 communicator.bridge.parabolic.client.hostRequestUpdateHigherItemScale(1, step);
             } else {
                 signalUpdateScale(appletItem.index, 1, 0);
             }
         }
     }
 
     Component.onCompleted: {
         parabolic.sglUpdateLowerItemScale.connect(sltUpdateLowerItemScale);
         parabolic.sglUpdateHigherItemScale.connect(sltUpdateHigherItemScale);
     }
 
     Component.onDestruction: {
         parabolic.sglUpdateLowerItemScale.disconnect(sltUpdateLowerItemScale);
         parabolic.sglUpdateHigherItemScale.disconnect(sltUpdateHigherItemScale);
     }
 }// Main task area // id:wrapper
diff --git a/containment/package/contents/ui/layouts/LayoutsContainer.qml b/containment/package/contents/ui/layouts/LayoutsContainer.qml
index 9fe33247..09babbd0 100644
--- a/containment/package/contents/ui/layouts/LayoutsContainer.qml
+++ b/containment/package/contents/ui/layouts/LayoutsContainer.qml
@@ -1,458 +1,455 @@
 /*
 *  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 org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.private.containment 0.1 as LatteContainment
 
 import "./abilities" as AbilitiesTypes
 import "../debug" as Debug
 
 Item{
     id: layoutsContainer
 
     readonly property bool isHidden: root.inStartup || (latteView && latteView.visibility && latteView.visibility.isHidden)
-    readonly property bool useMaxLength: plasmoid.configuration.alignment === LatteCore.Types.Justify
-                                         || (plasmoid.configuration.alignment !== LatteCore.Types.Justify && layouter.mainLayout.fillApplets>0)
-
 
     property int currentSpot: -1000
 
     readonly property alias startLayout : _startLayout
     readonly property alias mainLayout: _mainLayout
     readonly property alias endLayout: _endLayout
 
     readonly property AbilitiesTypes.AbilityLayouts applets: AbilitiesTypes.AbilityLayouts{
         startLayout: _startLayout
         mainLayout: _mainLayout
         endLayout: _endLayout
     }
 
     signal contentsLengthChanged();
 
     Binding {
         target: layoutsContainer
         property: "x"
         when: !visibilityManager.inLocationAnimation
         value: {
             if (root.behaveAsPlasmaPanel) {
                 return 0;
             }
 
             if ( latteView && root.isHorizontal && root.panelAlignment === LatteCore.Types.Justify ){
                 return ((latteView.width/2) - (root.maxLength/2) + background.offset);
             } else {
                 if ((visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) && root.isVertical){
                     return;
                 }
 
                 if (layoutsContainer.isHidden && root.isVertical) {
                     if (LatteCore.WindowSystem.compositingActive) {
                         return visibilityManager.slidingOutToPos;
                     } else {
                         if ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge)) {
                             return visibilityManager.slidingOutToPos + 1;
                         } else {
                             return visibilityManager.slidingOutToPos - 1;
                         }
                     }
                 } else {
                     return 0;
                 }
             }
         }
     }
 
     Binding{
         target: layoutsContainer
         property: "y"
         when: !visibilityManager.inLocationAnimation
         value: {
             if (root.behaveAsPlasmaPanel) {
                 return 0;
             }
 
             if ( latteView && root.isVertical && root.panelAlignment === LatteCore.Types.Justify ) {
                 return ((latteView.height/2) - (root.maxLength/2) + background.offset);
             } else {
                 if ((visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) && root.isHorizontal){
                     return;
                 }
 
                 if (layoutsContainer.isHidden && root.isHorizontal) {
                     if (LatteCore.WindowSystem.compositingActive) {
                         return visibilityManager.slidingOutToPos;
                     } else {
                         if ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge)) {
                             return visibilityManager.slidingOutToPos + 1;
                         } else {
                             return visibilityManager.slidingOutToPos - 1;
                         }
                     }
                 } else {
                     return 0;
                 }
             }
         }
     }
 
     width:  root.isHorizontal && root.panelAlignment === LatteCore.Types.Justify ? root.maxLength : parent.width
     height: root.isVertical && root.panelAlignment === LatteCore.Types.Justify ? root.maxLength : parent.height
     z:10
 
     property bool animationSent: false
     property bool shouldCheckHalfs: (plasmoid.configuration.alignment === LatteCore.Types.Justify) && (_mainLayout.children>1)
 
     property int contentsWidth: _startLayout.width + _mainLayout.width + _endLayout.width
     property int contentsHeight: _startLayout.height + _mainLayout.height + _endLayout.height
 
     onContentsWidthChanged: {
         if (root.isHorizontal){
             var firstHalfExited = false;
             var secondHalfExited = false;
 
             if (shouldCheckHalfs){
                 firstHalfExited = ( (_startLayout.width + _mainLayout.width/2) >= root.maxLength/2 );
                 secondHalfExited = ( (_endLayout.width + _mainLayout.width/2) >= root.maxLength/2 );
             }
 
             if (latteView && ((contentsWidth >= root.maxLength) || firstHalfExited || secondHalfExited)) {
                 autosize.updateIconSize();
             }
 
             if (!animationSent) {
                 animationSent = true;
                 animations.needLength.addEvent(layoutsContainer);
             }
 
             contentsLengthChanged();
 
             delayUpdateMaskArea.start();
         }
     }
 
     onContentsHeightChanged: {
         if (root.isVertical){
             var firstHalfExited = false;
             var secondHalfExited = false;
 
             if (shouldCheckHalfs){
                 firstHalfExited = ( (_startLayout.height + _mainLayout.height/2) >= root.maxLength/2 );
                 secondHalfExited = ( (_endLayout.height + _mainLayout.height/2) >= root.maxLength/2 );
             }
 
             if (latteView && ((contentsHeight >= root.maxLength) || firstHalfExited || secondHalfExited)) {
                 autosize.updateIconSize();
             }
 
             if (!animationSent) {
                 animationSent = true;
                 animations.needLength.removeEvent(layoutsContainer);
             }
 
             contentsLengthChanged();
 
             delayUpdateMaskArea.start();
         }
     }
 
     onXChanged: root.updateEffectsArea();
     onYChanged: root.updateEffectsArea();
 
     EnvironmentActions {
         active: root.scrollAction !== LatteContainment.Types.ScrollNone || root.dragActiveWindowEnabled || root.closeActiveWindowEnabled
         alignment: _mainLayout.alignment
     }
 
     AppletsContainer {
         id: _startLayout
         beginIndex: 0
         offset: 0
         alignment: {
             switch(plasmoid.location) {
             case PlasmaCore.Types.BottomEdge: return LatteCore.Types.BottomEdgeLeftAlign;
             case PlasmaCore.Types.TopEdge: return LatteCore.Types.TopEdgeLeftAlign;
             case PlasmaCore.Types.LeftEdge: return LatteCore.Types.LeftEdgeTopAlign;
             case PlasmaCore.Types.RightEdge: return LatteCore.Types.RightEdgeTopAlign;
             }
 
             return LatteCore.Types.BottomEdgeLeftAlign;
         }
     }
 
     AppletsContainer {
         id: _mainLayout
         z:10 //be on top of start and end layouts
         beginIndex: 100
         offset: {
             if (inConfigureOffset!==0) {
                 return inConfigureOffset;
             }
 
             if (background.hasBothLengthShadows && !centered) {
                 //! it is used for Top/Bottom/Left/Right alignments when they show both background length shadows
                 return background.offset + background.totals.shadowsLength/2;
             }
 
             return (root.panelAlignment === LatteCore.Types.Justify) ? 0 : background.offset
         }
 
         readonly property bool centered: (root.panelAlignment === LatteCore.Types.Center) || (root.panelAlignment === LatteCore.Types.Justify)
         readonly property bool reversed: Qt.application.layoutDirection === Qt.RightToLeft
 
         //! do not update during dragging/moving applets inConfigureAppletsMode
         readonly property bool offsetUpdateIsBlocked: ((root.dragOverlay && root.dragOverlay.pressed) || layouter.appletsInParentChange)
         property bool isCoveredFromSideLayouts: false
         property int inConfigureOffset: 0
 
         alignment: {
             if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                 if (centered) return LatteCore.Types.LeftEdgeCenterAlign;
                 if (root.panelAlignment === LatteCore.Types.Top) return LatteCore.Types.LeftEdgeTopAlign;
                 if (root.panelAlignment === LatteCore.Types.Bottom) return LatteCore.Types.LeftEdgeBottomAlign;
             }
 
             if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                 if (centered) return LatteCore.Types.RightEdgeCenterAlign;
                 if (root.panelAlignment === LatteCore.Types.Top) return LatteCore.Types.RightEdgeTopAlign;
                 if (root.panelAlignment === LatteCore.Types.Bottom) return LatteCore.Types.RightEdgeBottomAlign;
             }
 
             if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                 if (centered) return LatteCore.Types.BottomEdgeCenterAlign;
 
                 if ((root.panelAlignment === LatteCore.Types.Left && !reversed)
                         || (root.panelAlignment === LatteCore.Types.Right && reversed)) {
                     return LatteCore.Types.BottomEdgeLeftAlign;
                 }
 
                 if ((root.panelAlignment === LatteCore.Types.Right && !reversed)
                         || (root.panelAlignment === LatteCore.Types.Left && reversed)) {
                     return LatteCore.Types.BottomEdgeRightAlign;
                 }
             }
 
             if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                 if (centered) return LatteCore.Types.TopEdgeCenterAlign;
 
                 if ((root.panelAlignment === LatteCore.Types.Left && !reversed)
                         || (root.panelAlignment === LatteCore.Types.Right && reversed)) {
                     return LatteCore.Types.TopEdgeLeftAlign;
                 }
 
                 if ((root.panelAlignment === LatteCore.Types.Right && !reversed)
                         || (root.panelAlignment === LatteCore.Types.Left && reversed)) {
                     return LatteCore.Types.TopEdgeRightAlign;
                 }
             }
 
             return LatteCore.Types.BottomEdgeCenterAlign;
         }
 
         transitions: Transition {
             enabled: editModeVisual.plasmaEditMode
             AnchorAnimation {
                 duration: 0.8 * animations.duration.proposed
                 easing.type: Easing.OutCubic
             }
         }
 
         Binding{
             target: _mainLayout
             property:"isCoveredFromSideLayouts"
             when: !_mainLayout.offsetUpdateIsBlocked && layouter.inNormalFillCalculationsState
             value: {
                 if (!layouter.mainLayout.onlyInternalSplitters && !_mainLayout.offsetUpdateIsBlocked) {
                     //! one of side layouts goes underneath the main layout when the main layout contains valid applets
                     var limit = (root.maxLength - mainLayout.length)/2;
                     return ((startLayout.length > limit ) || (endLayout.length > limit));
                 }
 
                 //! start and end layouts length exceed the maximum length
                 return (startLayout.length + endLayout.length) > (root.maxLength);
             }
         }
 
         Binding{
             target: _mainLayout
             property:"inConfigureOffset"
             when: !_mainLayout.offsetUpdateIsBlocked && layouter.inNormalFillCalculationsState
             value: {
                 if (!root.inConfigureAppletsMode
                         || root.panelAlignment !== LatteCore.Types.Justify
                         || !layouter.mainLayout.onlyInternalSplitters) {
                     return 0;
                 }
 
                 var layoutMaxLength = root.maxLength / 2;
 
                 if (_mainLayout.isCoveredFromSideLayouts) {
                     return layoutMaxLength - mainLayout.length/2;
                 }
 
                 if (startLayout.length > layoutMaxLength) {
                     return (layoutMaxLength - endLayout.length - mainLayout.length/2);
                 } else if (endLayout.length > layoutMaxLength) {
                     return -(layoutMaxLength - startLayout.length - mainLayout.length/2);
                 }
 
                 return 0;
             }
         }
     }
 
     AppletsContainer {
         id: _endLayout
         beginIndex: 200
         offset: 0
         alignment: {
             switch(plasmoid.location) {
             case PlasmaCore.Types.BottomEdge: return LatteCore.Types.BottomEdgeRightAlign;
             case PlasmaCore.Types.TopEdge: return LatteCore.Types.TopEdgeRightAlign;
             case PlasmaCore.Types.LeftEdge: return LatteCore.Types.LeftEdgeBottomAlign;
             case PlasmaCore.Types.RightEdge: return LatteCore.Types.RightEdgeBottomAlign;
             }
 
             return LatteCore.Types.BottomEdgeLeftAlign;
         }
     }
 
     Connections {
         target: metrics
         onIconSizeAnimationEnded: delayUpdateMaskArea.start();
     }
 
     //! Debug Elements
     Loader{
         anchors.top: startLayout.top
         anchors.horizontalCenter: startLayout.horizontalCenter
         active: root.debugModeLayouter
 
         readonly property Item debugLayout: layouter.startLayout
 
         sourceComponent: Debug.Tag{
             background.color: "white"
             label.text: tagText
             label.color: "black"
             label.font.pointSize: 13
             readonly property int layoutLength: root.isHorizontal ? debugLayout.grid.width : debugLayout.grid.height
 
             readonly property string tagText: {
                 return "normal:" + debugLayout.shownApplets + " / fill:" + debugLayout.fillApplets + " / reg_len:" + debugLayout.sizeWithNoFillApplets + " / tot_len:"+layoutLength;
             }
         }
     }
 
     Loader{
         anchors.top: endLayout.top
         anchors.horizontalCenter: endLayout.horizontalCenter
         active: root.debugModeLayouter
 
         readonly property Item debugLayout: layouter.endLayout
 
         sourceComponent: Debug.Tag{
             background.color: "white"
             label.text: tagText
             label.color: "black"
             label.font.pointSize: 13
             readonly property int layoutLength: root.isHorizontal ? debugLayout.grid.width : debugLayout.grid.height
 
             readonly property string tagText: {
                 return "normal:" + debugLayout.shownApplets + " / fill:" + debugLayout.fillApplets + " / reg_len:" + debugLayout.sizeWithNoFillApplets + " / tot_len:"+layoutLength;
             }
         }
     }
 
     Loader{
         anchors.top: mainLayout.top
         anchors.horizontalCenter: mainLayout.horizontalCenter
         active: root.debugModeLayouter
         z:70
 
         readonly property Item debugLayout: layouter.mainLayout
 
         sourceComponent: Debug.Tag{
             background.color: "white"
             label.text: tagText
             label.color: "black"
             label.font.pointSize: 13
             readonly property int layoutLength: root.isHorizontal ? debugLayout.grid.width : debugLayout.grid.height
 
             readonly property string tagText: {
                 return "normal:" + debugLayout.shownApplets + " / fill:" + debugLayout.fillApplets + " / reg_len:" + debugLayout.sizeWithNoFillApplets + " / tot_len:"+layoutLength;
             }
         }
     }
 
     Loader{
         anchors.top: mainLayout.top
         anchors.left: parent.left
         active: root.debugModeLayouter
 
         readonly property Item debugLayout: layoutsContainer
 
         sourceComponent: Debug.Tag{
             background.color: "blue"
             label.text: tagText
             label.color: "yellow"
             label.font.pointSize: 13
             label.font.bold: true
             readonly property int layoutLength: root.isHorizontal ? debugLayout.width : debugLayout.height
 
             readonly property int layoutsLength: {
                 if (root.isVertical) {
                     return layouter.startLayout.grid.height + layouter.mainLayout.grid.height + layouter.endLayout.grid.height;
                 }
 
                 return layouter.startLayout.grid.width + layouter.mainLayout.grid.width + layouter.endLayout.grid.width;
             }
 
             readonly property string tagText: {
                 return "MAX:" + root.maxLength + " / TOT:"+layoutLength + " / LAYS:"+ layoutsLength;
             }
         }
     }
 
     //! This timer is needed in order to update mask area after ContentsWidth/Height and iconSize changes
     Timer{
         id:delayUpdateMaskArea
         repeat:false;
         interval:300;
 
         onTriggered: {
             if (layoutsContainer.animationSent) {
                 animations.needLength.removeEvent(layoutsContainer);
                 layoutsContainer.animationSent = false;
             }
 
             visibilityManager.updateMaskArea();
 
             if (root.debugModeTimers) {
                 console.log("LayoutsContainer timer: delayUpdateMaskArea called...");
             }
         }
     }
 }