diff --git a/containment/package/contents/ui/VisibilityManager.qml b/containment/package/contents/ui/VisibilityManager.qml
index d0aaf9b5..e35e16d7 100644
--- a/containment/package/contents/ui/VisibilityManager.qml
+++ b/containment/package/contents/ui/VisibilityManager.qml
@@ -1,1019 +1,1019 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.1
 import QtQuick.Window 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.private.containment 0.1 as LatteContainment
 
 Item{
     id: manager
 
     anchors.fill: parent
 
     property QtObject window
 
     property bool debugManager: Qt.application.arguments.indexOf("--mask") >= 0
 
     property bool blockUpdateMask: false
     property bool inForceHiding: false //is used when the docks are forced in hiding e.g. when changing layouts
     property bool normalState : false  // this is being set from updateMaskArea
     property bool previousNormalState : false // this is only for debugging purposes
     property bool panelIsBiggerFromIconSize: root.useThemePanel && (background.totals.visualThickness >= (metrics.iconSize + metrics.margin.thickness))
 
     property bool maskIsFloating: !root.behaveAsPlasmaPanel
                                   && !root.editMode
                                   && screenEdgeMarginEnabled
                                   && !plasmoid.configuration.fittsLawIsRequested
                                   && !inSlidingIn
                                   && !inSlidingOut
 
     property int maskFloatedGap: maskIsFloating ? Math.max(0, metrics.margin.screenEdge - background.shadows.headThickness) : 0
 
     property int animationSpeed: LatteCore.WindowSystem.compositingActive ?
                                      (editModeVisual.inEditMode ? editModeVisual.speed * 0.8 : animations.speedFactor.normal * 1.62 * animations.duration.large) : 0
 
     property bool inLocationAnimation: latteView && latteView.positioner && latteView.positioner.inLocationAnimation
     property bool inSlidingIn: false //necessary because of its init structure
     property alias inSlidingOut: slidingAnimationAutoHiddenOut.running
     property bool inTempHiding: false
     property int length: root.isVertical ?  Screen.height : Screen.width   //screenGeometry.height : screenGeometry.width
 
     property int slidingOutToPos: {
         if (root.behaveAsPlasmaPanel) {
             var edgeMargin = screenEdgeMarginEnabled ? plasmoid.configuration.screenEdgeMargin : 0
 
             root.isHorizontal ? root.height + edgeMargin - 1 : root.width + edgeMargin - 1;
         } else {
             var topOrLeftEdge = ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge));
             return (topOrLeftEdge ? -thicknessNormal : thicknessNormal);
         }
     }
 
     property int finalScreenEdgeMargin: {
         //! is used for window geometry calculations
         if (!screenEdgeMarginEnabled
                 || (hideThickScreenGap && metrics.margin.screenEdge === 0)) {
             /*window geometry is updated after the local screen margin animation was zeroed*/
             return 0;
         }
 
         return plasmoid.configuration.screenEdgeMargin;
     }
 
     property int thicknessAutoHidden: LatteCore.WindowSystem.compositingActive ?  2 : 1
     property int thicknessMid: finalScreenEdgeMargin + (1 + (0.65 * (parabolic.factor.maxZoom-1)))*(metrics.totals.thickness+extraThickMask) //needed in some animations
     property int thicknessNormal: finalScreenEdgeMargin + Math.max(metrics.totals.thickness + extraThickMask + 1, background.thickness + background.shadows.headThickness)
 
     property int thicknessZoom: finalScreenEdgeMargin + ((metrics.totals.thickness+extraThickMask) * parabolic.factor.maxZoom) + 2
     //it is used to keep thickness solid e.g. when iconSize changes from auto functions
     property int thicknessMidOriginal: finalScreenEdgeMargin + Math.max(thicknessNormalOriginal,extraThickMask + (1 + (0.65 * (parabolic.factor.maxZoom-1)))*(metrics.maxIconSize+metrics.margin.maxThickness)) //needed in some animations
     property int thicknessNormalOriginal: finalScreenEdgeMargin + metrics.maxIconSize + (metrics.margin.maxThickness * 2) //this way we always have the same thickness published at all states
     /*property int thicknessNormalOriginal: !root.behaveAsPlasmaPanel || root.editMode ?
                                                thicknessNormalOriginalValue : background.thickness + background.shadows.headThickness*/
 
     property int thicknessNormalOriginalValue: finalScreenEdgeMargin + metrics.maxIconSize + (metrics.margin.maxThickness * 2) + extraThickMask + 1
     property int thicknessZoomOriginal: finalScreenEdgeMargin + Math.max( ((metrics.maxIconSize+(metrics.margin.maxThickness * 2)) * parabolic.factor.maxZoom) + extraThickMask + 2,
                                                                          background.thickness + background.shadows.headThickness,
                                                                          (LatteCore.WindowSystem.compositingActive ? thicknessEditMode + root.editShadow : thicknessEditMode))
 
     //! is used from Panel in edit mode in order to provide correct masking
     property int thicknessEditMode: thicknessNormalOriginalValue + editModeVisual.settingsThickness
     //! when Latte behaves as Plasma panel
     property int thicknessAsPanel: metrics.totals.thickness
 
     //! is used to increase the mask thickness
     readonly property int marginBetweenContentsAndRuler: root.editMode ? 10 : 0
     property int extraThickMask: marginBetweenContentsAndRuler + Math.max(indicatorsExtraThickMask, shadowsExtraThickMask)
     //! this is set from indicators when they need extra thickness mask size
     readonly property int indicatorsExtraThickMask: indicators.info.extraMaskThickness
     property int shadowsExtraThickMask: {
         if (LatteCore.WindowSystem.isPlatformWayland) {
             return 0;
         }
 
         //! 45% of max shadow size in px.
         var shadowMaxNeededMargin = 0.45 * root.appShadowSizeOriginal;
         var shadowOpacity = (plasmoid.configuration.shadowOpacity) / 100;
         //! +40% of shadow opacity in percentage
         shadowOpacity = shadowOpacity + shadowOpacity*0.4;
 
         //! This way we are trying to calculate how many pixels are needed in order for the shadow
         //! to be drawn correctly without being cut of from View::mask() under X11
         shadowMaxNeededMargin = (shadowMaxNeededMargin * shadowOpacity);
 
         //! give some more space when items shadows are enabled and extremely big
         if (root.enableShadows && metrics.margin.maxThickness < shadowMaxNeededMargin) {
             return shadowMaxNeededMargin - metrics.margin.maxThickness;
         }
 
         return 0;
     }
 
     property Item applets: null
 
     Binding{
         target: latteView
         property:"maxThickness"
         //! prevents updating window geometry during closing window in wayland and such fixes a crash
         when: latteView && !inTempHiding && !inForceHiding
         value: root.behaveAsPlasmaPanel && !root.editMode ? thicknessAsPanel : thicknessZoomOriginal
     }
 
     property bool validIconSize: (metrics.iconSize===metrics.maxIconSize || metrics.iconSize === autosize.iconSize)
     property bool inPublishingState: validIconSize && !inSlidingIn && !inSlidingOut && !inTempHiding && !inForceHiding
 
     Binding{
         target: latteView
         property:"normalThickness"
         when: latteView && inPublishingState
         value: root.behaveAsPlasmaPanel && !root.editMode ? thicknessAsPanel : thicknessNormalOriginal
     }
 
     Binding{
         target: latteView
         property:"editThickness"
         when: latteView
         value: thicknessEditMode
     }
 
     Binding{
         target: latteView
         property: "type"
         when: latteView
         value: root.viewType
     }
 
     Binding{
         target: latteView
         property: "behaveAsPlasmaPanel"
         when: latteView
         value: root.editMode ? false : root.behaveAsPlasmaPanel
     }
 
     Binding{
         target: latteView
         property: "fontPixelSize"
         when: theme
         value: theme.defaultFont.pixelSize
     }
 
     Binding{
         target: latteView
         property:"inEditMode"
         when: latteView
         value: root.editMode
     }
 
     Binding{
         target: latteView
         property:"latteTasksArePresent"
         when: latteView
         value: latteApplet !== null
     }
 
     Binding{
         target: latteView
         property: "maxLength"
         when: latteView
         value: root.inConfigureAppletsMode ? 1 : maxLengthPerCentage/100
     }
 
     Binding{
         target: latteView
         property: "offset"
         when: latteView
         value: plasmoid.configuration.offset/100
     }
 
     Binding{
         target: latteView
         property: "screenEdgeMargin"
         when: latteView
         value: plasmoid.configuration.screenEdgeMargin
     }
 
     Binding{
         target: latteView
         property: "screenEdgeMarginEnabled"
         when: latteView
         value: root.screenEdgeMarginEnabled && !root.hideThickScreenGap
     }
 
     Binding{
         target: latteView
         property: "alignment"
         when: latteView
         value: root.panelAlignment
     }
 
     Binding{
         target: latteView
         property: "isTouchingTopViewAndIsBusy"
         when: latteView
         value: {
             var isTouchingTopScreenEdge = (latteView.y === latteView.screenGeometry.y);
             var hasTopBorder = ((latteView.effects && (latteView.effects.enabledBorders & PlasmaCore.FrameSvg.TopBorder)) > 0);
 
             return root.isVertical && !latteView.visibility.isHidden && !isTouchingTopScreenEdge && !hasTopBorder && background.isShown;
         }
     }
 
     Binding{
         target: latteView
         property: "isTouchingBottomViewAndIsBusy"
         when: latteView
         value: {
             var latteBottom = latteView.y + latteView.height;
             var screenBottom = latteView.screenGeometry.y + latteView.screenGeometry.height;
             var isTouchingBottomScreenEdge = (latteBottom === screenBottom);
 
             var hasBottomBorder = ((latteView.effects && (latteView.effects.enabledBorders & PlasmaCore.FrameSvg.BottomBorder)) > 0);
 
             return root.isVertical && !latteView.visibility.isHidden && !isTouchingBottomScreenEdge && !hasBottomBorder && background.isShown;
         }
     }
 
     //! View::Effects bindings
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "backgroundOpacity"
         when: latteView && latteView.effects
         value: background.currentOpacity
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "drawEffects"
         when: latteView && latteView.effects
         value: LatteCore.WindowSystem.compositingActive
                && !root.inConfigureAppletsMode
                && (((root.blurEnabled && root.useThemePanel)
                     || (root.blurEnabled && root.forceSolidPanel && LatteCore.WindowSystem.compositingActive))
                    && (!root.inStartup || inForceHiding || inTempHiding))
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "drawShadows"
         when: latteView && latteView.effects
         value: root.drawShadowsExternal && (!root.inStartup || inForceHiding || inTempHiding) && !(latteView && latteView.visibility.isHidden)
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property:"editShadow"
         when: latteView && latteView.effects
         value: root.editShadow
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property:"innerShadow"
         when: latteView && latteView.effects
         value: {
             if (editModeVisual.editAnimationEnded && !root.behaveAsPlasmaPanel) {
                 return root.editShadow;
             } else {
                 return background.shadows.headThickness;
             }
         }
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "settingsMaskSubtracted"
         when: latteView && latteView.effects
         value: {
             if (LatteCore.WindowSystem.compositingActive
                     && root.editMode
                     && editModeVisual.editAnimationEnded
                     && (animations.needBothAxis.count === 0 || parabolic.factor.maxZoom===1) ) {
                 return true;
             } else {
                 return false;
             }
         }
     }
 
     //! View::Positioner bindings
     Binding{
         target: latteView && latteView.positioner ? latteView.positioner : null
         property: "isStickedOnTopEdge"
         when: latteView && latteView.positioner
         value: plasmoid.configuration.isStickedOnTopEdge
     }
 
     Binding{
         target: latteView && latteView.positioner ? latteView.positioner : null
         property: "isStickedOnBottomEdge"
         when: latteView && latteView.positioner
         value: plasmoid.configuration.isStickedOnBottomEdge
     }
 
     //! View::WindowsTracker bindings
     Binding{
         target: latteView && latteView.windowsTracker ? latteView.windowsTracker : null
         property: "enabled"
         when: latteView && latteView.windowsTracker && latteView.visibility
         value: (latteView && latteView.visibility
                 && !(latteView.visibility.mode === LatteCore.Types.AlwaysVisible /* Visibility */
                      || latteView.visibility.mode === LatteCore.Types.WindowsGoBelow
                      || latteView.visibility.mode === LatteCore.Types.AutoHide))
                || applets.require.windowsTrackingCount > 0                   /*Applets Need Windows Tracking */
                || root.dragActiveWindowEnabled                               /*Dragging Active Window(Empty Areas)*/
                || ((root.backgroundOnlyOnMaximized                           /*Dynamic Background */
                     || plasmoid.configuration.solidBackgroundForMaximized
                     || root.disablePanelShadowMaximized
                     || root.windowColors !== LatteContainment.Types.NoneWindowColors))
                || (root.screenEdgeMarginsEnabled                             /*Dynamic Screen Edge Margin*/
                    && plasmoid.configuration.hideScreenGapForMaximized)
     }
 
     Connections{
         target:root      
         onEditModeChanged: {
             if (root.editMode) {
                 visibilityManager.updateMaskArea();
             }
         }
     }
 
     Connections{
         target: background.totals
         onVisualLengthChanged: updateMaskArea();
         onVisualThicknessChanged: updateMaskArea();
     }
 
     Connections{
         target: background.shadows
         onHeadThicknessChanged: updateMaskArea();
     }
 
     Connections{
         target: latteView ? latteView : null
         onXChanged: updateMaskArea();
         onYChanged: updateMaskArea()
         onWidthChanged: updateMaskArea();
         onHeightChanged: updateMaskArea();
     }
 
     Connections{
         target: animations.needBothAxis
         onCountChanged: updateMaskArea();
     }
 
     Connections{
         target: animations.needLength
         onCountChanged: updateMaskArea();
     }
 
     Connections{
         target: animations.needThickness
         onCountChanged: updateMaskArea();
     }
 
     Connections{
         target: layoutsManager
         onCurrentLayoutIsSwitching: {
             if (LatteCore.WindowSystem.compositingActive && latteView && latteView.layout && latteView.layout.name === layoutName) {
                 manager.inTempHiding = true;
                 manager.inForceHiding = true;
                 parabolic.sglClearZoom();
                 manager.slotMustBeHide();
             }
         }
     }
 
     Connections{
         target: themeExtended ? themeExtended : null
         onRoundnessChanged: latteView.effects.forceMaskRedraw();
         onThemeChanged: latteView.effects.forceMaskRedraw();
     }
 
     onMaskIsFloatingChanged: updateMaskArea();
 
     onNormalStateChanged: {
         if (normalState) {
             autosize.updateIconSize();
             root.updateSizeForAppletsInFill();
         }
     }
 
     onThicknessZoomOriginalChanged: {
         updateMaskArea();
     }
 
     function slotContainsMouseChanged() {
         if(latteView.visibility.containsMouse && latteView.visibility.mode !== LatteCore.Types.SideBar) {
             updateMaskArea();
 
             if (slidingAnimationAutoHiddenOut.running && !inTempHiding && !inForceHiding) {
                 slotMustBeShown();
             }
         }
     }
 
     function slotMustBeShown() {
         //! WindowsCanCover case
         if (latteView && latteView.visibility.mode === LatteCore.Types.WindowsCanCover) {
             latteView.visibility.setViewOnFrontLayer();
             return;
         }
 
         //! Normal Dodge/AutoHide case
         if (!slidingAnimationAutoHiddenIn.running && !inTempHiding && !inForceHiding){
             slidingAnimationAutoHiddenIn.init();
         }
     }
 
     function slotMustBeHide() {
         if (latteView && latteView.visibility.mode === LatteCore.Types.WindowsCanCover) {
             latteView.visibility.setViewOnBackLayer();
             return;
         }
 
         //! prevent sliding-in on startup if the dodge modes have sent a hide signal
         if (inStartupTimer.running && root.inStartup) {
             root.inStartup = false;
         }
 
         //! Normal Dodge/AutoHide case
         if((!slidingAnimationAutoHiddenOut.running
             && !latteView.visibility.blockHiding
             && (!latteView.visibility.containsMouse || latteView.visibility.mode === LatteCore.Types.SideBar))
                 || inForceHiding) {
             slidingAnimationAutoHiddenOut.init();
         }
     }
 
     //! functions used for sliding out/in during location/screen changes
     function slotHideDockDuringLocationChange() {
         inTempHiding = true;
         blockUpdateMask = true;
 
         if(!slidingAnimationAutoHiddenOut.running) {
             slidingAnimationAutoHiddenOut.init();
         }
     }
 
     function slotShowDockAfterLocationChange() {
         slidingAnimationAutoHiddenIn.init();
     }
 
     function sendHideDockDuringLocationChangeFinished(){
         blockUpdateMask = false;
         latteView.positioner.hideDockDuringLocationChangeFinished();
     }
 
     function sendSlidingOutAnimationEnded() {
         latteView.visibility.hide();
         latteView.visibility.isHidden = true;
 
         if (visibilityManager.debugManager) {
             console.log("hiding animation ended...");
         }
 
         sendHideDockDuringLocationChangeFinished();
     }
 
     ///test maskArea
     function updateMaskArea() {
         if (!latteView || blockUpdateMask) {
             return;
         }
 
         var localX = 0;
         var localY = 0;
 
         normalState = ((animations.needBothAxis.count === 0) && (animations.needLength.count === 0))
                 || (latteView.visibility.isHidden && !latteView.visibility.containsMouse && animations.needThickness.count === 0);
 
 
         // debug maskArea criteria
         if (debugManager) {
             console.log(animations.needBothAxis.count + ", " + animations.needLength.count + ", " +
                         animations.needThickness.count + ", " + latteView.visibility.isHidden);
 
             if (previousNormalState !== normalState) {
                 console.log("normal state changed to:" + normalState);
                 previousNormalState = normalState;
             }
         }
 
         var tempLength = root.isHorizontal ? width : height;
         var tempThickness = root.isHorizontal ? height : width;
 
         var noCompositingEdit = !LatteCore.WindowSystem.compositingActive && root.editMode;
 
         if (LatteCore.WindowSystem.compositingActive || noCompositingEdit) {
             if (normalState) {
                 //console.log("entered normal state...");
                 //count panel length
 
 
                 //used when !compositing and in editMode
                 if (noCompositingEdit) {
                     tempLength = root.isHorizontal ? root.width : root.height;
                 } else {
                     tempLength = background.totals.visualLength;
                 }
 
                 tempThickness = thicknessNormal;
 
                 if (animations.needThickness.count > 0) {
                     tempThickness = LatteCore.WindowSystem.compositingActive ? thicknessZoom : thicknessNormal;
                 }
 
                 if (maskIsFloating) {
                     tempThickness = tempThickness - maskFloatedGap;
                 }
 
                 if (latteView.visibility.isHidden && !slidingAnimationAutoHiddenOut.running ) {
                     tempThickness = thicknessAutoHidden;
                 }
 
                 //configure x,y based on plasmoid position and root.panelAlignment(Alignment)
                 if ((plasmoid.location === PlasmaCore.Types.BottomEdge) || (plasmoid.location === PlasmaCore.Types.TopEdge)) {
                     if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                         if (latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges) {
                             localY = latteView.height + tempThickness;
                         } else if (maskIsFloating && !latteView.visibility.isHidden) {
                             localY = latteView.height - tempThickness - maskFloatedGap;
                         } else {
                             localY = latteView.height - tempThickness;
                         }
                     } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                         if (latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges) {
                             localY = -tempThickness;
                         } else if (maskIsFloating && !latteView.visibility.isHidden) {
                             localY = maskFloatedGap;
                         } else {
                             localY = 0;
                         }
                     }
 
                     if (noCompositingEdit) {
                         localX = 0;
                     } else if (plasmoid.configuration.alignment === LatteCore.Types.Justify) {
-                        localX = (latteView.width/2) - tempLength/2 + root.offset;
+                        localX = (latteView.width/2) - tempLength/2 + background.offset;
                     } else if (root.panelAlignment === LatteCore.Types.Left) {
-                        localX = root.offset;
+                        localX = background.offset;
                     } else if (root.panelAlignment === LatteCore.Types.Center) {
-                        localX = (latteView.width/2) - tempLength/2 + root.offset;
+                        localX = (latteView.width/2) - tempLength/2 + background.offset;
                     } else if (root.panelAlignment === LatteCore.Types.Right) {
-                        localX = latteView.width - tempLength - root.offset;
+                        localX = latteView.width - tempLength - background.offset;
                     }
                 } else if ((plasmoid.location === PlasmaCore.Types.LeftEdge) || (plasmoid.location === PlasmaCore.Types.RightEdge)){
                     if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                         if (latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges) {
                             localX = -tempThickness;
                         } else if (maskIsFloating && !latteView.visibility.isHidden) {
                             localX = maskFloatedGap;
                         } else {
                             localX = 0;
                         }
                     } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                         if (latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges) {
                             localX = latteView.width + tempThickness;
                         } else if (maskIsFloating && !latteView.visibility.isHidden) {
                             localX = latteView.width - tempThickness - maskFloatedGap;
                         } else {
                             localX = latteView.width - tempThickness;
                         }
                     }
 
                     if (noCompositingEdit) {
                         localY = 0;
                     } else if (plasmoid.configuration.alignment === LatteCore.Types.Justify) {
-                        localY = (latteView.height/2) - tempLength/2 + root.offset;
+                        localY = (latteView.height/2) - tempLength/2 + background.offset;
                     } else if (root.panelAlignment === LatteCore.Types.Top) {
-                        localY = root.offset;
+                        localY = background.offset;
                     } else if (root.panelAlignment === LatteCore.Types.Center) {
-                        localY = (latteView.height/2) - tempLength/2 + root.offset;
+                        localY = (latteView.height/2) - tempLength/2 + background.offset;
                     } else if (root.panelAlignment === LatteCore.Types.Bottom) {
-                        localY = latteView.height - tempLength - root.offset;
+                        localY = latteView.height - tempLength - background.offset;
                     }
                 }
 
                 if (latteView.visibility.isHidden && latteView && latteView.visibility.mode === LatteCore.Types.SideBar) {
                     //!hide completely
                     localX = -1;
                     localY = -1;
                     tempThickness = 1;
                     tempLength = 1;
                 }
             } else {
                 // !inNormalState
 
                 if(root.isHorizontal)
                     tempLength = Screen.width; //screenGeometry.width;
                 else
                     tempLength = Screen.height; //screenGeometry.height;
 
                 //grow only on length and not thickness
                 var onlyLengthAnimation = (animations.needLength.count>0 && animations.needBothAxis.count === 0);
 
                 if(onlyLengthAnimation) {
 
                     //this is used to fix a bug with shadow showing when the animation of edit mode
                     //is triggered
                     tempThickness = editModeVisual.editAnimationEnded ? thicknessEditMode + root.editShadow : thicknessEditMode
 
                     if (latteView.visibility.isHidden && !slidingAnimationAutoHiddenOut.running ) {
                         tempThickness = thicknessAutoHidden;
                     } else if (animations.needThickness.count > 0) {
                         tempThickness = thicknessZoomOriginal;
                     }
                 } else{
                     //use all thickness space
                     if (latteView.visibility.isHidden && !slidingAnimationAutoHiddenOut.running ) {
                         tempThickness = LatteCore.WindowSystem.compositingActive ? thicknessAutoHidden : thicknessNormalOriginal;
                     } else {
                         tempThickness = !maskIsFloating ? thicknessZoomOriginal : thicknessZoomOriginal - maskFloatedGap;
                     }
                 }
 
                 //configure the x,y position based on thickness
                 if(plasmoid.location === PlasmaCore.Types.RightEdge) {
                     localX = !maskIsFloating ? latteView.width - tempThickness : latteView.width - tempThickness - maskFloatedGap;
 
                     if (localX < 0) {
                         tempThickness = tempThickness + localX;
                         localX = 0;
                     }
                 } else if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                     localY = !maskIsFloating ? latteView.height - tempThickness : latteView.height - tempThickness - maskFloatedGap;
 
                     if (localY < 0) {
                         tempThickness = tempThickness + localY;
                         localY = 0;
                     }
                 } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                     localY = !maskIsFloating ? 0 : maskFloatedGap;
                 } else if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                     localX = !maskIsFloating ? 0 : maskFloatedGap;
                 }
             }
         } // end of compositing calculations
 
         var maskArea = latteView.effects.mask;
 
         if (LatteCore.WindowSystem.compositingActive) {
             var maskLength = maskArea.width; //in Horizontal
             if (root.isVertical) {
                 maskLength = maskArea.height;
             }
 
             var maskThickness = maskArea.height; //in Horizontal
             if (root.isVertical) {
                 maskThickness = maskArea.width;
             }
         } else if (!noCompositingEdit){
             //! no compositing case
             var overridesHidden = latteView.visibility.isHidden && !latteView.visibility.supportsKWinEdges;
 
             if (!overridesHidden) {
                 localX = latteView.effects.rect.x;
                 localY = latteView.effects.rect.y;
             } else {
                 if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                     localX = latteView.effects.rect.x;
                     localY = root.height - thicknessAutoHidden;
                 } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                     localX = latteView.effects.rect.x;
                     localY = 0;
                 } else if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                     localX = 0;
                     localY = latteView.effects.rect.y;
                 } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                     localX = root.width - thicknessAutoHidden;
                     localY = latteView.effects.rect.y;
                 }
             }
 
             if (root.isHorizontal) {
                 tempThickness = overridesHidden ? thicknessAutoHidden : latteView.effects.rect.height;
                 tempLength = latteView.effects.rect.width;
             } else {
                 tempThickness = overridesHidden ? thicknessAutoHidden : latteView.effects.rect.width;
                 tempLength = latteView.effects.rect.height;
             }
         }
 
 
 
         //  console.log("Not updating mask...");
         if( maskArea.x !== localX || maskArea.y !== localY
                 || maskLength !== tempLength || maskThickness !== tempThickness) {
 
             // console.log("Updating mask...");
             var newMaskArea = Qt.rect(-1,-1,0,0);
             newMaskArea.x = localX;
             newMaskArea.y = localY;
 
             if (isHorizontal) {
                 newMaskArea.width = tempLength;
                 newMaskArea.height = tempThickness;
             } else {
                 newMaskArea.width = tempThickness;
                 newMaskArea.height = tempLength;
             }
 
             if (!LatteCore.WindowSystem.compositingActive) {
                 latteView.effects.mask = newMaskArea;
             } else {
                 if (latteView.behaveAsPlasmaPanel && !root.editMode) {
                     latteView.effects.mask = Qt.rect(0,0,root.width,root.height);
                 } else {
                     latteView.effects.mask = newMaskArea;
                 }
             }
         }
 
         var validIconSize = (metrics.iconSize===metrics.maxIconSize || metrics.iconSize === autosize.iconSize);
 
         //console.log("reached updating geometry ::: "+dock.maskArea);
 
         if(inPublishingState && !latteView.visibility.isHidden && (normalState || root.editMode)) {
             //! Important: Local Geometry must not be updated when view ISHIDDEN
             //! because it breaks Dodge(s) modes in such case
 
             var localGeometry = Qt.rect(0, 0, root.width, root.height);
 
             //the shadows size must be removed from the maskArea
             //before updating the localDockGeometry
             if (!latteView.behaveAsPlasmaPanel || root.editMode) {
                 var cleanThickness = metrics.totals.thickness;
                 var edgeMargin = finalScreenEdgeMargin;
 
                 if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                     localGeometry.x = latteView.effects.rect.x; // from effects area
                     localGeometry.width = latteView.effects.rect.width; // from effects area
 
                     localGeometry.y = edgeMargin;
                     localGeometry.height = cleanThickness ;
                 } else if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                     localGeometry.x = latteView.effects.rect.x; // from effects area
                     localGeometry.width = latteView.effects.rect.width; // from effects area
 
                     localGeometry.y = root.height - cleanThickness - edgeMargin;
                     localGeometry.height = cleanThickness;
                 } else if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                     localGeometry.y = latteView.effects.rect.y; // from effects area
                     localGeometry.height = latteView.effects.rect.height; // from effects area
 
                     localGeometry.x = edgeMargin;
                     localGeometry.width = cleanThickness;
                 } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                     localGeometry.y = latteView.effects.rect.y; // from effects area
                     localGeometry.height = latteView.effects.rect.height; // from effects area
 
                     localGeometry.x = root.width - cleanThickness - edgeMargin;
                     localGeometry.width = cleanThickness;
                 }
 
                 //set the boundaries for latteView local geometry
                 //qBound = qMax(min, qMin(value, max)).
 
                 localGeometry.x = Math.max(0, Math.min(localGeometry.x, latteView.width));
                 localGeometry.y = Math.max(0, Math.min(localGeometry.y, latteView.height));
                 localGeometry.width = Math.min(localGeometry.width, latteView.width);
                 localGeometry.height = Math.min(localGeometry.height, latteView.height);
             }
 
             //console.log("update geometry ::: "+localGeometry);
             latteView.localGeometry = localGeometry;
         }
     }
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
 
         sourceComponent: Item{
             anchors.fill:parent
 
             Rectangle{
                 id: windowBackground
                 anchors.fill: parent
                 border.color: "red"
                 border.width: 1
                 color: "transparent"
             }
 
             Rectangle{
                 x: latteView ? latteView.effects.mask.x : -1
                 y: latteView ? latteView.effects.mask.y : -1
                 height: latteView ? latteView.effects.mask.height : 0
                 width: latteView ? latteView.effects.mask.width : 0
 
                 border.color: "green"
                 border.width: 1
                 color: "transparent"
             }
         }
     }
 
     /***Hiding/Showing Animations*****/
 
     //////////////// Animations - Slide In - Out
     SequentialAnimation{
         id: slidingAnimationAutoHiddenOut
 
         ScriptAction{
             script: {
                 root.isHalfShown = true;
             }
         }
 
         PropertyAnimation {
             target: !root.behaveAsPlasmaPanel ? layoutsContainer : latteView.positioner
             property: !root.behaveAsPlasmaPanel ? (root.isVertical ? "x" : "y") : "slideOffset"
             to: {
                 if (root.behaveAsPlasmaPanel) {
                     return slidingOutToPos;
                 }
 
                 if (LatteCore.WindowSystem.compositingActive) {
                     return slidingOutToPos;
                 } else {
                     if ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge)) {
                         return slidingOutToPos + 1;
                     } else {
                         return slidingOutToPos - 1;
                     }
                 }
             }
             duration: manager.animationSpeed
             easing.type: Easing.InQuad
         }
 
         ScriptAction{
             script: {
                 latteView.visibility.isHidden = true;
 
                 if (root.behaveAsPlasmaPanel && latteView.positioner.slideOffset !== 0) {
                     //! hide real panels when they slide-out
                     latteView.visibility.hide();
                 }
             }
         }
 
         onStarted: {
             if (manager.debugManager) {
                 console.log("hiding animation started...");
             }
         }
 
         onStopped: {
             //! Trying to move the ending part of the signals at the end of editing animation
             if (!manager.inTempHiding) {
                 manager.updateMaskArea();
             } else {
                 if (!editModeVisual.inEditMode) {
                     manager.sendSlidingOutAnimationEnded();
                 }
             }
 
             latteView.visibility.slideOutFinished();
         }
 
         function init() {
             if (manager.inLocationAnimation || !latteView.visibility.blockHiding) {
                 start();
             }
         }
     }
 
     SequentialAnimation{
         id: slidingAnimationAutoHiddenIn
 
         PauseAnimation{
             duration: manager.inTempHiding && animations.active ? 500 : 0
         }
 
         PropertyAnimation {
             target: !root.behaveAsPlasmaPanel ? layoutsContainer : latteView.positioner
             property: !root.behaveAsPlasmaPanel ? (root.isVertical ? "x" : "y") : "slideOffset"
             to: 0
             duration: manager.animationSpeed
             easing.type: Easing.OutQuad
         }
 
         ScriptAction{
             script: {
                 root.isHalfShown = false;
                 root.inStartup = false;
             }
         }
 
         onStarted: {
             latteView.visibility.show();
 
             if (manager.debugManager) {
                 console.log("showing animation started...");
             }
         }
 
         onStopped: {
             inSlidingIn = false;
 
             if (manager.inTempHiding) {
                 manager.inTempHiding = false;
                 autosize.updateIconSize();
             }
 
             manager.inTempHiding = false;
             autosize.updateIconSize();
 
             if (manager.debugManager) {
                 console.log("showing animation ended...");
             }
 
             latteView.visibility.slideInFinished();
 
             //! this is needed in order to update dock absolute geometry correctly in the end AND
             //! when a floating dock is sliding-in through masking techniques
             updateMaskArea();
         }
 
         function init() {
             inSlidingIn = true;
 
             if (slidingAnimationAutoHiddenOut.running) {
                 slidingAnimationAutoHiddenOut.stop();
             }
 
             latteView.visibility.isHidden = false;
             updateMaskArea();
 
             start();
         }
     }
 
     //! Slides Animations for FLOATING+BEHAVEASPLASMAPANEL when
     //! HIDETHICKSCREENCAP dynamically is enabled/disabled
     SequentialAnimation{
         id: slidingInRealFloating
 
         PropertyAnimation {
             target: latteView.positioner
             property: "slideOffset"
             to: 0
             duration: manager.animationSpeed
             easing.type: Easing.OutQuad
         }
     }
 
     SequentialAnimation{
         id: slidingOutRealFloating
 
         PropertyAnimation {
             target: latteView.positioner
             property: "slideOffset"
             to: plasmoid.configuration.screenEdgeMargin
             duration: manager.animationSpeed
             easing.type: Easing.InQuad
         }
     }
 
     Connections {
         target: root
         onHideThickScreenGapChanged: {
             if (root.behaveAsPlasmaPanel && !latteView.visibility.isHidden && !inSlidingIn && !inSlidingOut && !inStartup) {
                 if (hideThickScreenGap) {
                     latteView.positioner.inSlideAnimation = true;
                     slidingInRealFloating.stop();
                     slidingOutRealFloating.start();
                 } else {
                     slidingOutRealFloating.stop();
                     slidingInRealFloating.start();
                     latteView.positioner.inSlideAnimation = false;
                 }
             }
         }
     }
 
 }
diff --git a/containment/package/contents/ui/background/BackgroundProperties.qml b/containment/package/contents/ui/background/BackgroundProperties.qml
index 6559511c..f8a59298 100644
--- a/containment/package/contents/ui/background/BackgroundProperties.qml
+++ b/containment/package/contents/ui/background/BackgroundProperties.qml
@@ -1,35 +1,51 @@
 /*
 *  Copyright 2020  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.0
 
 import "./types" as BackgroundTypes
+import org.kde.plasma.plasmoid 2.0
+import org.kde.plasma.core 2.0 as PlasmaCore
 
 Item{
     property bool isShown: false
+
+    property bool hasAllBorders: false
+    property bool hasLeftBorder: false
+    property bool hasRightBorder: false
+    property bool hasTopBorder: false
+    property bool hasBottomBorder: false
+    readonly property bool hasBothLengthShadows:{
+        if (plasmoid.formFactor === PlasmaCore.Types.Vertical) {
+            return (hasTopBorder && hasBottomBorder);
+        }
+
+        return (hasLeftBorder && hasRightBorder);
+    }
+
     property int offset: 0
     property int length: 0
     property int thickness: 0
     property int screenEdgeMargin: 0
     property real currentOpacity: 0
 
     readonly property BackgroundTypes.Shadows shadows: BackgroundTypes.Shadows{}
     readonly property BackgroundTypes.Paddings paddings: BackgroundTypes.Paddings{}
     readonly property BackgroundTypes.Totals totals: BackgroundTypes.Totals{}
 }
diff --git a/containment/package/contents/ui/background/MultiLayered.qml b/containment/package/contents/ui/background/MultiLayered.qml
index a0ef6d01..bf3fa524 100644
--- a/containment/package/contents/ui/background/MultiLayered.qml
+++ b/containment/package/contents/ui/background/MultiLayered.qml
@@ -1,798 +1,900 @@
 /*
 *  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 QtQuick.Window 2.2
 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 "../colorizer" as Colorizer
 
 BackgroundProperties{
     id:barLine
 
     //! Layer 0: Multi-Layer container in order to provide a consistent final element that acts
     //! as a single entity/background
     width: root.isHorizontal ? totals.visualLength : 16
     height: root.isVertical ? totals.visualLength : 16
 
     opacity: root.useThemePanel ? 1 : 0
     currentOpacity: overlayedBackground.opacity>0 ? overlayedBackground.opacity : solidBackground.opacity
 
     isShown: (solidBackground.opacity > 0) || (overlayedBackground.opacity > 0)
 
-    shadows.left: shadowsSvgItem.margins.left
-    shadows.right: shadowsSvgItem.margins.right
-    shadows.top: shadowsSvgItem.margins.top
-    shadows.bottom: shadowsSvgItem.margins.bottom
+    hasAllBorders: solidBackground.enabledBorders === PlasmaCore.FrameSvg.AllBorders
+    hasLeftBorder: hasAllBorders || ((solidBackground.enabledBorders & PlasmaCore.FrameSvg.LeftBorder) > 0)
+    hasRightBorder: hasAllBorders || ((solidBackground.enabledBorders & PlasmaCore.FrameSvg.RightBorder) > 0)
+    hasTopBorder: hasAllBorders || ((solidBackground.enabledBorders & PlasmaCore.FrameSvg.TopBorder) > 0)
+    hasBottomBorder: hasAllBorders || ((solidBackground.enabledBorders & PlasmaCore.FrameSvg.BottomBorder) > 0)
+
+    shadows.left: hasLeftBorder ? shadowsSvgItem.margins.left : 0
+    shadows.right: hasRightBorder ? shadowsSvgItem.margins.right : 0
+    shadows.top: hasTopBorder ? shadowsSvgItem.margins.top : 0
+    shadows.bottom: hasBottomBorder ? shadowsSvgItem.margins.bottom : 0
 
     screenEdgeMargin: root.screenEdgeMarginEnabled ? Math.max(0, metrics.margin.screenEdge - shadows.tailThickness) : 0
 
     paddings.top: {
-        if (root.isHorizontal) {
+        if (root.isHorizontal && hasTopBorder) {
             var minimum = root.screenEdgeMarginEnabled && themeExtended ? themeExtended.topEdgeRoundness : 0;
             return Math.max(minimum, solidBackground.margins.top);
         }
 
         return 0;
     }
     paddings.bottom: {
-        if (root.isHorizontal) {
+        if (root.isHorizontal && hasBottomBorder) {
             var minimum = root.screenEdgeMarginEnabled && themeExtended ? themeExtended.bottomEdgeRoundness : 0;
             return Math.max(minimum, solidBackground.margins.bottom);
         }
 
         return 0;
     }
 
     paddings.left: {
-        if (root.isVertical) {
+        if (root.isVertical && hasLeftBorder) {
             var minimum = root.screenEdgeMarginEnabled && themeExtended ? themeExtended.leftEdgeRoundness : 0;
             return Math.max(minimum, solidBackground.margins.left);
         }
 
         return 0;
     }
 
     paddings.right: {
-        if (root.isVertical) {
+        if (root.isVertical && hasRightBorder) {
             var minimum = root.screenEdgeMarginEnabled && themeExtended ? themeExtended.rightEdgeRoundness : 0;
             return Math.max(minimum, solidBackground.margins.right);
         }
 
         return 0;
     }
 
     length: {
         if (root.behaveAsPlasmaPanel && LatteCore.WindowSystem.compositingActive && !root.editMode) {
             return root.isVertical ? root.height : root.width;
         }
 
-        if ((root.panelAlignment === LatteCore.Types.Justify) && root.isHorizontal) {
+        if (root.panelAlignment === LatteCore.Types.Justify) {
             return root.maxLength;
         }
 
         if (root.isVertical) {
             return Math.max(root.minLength, layoutsContainerItem.mainLayout.height);
         } else {
             return Math.max(root.minLength, layoutsContainerItem.mainLayout.width);
         }
     }
 
     thickness: {
         if (root.behaveAsPlasmaPanel) {
             return metrics.totals.thickness;
         } else {
             return Math.min(metrics.totals.thickness, background.totals.visualThickness);
         }
     }
 
+    offset: {
+        if (behaveAsPlasmaPanel || !LatteCore.WindowSystem.compositingActive) {
+            return 0;
+        }
+
+        if (root.isHorizontal) {
+            if (root.panelAlignment === LatteCore.Types.Left) {
+                return root.offset - shadows.left;
+            } else if (root.panelAlignment === LatteCore.Types.Right) {
+                return root.offset - shadows.right;
+            }
+        }
+
+        if (root.isVertical) {
+            if (root.panelAlignment === LatteCore.Types.Top) {
+                return root.offset - shadows.top;
+            } else if (root.panelAlignment === LatteCore.Types.Bottom) {
+                return root.offset - shadows.bottom;
+            }
+        }
+
+        return root.offset;// (root.panelAlignment === LatteCore.Types.Center ? root.offset : 0);
+    }
+
     totals.visualThickness: {
         var minimumBackground = paddings.headThickness + paddings.tailThickness;
         var itemMargins = root.shrinkThickMargins ? 0 : metrics.totals.thicknessEdges + metrics.margin.screenEdge;
         var maximumItem = metrics.iconSize + itemMargins;
         var percentage = LatteCore.WindowSystem.compositingActive ? plasmoid.configuration.panelSize/100 : 1;
         return Math.max(minimumBackground, percentage*maximumItem);
     }
 
     totals.visualLength: Math.max(background.length + totals.shadowsLength, totals.paddingsLength + totals.shadowsLength)
 
     property int animationTime: 6*animations.speedFactor.current*animations.duration.small
 
 
     Behavior on opacity{
         enabled: LatteCore.WindowSystem.compositingActive
         NumberAnimation {
             duration: barLine.animationTime
         }
     }
 
     Behavior on opacity{
         enabled: !LatteCore.WindowSystem.compositingActive
         NumberAnimation {
             duration: 0
         }
     }
 
     onXChanged: solidBackground.updateEffectsArea();
     onYChanged: solidBackground.updateEffectsArea();
 
     //! Layer 1: Shadows that are drawn around the background but always inside the View window (these are internal drawn shadows).
     //!          When the container has chosen external shadows (these are shadows that are drawn out of the View window from the compositor)
     //!          in such case the internal drawn shadows are NOT drawn at all.
     PlasmaCore.FrameSvgItem{
         id: shadowsSvgItem
         width: root.isVertical ?  background.thickness + totals.shadowsThickness : totals.visualLength
         height: root.isVertical ? totals.visualLength : background.thickness + totals.shadowsThickness
 
         imagePath: hideShadow ? "" : "widgets/panel-background"
         prefix: hideShadow ? "" : "shadow"
 
         visible: (opacity == 0) ? false : true
 
         opacity: {
             if ((root.forceTransparentPanel && !root.forcePanelForBusyBackground)
                     || !root.useThemePanel)
                 return 0;
             else
                 return 1;
         }
 
         enabledBorders: latteView && latteView.effects ? latteView.effects.enabledBorders : PlasmaCore.FrameSvg.NoBorder
 
         //! set true by default in order to avoid crash on startup because imagePath is set to ""
         readonly property bool themeHasShadow: themeExtended ? themeExtended.hasShadow : true
 
         readonly property bool hideShadow: (root.behaveAsPlasmaPanel && !root.editMode)
                                            || !LatteCore.WindowSystem.compositingActive
                                            || !root.panelShadowsActive
                                            || !themeHasShadow
 
         Behavior on opacity {
             enabled: LatteCore.WindowSystem.compositingActive
             NumberAnimation { duration: barLine.animationTime }
         }
 
 
         Behavior on opacity{
             enabled: !LatteCore.WindowSystem.compositingActive
             NumberAnimation { duration: 0 }
         }
 
         Behavior on opacity{
             enabled: LatteCore.WindowSystem.compositingActive
             NumberAnimation { duration: barLine.animationTime }
         }
 
         Behavior on opacity{
             enabled: !LatteCore.WindowSystem.compositingActive
             NumberAnimation { duration: 0 }
         }
 
 
         //! Layer 2: Draw fake blurness under background when the user is INEDITMODE state for visual feedback
         Loader {
             anchors.fill: solidBackground
             active: editModeVisual.inEditMode && root.userShowPanelBackground && plasmoid.configuration.blurEnabled
             sourceComponent: Item {
                 Image{
                     id: backTiler
                     anchors.fill: parent
                     visible: false
 
                     fillMode: Image.Tile
                     source: hasBackground ? latteView.layout.background : "../../icons/"+latteView.layout.background+"print.jpg"
 
                     readonly property bool hasBackground: (latteView && latteView.layout && latteView.layout.background.startsWith("/")) ?
                                                               true : false
                 }
 
                 ShaderEffectSource {
                     id: effectSource
                     anchors.fill: parent
                     visible: false
 
                     sourceItem: backTiler
                     sourceRect: Qt.rect(0,0, width, height)
                 }
 
                 FastBlur{
                     id: blur
                     anchors.fill: parent
                     opacity: editModeVisual.appliedOpacity * 1.4
 
                     source: effectSource
                     radius: 50
                     visible: false
                 }
 
                 OpacityMask {
                     anchors.horizontalCenter: parent.horizontalCenter
                     anchors.verticalCenter: parent.verticalCenter
                     anchors.horizontalCenterOffset: overlayedBackground.painterRectangle.anchors.horizontalCenterOffset
                     anchors.verticalCenterOffset: overlayedBackground.painterRectangle.anchors.verticalCenterOffset
 
                     width: overlayedBackground.painterRectangle.width
                     height: overlayedBackground.painterRectangle.height
 
                     source: blur
                     maskSource: overlayedBackground.painterRectangle
                     opacity: blur.opacity
                 }
             }
         }
 
         //! Layer 3: Provide visual solidness. Plasma themes by design may provide a panel-background svg that is not
         //!          solid. That means that user can not gain full solidness in such cases. This layer is responsible
         //!          to solve the previous mentioned plasma theme limitation.
         Colorizer.CustomBackground {
             id: backgroundLowestRectangle
             anchors.fill: solidBackground
             opacity: normalizedOpacity
             backgroundColor: colorizerManager.backgroundColor
             roundness: overlayedBackground.roundness
             visible: LatteCore.WindowSystem.compositingActive && solidBackground.exceedsThemeOpacityLimits
 
             readonly property real normalizedOpacity: visible ?  Math.min(1, (appliedOpacity - solidBackground.themeMaxOpacity)/(1-solidBackground.themeMaxOpacity)) : 0
             readonly property real appliedOpacity: visible ? solidBackground.appliedOpacity : 0
 
             Behavior on opacity{
                 enabled: LatteCore.WindowSystem.compositingActive
                 NumberAnimation { duration: barLine.animationTime }
             }
 
             Behavior on opacity{
                 enabled: !LatteCore.WindowSystem.compositingActive
                 NumberAnimation { duration: 0 }
             }
         }
 
         //! Layer 4: Original Plasma Theme "panel-background" svg. It is used for calculations and also to draw
         //!          the original background when to special settings and options exist from the user. It is also
         //!          doing one very important job which is to calculate the Effects Rectangle which is used from
         //!          the compositor to provide blurriness and from Mask calculations to provide the View Local Geometry
         PlasmaCore.FrameSvgItem{
             id: solidBackground
             anchors.leftMargin: LatteCore.WindowSystem.compositingActive ? shadowsSvgItem.margins.left : 0
             anchors.rightMargin: LatteCore.WindowSystem.compositingActive ? shadowsSvgItem.margins.right : 0
             anchors.topMargin: LatteCore.WindowSystem.compositingActive ? shadowsSvgItem.margins.top : 0
             anchors.bottomMargin: LatteCore.WindowSystem.compositingActive ? shadowsSvgItem.margins.bottom : 0
             anchors.fill:parent
 
             opacity: normalizedOpacity
 
             readonly property bool exceedsThemeOpacityLimits: appliedOpacity > themeMaxOpacity
             readonly property bool forceSolidness: root.forceSolidPanel || !LatteCore.WindowSystem.compositingActive
 
             //! must be normalized to plasma theme maximum opacity
             readonly property real normalizedOpacity: Math.min(1, appliedOpacity / themeMaxOpacity)
 
             readonly property real appliedOpacity: overlayedBackground.opacity > 0 && !paintInstantly ? 0 : overlayedBackground.midOpacity
             readonly property real themeMaxOpacity: {
                 if (themeExtended) {
                     switch(plasmoid.location) {
                     case PlasmaCore.Types.BottomEdge: return themeExtended.bottomEdgeMaxOpacity;
                     case PlasmaCore.Types.LeftEdge: return themeExtended.leftEdgeMaxOpacity;
                     case PlasmaCore.Types.TopEdge: return themeExtended.topEdgeMaxOpacity;
                     case PlasmaCore.Types.RightEdge: return themeExtended.rightEdgeMaxOpacity;
                     default: return 0;
                     }
                 }
 
                 return 1;
             }
 
             //! When switching from overlaied background to regular one this must be done
             //! instantly otherwise the transition is not smooth
             readonly property bool paintInstantly: (root.hasExpandedApplet && root.plasmaBackgroundForPopups)
                                                    || root.plasmaStyleBusyForTouchingBusyVerticalView
 
             property rect efGeometry: Qt.rect(-1,-1,0,0)
 
             imagePath: "widgets/panel-background"
 
             property int paddingsWidth: margins.left+margins.right
             property int paddingsHeight: margins.top + margins.bottom
 
             onWidthChanged: updateEffectsArea();
             onHeightChanged: updateEffectsArea();
             onImagePathChanged: solidBackground.adjustPrefix();
 
 
             Component.onCompleted: {
                 root.updateEffectsArea.connect(updateEffectsArea);
                 adjustPrefix();
             }
 
             Component.onDestruction: {
                 root.updateEffectsArea.disconnect(updateEffectsArea);
             }
 
             Connections{
                 target: root
 
                 onEditModeChanged: {
                     solidBackground.updateEffectsArea();
                 }
             }
 
             //! Fix for FrameSvgItem QML version not updating its margins after a theme change
             //! with this hack we enforce such update. I could use the repaintNeeded signal but
             //! it is called more often than the themeChanged one.
             Connections {
                 target: themeExtended
                 onThemeChanged: {
                     solidBackground.adjustPrefix();
                     plasmoid.configuration.panelShadows = !plasmoid.configuration.panelShadows;
                     plasmoid.configuration.panelShadows = !plasmoid.configuration.panelShadows;
                     updateEffectsArea();
                 }
             }
 
             Connections {
                 target: latteView ? latteView.visibility : null
                 onIsHiddenChanged: solidBackground.updateEffectsArea();
             }
 
 
             Connections{
                 target: plasmoid
                 onLocationChanged: solidBackground.adjustPrefix();
             }
 
             function updateEffectsArea(){
                 if (!latteView)
                     return;
 
                 if (!LatteCore.WindowSystem.compositingActive) {
                     //! NOCOMPOSITING mode is a special case and Effects Area is also used for
                     //! different calculations for View::mask()
                     var rootGeometry = mapToItem(root, 0, 0);
                     efGeometry.x = rootGeometry.x;
                     efGeometry.y = rootGeometry.y;
                     efGeometry.width = width;
                     efGeometry.height = height;
                 } else {
                     if (latteView.visibility.isHidden) {
                         //! valid hide mask
                         efGeometry.x = -1;
                         efGeometry.y = -1;
                         efGeometry.width = 1;
                         efGeometry.height = 1;
                     } else {
                         if (!root.behaveAsPlasmaPanel || root.editMode) {
                             var rootGeometry = mapToItem(root, 0, 0);
                             efGeometry.x = rootGeometry.x;
                             efGeometry.y = rootGeometry.y;
                         } else {
                             efGeometry.x = 0;
                             efGeometry.y = 0;
                         }
 
                         efGeometry.width = width;
                         efGeometry.height = height;
                     }
                 }
 
                 latteView.effects.rect = efGeometry;
 
                 //! needed both for NOCOMPOSITING environments AND
                 //! View::localGeometry calculations
                 visibilityManager.updateMaskArea();
             }
 
             onRepaintNeeded: {
                 if (root.behaveAsPlasmaPanel)
                     adjustPrefix();
             }
 
             enabledBorders: latteView && latteView.effects ? latteView.effects.enabledBorders : PlasmaCore.FrameSvg.NoBorder
 
             Behavior on opacity{
                 enabled: LatteCore.WindowSystem.compositingActive && !solidBackground.paintInstantly
                 NumberAnimation { duration: barLine.animationTime }
             }
 
             Behavior on opacity{
                 enabled: !LatteCore.WindowSystem.compositingActive
                 NumberAnimation { duration: 0 }
             }
 
             function adjustPrefix() {
                 if (!plasmoid) {
                     return "";
                 }
                 var pre;
                 switch (plasmoid.location) {
                 case PlasmaCore.Types.LeftEdge:
                     pre = "west";
                     break;
                 case PlasmaCore.Types.TopEdge:
                     pre = "north";
                     break;
                 case PlasmaCore.Types.RightEdge:
                     pre = "east";
                     break;
                 case PlasmaCore.Types.BottomEdge:
                     pre = "south";
                     break;
                 default:
                     prefix = "";
                 }
 
                 prefix = [pre, ""];
             }
         }
 
         //! Layer 5: Plasma theme design does not provide a way to colorize the background. This layer
         //!          solves this by providing a custom background layer that respects the Colorizer palette
         Colorizer.CustomBackground {
             id: overlayedBackground
             anchors.fill: solidBackground
 
             readonly property bool busyBackground: root.forcePanelForBusyBackground
                                                    && (solidBackground.opacity === 0 || !solidBackground.paintInstantly)
             readonly property bool coloredView: colorizerManager.mustBeShown && colorizerManager.applyTheme !== theme
 
             opacity: {
                 if (busyBackground && !forceSolidness) {
                     return plasmoid.configuration.panelTransparency / 100;
                 }
 
                 if (coloredView) {
                     return midOpacity;
                 }
 
                 return 0;
             }
 
             backgroundColor: colorizerManager.backgroundColor
 
             borderWidth: 1
             borderColor: backgroundColor
 
             roundness: {
                 if (themeExtended) {
                     switch(plasmoid.location) {
                     case PlasmaCore.Types.BottomEdge: return themeExtended.bottomEdgeRoundness;
                     case PlasmaCore.Types.LeftEdge: return themeExtended.leftEdgeRoundness;
                     case PlasmaCore.Types.TopEdge: return themeExtended.topEdgeRoundness;
                     case PlasmaCore.Types.RightEdge: return themeExtended.rightEdgeRoundness;
                     default: return 0;
                     }
                 }
 
                 return 0;
             }
 
             property real midOpacity: {
                 if (forceSolidness) {
                     return 1;
                 } else if (!root.userShowPanelBackground || root.forcePanelForBusyBackground || root.forceTransparentPanel) {
                     return 0;
                 } else {
                     return plasmoid.configuration.panelTransparency / 100;
                 }
             }
 
             readonly property bool forceSolidness: root.forceSolidPanel || !LatteCore.WindowSystem.compositingActive
 
 
             Behavior on opacity{
                 enabled: LatteCore.WindowSystem.compositingActive
                 NumberAnimation { duration: barLine.animationTime }
             }
 
             Behavior on opacity{
                 enabled: !LatteCore.WindowSystem.compositingActive
                 NumberAnimation { duration: 0 }
             }
 
             Behavior on backgroundColor{
                 enabled: LatteCore.WindowSystem.compositingActive
                 ColorAnimation { duration: barLine.animationTime }
             }
 
             Behavior on backgroundColor{
                 enabled: !LatteCore.WindowSystem.compositingActive
                 ColorAnimation { duration: 0 }
             }
         }
 
         //! Layer 6: Plasma theme design does not provide a way to draw background outline on demand. This layer
         //!          solves this by providing a custom background layer that only draws an outline on top of all
         //!          previous layers
         Loader{
             anchors.fill: solidBackground
             active: root.panelOutline && !(root.hasExpandedApplet && root.plasmaBackgroundForPopups)
             sourceComponent: Colorizer.CustomBackground{
                 backgroundColor: "transparent"
                 borderColor: colorizerManager.outlineColor
                 borderWidth: themeExtended ? themeExtended.outlineWidth : 1
                 roundness: overlayedBackground.roundness
             }
         }
 
         //! CustomBackground debugger
         /*Colorizer.CustomBackground {
             anchors.fill: solidBackground
             backgroundColor: "transparent"
             borderWidth: 1
             borderColor: "red"
             roundness: overlayedBackground.roundness
         }*/
     }
 
     transitions: Transition {
         enabled: editModeVisual.plasmaEditMode
         AnchorAnimation {
             duration: 0.8 * animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
 
     //BEGIN states
     //user set Panel Positions
     //0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Left
         State {
-            name: "leftCenterOrJustify"
-            when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === LatteCore.Types.Center || root.panelAlignment === LatteCore.Types.Justify)
+            name: "leftCenter"
+            when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: barLine.screenEdgeMargin;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
-                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: (root.panelAlignment === LatteCore.Types.Center ? root.offset : 0);
+                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: background.offset;
+            }
+        },
+        State {
+            name: "leftJustify"
+            when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === LatteCore.Types.Justify)
+
+            AnchorChanges {
+                target: barLine
+                anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
+            }
+            AnchorChanges {
+                target: shadowsSvgItem
+                anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
+            }
+            PropertyChanges{
+                target: barLine
+                anchors.leftMargin: barLine.screenEdgeMargin;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
+                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Left
         State {
             name: "leftTop"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: barLine.screenEdgeMargin;    anchors.rightMargin:0;     anchors.topMargin:root.offset - shadowsSvgItem.margins.top;    anchors.bottomMargin:0;
+                anchors.leftMargin: barLine.screenEdgeMargin;    anchors.rightMargin:0;     anchors.topMargin:background.offset;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Left
         State {
             name: "leftBottom"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: barLine.screenEdgeMargin;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:root.offset - shadowsSvgItem.margins.bottom;
+                anchors.leftMargin: barLine.screenEdgeMargin;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:background.offset;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Right
         State {
-            name: "rightCenterOrJustify"
-            when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === LatteCore.Types.Center || root.panelAlignment === LatteCore.Types.Justify)
+            name: "rightCenter"
+            when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin: barLine.screenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin:0;
-                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: (root.panelAlignment === LatteCore.Types.Center ? root.offset : 0);
+                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: background.offset;
+            }
+        },
+        State {
+            name: "rightJustify"
+            when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === LatteCore.Types.Justify)
+
+            AnchorChanges {
+                target: barLine
+                anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
+            }
+            AnchorChanges {
+                target: shadowsSvgItem
+                anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
+            }
+            PropertyChanges{
+                target: barLine
+                anchors.leftMargin: 0;    anchors.rightMargin: barLine.screenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin:0;
+                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "rightTop"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: 0;    anchors.rightMargin: barLine.screenEdgeMargin;     anchors.topMargin:root.offset-shadowsSvgItem.margins.top;    anchors.bottomMargin:0;
+                anchors.leftMargin: 0;    anchors.rightMargin: barLine.screenEdgeMargin;     anchors.topMargin:background.offset;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "rightBottom"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined }
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: 0;    anchors.rightMargin: barLine.screenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin:root.offset-shadowsSvgItem.margins.bottom;
+                anchors.leftMargin: 0;    anchors.rightMargin: barLine.screenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin:background.offset;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Bottom
         State {
-            name: "bottomCenterOrJustify"
-            when: (plasmoid.location === PlasmaCore.Types.BottomEdge)&&(root.panelAlignment === LatteCore.Types.Center || root.panelAlignment === LatteCore.Types.Justify)
+            name: "bottomCenter"
+            when: (plasmoid.location === PlasmaCore.Types.BottomEdge)&&(root.panelAlignment === LatteCore.Types.Center)
+
+            AnchorChanges {
+                target: barLine
+                anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
+            }
+            AnchorChanges {
+                target: shadowsSvgItem
+                anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
+            }
+            PropertyChanges{
+                target: barLine
+                anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin: barLine.screenEdgeMargin;
+                anchors.horizontalCenterOffset: background.offset; anchors.verticalCenterOffset: 0;
+            }
+        },
+        State {
+            name: "bottomJustify"
+            when: (plasmoid.location === PlasmaCore.Types.BottomEdge)&&(root.panelAlignment === LatteCore.Types.Justify)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin: barLine.screenEdgeMargin;
-                anchors.horizontalCenterOffset: (root.panelAlignment === LatteCore.Types.Center ? root.offset : 0); anchors.verticalCenterOffset: 0;
+                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "bottomLeft"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
                   &&(((root.panelAlignment === LatteCore.Types.Left)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      || ((root.panelAlignment === LatteCore.Types.Right)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: root.offset-shadowsSvgItem.margins.left;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin: barLine.screenEdgeMargin;
+                anchors.leftMargin: background.offset;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin: barLine.screenEdgeMargin;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
 
         },
         State {
             name: "bottomRight"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
                   &&(((root.panelAlignment === LatteCore.Types.Right)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      ||((root.panelAlignment === LatteCore.Types.Left)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: 0;    anchors.rightMargin:root.offset-shadowsSvgItem.margins.right;     anchors.topMargin:0;    anchors.bottomMargin: barLine.screenEdgeMargin;
+                anchors.leftMargin: 0;    anchors.rightMargin:background.offset;     anchors.topMargin:0;    anchors.bottomMargin: barLine.screenEdgeMargin;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Top
         State {
-            name: "topCenterOrJustify"
-            when: (plasmoid.location === PlasmaCore.Types.TopEdge)&&(root.panelAlignment === LatteCore.Types.Center || root.panelAlignment === LatteCore.Types.Justify)
+            name: "topCenter"
+            when: (plasmoid.location === PlasmaCore.Types.TopEdge)&&(root.panelAlignment === LatteCore.Types.Center)
+
+            AnchorChanges {
+                target: barLine
+                anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
+            }
+            AnchorChanges {
+                target: shadowsSvgItem
+                anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
+            }
+            PropertyChanges{
+                target: barLine
+                anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin: barLine.screenEdgeMargin;    anchors.bottomMargin:0;
+                anchors.horizontalCenterOffset: background.offset; anchors.verticalCenterOffset: 0;
+            }
+        },
+        State {
+            name: "topJustify"
+            when: (plasmoid.location === PlasmaCore.Types.TopEdge)&&(root.panelAlignment === LatteCore.Types.Justify)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin: barLine.screenEdgeMargin;    anchors.bottomMargin:0;
-                anchors.horizontalCenterOffset: (root.panelAlignment === LatteCore.Types.Center ? root.offset : 0); anchors.verticalCenterOffset: 0;
+                anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "topLeft"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
                   &&(((root.panelAlignment === LatteCore.Types.Left)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      || ((root.panelAlignment === LatteCore.Types.Right)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: root.offset-shadowsSvgItem.margins.left;    anchors.rightMargin:0;     anchors.topMargin: barLine.screenEdgeMargin;    anchors.bottomMargin:0;
+                anchors.leftMargin: background.offset;    anchors.rightMargin:0;     anchors.topMargin: barLine.screenEdgeMargin;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "topRight"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
                   &&(((root.panelAlignment === LatteCore.Types.Right)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      ||((root.panelAlignment === LatteCore.Types.Left)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
-                anchors.leftMargin: 0;    anchors.rightMargin:root.offset-shadowsSvgItem.margins.right;     anchors.topMargin: barLine.screenEdgeMargin;    anchors.bottomMargin:0;
+                anchors.leftMargin: 0;    anchors.rightMargin:background.offset;     anchors.topMargin: barLine.screenEdgeMargin;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         }
     ]
     //END states
 }
 
 
diff --git a/containment/package/contents/ui/layouts/LayoutsContainer.qml b/containment/package/contents/ui/layouts/LayoutsContainer.qml
index a40ebba6..b1fc7d06 100644
--- a/containment/package/contents/ui/layouts/LayoutsContainer.qml
+++ b/containment/package/contents/ui/layouts/LayoutsContainer.qml
@@ -1,333 +1,339 @@
 /*
 *  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 "../../code/HeuristicTools.js" as HeuristicTools
 
 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 && !root.inConfigureAppletsMode)
     /*   && ((!root.inConfigureAppletsMode && !root.behaveAsPlasmaPanel )
                                              || (behaveAsPlasmaPanel && root.inConfigureAppletsMode))*/
 
     property int allCount: root.latteApplet ? _mainLayout.count-1+latteApplet.tasksCount : _mainLayout.count
     property int currentSpot: -1000
 
     readonly property int fillApplets: _startLayout.fillApplets + _mainLayout.fillApplets + _endLayout.fillApplets
 
     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
     }
 
     Binding {
         target: layoutsContainer
         property: "x"
         when: !visibilityManager.inLocationAnimation
         value: {
             if (root.behaveAsPlasmaPanel) {
                 return 0;
             }
 
             if ( latteView && root.isHorizontal && useMaxLength ){
-                return ((latteView.width/2) - (root.maxLength/2) + root.offset);
+                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 && useMaxLength ) {
-                return ((latteView.height/2) - (root.maxLength/2) + root.offset);
+                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 && useMaxLength ? root.maxLength : parent.width
     height: root.isVertical && useMaxLength ? 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);
             }
 
             layoutsContainer.updateSizeForAppletsInFill();
 
             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);
             }
 
             layoutsContainer.updateSizeForAppletsInFill();
 
             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: background.totals.shadowsLength/2
+        offset: background.totals.shadowsLength/2 //it is applied only in Justify when both background length shadows are drawn
         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
         beginIndex: 100
-        offset: centered ? appliedOffset : root.offsetFixed
+        offset: {
+            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
-        readonly property int appliedOffset: root.panelAlignment === LatteCore.Types.Justify ? 0 : root.offset
 
         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
             }
         }
     }
 
     AppletsContainer {
         id: _endLayout
         beginIndex: 200
-        offset: background.totals.shadowsLength/2
+        offset: background.totals.shadowsLength/2 //it is applied only in Justify when both background length shadows are drawn
         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;
         }
     }
 
     function updateSizeForAppletsInFill() {
         if (!updateSizeForAppletsInFillTimer.running) {
             HeuristicTools.updateSizeForAppletsInFill();
             updateSizeForAppletsInFillTimer.start();
         }
     }
 
     Connections {
         target: metrics
         onIconSizeAnimationEnded: delayUpdateMaskArea.start();
     }
 
     Connections {
         target: animations
         onInNormalFillCalculationsStateChanged: {
             if (animations.inNormalFillCalculationsState) {
                 layoutsContainer.updateSizeForAppletsInFill();
             }
         }
     }
 
     //! This timer is needed in order to reduce the calls to heavy cpu function
     //! HeuristicTools.updateSizeForAppletsInFill()
     Timer{
         id: updateSizeForAppletsInFillTimer
         interval: 50
         onTriggered: HeuristicTools.updateSizeForAppletsInFill();
     }
 
     //! 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...");
             }
         }
     }
 }
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index 779f5db6..b238b82a 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1649 +1,1645 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.8
 import QtQuick.Layouts 1.1
 import QtQuick.Window 2.2
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 import org.kde.latte.private.app 0.1 as LatteApp
 import org.kde.latte.private.containment 0.1 as LatteContainment
 
 
 import "abilities" as Ability
 import "applet" as Applet
 import "colorizer" as Colorizer
 import "editmode" as EditMode
 import "indicators" as Indicators
 import "layouts" as Layouts
 import "./background" as Background
 import "../code/LayoutManager.js" as LayoutManager
 
 Item {
     id: root
     objectName: "containmentViewLayout"
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.isVertical
     LayoutMirroring.childrenInherit: true
 
     //// BEGIN SIGNALS
     signal destroyInternalViewSplitters();
     signal emptyAreasWheel(QtObject wheel);
     signal separatorsUpdated();
     signal signalActivateEntryAtIndex(int entryIndex);
     signal signalNewInstanceForEntryAtIndex(int entryIndex);
     signal updateEffectsArea();
     signal updateIndexes();
 
     signal broadcastedToApplet(string pluginName, string action, variant value);
     //// END SIGNALS
 
     ////BEGIN properties
     property bool debugMode: Qt.application.arguments.indexOf("--graphics")>=0
     property bool debugModeLocalGeometry: Qt.application.arguments.indexOf("--localgeometry")>=0
     property bool debugModeSpacers: Qt.application.arguments.indexOf("--spacers")>=0
     property bool debugModeTimers: Qt.application.arguments.indexOf("--timers")>=0
     property bool debugModeWindow: Qt.application.arguments.indexOf("--with-window")>=0
     property bool debugModeOverloadedIcons: Qt.application.arguments.indexOf("--overloaded-icons")>=0
 
     readonly property int version: LatteCore.Environment.makeVersion(0,9,4)
 
     property bool addLaunchersMessage: false
     property bool addLaunchersInTaskManager: plasmoid.configuration.addLaunchersInTaskManager
     property bool backgroundOnlyOnMaximized: plasmoid.configuration.backgroundOnlyOnMaximized
     property bool behaveAsPlasmaPanel: {
         if (!LatteCore.WindowSystem.compositingActive) {
             //! In NOCOMPOSITING mode VIEWS should behave as real windows and that way
             //! we gain also the snapping features from KWin
             return true;
         }
 
         if (!latteView || !latteView.visibility) {
             return false;
         }
 
         if (screenEdgeMarginEnabled && plasmoid.configuration.fittsLawIsRequested) {
             //! dont use when floating views are requesting Fitt's Law
             return false;
         }
 
         var staticLayout = (plasmoid.configuration.minLength === plasmoid.configuration.maxLength);
 
         return (visibilityManager.panelIsBiggerFromIconSize
                 && (parabolic.factor.maxZoom === 1.0)
                 && (plasmoid.configuration.alignment === LatteCore.Types.Justify || staticLayout)
                 && !root.editMode
                 && !visibilityManager.inLocationAnimation);
     }
 
     property int viewType: {
         var staticLayout = (plasmoid.configuration.minLength === plasmoid.configuration.maxLength);
 
         if ((plasmoid.configuration.alignment === LatteCore.Types.Justify || staticLayout)
                 && (plasmoid.configuration.useThemePanel)
                 && (plasmoid.configuration.panelSize === 100)
                 && (parabolic.factor.maxZoom === 1.0)) {
             return LatteCore.Types.PanelView;
         }
 
         return LatteCore.Types.DockView;
     }
 
     property bool blurEnabled: plasmoid.configuration.blurEnabled && (!forceTransparentPanel || forcePanelForBusyBackground)
 
     readonly property bool ignoreRegularFilesDragging: !root.editMode
                                                        && (dragInfo.computationsAreValid || foreDropArea.dragInfo.computationsAreValid)
                                                        && !root.dragInfo.isPlasmoid
                                                        && !root.dragInfo.onlyLaunchers
     readonly property Item dragInfo: Item {
         property bool entered: backDropArea.dragInfo.entered || foreDropArea.dragInfo.entered
         property bool isTask: backDropArea.dragInfo.isTask || foreDropArea.dragInfo.isTask
         property bool isPlasmoid: backDropArea.dragInfo.isPlasmoid || foreDropArea.dragInfo.isPlasmoid
         property bool isSeparator: backDropArea.dragInfo.isSeparator || foreDropArea.dragInfo.isSeparator
         property bool isLatteTasks: backDropArea.dragInfo.isLatteTasks || foreDropArea.dragInfo.isLatteTasks
         property bool onlyLaunchers: backDropArea.dragInfo.onlyLaunchers || foreDropArea.dragInfo.onlyLaunchers
 
         //  onIsPlasmoidChanged: console.log("isPlasmoid :: " + backDropArea.dragInfo.isPlasmoid + " _ " + foreDropArea.dragInfo.isPlasmoid );
         //  onEnteredChanged: console.log("entered :: " + backDropArea.dragInfo.entered + " _ " + foreDropArea.dragInfo.entered );
     }
 
     property bool containsOnlyPlasmaTasks: false //this is flag to indicate when from tasks only a plasma based one is found
     property bool dockContainsMouse: latteView && latteView.visibility ? latteView.visibility.containsMouse : false
 
     property bool disablePanelShadowMaximized: plasmoid.configuration.disablePanelShadowForMaximized && LatteCore.WindowSystem.compositingActive
     property bool drawShadowsExternal: panelShadowsActive && behaveAsPlasmaPanel && !visibilityManager.inTempHiding
     property bool editMode: editModeVisual.inEditMode
     property bool windowIsTouching: latteView && latteView.windowsTracker
                                     && (latteView.windowsTracker.currentScreen.activeWindowTouching || hasExpandedApplet)
 
     property bool forceSolidPanel: (latteView && latteView.visibility
                                     && LatteCore.WindowSystem.compositingActive
                                     && !inConfigureAppletsMode
                                     && userShowPanelBackground
                                     && ( (plasmoid.configuration.solidBackgroundForMaximized
                                           && !(hasExpandedApplet && !plasmaBackgroundForPopups)
                                           && latteView.windowsTracker.currentScreen.existsWindowTouching)
                                         || (hasExpandedApplet && plasmaBackgroundForPopups) ))
                                    || solidBusyForTouchingBusyVerticalView
                                    || plasmaStyleBusyForTouchingBusyVerticalView
                                    || !LatteCore.WindowSystem.compositingActive
 
     property bool forceTransparentPanel: root.backgroundOnlyOnMaximized
                                          && latteView && latteView.visibility
                                          && LatteCore.WindowSystem.compositingActive
                                          && !inConfigureAppletsMode
                                          && !forceSolidPanel
                                          && !latteView.windowsTracker.currentScreen.existsWindowTouching
                                          && !(windowColors === LatteContainment.Types.ActiveWindowColors && selectedWindowsTracker.existsWindowActive)
 
     property bool forcePanelForBusyBackground: userShowPanelBackground && (root.themeColors === LatteContainment.Types.SmartThemeColors)
                                                && ( (root.forceTransparentPanel && colorizerManager.backgroundIsBusy)
                                                    || normalBusyForTouchingBusyVerticalView )
 
     property bool normalBusyForTouchingBusyVerticalView: (latteView && latteView.windowsTracker /*is touching a vertical view that is in busy state and the user prefers isBusy transparency*/
                                                           && latteView.windowsTracker.currentScreen.isTouchingBusyVerticalView
                                                           && root.themeColors === LatteContainment.Types.SmartThemeColors
                                                           && plasmoid.configuration.backgroundOnlyOnMaximized
                                                           /*&& !plasmoid.configuration.solidBackgroundForMaximized
                                                           && !plasmaBackgroundForPopups*/)
 
     property bool solidBusyForTouchingBusyVerticalView: false //DISABLED, until to check if the normalBusyForTouchingBusyVerticalView is enough to catch and handle the case
     /*(latteView && latteView.windowsTracker /*is touching a vertical view that is in busy state and the user prefers solidness*/
     /* && latteView.windowsTracker.currentScreen.isTouchingBusyVerticalView
                                                          && root.themeColors === LatteContainment.Types.SmartThemeColors
                                                          && plasmoid.configuration.backgroundOnlyOnMaximized
                                                          && plasmoid.configuration.solidBackgroundForMaximized
                                                          && !plasmaBackgroundForPopups)*/
 
     property bool plasmaStyleBusyForTouchingBusyVerticalView: false //DISABLED, until to check if the normalBusyForTouchingBusyVerticalView is enough to catch and handle the case
     //(latteView && latteView.windowsTracker /*is touching a vertical view that is in busy state and the user prefers solidness*/
     /* && latteView.windowsTracker.currentScreen.isTouchingBusyVerticalView
                                                                && root.themeColors === LatteContainment.Types.SmartThemeColors
                                                                && plasmoid.configuration.backgroundOnlyOnMaximized
                                                                && plasmaBackgroundForPopups)*/
 
     property bool hideThickScreenGap: screenEdgeMarginEnabled
                                       && plasmoid.configuration.hideScreenGapForMaximized
                                       && latteView && latteView.windowsTracker
                                       && latteView.windowsTracker.currentScreen.existsWindowMaximized
 
     property bool hideLengthScreenGaps: hideThickScreenGap
                                         && (latteView.visibility.mode === LatteCore.Types.AlwaysVisible
                                             || latteView.visibility.mode === LatteCore.Types.WindowsGoBelow)
                                         && (plasmoid.configuration.alignment === LatteCore.Types.Justify)
                                         && plasmoid.configuration.maxLength>85
                                         && !root.editMode
 
 
 
     property int themeColors: plasmoid.configuration.themeColors
     property int windowColors: plasmoid.configuration.windowColors
 
     property bool colorizerEnabled: themeColors !== LatteContainment.Types.PlasmaThemeColors || windowColors !== LatteContainment.Types.NoneWindowColors
 
     property bool plasmaBackgroundForPopups: plasmoid.configuration.plasmaBackgroundForPopups
 
     readonly property bool hasExpandedApplet: latteView && latteView.extendedInterface.hasExpandedApplet;
     readonly property bool hasUserSpecifiedBackground: (latteView && latteView.layout && latteView.layout.background.startsWith("/")) ?
                                                            true : false
 
     readonly property bool inConfigureAppletsMode: root.editMode && (plasmoid.configuration.inConfigureAppletsMode || !LatteCore.WindowSystem.compositingActive)
     readonly property bool parabolicEffectEnabled: parabolic.factor.zoom>1 && !inConfigureAppletsMode
 
     property bool dockIsShownCompletely: !(dockIsHidden || inSlidingIn || inSlidingOut) && !root.editMode
     property bool closeActiveWindowEnabled: plasmoid.configuration.closeActiveWindowEnabled
     property bool dragActiveWindowEnabled: plasmoid.configuration.dragActiveWindowEnabled
     property bool immutable: plasmoid.immutable
     property bool inFullJustify: (plasmoid.configuration.alignment === LatteCore.Types.Justify) && (maxLengthPerCentage===100)
     property bool inSlidingIn: visibilityManager ? visibilityManager.inSlidingIn : false
     property bool inSlidingOut: visibilityManager ? visibilityManager.inSlidingOut : false
     property bool inStartup: true
     property bool isHalfShown: false //is used to disable the zoom hovering effect at sliding in-out the dock
     property bool isHorizontal: plasmoid.formFactor === PlasmaCore.Types.Horizontal
     property bool isReady: !(dockIsHidden || inSlidingIn || inSlidingOut)
     property bool isVertical: !isHorizontal
 
     property bool mouseWheelActions: plasmoid.configuration.mouseWheelActions
     property bool onlyAddingStarup: true //is used for the initialization phase in startup where there aren't removals, this variable provides a way to grow icon size
     property bool shrinkThickMargins: plasmoid.configuration.shrinkThickMargins
     property bool showLatteShortcutBadges: false
     property bool showAppletShortcutBadges: false
     property bool showMetaBadge: false
     property int applicationLauncherId: -1
 
     //FIXME: possibly this is going to be the default behavior, this user choice
     //has been dropped from the Dock Configuration Window
     //property bool smallAutomaticIconJumps: plasmoid.configuration.smallAutomaticIconJumps
     property bool smallAutomaticIconJumps: true
 
     property bool userShowPanelBackground: LatteCore.WindowSystem.compositingActive ? plasmoid.configuration.useThemePanel : true
     property bool useThemePanel: noApplets === 0 || !LatteCore.WindowSystem.compositingActive ?
                                      true : (plasmoid.configuration.useThemePanel || plasmoid.configuration.solidBackgroundForMaximized)
 
     property bool plasma515: LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,15,0)
     property bool plasma518: LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,18,0)
 
     readonly property int minAppletLengthInConfigure: 64
     readonly property int maxJustifySplitterSize: 96
 
     property int latteAppletPos: -1
     property real minLengthPerCentage: plasmoid.configuration.minLength
     property real maxLengthPerCentage: hideLengthScreenGaps ? 100 : plasmoid.configuration.maxLength
 
     property int minLength: {
         if (root.isHorizontal) {
             return behaveAsPlasmaPanel && LatteCore.WindowSystem.compositingActive ? width : width * (minLengthPerCentage/100)
         } else {
             return behaveAsPlasmaPanel && LatteCore.WindowSystem.compositingActive ? height : height * (minLengthPerCentage/100)
         }
     }
 
     property int maxLength: {
         if (root.isHorizontal) {
             return behaveAsPlasmaPanel ? width : width * (maxLengthPerCentage/100)
         } else {
             return behaveAsPlasmaPanel ? height : height * (maxLengthPerCentage/100)
         }
     }
 
     property int scrollAction: plasmoid.configuration.scrollAction
 
     property bool panelOutline: plasmoid.configuration.panelOutline
     property int panelEdgeSpacing: Math.max(background.lengthMargins, 1.5*appShadowSize)
     property int panelTransparency: plasmoid.configuration.panelTransparency //user set
 
     property bool panelShadowsActive: {
         if (!userShowPanelBackground) {
             return false;
         }
 
         if (inConfigureAppletsMode) {
             return plasmoid.configuration.panelShadows;
         }
 
         var forcedNoShadows = (plasmoid.configuration.panelShadows && disablePanelShadowMaximized
                                && latteView && latteView.windowsTracker && latteView.windowsTracker.currentScreen.activeWindowMaximized);
 
         if (forcedNoShadows) {
             return false;
         }
 
         var transparencyCheck = (blurEnabled || (!blurEnabled && background.currentOpacity>20));
 
         //! Draw shadows for isBusy state only when current panelTransparency is greater than 10%
         if (plasmoid.configuration.panelShadows && root.forcePanelForBusyBackground && transparencyCheck) {
             return true;
         }
 
         if (( (plasmoid.configuration.panelShadows && !root.backgroundOnlyOnMaximized)
              || (plasmoid.configuration.panelShadows && root.backgroundOnlyOnMaximized && !root.forceTransparentPanel))
                 && !forcedNoShadows) {
             return true;
         }
 
         if (hasExpandedApplet && plasmaBackgroundForPopups) {
             return true;
         }
 
         return false;
     }
 
     property int appShadowOpacity: (plasmoid.configuration.shadowOpacity/100) * 255
     property int appShadowSize: enableShadows ? (0.5*metrics.iconSize) * (plasmoid.configuration.shadowSize/100) : 0
     property int appShadowSizeOriginal: enableShadows ? (0.5*metrics.maxIconSize) * (plasmoid.configuration.shadowSize/100) : 0
 
     property string appChosenShadowColor: {
         if (plasmoid.configuration.shadowColorType === LatteContainment.Types.ThemeColorShadow) {
             var strC = String(theme.textColor);
             return strC.indexOf("#") === 0 ? strC.substr(1) : strC;
         } else if (plasmoid.configuration.shadowColorType === LatteContainment.Types.UserColorShadow) {
             return plasmoid.configuration.shadowColor;
         }
 
         // default shadow color
         return "080808";
     }
 
     property string appShadowColor: "#" + decimalToHex(appShadowOpacity) + appChosenShadowColor
     property string appShadowColorSolid: "#" + appChosenShadowColor
 
     property int offset: {
         if (behaveAsPlasmaPanel) {
             return 0;
         }
 
         if (root.isHorizontal) {
             return width * (plasmoid.configuration.offset/100);
         } else {
             height * (plasmoid.configuration.offset/100)
         }
     }
 
-    //center the layout correctly when the user uses an offset
-    property int offsetFixed: (offset===0 || panelAlignment === LatteCore.Types.Center || plasmoid.configuration.alignment === LatteCore.Types.Justify)?
-                                  offset : offset + background.totals.shadowsLength/2
-
     property int editShadow: {
         if (!LatteCore.WindowSystem.compositingActive) {
             return 0;
         } else if (latteView && latteView.screenGeometry) {
             return latteView.screenGeometry.height/90;
         } else {
             return 7;
         }
     }
 
     property bool screenEdgeMarginEnabled: plasmoid.configuration.screenEdgeMargin >= 0 && !plasmoid.configuration.shrinkThickMargins
 
     property int widthMargins: root.isVertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
     property int heightMargins: root.isHorizontal ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
 
     ///FIXME: <delete both> I can't remember why this is needed, maybe for the anchorings!!! In order for the Double Layout to not mess the anchorings...
     //property int layoutsContainer.mainLayoutPosition: !plasmoid.immutable ? LatteCore.Types.Center : (root.isVertical ? LatteCore.Types.Top : LatteCore.Types.Left)
     //property int panelAlignment: plasmoid.configuration.alignment !== LatteCore.Types.Justify ? plasmoid.configuration.alignment : layoutsContainer.mainLayoutPosition
 
     property int panelAlignment: plasmoid.configuration.alignment /*!root.inConfigureAppletsMode ? plasmoid.configuration.alignment :
                                                                 ( plasmoid.configuration.alignment === LatteCore.Types.Justify ?
                                                                      LatteCore.Types.Center : plasmoid.configuration.alignment )*/
 
     property int panelUserSetAlignment: plasmoid.configuration.alignment
 
     readonly property string plasmoidName: "org.kde.latte.plasmoid"
 
     property var badgesForActivate: {
         if (!shortcutsEngine) {
             return ['1','2','3','4','5','6','7','8','9','0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.'];
         }
 
         return shortcutsEngine.badgesForActivate;
     }
 
     property var iconsArray: [16, 22, 32, 48, 64, 96, 128, 256]
 
     property Item dragOverlay
     property Item toolBox
     property Item latteAppletContainer
     property Item latteApplet
 
     readonly property alias animations: _animations
     readonly property alias background: _background
     readonly property alias autosize: _autosize
     readonly property alias indexer: _indexer
     readonly property alias indicatorsManager: indicators
     readonly property alias metrics: _metrics
     readonly property alias parabolic: _parabolic
     readonly property alias parabolicManager: _parabolicManager
 
     readonly property alias maskManager: visibilityManager
     readonly property alias layoutsContainerItem: layoutsContainer
 
     readonly property alias latteView: _interfaces.view
     readonly property alias layoutsManager: _interfaces.layoutsManager
     readonly property alias shortcutsEngine: _interfaces.globalShortcuts
     readonly property alias themeExtended: _interfaces.themeExtended
     readonly property alias universalSettings: _interfaces.universalSettings
 
     readonly property QtObject viewLayout: latteView && latteView.layout ? latteView.layout : null
     readonly property QtObject selectedWindowsTracker: {
         if (latteView && latteView.windowsTracker) {
             switch(plasmoid.configuration.activeWindowFilter) {
             case LatteContainment.Types.ActiveInCurrentScreen:
                 return latteView.windowsTracker.currentScreen;
             case LatteContainment.Types.ActiveFromAllScreens:
                 return latteView.windowsTracker.allScreens;
             }
         }
 
         return null;
     }
 
     // TO BE DELETED, if not needed: property int counter:0;
 
     ///BEGIN properties provided to Latte Plasmoid
     //shadows for applets, it should be removed as the appleitems don't need it any more
     property bool badges3DStyle: universalSettings ? universalSettings.badges3DStyle : true
     property bool enableShadows: plasmoid.configuration.appletShadowsEnabled
     property bool dockIsHidden: latteView ? latteView.visibility.isHidden : true
 
     property bool titleTooltips: plasmoid.configuration.titleTooltips
     property bool unifiedGlobalShortcuts: true
 
     property int tasksCount: latteApplet ? latteApplet.tasksCount : 0  
 
     property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property color minimizedDotColor: colorizerManager.minimizedDotColor
     ///END properties from latteApplet
 
 
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     //// BEGIN properties in functions
     property int noApplets: {
         var count1 = 0;
         var count2 = 0;
 
         count1 = layoutsContainer.mainLayout.children.length;
         var tempLength = layoutsContainer.mainLayout.children.length;
 
         for (var i=tempLength-1; i>=0; --i) {
             var applet = layoutsContainer.mainLayout.children[i];
             if (applet && (applet === dndSpacer || applet === lastSpacer ||  applet.isInternalViewSplitter))
                 count1--;
         }
 
         count2 = layoutsContainer.endLayout.children.length;
         tempLength = layoutsContainer.endLayout.children.length;
 
         for (var i=tempLength-1; i>=0; --i) {
             var applet = layoutsContainer.endLayout.children[i];
             if (applet && (applet === dndSpacer || applet === lastSpacer  || applet.isInternalViewSplitter))
                 count2--;
         }
 
         return (count1 + count2);
     }
 
     ///The index of user's current icon size
     property int currentIconIndex:{
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === metrics.iconSize){
                 return i;
             }
         }
         return 3;
     }
 
     //// END properties in functions
 
     ////////////////END properties
 
     //// BEGIN OF Behaviors
     Behavior on offset {
         enabled: editModeVisual.editAnimationInFullThickness
         NumberAnimation {
             id: offsetAnimation
 
             duration: 0.8 * animations.duration.proposed
             easing.type: Easing.OutCubic
         }
     }
     //// END OF Behaviors
 
     //////////////START OF CONNECTIONS
     onEditModeChanged: {
         if (!editMode) {
             layoutsContainer.updateSizeForAppletsInFill();
         }
 
         //! This is used in case the dndspacer has been left behind
         //! e.g. the user drops a folder and a context menu is appearing
         //! but the user decides to not make a choice for the applet type
         if (dndSpacer.parent !== root) {
             dndSpacer.parent = root;
         }
     }
 
     onInConfigureAppletsModeChanged: {
         updateIndexes();
     }
 
     //! It is used only when the user chooses different alignment types
     //! and not during startup
     onPanelUserSetAlignmentChanged: {
         if (!root.editMode) {
             return;
         }
 
         if (root.editMode/*!inConfigureAppletsMode*/){
             if (panelUserSetAlignment===LatteCore.Types.Justify) {
                 addInternalViewSplitters();
                 splitMainLayoutToLayouts();
             } else {
                 joinLayoutsToMainLayout();
                 root.destroyInternalViewSplitters();
             }
         }
 
         LayoutManager.save();
         updateIndexes();
     }
 
     onLatteViewChanged: {
         if (latteView) {
             latteView.positioner.hideDockDuringLocationChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
 
 
             latteView.visibility.onContainsMouseChanged.connect(visibilityManager.slotContainsMouseChanged);
             latteView.visibility.onMustBeHide.connect(visibilityManager.slotMustBeHide);
             latteView.visibility.onMustBeShown.connect(visibilityManager.slotMustBeShown);
 
             updateContainsOnlyPlasmaTasks();
         }
     }
 
     onMaxLengthChanged: {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     onToolBoxChanged: {
         if (toolBox) {
             toolBox.visible = false;
         }
     }
 
     onIsReadyChanged: {
         if (isReady && !titleTooltipDialog.visible && titleTooltipDialog.activeItemHovered){
             titleTooltipDialog.show(titleTooltipDialog.activeItem, titleTooltipDialog.activeItemText);
         }
     }
 
     onIsVerticalChanged: {
         if (isVertical) {
             if (plasmoid.configuration.alignment === LatteCore.Types.Left)
                 plasmoid.configuration.alignment = LatteCore.Types.Top;
             else if (plasmoid.configuration.alignment === LatteCore.Types.Right)
                 plasmoid.configuration.alignment = LatteCore.Types.Bottom;
         } else {
             if (plasmoid.configuration.alignment === LatteCore.Types.Top)
                 plasmoid.configuration.alignment = LatteCore.Types.Left;
             else if (plasmoid.configuration.alignment === LatteCore.Types.Bottom)
                 plasmoid.configuration.alignment = LatteCore.Types.Right;
         }
     }
 
     Component.onCompleted: {
         //  currentLayout.isLayoutHorizontal = isHorizontal
         LayoutManager.plasmoid = plasmoid;
         LayoutManager.root = root;
         LayoutManager.layout = layoutsContainer.mainLayout;
         LayoutManager.layoutS = layoutsContainer.startLayout;
         LayoutManager.layoutE = layoutsContainer.endLayout;
         LayoutManager.lastSpacer = lastSpacer;
         LayoutManager.metrics = metrics;
 
         upgrader_v010_alignment();
 
         LayoutManager.restore();
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         inStartupTimer.start();
     }
 
     Component.onDestruction: {
         console.debug("Destroying Latte Dock Containment ui...");
 
         animations.appletsInParentChange = true;
 
         if (latteView) {
             latteView.positioner.hideDockDuringLocationChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
 
             if (latteView.visibility) {
                 latteView.visibility.onContainsMouseChanged.disconnect(visibilityManager.slotContainsMouseChanged);
                 latteView.visibility.onMustBeHide.disconnect(visibilityManager.slotMustBeHide);
                 latteView.visibility.onMustBeShown.disconnect(visibilityManager.slotMustBeShown);
             }
         }
     }
 
     Containment.onAppletAdded: {
         addApplet(applet, x, y);
         console.log(applet.pluginName);
         LayoutManager.save();
         updateIndexes();
     }
 
     Containment.onAppletRemoved: {
         LayoutManager.removeApplet(applet);
         var flexibleFound = false;
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var applet = layoutsContainer.mainLayout.children[i].applet;
             if (applet && ((root.isHorizontal && applet.Layout.fillWidth) ||
                            (!root.isHorizontal && applet.Layout.fillHeight)) &&
                     applet.visible) {
                 flexibleFound = true;
                 break
             }
         }
         if (!flexibleFound) {
             lastSpacer.parent = layoutsContainer.mainLayout;
         }
 
         console.log(applet.pluginName);
         LayoutManager.save();
 
         updateIndexes();
         updateContainsOnlyPlasmaTasks();
     }
 
     Plasmoid.onUserConfiguringChanged: {
         if (plasmoid.immutable) {
             if (dragOverlay) {
                 dragOverlay.destroy();
             }
             return;
         }
 
         // console.debug("user configuring", plasmoid.userConfiguring)
 
         if (plasmoid.userConfiguring) {
             //  console.log("applets------");
             for (var i = 0; i < plasmoid.applets.length; ++i) {
                 //    console.log("applet:"+i);
                 plasmoid.applets[i].expanded = false;
             }
             if (!dragOverlay) {
                 var component = Qt.createComponent("editmode/ConfigOverlay.qml");
                 if (component.status == Component.Ready) {
                     dragOverlay = component.createObject(root);
                 } else {
                     console.log("Could not create ConfigOverlay");
                     console.log(component.errorString());
                 }
                 component.destroy();
             } else {
                 dragOverlay.visible = true;
             }
         } else {
             if (dragOverlay) {
                 dragOverlay.visible = false;
                 dragOverlay.destroy();
             }
         }
     }
 
     Plasmoid.onImmutableChanged: {
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         ///Set Preferred Sizes///
         ///Notice: they are set here because if they are set with a binding
         ///they break the !immutable experience, the latteView becomes too small
         ///to add applets
         /*   if (plasmoid.immutable) {
             if(root.isHorizontal) {
                 root.Layout.preferredWidth = (plasmoid.configuration.alignment === LatteCore.Types.Justify ?
                                                   layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin);
             } else {
                 root.Layout.preferredHeight = (plasmoid.configuration.alignment === LatteCore.Types.Justify ?
                                                    layoutsContainer.height + 0.5*iconMargin : layoutsContainer.mainLayout.height + iconMargin);
             }
         } else {
             if (root.isHorizontal) {
                 root.Layout.preferredWidth = Screen.width;
             } else {
                 root.Layout.preferredHeight = Screen.height;
             }
         }*/
 
         visibilityManager.updateMaskArea();
     }
     //////////////END OF CONNECTIONS
 
     //////////////START OF FUNCTIONS
     function addApplet(applet, x, y) {
         var container = appletContainerComponent.createObject(dndSpacer.parent)
 
         container.applet = applet;
         applet.parent = container.appletWrapper;
 
         applet.anchors.fill = container.appletWrapper;
 
         applet.visible = true;
 
 
         // don't show applet if it chooses to be hidden but still make it
         // accessible in the panelcontroller
         container.visible = Qt.binding(function() {
             return applet.status !== PlasmaCore.Types.HiddenStatus || (!plasmoid.immutable && root.inConfigureAppletsMode)
         })
 
         addContainerInLayout(container, applet, x, y);
 
         updateContainsOnlyPlasmaTasks();
     }
 
     function addContainerInLayout(container, applet, x, y){
         // Is there a DND placeholder? Replace it!
         if ( (dndSpacer.parent === layoutsContainer.mainLayout)
                 || (dndSpacer.parent === layoutsContainer.startLayout)
                 || (dndSpacer.parent===layoutsContainer.endLayout)) {
             LayoutManager.insertBeforeForLayout(dndSpacer.parent, dndSpacer, container);
             dndSpacer.parent = root;
             return;
             // If the provided position is valid, use it.
         } else if (x >= 0 && y >= 0) {
             var index = LayoutManager.insertAtCoordinates2(container, x , y);
 
             // Fall through to determining an appropriate insert position.
         } else {
             var before = null;
             container.animationsEnabled = false;
 
             if (lastSpacer.parent === layoutsContainer.mainLayout) {
                 before = lastSpacer;
             }
 
             // Insert icons to the left of whatever is at the center (usually a Task Manager),
             // if it exists.
             // FIXME TODO: This is a real-world fix to produce a sensible initial position for
             // launcher icons added by launcher menu applets. The basic approach has been used
             // since Plasma 1. However, "add launcher to X" is a generic-enough concept and
             // frequent-enough occurrence that we'd like to abstract it further in the future
             // and get rid of the ugliness of parties external to the containment adding applets
             // of a specific type, and the containment caring about the applet type. In a better
             // system the containment would be informed of requested launchers, and determine by
             // itself what it wants to do with that information.
             if (applet.pluginName == "org.kde.plasma.icon") {
                 var middle = layoutsContainer.mainLayout.childAt(root.width / 2, root.height / 2);
 
                 if (middle) {
                     before = middle;
                 }
 
                 // Otherwise if lastSpacer is here, enqueue before it.
             }
 
             if (before) {
                 LayoutManager.insertBefore(before, container);
 
                 // Fall through to adding at the end.
             } else {
                 container.parent = layoutsContainer.mainLayout;
             }
         }
 
         //Important, removes the first children of the layoutsContainer.mainLayout after the first
         //applet has been added
         lastSpacer.parent = root;
 
         updateIndexes();
     }
 
     function addInternalViewSplitters(){
         if (internalViewSplittersCount() === 0) {
             addInternalViewSplitter(plasmoid.configuration.splitterPosition);
             addInternalViewSplitter(plasmoid.configuration.splitterPosition2);
         }        
     }
 
     function addInternalViewSplitter(pos){
         var splittersCount = internalViewSplittersCount();
         if(splittersCount<2){
             var container = appletContainerComponent.createObject(root);
 
             container.internalSplitterId = splittersCount+1;
             container.visible = true;
 
             if(pos>=0 ){
                 LayoutManager.insertAtIndex(layoutsContainer.mainLayout, container, pos);
             } else {
                 LayoutManager.insertAtIndex(layoutsContainer.mainLayout, container, Math.floor(layoutsContainer.mainLayout.count / 2));
             }
         }
     }
 
     //! it is used in order to check the right click position
     //! the only way to take into account the visual appearance
     //! of the applet (including its spacers)
     function appletContainsPos(appletId, pos){
         for (var i = 0; i < layoutsContainer.startLayout.children.length; ++i) {
             var child = layoutsContainer.startLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var child = layoutsContainer.mainLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.endLayout.children.length; ++i) {
             var child = layoutsContainer.endLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         return false;
     }
 
     function checkLastSpacer() {
         lastSpacer.parent = root
 
         var expands = false;
 
         if (isHorizontal) {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillWidth) {
                     expands = true;
                 }
             }
         } else {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillHeight) {
                     expands = true;
                 }
             }
         }
         if (!expands) {
             lastSpacer.parent = layoutsContainer.mainLayout
         }
     }
 
     function containmentActions(){
         return latteView.containmentActions();
     }
 
     function decimalToHex(d, padding) {
         var hex = Number(d).toString(16);
         padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
 
         while (hex.length < padding) {
             hex = "0" + hex;
         }
 
         return hex;
     }
 
     function internalViewSplittersCount(){
         var splitters = 0;
         for (var container in layoutsContainer.startLayout.children) {
             var item = layoutsContainer.startLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.mainLayout.children) {
             var item = layoutsContainer.mainLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.endLayout.children) {
             var item = layoutsContainer.endLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         return splitters;
     }
 
     function layoutManager() {
         return LayoutManager;
     }
 
     function layoutManagerInsertBefore(place, item) {
         LayoutManager.insertBefore(place, item);
     }
 
     function layoutManagerInsertAfter(place, item) {
         LayoutManager.insertAfter(place, item);
     }
 
     function layoutManagerSave() {
         LayoutManager.save();
     }
 
     function layoutManagerSaveOptions() {
         LayoutManager.saveOptions();
     }
 
     function mouseInCanBeHoveredApplet(){
         var applets = layoutsContainer.startLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         applets = layoutsContainer.mainLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         ///check second layout also
         applets = layoutsContainer.endLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         return false;
     }
 
     function mouseInHoverableArea() {
         return (latteView.visibility.containsMouse && !rootMouseArea.containsMouse && mouseInCanBeHoveredApplet());
     }
 
     function hideTooltipLabel(debug){
         titleTooltipDialog.hide(debug);
     }
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletShortcutBadges(showLatteShortcuts, showShortcuts, showMeta, applicationLauncher){
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.setShowTaskShortcutBadges(showLatteShortcuts);
         }
 
         showLatteShortcutBadges = showLatteShortcuts;
         showAppletShortcutBadges = showShortcuts;
         showMetaBadge = showMeta;
         applicationLauncherId = applicationLauncher;
 
         if (latteApplet) {
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function activateEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalActivateEntryAtIndex(index);
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function newInstanceForEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalNewInstanceForEntryAtIndex(index);
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function appletIdForIndex(index) {
         if (!root.unifiedGlobalShortcuts || parabolicManager.pseudoIndexBelongsToLatteApplet(index)) {
             return -1;
         }
 
         for (var i=0; i<layoutsContainer.startLayout.children.length; ++i){
             var appletItem = layoutsContainer.startLayout.children[i];
 
             if (appletItem && appletItem.refersEntryIndex(index)) {
                 return appletItem.applet.id;
             }
         }
 
         for (var j=0; j<layoutsContainer.mainLayout.children.length; ++j){
             var appletItem2 = layoutsContainer.mainLayout.children[j];
 
             if (appletItem2 && appletItem2.refersEntryIndex(index)) {
                 return appletItem2.applet.id;
             }
         }
 
         for (var k=0; j<layoutsContainer.endLayout.children.length; ++k){
             var appletItem3 = layoutsContainer.endLayout.children[k];
 
             if (appletItem3 && appletItem3.refersEntryIndex(index)) {
                 return appletItem3.applet.id;
             }
         }
 
         return -1;
     }
 
 
     function showTooltipLabel(taskItem, text){
         titleTooltipDialog.show(taskItem, text);
     }
 
     function sizeIsFromAutomaticMode(size){
 
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === size){
                 return true;
             }
         }
 
         return false;
     }
 
     function slotPreviewsShown(){
         if (latteView) {
             latteView.extendedInterface.deactivateApplets();
         }
     }
 
     function updateContainsOnlyPlasmaTasks() {
         if (latteView) {
             root.containsOnlyPlasmaTasks = (latteView.tasksPresent() && !latteApplet);
         } else {
             root.containsOnlyPlasmaTasks = false;
         }
     }
 
     function updateSizeForAppletsInFill() {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     function layoutManagerMoveAppletsBasedOnJustifyAlignment() {
         if (plasmoid.configuration.alignment !== 10) {
             return;
         }
         animations.appletsInParentChange = true;
 
         var splitter = -1;
         var startChildrenLength = layoutsContainer.startLayout.children.length;
 
         //! Check if there is a splitter inside start layout after the user was dragging its applets
         for (var i=0; i<startChildrenLength; ++i) {
             var item = layoutsContainer.startLayout.children[i];
             if(item.isInternalViewSplitter) {
                 splitter = i;
                 break;
             }
         }
 
         //! If a splitter was found inside the startlayout move the head applets after splitter as tail
         //! applets of mainlayout
         if (splitter>=0) {
             for (var i=startChildrenLength-1; i>=splitter; --i){
                 var item = layoutsContainer.startLayout.children[i];
                 LayoutManager.insertAtIndex(layoutsContainer.mainLayout, item, 0);
             }
         }
 
         var splitter2 = -1;
         var endChildrenLength = layoutsContainer.endLayout.children.length;
 
         //! Check if there is a splitter inside endlayout after the user was dragging its applets
         for (var i=0; i<endChildrenLength; ++i) {
             var item = layoutsContainer.endLayout.children[i];
             if(item.isInternalViewSplitter) {
                 splitter2 = i;
                 break;
             }
         }
 
         //! If a splitter was found inside the endlayout move the tail applets until splitter as head
         //! applets of mainlayout
         if (splitter2>=0) {
             for (var i=0; i<=splitter2; ++i){
                 var item = layoutsContainer.endLayout.children[0];
                 item.parent = layoutsContainer.mainLayout;
             }
         }
 
         //! Validate applets positioning and move applets out of splitters to start/endlayouts accordingly
         splitMainLayoutToLayouts();
 
         animations.appletsInParentChange = false;
     }
 
     function splitMainLayoutToLayouts() {
         if (internalViewSplittersCount() === 2) {
             animations.appletsInParentChange = true;
 
             console.log("LAYOUTS: Moving applets from MAIN to THREE Layouts mode...");
             var splitter = -1;
             var splitter2 = -1;
 
             var totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=0; i<totalChildren; ++i) {
                 var item = layoutsContainer.mainLayout.children[i];
 
                 if(item.isInternalViewSplitter && splitter === -1) {
                     splitter = i;
                 } else if (item.isInternalViewSplitter && splitter>=0 && splitter2 === -1) {
                     splitter2 = i;
                 }
             }
 
             // console.log("update layouts 1:"+splitter + " - "+splitter2);
 
             if (splitter > 0) {
                 for (var i=0; i<splitter; ++i){
                     var item = layoutsContainer.mainLayout.children[0];
                     item.parent = layoutsContainer.startLayout;
                 }
             }
 
             if (splitter2 > 0) {
                 splitter2 = splitter2 - splitter;
                 // console.log("update layouts 2:"+splitter + " - "+splitter2);
 
                 totalChildren = layoutsContainer.mainLayout.children.length;
 
                 for (var i=totalChildren-1; i>=splitter2+1; --i){
                     var item = layoutsContainer.mainLayout.children[i];
                     LayoutManager.insertAtIndex(layoutsContainer.endLayout, item, 0);
                 }
             }
 
             animations.appletsInParentChange = false;
         }
     }
 
     function joinLayoutsToMainLayout() {
         animations.appletsInParentChange = true;
 
         console.log("LAYOUTS: Moving applets from THREE to MAIN Layout mode...");
         var totalChildren1 = layoutsContainer.mainLayout.children.length;
         for (var i=totalChildren1-1; i>=0; --i) {
             var item1 = layoutsContainer.mainLayout.children[0];
             item1.parent = layoutsContainer.startLayout;
         }
 
         var totalChildren2 = layoutsContainer.endLayout.children.length;
 
         for (var i=totalChildren2-1; i>=0; --i) {
             var item2 = layoutsContainer.endLayout.children[0];
             item2.parent = layoutsContainer.startLayout;
         }
 
         var totalChildrenL = layoutsContainer.startLayout.children.length;
         for (var i=totalChildrenL-1; i>=0; --i) {
             var itemL = layoutsContainer.startLayout.children[0];
             itemL.parent = layoutsContainer.mainLayout;
         }
 
         animations.appletsInParentChange = false;
     }
 
     function upgrader_v010_alignment() {
         //! IMPORTANT, special case because it needs to be loaded on Component constructor
         if (!plasmoid.configuration.alignmentUpgraded) {
             plasmoid.configuration.alignment = plasmoid.configuration.panelPosition;
             plasmoid.configuration.alignmentUpgraded = true;
         }
     }
     //END functions
 
 
     ////BEGIN interfaces
 
     Connections {
         target: LatteCore.WindowSystem
 
         onCompositingActiveChanged: {
             visibilityManager.updateMaskArea();
         }
     }
 
     ////END interfaces
 
     /////BEGIN: Title Tooltip///////////
     PlasmaCore.Dialog{
         id: titleTooltipDialog
 
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: plasmoid.location
         mainItem: RowLayout{
             Layout.fillWidth: true
             Layout.fillHeight: true
             PlasmaComponents.Label{
                 id:titleLbl
                 Layout.leftMargin: 4
                 Layout.rightMargin: 4
                 Layout.topMargin: 2
                 Layout.bottomMargin: 2
                 text: titleTooltipDialog.title
             }
         }
 
         visible: false
 
         property string title: ""
 
         property bool activeItemHovered: false
         property Item activeItem: null
         property Item activeItemTooltipParent: null
         property string activeItemText: ""
 
 
         Component.onCompleted: {
             parabolic.sglClearZoom.connect(titleTooltipDialog.hide);
         }
 
         Component.onDestruction: {
             parabolic.sglClearZoom.disconnect(titleTooltipDialog.hide);
         }
 
         function hide(debug){
             if (!root.titleTooltips)
                 return;
 
             activeItemHovered = false;
             hideTitleTooltipTimer.start();
         }
 
         function show(taskItem, text){
             if (!root.titleTooltips || (latteApplet && latteApplet.contextMenu)){
                 return;
             }
 
             activeItemHovered = true;
 
             if (activeItem !== taskItem) {
                 activeItem = taskItem;
                 activeItemTooltipParent = taskItem.tooltipVisualParent;
                 activeItemText = text;
             }
 
             if (isReady) {
                 showTitleTooltipTimer.start();
             }
 
         }
 
         function update() {
             activeItemHovered = true
             title = activeItemText;
             visualParent = activeItemTooltipParent;
             if (latteApplet && latteApplet.windowPreviewIsShown) {
                 latteApplet.hidePreview();
             }
 
             visible = true;
         }
     }
 
     Timer {
         id: showTitleTooltipTimer
         interval: 100
         onTriggered: {
             if (latteView && latteView.visibility && latteView.visibility.containsMouse) {
                 titleTooltipDialog.update();
             }
 
             if (titleTooltipDialog.visible) {
                 titleTooltipCheckerToNotShowTimer.start();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: showTitleTooltipTimer called...");
             }
         }
     }
 
     Timer {
         id: hideTitleTooltipTimer
         interval: 200
         onTriggered: {
             if (!titleTooltipDialog.activeItemHovered) {
                 titleTooltipDialog.visible = false;
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: hideTitleTooltipTimer called...");
             }
 
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown
     Timer {
         id: titleTooltipCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (titleTooltipDialog.visible && latteApplet && (latteApplet.contextMenu || latteApplet.windowPreviewIsShown)) {
                 titleTooltipDialog.visible = false;
             }
         }
     }
     /////END: Title Tooltip///////////
 
     ///////////////BEGIN components
     Component {
         id: appletContainerComponent
         Applet.AppletItem{
             animations: _animations
             indexer: _indexer
             metrics: _metrics
             parabolic: _parabolic
         }
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     Indicators.Manager{
         id: indicators
     }
 
     Item {
         id: graphicsSystem
         readonly property bool isAccelerated: (GraphicsInfo.api !== GraphicsInfo.Software)
                                               && (GraphicsInfo.api !== GraphicsInfo.Unknown)
     }
 
     Upgrader {
         id: upgrader
     }
 
     ///////////////END components
 
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
 
     ///////////////BEGIN UI elements
 
     //it is used to check if the mouse is outside the layoutsContainer borders,
     //so in that case the onLeave event behavior should be trigerred
     RootMouseArea{
         id: rootMouseArea
     }
 
     Loader{
         active: root.debugModeWindow
         sourceComponent: DebugWindow{}
     }
 
     EditMode.Visual{
         id:editModeVisual
         //   z: root.behaveAsPlasmaPanel ? 1 : 0
     }
 
     Item {
         id: lastSpacer
         parent: layoutsContainer.mainLayout
 
         Layout.fillWidth: true
         Layout.fillHeight: true
         z:10
 
         Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.color: "yellow"
             border.width: 1
         }
     }
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
         z:10
 
         sourceComponent: Item{
             Rectangle{
                 anchors.fill: parent
                 color: "yellow"
                 opacity: 0.06
             }
         }
     }
 
     VisibilityManager{
         id: visibilityManager
         applets: layoutsContainer.applets
     }
 
     DragDropArea {
         id: backDropArea
         anchors.fill: parent
         readonly property bool higherPriority: latteView && latteView.containsDrag
                                                && ((root.dragInfo.isPlasmoid && root.dragInfo.isSeparator)
                                                    || (foreDropArea.dragInfo.computationsAreValid && !root.dragInfo.isPlasmoid && !root.dragInfo.onlyLaunchers))
 
         Item{
             anchors.fill: layoutsContainer
 
             Background.MultiLayered{
                 id: _background
             }
         }
 
         Layouts.LayoutsContainer {
             id: layoutsContainer
         }
 
         DragDropArea {
             id: foreDropArea
             anchors.fill: parent
             visible: !backDropArea.higherPriority
             isForeground: true
 
             /* Rectangle {
                 anchors.fill: parent
                 color: "blue"
                 opacity: 0.5
             }*/
         }
     }
 
     Colorizer.Manager {
         id: colorizerManager
     }
 
     Item {
         id: dndSpacer
 
         width: root.isHorizontal ? length : thickness
         height: root.isHorizontal ? thickness : length
 
         readonly property int length: metrics.totals.length
         readonly property int thickness: metrics.totals.thickness + metrics.margin.screenEdge
 
         Layout.preferredWidth: width
         Layout.preferredHeight: height
         opacity: 0
         z:1500
 
         LatteComponents.AddItem{
             id: dndSpacerAddItem
             width: root.isHorizontal ? parent.width : parent.width - metrics.margin.screenEdge
             height: root.isHorizontal ? parent.height - metrics.margin.screenEdge: parent.height
 
             states:[
                 State{
                     name: "bottom"
                     when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                         anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: metrics.margin.screenEdge;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "top"
                     when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                         anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: metrics.margin.screenEdge;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "left"
                     when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                         anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 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: dndSpacerAddItem;
                         anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                         anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: metrics.margin.screenEdge;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 }
             ]
         }
     }
 
     ///////////////END UI elements
 
     ///////////////BEGIN ABILITIES
 
     Ability.Animations {
         id: _animations
         metrics: _metrics
         settings: universalSettings
     }
 
     Ability.AutoSize {
         id: _autosize
         layouts: layoutsContainer
         metrics: _metrics
         visibility: visibilityManager
     }
 
     Ability.Indexer {
         id: _indexer
         layouts: layoutsContainer
     }
 
     Ability.Metrics {
         id: _metrics
         animations: _animations
         autosize: _autosize
         indicators: indicatorsManager
     }
 
     Ability.ParabolicEffect {
         id: _parabolic
         animations: _animations
         applets: layoutsContainer.applets
         view: latteView
     }
 
     LatteApp.Interfaces {
         id: _interfaces
         plasmoidInterface: plasmoid
     }
 
     ///////////////END ABILITIES
 
     ///////////////BEGIN TIMER elements
 
     //! It is used in order to slide-in the latteView on startup
     Timer{
         id: inStartupTimer
         interval: 1500
         repeat: false
         onTriggered: {
             if (inStartup) {
                 visibilityManager.slotMustBeShown();
             }
         }
     }
 
     ///////////////END TIMER elements
 
     Loader{
         anchors.fill: parent
         active: root.debugModeLocalGeometry
         sourceComponent: Rectangle{
             x: latteView.localGeometry.x
             y: latteView.localGeometry.y
             width: latteView.localGeometry.width
             height: latteView.localGeometry.height
 
             color: "blue"
             border.width: 2
             border.color: "red"
 
             opacity: 0.35
         }
     }
 }