diff --git a/containment/package/contents/ui/applet/ItemWrapper.qml b/containment/package/contents/ui/applet/ItemWrapper.qml
index 25fa5de8..0e4362ad 100644
--- a/containment/package/contents/ui/applet/ItemWrapper.qml
+++ b/containment/package/contents/ui/applet/ItemWrapper.qml
@@ -1,685 +1,688 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.1
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 
 import org.kde.latte 0.2 as Latte
 
 import "../../code/MathTools.js" as MathTools
 
 Item{
     id: wrapper
 
     width: {
         if (appletItem.isInternalViewSplitter && !root.inConfigureAppletsMode)
             return 0;
 
         if (isSeparator && root.parabolicEffectEnabled && root.isHorizontal) {
             return -1;
         }
 
         //! width for applets that use fillWidth/fillHeight such plasma taskmanagers and AWC
         if (appletItem.needsFillSpace && root.isHorizontal) {
             if (root.panelAlignment !== Latte.Types.Justify) {
                 var maximumValue = (applet.Layout.maximumWidth === Infinity) || applet.Layout.maximumWidth === -1 ?
                             appletItem.sizeForFill : Math.min(appletItem.sizeForFill, applet.Layout.maximumWidth);
 
                 var constrainedWidth = MathTools.bound(applet.Layout.minimumWidth, applet.Layout.preferredWidth, maximumValue);
 
                 return root.editMode ? Math.max(constrainedWidth, root.iconSize) : constrainedWidth;
             }
 
             if(appletItem.sizeForFill>-1){
                 return appletItem.sizeForFill;
             }
         }
 
         if (appletItem.latteApplet) {
             return latteApplet.tasksWidth;
         } else {
             return scaledWidth;
         }
     }
 
     height: {
         if (appletItem.isInternalViewSplitter && !root.inConfigureAppletsMode)
             return 0;
 
         if (isSeparator && root.parabolicEffectEnabled && root.isVertical) {
             return -1;
         }
 
         //! height for applets that use fillWidth/fillHeight such plasma taskmanagers and AWC
         if (appletItem.needsFillSpace && root.isVertical) {
             if (root.panelAlignment !== Latte.Types.Justify) {
                 var maximumValue = (applet.Layout.maximumHeight === Infinity) || applet.Layout.maximumHeight === -1 ?
                             appletItem.sizeForFill : Math.min(appletItem.sizeForFill, applet.Layout.maximumHeight);
 
                 var constrainedHeight = MathTools.bound(applet.Layout.minimumHeight, applet.Layout.preferredHeight, maximumValue);
 
                 return root.editMode ? Math.max(constrainedHeight, root.iconSize) : constrainedHeight;
             }
 
             if (appletItem.sizeForFill>-1){
                 return appletItem.sizeForFill;
             }
         }
 
         if (appletItem.latteApplet) {
             return latteApplet.tasksHeight;
         } else {
             return scaledHeight;
         }
     }
 
     opacity: appletColorizer.mustBeShown ? 0 : 1
 
     property bool disableScaleWidth: false
     property bool disableScaleHeight: false
     property bool editMode: root.editMode
 
     property int appletWidth: applet ?  applet.width : -1
     property int appletHeight: applet ?  applet.height : -1
 
     property int appletMinimumWidth: applet && applet.Layout ?  applet.Layout.minimumWidth : -1
     property int appletMinimumHeight: applet && applet.Layout ? applet.Layout.minimumHeight : -1
 
     property int appletPreferredWidth: applet && applet.Layout ?  applet.Layout.preferredWidth : -1
     property int appletPreferredHeight: applet && applet.Layout ?  applet.Layout.preferredHeight : -1
 
     property int appletMaximumWidth: applet && applet.Layout ?  applet.Layout.maximumWidth : -1
     property int appletMaximumHeight: applet && applet.Layout ?  applet.Layout.maximumHeight : -1
 
     property int iconSize: root.iconSize
 
     property int marginWidth: root.isVertical ?
                                   root.thickMargins :
                                   (root.inFullJustify && (appletItem.firstChildOfStartLayout || appletItem.lastChildOfEndLayout ) ? 0 : root.lengthMargins)  //Fitt's Law
     property int marginHeight: root.isHorizontal ?
                                    root.thickMargins :
                                    (root.inFullJustify && (appletItem.firstChildOfStartLayout || appletItem.lastChildOfEndLayout ) ? 0 : root.lengthMargins)  //Fitt's Law
 
     property real scaledWidth: zoomScaleWidth * (layoutWidth + marginWidth)
     property real scaledHeight: zoomScaleHeight * (layoutHeight + marginHeight)
     property real zoomScaleWidth: disableScaleWidth ? 1 : zoomScale
     property real zoomScaleHeight: disableScaleHeight ? 1 : zoomScale
 
     property int layoutWidthResult: 0
 
     property int layoutWidth
     property int layoutHeight
 
-    property real center:(width + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2
+    property real center:root.isHorizontal ?
+                             (width + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2 :
+                             (height + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2
+
     property real zoomScale: 1
 
     property int index: appletItem.index
 
     property Item wrapperContainer: _wrapperContainer
     property Item clickedEffect: _clickedEffect
     property Item containerForOverlayIcon: _containerForOverlayIcon
     property Item overlayIconLoader: _overlayIconLoader
 
     Behavior on opacity {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     // property int pHeight: applet ? applet.Layout.preferredHeight : -10
 
     /*function debugLayouts(){
         if(applet){
             console.log("---------- "+ applet.pluginName +" ----------");
             console.log("MinW "+applet.Layout.minimumWidth);
             console.log("PW "+applet.Layout.preferredWidth);
             console.log("MaxW "+applet.Layout.maximumWidth);
             console.log("FillW "+applet.Layout.fillWidth);
             console.log("-----");
             console.log("MinH "+applet.Layout.minimumHeight);
             console.log("PH "+applet.Layout.preferredHeight);
             console.log("MaxH "+applet.Layout.maximumHeight);
             console.log("FillH "+applet.Layout.fillHeight);
             console.log("-----");
             console.log("Real Applet Width: "+applet.width);
             console.log("Real Applet Height: "+applet.height);
             console.log("-----");
             console.log("Real Wrapper Width: "+wrapper.width);
             console.log("Real Wrapper Height: "+wrapper.height);
             console.log("-----");
             console.log("Can be hovered: " + canBeHovered);
             console.log("Icon size: " + root.iconSize);
             console.log("Thick Margins: " + root.thickMargins);
             console.log("Intern. Margins: " + (root.lengthIntMargin * 2));
             console.log("Intern. Margins: " + (root.lengthExtMargin * 2));
             console.log("Max hovered criteria: " + (root.iconSize + thickMargins));
             console.log("-----");
             console.log("LayoutW: " + layoutWidth);
             console.log("LayoutH: " + layoutHeight);
         }
     }
 
     onLayoutWidthChanged: {
         debugLayouts();
     }
 
     onLayoutHeightChanged: {
         debugLayouts();
     }*/
 
     onAppletWidthChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
     }
 
     onAppletHeightChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
     }
 
     onAppletMinimumWidthChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
 
         updateLayoutWidth();
     }
     onAppletMinimumHeightChanged: {
         if(zoomScale === 1) {
             checkCanBeHovered();
         }
 
         updateLayoutHeight();
     }
 
     onAppletPreferredWidthChanged: updateLayoutWidth();
     onAppletPreferredHeightChanged: updateLayoutHeight();
 
     onAppletMaximumWidthChanged: updateLayoutWidth();
     onAppletMaximumHeightChanged: updateLayoutHeight();
 
     Connections {
         target: appletItem
         onCanBeHoveredChanged: {
             updateLayoutWidth();
             updateLayoutHeight();
         }
     }
 
     onIconSizeChanged: {
         updateLayoutWidth();
         updateLayoutHeight();
     }
 
     onEditModeChanged: {
         updateLayoutWidth();
         updateLayoutHeight();
     }
 
     onZoomScaleChanged: {
         if ((zoomScale === root.zoomFactor) && !root.globalDirectRender) {
             root.setGlobalDirectRender(true);
         }
 
         if ((zoomScale > 1) && !appletItem.isZoomed) {
             appletItem.isZoomed = true;
             if (!animationWasSent) {
                 root.slotAnimationsNeedBothAxis(1);
                 animationWasSent = true;
             }
         } else if (zoomScale == 1) {
             appletItem.isZoomed = false;
             if (animationWasSent) {
                 root.slotAnimationsNeedBothAxis(-1);
                 animationWasSent = false;
             }
         }
     }
 
     Connections {
         target: root
         onIsVerticalChanged: {
             if (appletItem.latteApplet) {
                 return;
             }
 
             wrapper.disableScaleWidth = false;
             wrapper.disableScaleHeight = false;
 
             if (root.isVertical)  {
                 wrapper.updateLayoutHeight();
                 wrapper.updateLayoutWidth();
             } else {
                 wrapper.updateLayoutWidth();
                 wrapper.updateLayoutHeight();
             }
         }
     }
 
     function updateLayoutHeight(){
         if (appletItem.needsFillSpace && root.isVertical) {
             layoutsContainer.updateSizeForAppletsInFill();
             return;
         }
 
         if (isLattePlasmoid) {
             return;
         } else if (appletItem.isInternalViewSplitter){
             if(!root.editMode)
                 layoutHeight = 0;
             else
                 layoutHeight = root.iconSize;
         }
         else if(applet && applet.pluginName === "org.kde.plasma.panelspacer"){
             layoutHeight = root.iconSize;
         }
         else if(appletItem.isSystray && root.isHorizontal){
             layoutHeight = root.iconSize;
         }
         else{
             if(applet && (applet.Layout.minimumHeight > root.iconSize) && root.isVertical && !canBeHovered && !communicator.overlayLatteIconIsActive){
                 layoutHeight = applet.Layout.minimumHeight;
             } //it is used for plasmoids that need to scale only one axis... e.g. the Weather Plasmoid
             else if(applet
                     && ( applet.Layout.maximumHeight < root.iconSize
                         || applet.Layout.preferredHeight > root.iconSize
                         || appletItem.originalAppletBehavior)
                     && root.isVertical
                     && !disableScaleWidth
                     && !communicator.overlayLatteIconIsActive) {
 
                 if (!appletItem.isSpacer) {
                     disableScaleHeight = true;
                 }
                 //this way improves performance, probably because during animation the preferred sizes update a lot
                 if((applet.Layout.maximumHeight < root.iconSize)){
                     layoutHeight = applet.Layout.maximumHeight;
                 } else if (applet.Layout.minimumHeight > root.iconSize){
                     layoutHeight = applet.Layout.minimumHeight;
                 } else if ((applet.Layout.preferredHeight > root.iconSize)
                            || (appletItem.originalAppletBehavior && applet.Layout.preferredHeight > 0 )){
                     layoutHeight = applet.Layout.preferredHeight;
                 } else{
                     layoutHeight = root.iconSize;
                 }
             } else {
                 layoutHeight = root.iconSize;
             }
         }
     }
 
     function updateLayoutWidth(){
         if (appletItem.needsFillSpace && root.isHorizontal) {
             layoutsContainer.updateSizeForAppletsInFill();
             return;
         }
 
         if (isLattePlasmoid) {
             return;
         } else if (appletItem.isInternalViewSplitter){
             if(!root.editMode)
                 layoutWidth = 0;
             else
                 layoutWidth = root.iconSize;
         }
         else if(applet && applet.pluginName === "org.kde.plasma.panelspacer"){
             layoutWidth = root.iconSize;
         }
         else if(appletItem.isSystray && root.isVertical){
             layoutWidth = root.iconSize;
         }
         else{
             if(applet && (applet.Layout.minimumWidth > root.iconSize) && root.isHorizontal && !canBeHovered && !communicator.overlayLatteIconIsActive){
                 layoutWidth = applet.Layout.minimumWidth;
             } //it is used for plasmoids that need to scale only one axis... e.g. the Weather Plasmoid
             else if(applet
                     && ( applet.Layout.maximumWidth < root.iconSize
                         || applet.Layout.preferredWidth > root.iconSize
                         || appletItem.originalAppletBehavior)
                     && root.isHorizontal
                     && !disableScaleHeight
                     && !communicator.overlayLatteIconIsActive){
 
                 if (!appletItem.isSpacer) {
                     disableScaleWidth = true;
                 }
                 //this way improves performance, probably because during animation the preferred sizes update a lot
                 if((applet.Layout.maximumWidth < root.iconSize)){
                     //   return applet.Layout.maximumWidth;
                     layoutWidth = applet.Layout.maximumWidth;
                 } else if (applet.Layout.minimumWidth > root.iconSize){
                     layoutWidth = applet.Layout.minimumWidth;
                 } else if ((applet.Layout.preferredWidth > root.iconSize)
                            || (appletItem.originalAppletBehavior && applet.Layout.preferredWidth > 0 )){
                     layoutWidth = applet.Layout.preferredWidth;
                 } else{
                     layoutWidth = root.iconSize;
                 }
             } else{
                 layoutWidth = root.iconSize;
             }
         }
     }
 
     Item{
         id:_wrapperContainer
 
         width:{
             if (appletItem.needsFillSpace && (appletItem.sizeForFill>-1) && root.isHorizontal){
                 return wrapper.width;
             }
 
             if (appletItem.isInternalViewSplitter) {
                 return wrapper.layoutWidth;
             } else {
                 if (plasmoid.formFactor === PlasmaCore.Types.Vertical) {
                     return parent.zoomScaleWidth * (root.iconSize + root.thickMargins);
                 } else {
                     return parent.zoomScaleWidth * wrapper.layoutWidth;
                 }
             }
         }
 
         height:{
             if (appletItem.needsFillSpace && (appletItem.sizeForFill>-1) && root.isVertical){
                 return wrapper.height;
             }
 
             if (appletItem.isInternalViewSplitter) {
                 return wrapper.layoutHeight;
             } else {
                 if (plasmoid.formFactor === PlasmaCore.Types.Horizontal) {
                     return parent.zoomScaleHeight * (root.iconSize + root.thickMargins);
                 } else {
                     return parent.zoomScaleHeight * wrapper.layoutHeight;
                 }
             }
 
         }
 
         opacity: appletShadow.active ? 0 : 1
 
         anchors.centerIn: parent
 
         ///Secret MouseArea to be used by the folder widget
         Loader{
             anchors.fill: parent
             active: communicator.overlayLatteIconIsActive && applet.pluginName === "org.kde.plasma.folder"
             sourceComponent: MouseArea{
                 onClicked: latteView.toggleAppletExpanded(applet.id);
             }
         }
 
         Item{
             id: _containerForOverlayIcon
             anchors.fill: parent
         }
 
         Loader{
             id: _overlayIconLoader
             anchors.fill: parent
             active: communicator.overlayLatteIconIsActive
 
             property color backgroundColor: "black"
             property color glowColor: "white"
 
             sourceComponent: Latte.IconItem{
                 id: overlayIconItem
                 anchors.fill: parent
                 source: {
                     if (communicator.appletIconItemIsShown())
                         return communicator.appletIconItem.source;
                     else if (communicator.appletImageItemIsShown())
                         return communicator.appletImageItem.source;
 
                     return "";
                 }
 
                 providesColors: indicators.info.needsIconColors && source != ""
                 usesPlasmaTheme: communicator.appletIconItemIsShown() ? communicator.appletIconItem.usesPlasmaTheme : false
 
                 Binding{
                     target: _overlayIconLoader
                     property: "backgroundColor"
                     when: overlayIconItem.providesColors
                     value: overlayIconItem.backgroundColor
                 }
 
                 Binding{
                     target: _overlayIconLoader
                     property: "glowColor"
                     when: overlayIconItem.providesColors
                     value: overlayIconItem.glowColor
                 }
 
                 Loader{
                     anchors.centerIn: parent
                     active: root.debugModeOverloadedIcons
                     sourceComponent: Rectangle{
                         width: 30
                         height: 30
                         color: "green"
                         opacity: 0.65
                     }
                 }
             }
         }
     }
 
     Loader{
         anchors.fill: _wrapperContainer
         active: appletItem.isInternalViewSplitter && root.inConfigureAppletsMode
 
         rotation: root.isVertical ? 90 : 0
 
         sourceComponent: PlasmaCore.SvgItem{
             id:splitterImage
             anchors.fill: parent
 
             svg: PlasmaCore.Svg{
                 imagePath: root.universalSettings.splitterIconPath()
             }
 
             layer.enabled: true
             layer.effect: DropShadow {
                 radius: root.appShadowSize
                 fast: true
                 samples: 2 * radius
                 color: root.appShadowColor
 
                 verticalOffset: 2
             }
 
             Component.onCompleted: {
                 if (root.isVertical)  {
                     wrapper.updateLayoutHeight();
                     wrapper.updateLayoutWidth();
                 } else {
                     wrapper.updateLayoutWidth();
                     wrapper.updateLayoutHeight();
                 }
             }
         }
     }
 
     ///Shadow in applets
     Loader{
         id: appletShadow
         anchors.fill: appletItem.appletWrapper
 
         active: appletItem.applet && !appletColorizer.mustBeShown
                 && (((plasmoid.configuration.shadows === 1 /*Locked Applets*/
                       && (!appletItem.canBeHovered || (appletItem.originalAppletBehavior && (applet.pluginName !== root.plasmoidName))) )
                      || (plasmoid.configuration.shadows === 2 /*All Applets*/
                          && (applet.pluginName !== root.plasmoidName)))
                     || (root.forceTransparentPanel && plasmoid.configuration.shadows>0 && applet.pluginName !== root.plasmoidName)) /*on forced transparent state*/
 
         onActiveChanged: {
             if (active && !isSeparator) {
                 wrapperContainer.opacity = 0;
             } else {
                 wrapperContainer.opacity = 1;
             }
         }
 
         opacity: isSeparator ? 0.4 : 1
 
         sourceComponent: DropShadow{
             anchors.fill: parent
             color: root.appShadowColor //"#ff080808"
             fast: true
             samples: 2 * radius
             source: communicator.overlayLatteIconIsActive ? _wrapperContainer : appletItem.applet
             radius: shadowSize
             verticalOffset: root.forceTransparentPanel || root.forcePanelForBusyBackground ? 0 : 2
 
             property int shadowSize : root.appShadowSize
         }
     }
 
     BrightnessContrast{
         id:hoveredImage
         anchors.fill: _wrapperContainer
         source: _wrapperContainer
 
         enabled: opacity != 0 ? true : false
         opacity: appletMouseArea.containsMouse ? 1 : 0
         brightness: 0.25
         contrast: 0.15
 
         Behavior on opacity {
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
     }
 
     BrightnessContrast {
         id: _clickedEffect
         anchors.fill: _wrapperContainer
         source: _wrapperContainer
 
         visible: clickedAnimation.running
     }
 
     /*   onHeightChanged: {
         if ((index == 1)|| (index==3)){
             console.log("H: "+index+" ("+zoomScale+"). "+currentLayout.children[1].height+" - "+currentLayout.children[3].height+" - "+(currentLayout.children[1].height+currentLayout.children[3].height));
         }
     }
 
     onZoomScaleChanged:{
         if ((index == 1)|| (index==3)){
             console.log(index+" ("+zoomScale+"). "+currentLayout.children[1].height+" - "+currentLayout.children[3].height+" - "+(currentLayout.children[1].height+currentLayout.children[3].height));
         }
     }*/
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             color: "transparent"
             //! red visualizer, in debug mode for the applets that use fillWidth or fillHeight
             //! green, for the rest
             border.color:  (appletItem.needsFillSpace && (appletItem.sizeForFill>-1) && root.isHorizontal) ? "red" : "green"
             border.width: 1
         }
     }
 
     Behavior on zoomScale {
         enabled: !root.globalDirectRender
         NumberAnimation {
             duration: 3 * appletItem.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on zoomScale {
         enabled: root.globalDirectRender && !restoreAnimation.running
         NumberAnimation { duration: root.directRenderAnimationTime }
     }
 
     function calculateScales( currentMousePosition ){
         if (root.zoomFactor===1) {
             return;
         }
 
         var distanceFromHovered = Math.abs(index - layoutsContainer.hoveredIndex);
 
         // A new algorithm trying to make the zoom calculation only once
         // and at the same time fixing glitches
         if ((distanceFromHovered == 0)&&
                 (currentMousePosition  > 0) ){
 
             //use the new parabolicManager in order to handle all parabolic effect messages
             var scales = parabolicManager.applyParabolicEffect(index, currentMousePosition, center);
 
             /*if (root.latteApplet && Math.abs(index - root.latteAppletPos) > 2){
                 root.latteApplet.clearZoom();
             }*/
 
             //Left hiddenSpacer
             if(appletItem.startEdge){
                 hiddenSpacerLeft.nScale = scales.leftScale - 1;
             }
 
             //Right hiddenSpacer  ///there is one more item in the currentLayout ????
             if(appletItem.endEdge){
                 hiddenSpacerRight.nScale =  scales.rightScale - 1;
             }
 
             zoomScale = root.zoomFactor;
         }
 
     } //scale
 
 
     function signalUpdateScale(nIndex, nScale, step){
         if(appletItem && !appletItem.containsMouse && (appletItem.index === nIndex)){
             if ( ((canBeHovered && !appletItem.originalAppletBehavior) || appletItem.latteApplet)
                     && (applet && applet.status !== PlasmaCore.Types.HiddenStatus)
                     //&& (index != currentLayout.hoveredIndex)
                     ){
                 if(!appletItem.latteApplet){
                     if(nScale >= 0)
                         zoomScale = nScale + step;
                     else
                         zoomScale = zoomScale + step;
                 }
             }
         }
     }
 
     Component.onCompleted: {
         root.updateScale.connect(signalUpdateScale);
     }
 
     Component.onDestruction: {
         root.updateScale.disconnect(signalUpdateScale);
     }
 }// Main task area // id:wrapper
diff --git a/plasmoid/package/contents/ui/task/Wrapper.qml b/plasmoid/package/contents/ui/task/Wrapper.qml
index 27f36848..351d7010 100644
--- a/plasmoid/package/contents/ui/task/Wrapper.qml
+++ b/plasmoid/package/contents/ui/task/Wrapper.qml
@@ -1,258 +1,260 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 import org.kde.latte 0.2 as Latte
 
 Item{
     id: wrapper
 
     opacity: 0
     width: {
         if (!taskItem.visible)
             return 0;
 
         if (taskItem.isSeparator){
             if (!root.vertical)
                 return 0;
             else
                 return (root.iconSize + root.widthMargins);
         }
 
         if (taskItem.isStartup && root.durationTime !==0 ) {
             return cleanScalingWidth;
         } else {
             return showDelegateWidth;
         }
     }
 
     height: {
         if (!taskItem.visible)
             return 0;
 
         if (taskItem.isSeparator){
             if (root.vertical)
                 return 0;
             else
                 return (root.iconSize + root.heightMargins);
         }
 
         if (taskItem.isStartup && root.durationTime !==0){
             return cleanScalingHeight;
         } else {
             return showDelegateheight;
         }
     }
 
     property int maxThickness: !root.vertical ? root.zoomFactor*(root.iconSize+root.heightMargins)
                                               : root.zoomFactor*(root.iconSize+root.widthMargins)
 
     property real showDelegateWidth: basicScalingWidth
     property real showDelegateheight: basicScalingHeight
 
     //scales which are used mainly for activating InLauncher
     ////Scalers///////
     property bool inTempScaling: ((tempScaleWidth !== 1) || (tempScaleHeight !== 1) )
 
     property real mScale: 1
     property real tempScaleWidth: 1
     property real tempScaleHeight: 1
 
     property real scaleWidth: (inTempScaling == true) ? tempScaleWidth : mScale
     property real scaleHeight: (inTempScaling == true) ? tempScaleHeight : mScale
 
     property real cleanScalingWidth: (root.iconSize + root.widthMargins) * mScale
     property real cleanScalingHeight: (root.iconSize + root.heightMargins) * mScale
 
     property real basicScalingWidth : (inTempScaling == true) ? ((root.iconSize + root.widthMargins) * scaleWidth) : cleanScalingWidth
     property real basicScalingHeight : (inTempScaling == true) ? ((root.iconSize + root.heightMargins) * scaleHeight) : cleanScalingHeight
 
     property real regulatorWidth: taskItem.isSeparator ? width : basicScalingWidth;
     property real regulatorHeight: taskItem.isSeparator ? height : basicScalingHeight;
 
     property real visualScaledWidth: (root.iconSize + root.internalWidthMargins) * mScale
     property real visualScaledHeight: (root.iconSize + root.internalHeightMargins) * mScale
     /// end of Scalers///////
 
     //property int curIndex: icList.hoveredIndex
     //  property int index: taskItem.Positioner.index
     //property real center: (width + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2
-    property real center: (width + hiddenSpacerLeft.nHiddenSize + hiddenSpacerRight.nHiddenSize) / 2
+    property real center: !root.vertical ?
+                             (width + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2 :
+                             (height + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2
 
     property color backgroundColor: taskIconItem.backgroundColor
     property color glowColor: taskIconItem.glowColor
 
     property Item titleTooltipVisualParent: taskIconItem.titleTooltipVisualParent
     property Item previewsTooltipVisualParent: taskIconItem.previewsTootipVisualParent
 
     signal runLauncherAnimation();
 
     /*  Rectangle{
             anchors.fill: parent
             border.width: 1
             border.color: "green"
             color: "transparent"
         }*/
 
     Behavior on mScale {
         enabled: !root.globalDirectRender || inMimicParabolicAnimation
         NumberAnimation{
             duration: 3 * taskItem.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on mScale {
         enabled: root.globalDirectRender && !inMimicParabolicAnimation && !restoreAnimation.running
         NumberAnimation { duration: root.directRenderAnimationTime }
     }
 
     IconItem{
         id: taskIconItem
         anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? parent.bottom : undefined
         anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? parent.top : undefined
         anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? parent.left : undefined
         anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: wrapper.width
         height:wrapper.height
     }
 
     function calculateScales( currentMousePosition ){
         if (root.zoomFactor===1) {
             return;
         }
 
         var distanceFromHovered = Math.abs(index - icList.hoveredIndex);
 
         // A new algorithm trying to make the zoom calculation only once
         // and at the same time fixing glitches
         if ((distanceFromHovered === 0) &&
                 //! IMPORTANT: IS FIXING A BUG THAT NEGATIVE VALUES ARE SENT onEntered EVENT OF MOUSEAREA
                 // (currentMousePosition>=0) &&
                 (root.dragSource === null) ){
 
             //use the new parabolicManager in order to handle all parabolic effect messages
             var scales = parabolicManager.applyParabolicEffect(index, currentMousePosition, center);
 
             //Left hiddenSpacer for first task
             if(((index === parabolicManager.firstRealTaskIndex )&&(root.tasksCount>0)) && !root.disableLeftSpacer
                     && !inMimicParabolicAnimation && !inFastRestoreAnimation && !inAttentionAnimation){
                 hiddenSpacerLeft.nScale = scales.leftScale - 1;
             }
 
             //Right hiddenSpacer for last task
             if(((index === parabolicManager.lastRealTaskIndex )&&(root.tasksCount>0)) && !root.disableRightSpacer
                     && !inMimicParabolicAnimation && !inFastRestoreAnimation && !inAttentionAnimation){
                 hiddenSpacerRight.nScale =  scales.rightScale - 1;
             }
 
             if (!taskItem.inAttentionAnimation) {
                 mScale = root.zoomFactor;
             } else {
                 var subSpacerScale = (root.zoomFactor-1)/2;
 
                 hiddenSpacerLeft.nScale = subSpacerScale;
                 hiddenSpacerRight.nScale = subSpacerScale;
             }
 
             taskItem.scalesUpdatedOnce = false;
         }
 
     } //nScale
 
     function signalUpdateScale(nIndex, nScale, step){
         if (!taskItem.containsMouse && (index === nIndex)
                 && (taskItem.hoverEnabled || inMimicParabolicAnimation)&&(waitingLaunchers.length===0)){
             if (taskItem.inAttentionAnimation) {
                 var subSpacerScale = (nScale-1)/2;
 
                 hiddenSpacerLeft.nScale = subSpacerScale;
                 hiddenSpacerRight.nScale = subSpacerScale;
             } else if (!inBlockingAnimation || taskItem.inMimicParabolicAnimation) {
                 var newScale = 1;
 
                 if(nScale >= 0) {
                     newScale = nScale + step;
                 } else {
                     newScale = mScale + step;
                 }
 
                 if (inMimicParabolicAnimation && mimicParabolicScale === -1) {
                     mimicParabolicScale = newScale;
                 }
 
                 mScale = newScale;
             }
         }
     }
 
     function sendEndOfNeedBothAxisAnimation(){
         if (taskItem.isZoomed) {
             taskItem.isZoomed = false;
             root.signalAnimationsNeedBothAxis(-1);
         }
     }
 
     onMScaleChanged: {
         if ((mScale === root.zoomFactor) && !root.directRenderTimerIsRunning && !root.globalDirectRender) {
             root.setGlobalDirectRender(true);
         }
 
         if (inMimicParabolicAnimation){
             if (mScale >= mimicParabolicScale) {
                 inMimicParabolicAnimation = false;
                 inAnimation = false;
                 inBlockingAnimation = false;
                 mimicParabolicScale = -1;
             } else {
                 var tempScale = (root.zoomFactor - mScale) / 2;
 
                 hiddenSpacerLeft.nScale = tempScale;
                 hiddenSpacerRight.nScale = tempScale;
             }
         }
 
         if ((mScale > 1) && !taskItem.isZoomed) {
             taskItem.isZoomed = true;
             root.signalAnimationsNeedBothAxis(1);
         } else if ((mScale == 1) && taskItem.isZoomed) {
             sendEndOfNeedBothAxisAnimation();
         }
     }
 
     Component.onCompleted: {
         if (!Latte.WindowSystem.compositingActive) {
             opacity = 1;
         }
 
         root.updateScale.connect(signalUpdateScale);
     }
 
     Component.onDestruction: {
         root.updateScale.disconnect(signalUpdateScale);
     }
 }// Main task area // id:wrapper