diff --git a/app/view/positioner.cpp b/app/view/positioner.cpp
index c9c07f31..cd709c96 100644
--- a/app/view/positioner.cpp
+++ b/app/view/positioner.cpp
@@ -1,684 +1,727 @@
 /*
 *  Copyright 2018  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "positioner.h"
 
 // local
 #include "effects.h"
 #include "view.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../settings/universalsettings.h"
 #include "../../liblatte2/types.h"
 
 // Qt
 #include <QDebug>
 
 // KDE
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 namespace Latte {
 namespace ViewPart {
 
 Positioner::Positioner(Latte::View *parent)
     : QObject(parent),
       m_view(parent)
 {
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(2000);
     connect(&m_screenSyncTimer, &QTimer::timeout, this, &Positioner::reconsiderScreen);
 
     //! under X11 it was identified that windows many times especially under screen changes
     //! don't end up at the correct position and size. This timer will enforce repositionings
     //! and resizes every 500ms if the window hasn't end up to correct values and until this
     //! is achieved
     m_validateGeometryTimer.setSingleShot(true);
     m_validateGeometryTimer.setInterval(500);
     connect(&m_validateGeometryTimer, &QTimer::timeout, this, &Positioner::syncGeometry);
 
     m_corona = qobject_cast<Latte::Corona *>(m_view->corona());
 
     if (m_corona) {
         if (KWindowSystem::isPlatformX11()) {
             m_trackedWindowId = m_view->winId();
             m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
 
             connect(m_view, &Latte::View::forcedShown, this, [&]() {
                 m_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
                 m_trackedWindowId = m_view->winId();
                 m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
             });
         } else {
             connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
                 if (m_trackedWindowId.isNull()) {
                     m_trackedWindowId = m_corona->wm()->winIdFor("latte-dock", m_view->geometry());
                     m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
                 }
             });
         }
 
         /////
 
         m_screenSyncTimer.setInterval(qMax(m_corona->universalSettings()->screenTrackerInterval() - 500, 1000));
         connect(m_corona->universalSettings(), &UniversalSettings::screenTrackerIntervalChanged, this, [&]() {
             m_screenSyncTimer.setInterval(qMax(m_corona->universalSettings()->screenTrackerInterval() - 500, 1000));
         });
 
         connect(m_corona, &Latte::Corona::viewLocationChanged, this, [&]() {
             //! check if an edge has been freed for a primary dock
             //! from another screen
             if (m_view->onPrimary()) {
                 m_screenSyncTimer.start();
             }
         });
     }
 
     init();
 }
 
 Positioner::~Positioner()
 {
     m_inDelete = true;
     m_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
 
     m_screenSyncTimer.stop();
     m_validateGeometryTimer.stop();
 }
 
 void Positioner::init()
 {
     //! connections
     connect(this, &Positioner::screenGeometryChanged, this, &Positioner::syncGeometry);
 
     connect(m_view, &QQuickWindow::xChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::yChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::widthChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::heightChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::screenChanged, this, &Positioner::currentScreenChanged);
     connect(m_view, &QQuickWindow::screenChanged, this, &Positioner::screenChanged);
 
     connect(m_view, &Latte::View::behaveAsPlasmaPanelChanged, this, &Positioner::syncGeometry);
     connect(m_view, &Latte::View::maxThicknessChanged, this, &Positioner::syncGeometry);
     connect(m_view, &Latte::View::maxLengthChanged, this, &Positioner::syncGeometry);
     connect(m_view, &Latte::View::offsetChanged, this, &Positioner::syncGeometry);
 
     connect(m_view, &Latte::View::absoluteGeometryChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view, &Latte::View::locationChanged, this, [&]() {
         updateFormFactor();
         syncGeometry();
     });
 
     connect(m_view, &Latte::View::normalThicknessChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view, &Latte::View::screenEdgeMarginEnabledChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view->effects(), &Latte::ViewPart::Effects::drawShadowsChanged, this, [&]() {
         if (!m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view->effects(), &Latte::ViewPart::Effects::innerShadowChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(qGuiApp, &QGuiApplication::screenAdded, this, &Positioner::screenChanged);
     connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &Positioner::screenChanged);
 
     initSignalingForLocationChangeSliding();
 }
 
 int Positioner::currentScreenId() const
 {
     auto *latteCorona = qobject_cast<Latte::Corona *>(m_view->corona());
 
     if (latteCorona) {
         return latteCorona->screenPool()->id(m_screenToFollowId);
     }
 
     return -1;
 }
 
 Latte::WindowSystem::WindowId Positioner::trackedWindowId()
 {
     return m_trackedWindowId;
 }
 
 QString Positioner::currentScreenName() const
 {
     return m_screenToFollowId;
 }
 
 bool Positioner::setCurrentScreen(const QString id)
 {
     QScreen *nextScreen{qGuiApp->primaryScreen()};
 
     if (id != "primary") {
         for (const auto scr : qGuiApp->screens()) {
             if (scr && scr->name() == id) {
                 nextScreen = scr;
                 break;
             }
         }
     }
 
     if (m_screenToFollow == nextScreen) {
         return true;
     }
 
     if (nextScreen) {
         if (m_view->layout()) {
             auto freeEdges = m_view->layout()->freeEdges(nextScreen);
 
             if (!freeEdges.contains(m_view->location())) {
                 return false;
             } else {
                 m_goToScreen = nextScreen;
 
                 //! asynchronous call in order to not crash from configwindow
                 //! deletion from sliding out animation
                 QTimer::singleShot(100, [this]() {
                     emit hideDockDuringScreenChangeStarted();
                 });
             }
         }
     }
 
     return true;
 }
 
 //! this function updates the dock's associated screen.
 //! updateScreenId = true, update also the m_screenToFollowId
 //! updateScreenId = false, do not update the m_screenToFollowId
 //! that way an explicit dock can be shown in another screen when
 //! there isnt a tasks dock running in the system and for that
 //! dock its first origin screen is stored and that way when
 //! that screen is reconnected the dock will return to its original
 //! place
 void Positioner::setScreenToFollow(QScreen *scr, bool updateScreenId)
 {
     if (!scr || (scr && (m_screenToFollow == scr) && (m_view->screen() == scr))) {
         return;
     }
 
     qDebug() << "setScreenToFollow() called for screen:" << scr->name() << " update:" << updateScreenId;
 
     m_screenToFollow = scr;
 
     if (updateScreenId) {
         m_screenToFollowId = scr->name();
     }
 
     qDebug() << "adapting to screen...";
     m_view->setScreen(scr);
 
     if (m_view->containment()) {
         m_view->containment()->reactToScreenChange();
     }
 
     connect(scr, &QScreen::geometryChanged, this, &Positioner::screenGeometryChanged);
     syncGeometry();
     m_view->updateAbsoluteGeometry(true);
     qDebug() << "setScreenToFollow() ended...";
 
     emit screenGeometryChanged();
     emit currentScreenChanged();
 }
 
 //! the main function which decides if this dock is at the
 //! correct screen
 void Positioner::reconsiderScreen()
 {
     if (m_inDelete) {
         return;
     }
 
     qDebug() << "reconsiderScreen() called...";
     qDebug() << "  Delayer  ";
 
     for (const auto scr : qGuiApp->screens()) {
         qDebug() << "      D, found screen: " << scr->name();
     }
 
     bool screenExists{false};
 
     //!check if the associated screen is running
     for (const auto scr : qGuiApp->screens()) {
         if (m_screenToFollowId == scr->name()
-            || (m_view->onPrimary() && scr == qGuiApp->primaryScreen())) {
+                || (m_view->onPrimary() && scr == qGuiApp->primaryScreen())) {
             screenExists = true;
         }
     }
 
     qDebug() << "dock screen exists  ::: " << screenExists;
 
     //! 1.a primary dock must be always on the primary screen
     if (m_view->onPrimary() && (m_screenToFollowId != qGuiApp->primaryScreen()->name()
                                 || m_screenToFollow != qGuiApp->primaryScreen()
                                 || m_view->screen() != qGuiApp->primaryScreen())) {
         using Plasma::Types;
         QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
-                                     Types::TopEdge, Types::RightEdge};
+                    Types::TopEdge, Types::RightEdge};
 
         edges = m_view->layout() ? m_view->layout()->availableEdgesForView(qGuiApp->primaryScreen(), m_view) : edges;
 
         //change to primary screen only if the specific edge is free
         qDebug() << "updating the primary screen for dock...";
         qDebug() << "available primary screen edges:" << edges;
         qDebug() << "dock location:" << m_view->location();
 
         if (edges.contains(m_view->location())) {
             //! case 1
             qDebug() << "reached case 1: of updating dock primary screen...";
             setScreenToFollow(qGuiApp->primaryScreen());
         }
     } else if (!m_view->onPrimary()) {
         //! 2.an explicit dock must be always on the correct associated screen
         //! there are cases that window manager misplaces the dock, this function
         //! ensures that this dock will return at its correct screen
         for (const auto scr : qGuiApp->screens()) {
             if (scr && scr->name() == m_screenToFollowId) {
                 qDebug() << "reached case 2: updating the explicit screen for dock...";
                 setScreenToFollow(scr);
                 break;
             }
         }
     }
 
     syncGeometry();
     qDebug() << "reconsiderScreen() ended...";
 }
 
 void Positioner::screenChanged(QScreen *scr)
 {
     m_screenSyncTimer.start();
 
     //! this is needed in order to update the struts on screen change
     //! and even though the geometry has been set correctly the offsets
     //! of the screen must be updated to the new ones
     if (m_view->visibility() && m_view->visibility()->mode() == Latte::Types::AlwaysVisible) {
         m_view->updateAbsoluteGeometry(true);
     }
 }
 
 void Positioner::syncGeometry()
 {
-    if (!(m_view->screen() && m_view->containment()) || m_inDelete) {
+    if (!(m_view->screen() && m_view->containment()) || m_inDelete || m_slideOffset!=0) {
         return;
     }
 
     bool found{false};
 
     qDebug() << "syncGeometry() called...";
 
     //! before updating the positioning and geometry of the dock
     //! we make sure that the dock is at the correct screen
     if (m_view->screen() != m_screenToFollow) {
         qDebug() << "Sync Geometry screens inconsistent!!!! ";
 
         if (m_screenToFollow) {
             qDebug() << "Sync Geometry screens inconsistent for m_screenToFollow:" << m_screenToFollow->name() << " dock screen:" << m_view->screen()->name();
         }
 
         if (!m_screenSyncTimer.isActive()) {
             m_screenSyncTimer.start();
         }
     } else {
         found = true;
     }
 
     //! if the dock isnt at the correct screen the calculations
     //! are not executed
     if (found) {
         //! compute the free screen rectangle for vertical panels only once
         //! this way the costly QRegion computations are calculated only once
         //! instead of two times (both inside the resizeWindow and the updatePosition)
         QRegion freeRegion;;
         QRect maximumRect;
         QRect availableScreenRect{m_view->screen()->geometry()};
 
         if (m_view->formFactor() == Plasma::Types::Vertical) {
             QString layoutName = m_view->layout() ? m_view->layout()->name() : QString();
             auto latteCorona = qobject_cast<Latte::Corona *>(m_view->corona());
             int fixedScreen = m_view->onPrimary() ? latteCorona->screenPool()->primaryScreenId() : m_view->containment()->screen();
 
             freeRegion = latteCorona->availableScreenRegionWithCriteria(fixedScreen, layoutName);
             maximumRect = maximumNormalGeometry();
             QRegion availableRegion = freeRegion.intersected(maximumRect);
             availableScreenRect = freeRegion.intersected(maximumRect).boundingRect();
             float area = 0;
 
             //! it is used to choose which or the availableRegion rectangles will
             //! be the one representing dock geometry
             for (QRegion::const_iterator p_rect=availableRegion.begin(); p_rect!=availableRegion.end(); ++p_rect) {
                 //! the area of each rectangle in calculated in squares of 50x50
                 //! this is a way to avoid enourmous numbers for area value
                 float tempArea = (float)((*p_rect).width() * (*p_rect).height()) / 2500;
 
                 if (tempArea > area) {
                     availableScreenRect = (*p_rect);
                     area = tempArea;
                 }
             }
 
             if (availableRegion.rectCount() > 1 && m_view->behaveAsPlasmaPanel()) {
                 m_view->effects()->setForceDrawCenteredBorders(true);
             } else {
                 m_view->effects()->setForceDrawCenteredBorders(false);
             }
         } else {
             m_view->effects()->setForceDrawCenteredBorders(false);
         }
 
         m_view->effects()->updateEnabledBorders();
         resizeWindow(availableScreenRect);
         updatePosition(availableScreenRect);
 
         qDebug() << "syncGeometry() calculations for screen: " << m_view->screen()->name() << " _ " << m_view->screen()->geometry();
         qDebug() << "syncGeometry() calculations for edge: " << m_view->location();
     }
 
     qDebug() << "syncGeometry() ended...";
 
     // qDebug() << "dock geometry:" << qRectToStr(geometry());
 }
 
 void Positioner::validateDockGeometry()
 {
-    if (m_view->geometry() != m_validGeometry) {
+    if (m_slideOffset==0 && m_view->geometry() != m_validGeometry) {
         m_validateGeometryTimer.start();
     }
 }
 
 //! this is used mainly from vertical panels in order to
 //! to get the maximum geometry that can be used from the dock
 //! based on their alignment type and the location dock
 QRect Positioner::maximumNormalGeometry()
 {
     int xPos = 0;
     int yPos = m_view->screen()->geometry().y();;
     int maxHeight = m_view->screen()->geometry().height();
     int maxWidth = m_view->normalThickness();
     QRect maxGeometry;
     maxGeometry.setRect(0, 0, maxWidth, maxHeight);
 
     switch (m_view->location()) {
-        case Plasma::Types::LeftEdge:
-            xPos = m_view->screen()->geometry().x();
-            maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
-            break;
-
-        case Plasma::Types::RightEdge:
-            xPos = m_view->screen()->geometry().right() - maxWidth + 1;
-            maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
-            break;
-
-        default:
-            //! bypass clang warnings
-            break;
+    case Plasma::Types::LeftEdge:
+        xPos = m_view->screen()->geometry().x();
+        maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
+        break;
+
+    case Plasma::Types::RightEdge:
+        xPos = m_view->screen()->geometry().right() - maxWidth + 1;
+        maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
+        break;
+
+    default:
+        //! bypass clang warnings
+        break;
     }
 
     //! this is needed in order to preserve that the top dock will be above
     //! the others in case flag bypasswindowmanagerhint hasn't be set,
     //! such a case is the AlwaysVisible mode
     //! NO IDEA what this is trying to solve... It must be updated and checked
     //! if this IS STILL NEEDED
     if (m_view->location() == Plasma::Types::TopEdge
             && m_view->visibility()->mode() != Latte::Types::WindowsCanCover
             && m_view->visibility()->mode() != Latte::Types::WindowsAlwaysCover) {
         KWindowSystem::setState(m_view->winId(), NET::KeepAbove);
     } else {
-      //  KWindowSystem::clearState(m_view->winId(), NET::KeepAbove);
+        //  KWindowSystem::clearState(m_view->winId(), NET::KeepAbove);
     }
 
     return maxGeometry;
 }
 
 void Positioner::updatePosition(QRect availableScreenRect)
 {
     QRect screenGeometry{availableScreenRect};
     QPoint position;
     position = {0, 0};
 
     const auto length = [&](int length) -> int {
         float offs = static_cast<float>(m_view->offset());
         return static_cast<int>(length * ((1 - m_view->maxLength()) / 2) + length * (offs / 100));
     };
     int cleanThickness = m_view->normalThickness() - m_view->effects()->innerShadow();
 
     int screenEdgeMargin = (m_view->behaveAsPlasmaPanel() && m_view->screenEdgeMarginEnabled()) ? m_view->screenEdgeMargin() : 0;
 
     switch (m_view->location()) {
-        case Plasma::Types::TopEdge:
-            if (m_view->behaveAsPlasmaPanel()) {
-                position = {screenGeometry.x() + length(screenGeometry.width()),
-                            screenGeometry.y() + screenEdgeMargin};
-            } else {
-                position = {screenGeometry.x(), screenGeometry.y()};
-            }
+    case Plasma::Types::TopEdge:
+        if (m_view->behaveAsPlasmaPanel()) {
+            position = {screenGeometry.x() + length(screenGeometry.width()),
+                        screenGeometry.y() + screenEdgeMargin};
+        } else {
+            position = {screenGeometry.x(), screenGeometry.y()};
+        }
 
-            break;
+        break;
 
-        case Plasma::Types::BottomEdge:
-            if (m_view->behaveAsPlasmaPanel()) {
-                position = {screenGeometry.x() + length(screenGeometry.width()),
-                            screenGeometry.y() + screenGeometry.height() - cleanThickness - screenEdgeMargin};
-            } else {
-                position = {screenGeometry.x(), screenGeometry.y() + screenGeometry.height() - m_view->height()};
-            }
+    case Plasma::Types::BottomEdge:
+        if (m_view->behaveAsPlasmaPanel()) {
+            position = {screenGeometry.x() + length(screenGeometry.width()),
+                        screenGeometry.y() + screenGeometry.height() - cleanThickness - screenEdgeMargin};
+        } else {
+            position = {screenGeometry.x(), screenGeometry.y() + screenGeometry.height() - m_view->height()};
+        }
 
-            break;
+        break;
 
-        case Plasma::Types::RightEdge:
-            if (m_view->behaveAsPlasmaPanel()) {
-                position = {availableScreenRect.right() - cleanThickness + 1 - screenEdgeMargin,
-                            availableScreenRect.y() + length(availableScreenRect.height())};
-            } else {
-                position = {availableScreenRect.right() - m_view->width() + 1, availableScreenRect.y()};
-            }
+    case Plasma::Types::RightEdge:
+        if (m_view->behaveAsPlasmaPanel()) {
+            position = {availableScreenRect.right() - cleanThickness + 1 - screenEdgeMargin,
+                        availableScreenRect.y() + length(availableScreenRect.height())};
+        } else {
+            position = {availableScreenRect.right() - m_view->width() + 1, availableScreenRect.y()};
+        }
 
-            break;
+        break;
 
-        case Plasma::Types::LeftEdge:
-            if (m_view->behaveAsPlasmaPanel()) {
-                position = {availableScreenRect.x() + screenEdgeMargin,
-                            availableScreenRect.y() + length(availableScreenRect.height())};
-            } else {
-                position = {availableScreenRect.x(), availableScreenRect.y()};
-            }
+    case Plasma::Types::LeftEdge:
+        if (m_view->behaveAsPlasmaPanel()) {
+            position = {availableScreenRect.x() + screenEdgeMargin,
+                        availableScreenRect.y() + length(availableScreenRect.height())};
+        } else {
+            position = {availableScreenRect.x(), availableScreenRect.y()};
+        }
 
-            break;
+        break;
 
-        default:
-            qWarning() << "wrong location, couldn't update the panel position"
-                       << m_view->location();
+    default:
+        qWarning() << "wrong location, couldn't update the panel position"
+                   << m_view->location();
     }
 
     m_validGeometry.setTopLeft(position);
 
     m_view->setPosition(position);
 
     if (m_view->surface()) {
         m_view->surface()->setPosition(position);
     }
 }
 
+int Positioner::slideOffset() const
+{
+    return m_slideOffset;
+}
+
+void Positioner::setSlideOffset(int offset)
+{
+    if (m_slideOffset == offset) {
+        return;
+    }
+
+    m_slideOffset = offset;
+
+    QPoint slidedTopLeft;
+
+    if (m_view->location() == Plasma::Types::TopEdge) {
+        int boundedY = qMax(m_view->screenGeometry().top() - (m_validGeometry.height() - 1), m_validGeometry.y() - qAbs(m_slideOffset));
+        slidedTopLeft = {m_validGeometry.x(), boundedY};
+
+    } else if (m_view->location() == Plasma::Types::BottomEdge) {
+        int boundedY = qMin(m_view->screenGeometry().bottom() - 1, m_validGeometry.y() + qAbs(m_slideOffset));
+        slidedTopLeft = {m_validGeometry.x(), boundedY};
+
+    } else if (m_view->location() == Plasma::Types::RightEdge) {
+        int boundedX = qMax(m_view->screenGeometry().right() - 1, m_validGeometry.x() + qAbs(m_slideOffset));
+        slidedTopLeft = {boundedX, m_validGeometry.y()};
+
+    } else if (m_view->location() == Plasma::Types::LeftEdge) {
+        int boundedX = qMax(m_view->screenGeometry().left() - (m_validGeometry.width() - 1), m_validGeometry.x() - qAbs(m_slideOffset));
+        slidedTopLeft = {boundedX, m_validGeometry.y()};
+
+    }
+
+    m_view->setPosition(slidedTopLeft);
+
+    if (m_view->surface()) {
+        m_view->surface()->setPosition(slidedTopLeft);
+    }
+
+    emit slideOffsetChanged();
+}
+
+
 void Positioner::resizeWindow(QRect availableScreenRect)
 {
     QSize screenSize = m_view->screen()->size();
     QSize size = (m_view->formFactor() == Plasma::Types::Vertical) ? QSize(m_view->maxThickness(), availableScreenRect.height()) : QSize(screenSize.width(), m_view->maxThickness());
 
     if (m_view->formFactor() == Plasma::Types::Vertical) {
         //qDebug() << "MAXIMUM RECT :: " << maximumRect << " - AVAILABLE RECT :: " << availableRect;
         if (m_view->behaveAsPlasmaPanel()) {
             size.setWidth(m_view->normalThickness());
             size.setHeight(static_cast<int>(m_view->maxLength() * availableScreenRect.height()));
         }
     } else {
         if (m_view->behaveAsPlasmaPanel()) {
             size.setWidth(static_cast<int>(m_view->maxLength() * screenSize.width()));
             size.setHeight(m_view->normalThickness());
         }
     }
 
     m_validGeometry.setSize(size);
 
     m_view->setMinimumSize(size);
     m_view->setMaximumSize(size);
     m_view->resize(size);
 
     if (m_view->formFactor() == Plasma::Types::Horizontal) {
         emit windowSizeChanged();
     }
 }
 
 void Positioner::updateFormFactor()
 {
     if (!m_view->containment())
         return;
 
     switch (m_view->location()) {
-        case Plasma::Types::TopEdge:
-        case Plasma::Types::BottomEdge:
-            m_view->containment()->setFormFactor(Plasma::Types::Horizontal);
-            break;
-
-        case Plasma::Types::LeftEdge:
-        case Plasma::Types::RightEdge:
-            m_view->containment()->setFormFactor(Plasma::Types::Vertical);
-            break;
-
-        default:
-            qWarning() << "wrong location, couldn't update the panel position" << m_view->location();
+    case Plasma::Types::TopEdge:
+    case Plasma::Types::BottomEdge:
+        m_view->containment()->setFormFactor(Plasma::Types::Horizontal);
+        break;
+
+    case Plasma::Types::LeftEdge:
+    case Plasma::Types::RightEdge:
+        m_view->containment()->setFormFactor(Plasma::Types::Vertical);
+        break;
+
+    default:
+        qWarning() << "wrong location, couldn't update the panel position" << m_view->location();
     }
 }
 
 void Positioner::initSignalingForLocationChangeSliding()
 {
     //! signals to handle the sliding-in/out during location changes
     connect(this, &Positioner::hideDockDuringLocationChangeStarted, this, &Positioner::onHideWindowsForSlidingOut);
 
     connect(m_view, &View::locationChanged, this, [&]() {
         if (m_goToLocation != Plasma::Types::Floating) {
             m_goToLocation = Plasma::Types::Floating;
             QTimer::singleShot(100, [this]() {
                 m_view->effects()->setAnimationsBlocked(false);
                 emit showDockAfterLocationChangeFinished();
                 m_view->showSettingsWindow();
 
                 if (m_view->layout()) {
                     //! This is needed in case the edge is occupied and the occupying
                     //! view must be deleted
                     m_view->layout()->syncLatteViewsToScreens();
                 }
 
                 emit edgeChanged();
             });
         }
     });
 
     //! signals to handle the sliding-in/out during screen changes
     connect(this, &Positioner::hideDockDuringScreenChangeStarted, this, &Positioner::onHideWindowsForSlidingOut);
 
     connect(this, &Positioner::currentScreenChanged, this, [&]() {
         if (m_goToScreen) {
             m_goToScreen = nullptr;
             QTimer::singleShot(100, [this]() {
                 m_view->effects()->setAnimationsBlocked(false);
                 emit showDockAfterScreenChangeFinished();
                 m_view->showSettingsWindow();
 
                 if (m_view->layout()) {
                     //! This is needed in case the edge is occupied and the occupying
                     //! view must be deleted
                     m_view->layout()->syncLatteViewsToScreens();
                 }
 
                 emit edgeChanged();
             });
         }
     });
 
     //! signals to handle the sliding-in/out during moving to another layout
     connect(this, &Positioner::hideDockDuringMovingToLayoutStarted, this, &Positioner::onHideWindowsForSlidingOut);
 
     connect(m_view, &View::layoutChanged, this, [&]() {
         if (!m_moveToLayout.isEmpty() && m_view->layout()) {
             m_moveToLayout = "";
             QTimer::singleShot(100, [this]() {
                 m_view->effects()->setAnimationsBlocked(false);
                 emit showDockAfterMovingToLayoutFinished();
                 m_view->showSettingsWindow();
                 emit edgeChanged();
             });
         }
     });
 
     //!    ----  both cases   ----  !//
     //! this is used for both location and screen change cases, this signal
     //! is send when the sliding-out animation has finished
     connect(this, &Positioner::hideDockDuringLocationChangeFinished, this, [&]() {
         m_view->effects()->setAnimationsBlocked(true);
 
         if (m_goToLocation != Plasma::Types::Floating) {
             m_view->setLocation(m_goToLocation);
         } else if (m_goToScreen) {
             setScreenToFollow(m_goToScreen);
         } else if (!m_moveToLayout.isEmpty()) {
             m_view->moveToLayout(m_moveToLayout);
         }
     });
 }
 
 bool Positioner::inLocationChangeAnimation()
 {
     return ((m_goToLocation != Plasma::Types::Floating) || (m_moveToLayout != "") || m_goToScreen);
 }
 
 void Positioner::hideDockDuringLocationChange(int goToLocation)
 {
     m_goToLocation = static_cast<Plasma::Types::Location>(goToLocation);
     emit hideDockDuringLocationChangeStarted();
 }
 
 void Positioner::hideDockDuringMovingToLayout(QString layoutName)
 {
     m_moveToLayout = layoutName;
     emit hideDockDuringMovingToLayoutStarted();
 }
 
 }
 }
diff --git a/app/view/positioner.h b/app/view/positioner.h
index 9970ea37..9c8aa38c 100644
--- a/app/view/positioner.h
+++ b/app/view/positioner.h
@@ -1,136 +1,144 @@
 /*
 *  Copyright 2018  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef POSITIONER_H
 #define POSITIONER_H
 
 //local
 #include "../wm/windowinfowrap.h"
 
 // Qt
 #include <QObject>
 #include <QPointer>
 #include <QScreen>
 #include <QTimer>
 
 // Plasma
 #include <Plasma/Containment>
 
 namespace Plasma {
 class Types;
 }
 
 namespace Latte {
 class Corona;
 class View;
 }
 
 namespace Latte {
 namespace ViewPart {
 
 class Positioner: public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(int currentScreenId READ currentScreenId NOTIFY currentScreenChanged)
+    //! animating window slide
+    Q_PROPERTY(int slideOffset READ slideOffset WRITE setSlideOffset NOTIFY slideOffsetChanged)
     Q_PROPERTY(QString currentScreenName READ currentScreenName NOTIFY currentScreenChanged)
 
 public:
     Positioner(Latte::View *parent);
     virtual ~Positioner();
 
     int currentScreenId() const;
     QString currentScreenName() const;
 
+    int slideOffset() const;
+    void setSlideOffset(int offset);
+
     bool inLocationChangeAnimation();
     void setScreenToFollow(QScreen *scr, bool updateScreenId = true);
 
     void reconsiderScreen();
 
     Latte::WindowSystem::WindowId trackedWindowId();
 
 public slots:
     Q_INVOKABLE void hideDockDuringLocationChange(int goToLocation);
     Q_INVOKABLE void hideDockDuringMovingToLayout(QString layoutName);
 
     Q_INVOKABLE bool setCurrentScreen(const QString id);
 
     void syncGeometry();
 
 signals:
     void currentScreenChanged();
     void edgeChanged();
     void screenGeometryChanged();
+    void slideOffsetChanged();
     void windowSizeChanged();
 
     //! these two signals are used from config ui and containment ui
     //! in order to orchestrate an animated hiding/showing of dock
     //! during changing location
     void hideDockDuringLocationChangeStarted();
     void hideDockDuringLocationChangeFinished();
     void hideDockDuringScreenChangeStarted();
     void hideDockDuringScreenChangeFinished();
     void hideDockDuringMovingToLayoutStarted();
     void hideDockDuringMovingToLayoutFinished();
     void onHideWindowsForSlidingOut();
     void showDockAfterLocationChangeFinished();
     void showDockAfterScreenChangeFinished();
     void showDockAfterMovingToLayoutFinished();
 
 private slots:
     void screenChanged(QScreen *screen);
     void validateDockGeometry();
 
 private:
     void init();
     void initSignalingForLocationChangeSliding();
     void resizeWindow(QRect availableScreenRect = QRect());
 
     void updateFormFactor();
     void updatePosition(QRect availableScreenRect = QRect());
 
     QRect maximumNormalGeometry();
 
 private:
     bool m_inDelete{false};
 
+    int m_slideOffset{0};
+
     //! it is used in order to enforce X11 to never miss window geometry
     QRect m_validGeometry;
 
     QPointer<Latte::View> m_view;
     QPointer<Latte::Corona> m_corona;
 
     QString m_screenToFollowId;
     QPointer<QScreen> m_screenToFollow;
     QTimer m_screenSyncTimer;
 
     QTimer m_validateGeometryTimer;
 
     //!used at sliding out/in animation
     QString m_moveToLayout;
     Plasma::Types::Location m_goToLocation{Plasma::Types::Floating};
     QScreen *m_goToScreen{nullptr};
 
     Latte::WindowSystem::WindowId m_trackedWindowId;
 };
 
 }
 }
 
 #endif
diff --git a/app/view/visibilitymanager.cpp b/app/view/visibilitymanager.cpp
index ad4f3626..db168843 100644
--- a/app/view/visibilitymanager.cpp
+++ b/app/view/visibilitymanager.cpp
@@ -1,836 +1,836 @@
 /*
 *  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/>.
 */
 
 #include "visibilitymanager.h"
 
 // local
 #include "positioner.h"
 #include "screenedgeghostwindow.h"
 #include "view.h"
 #include "windowstracker/currentscreentracker.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../layouts/manager.h"
 #include "../wm/abstractwindowinterface.h"
 #include "../../liblatte2/extras.h"
 
 // Qt
 #include <QDebug>
 
 // KDE
 #include <KWindowSystem>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 
 //! Hide Timer can create cases that when it is low it does not allow the
 //! view to be show. For example !compositing+kwin_edges+hide inteval<50ms
 const int HIDEMINIMUMINTERVAL = 50;
 
 namespace Latte {
 namespace ViewPart {
 
 //! BEGIN: VisiblityManager implementation
 
 VisibilityManager::VisibilityManager(PlasmaQuick::ContainmentView *view)
     : QObject(view)
 {
     qDebug() << "VisibilityManager creating...";
 
     m_latteView = qobject_cast<Latte::View *>(view);
     m_corona = qobject_cast<Latte::Corona *>(view->corona());
     m_wm = m_corona->wm();
 
     connect(this, &VisibilityManager::slideInFinished, this, &VisibilityManager::updateHiddenState);
     connect(this, &VisibilityManager::slideOutFinished, this, &VisibilityManager::updateHiddenState);
 
     connect(this, &VisibilityManager::enableKWinEdgesChanged, this, &VisibilityManager::updateKWinEdgesSupport);
     connect(this, &VisibilityManager::modeChanged, this, &VisibilityManager::updateKWinEdgesSupport);
 
     if (m_latteView) {
         connect(m_latteView, &Latte::View::eventTriggered, this, &VisibilityManager::viewEventManager);
         connect(m_latteView, &Latte::View::byPassWMChanged, this, &VisibilityManager::updateKWinEdgesSupport);
 
         connect(m_latteView, &Latte::View::absoluteGeometryChanged, this, [&]() {
             if (m_mode == Types::AlwaysVisible && m_latteView->screen()) {
                 updateStrutsBasedOnLayoutsAndActivities();
             }
         });
 
         connect(m_latteView, &Latte::View::inEditModeChanged, this, &VisibilityManager::initViewFlags);
 
         connect(this, &VisibilityManager::modeChanged, this, [&]() {
             emit m_latteView->availableScreenRectChangedFrom(m_latteView);
         });
     }
 
     m_timerStartUp.setInterval(5000);
     m_timerStartUp.setSingleShot(true);
     m_timerShow.setSingleShot(true);
     m_timerHide.setSingleShot(true);
 
     connect(&m_timerShow, &QTimer::timeout, this, [&]() {
         if (m_isHidden ||  m_isBelowLayer) {
             //   qDebug() << "must be shown";
             emit mustBeShown();
         }
     });
     connect(&m_timerHide, &QTimer::timeout, this, [&]() {
         if (!m_blockHiding && !m_isHidden && !m_isBelowLayer && !m_dragEnter) {
             //   qDebug() << "must be hide";
             emit mustBeHide();
         }
     });
 
     restoreConfig();
 }
 
 VisibilityManager::~VisibilityManager()
 {
     qDebug() << "VisibilityManager deleting...";
     m_wm->removeViewStruts(*m_latteView);
 
     if (m_edgeGhostWindow) {
         m_edgeGhostWindow->deleteLater();
     }
 }
 
 Types::Visibility VisibilityManager::mode() const
 {
     return m_mode;
 }
 
 void VisibilityManager::initViewFlags()
 {
     if ((m_mode == Types::WindowsCanCover || m_mode == Types::WindowsAlwaysCover) && (!m_latteView->inEditMode())) {
         setViewOnBackLayer();
     } else {
         setViewOnFrontLayer();
     }
 }
 
 void VisibilityManager::setViewOnBackLayer()
 {
     m_wm->setViewExtraFlags(m_latteView, false, Types::WindowsAlwaysCover);
     setIsBelowLayer(true);
 }
 
 void VisibilityManager::setViewOnFrontLayer()
 {
     m_wm->setViewExtraFlags(m_latteView, true);
     setIsBelowLayer(false);
 }
 
 void VisibilityManager::setMode(Latte::Types::Visibility mode)
 {
     if (m_mode == mode)
         return;
 
     Q_ASSERT_X(mode != Types::None, staticMetaObject.className(), "set visibility to Types::None");
 
     // clear mode
     for (auto &c : m_connections) {
         disconnect(c);
     }
 
     int base{0};
 
     m_publishedStruts = QRect();
 
     if (m_mode == Types::AlwaysVisible) {
         //! remove struts for old always visible mode
         m_wm->removeViewStruts(*m_latteView);
     }
 
     m_timerShow.stop();
     m_timerHide.stop();
     m_mode = mode;
 
     initViewFlags();
 
     if (mode != Types::AlwaysVisible && mode != Types::WindowsGoBelow) {
         m_connections[0] = connect(m_wm, &WindowSystem::AbstractWindowInterface::currentDesktopChanged, this, [&] {
             if (m_raiseOnDesktopChange) {
                 raiseViewTemporarily();
             }
         });
         m_connections[1] = connect(m_wm, &WindowSystem::AbstractWindowInterface::currentActivityChanged, this, [&]() {
             if (m_raiseOnActivityChange) {
                 raiseViewTemporarily();
             } else {
                 updateHiddenState();
             }
         });
 
         base = 2;
     }
 
     switch (m_mode) {
     case Types::AlwaysVisible: {
         if (m_latteView->containment() && m_latteView->screen()) {
             updateStrutsBasedOnLayoutsAndActivities();
         }
 
         m_connections[base] = connect(m_latteView, &Latte::View::normalThicknessChanged, this, [&]() {
             updateStrutsBasedOnLayoutsAndActivities();
         });
 
         m_connections[base+1] = connect(m_corona->layoutsManager(),  &Layouts::Manager::currentLayoutNameChanged, this, [&]() {
             if (m_corona && m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
                 updateStrutsBasedOnLayoutsAndActivities(true);
             }
         });
 
         m_connections[base+2] = connect(m_latteView, &Latte::View::activitiesChanged, this, [&]() {
             if (m_corona && m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
                 updateStrutsBasedOnLayoutsAndActivities(true);
             }
         });
 
         raiseView(true);
         break;
     }
 
     case Types::AutoHide: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged, this, [&]() {
             raiseView(m_containsMouse);
         });
 
         raiseView(m_containsMouse);
         break;
     }
 
     case Types::DodgeActive: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged
                                       , this, &VisibilityManager::dodgeActive);
         m_connections[base+1] = connect(m_latteView->windowsTracker()->currentScreen(), &TrackerPart::CurrentScreenTracker::activeWindowTouchingChanged
                                         , this, &VisibilityManager::dodgeActive);
 
         dodgeActive();
         break;
     }
 
     case Types::DodgeMaximized: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged
                                       , this, &VisibilityManager::dodgeMaximized);
         m_connections[base+1] = connect(m_latteView->windowsTracker()->currentScreen(), &TrackerPart::CurrentScreenTracker::activeWindowMaximizedChanged
                                         , this, &VisibilityManager::dodgeMaximized);
 
         dodgeMaximized();
         break;
     }
 
     case Types::DodgeAllWindows: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged
                                       , this, &VisibilityManager::dodgeAllWindows);
 
         m_connections[base+1] = connect(m_latteView->windowsTracker()->currentScreen(), &TrackerPart::CurrentScreenTracker::existsWindowTouchingChanged
                                         , this, &VisibilityManager::dodgeAllWindows);
 
         dodgeAllWindows();
         break;
     }
 
     case Types::WindowsGoBelow:
         break;
 
     case Types::WindowsCanCover:
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged, this, [&]() {
             if (m_containsMouse) {
                 emit mustBeShown();
             } else {
                 raiseView(false);
             }
         });
 
         raiseView(m_containsMouse);
         break;
 
     case Types::WindowsAlwaysCover:
         break;
 
     default:
         break;
     }
 
     m_latteView->containment()->config().writeEntry("visibility", static_cast<int>(m_mode));
 
     updateKWinEdgesSupport();
 
     emit modeChanged();
 }
 
 void VisibilityManager::updateStrutsBasedOnLayoutsAndActivities(bool forceUpdate)
 {
     bool multipleLayoutsAndCurrent = (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts
                                       && m_latteView->layout() && !m_latteView->positioner()->inLocationChangeAnimation()
                                       && m_latteView->layout()->isCurrent());
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout || multipleLayoutsAndCurrent) {
         QRect computedStruts = acceptableStruts();
         if (m_publishedStruts != computedStruts || forceUpdate) {
             //! Force update is needed when very important events happen in DE and there is a chance
             //! that previously even though struts where sent the DE did not accept them.
             //! Such a case is when STOPPING an Activity and windows faulty become invisible even
             //! though they should not. In such case setting struts when the windows are hidden
             //! the struts do not take any effect
             m_publishedStruts = computedStruts;
             m_wm->setViewStruts(*m_latteView, m_publishedStruts, m_latteView->location());
         }
     } else {
         m_publishedStruts = QRect();
         m_wm->removeViewStruts(*m_latteView);
     }
 }
 
 QRect VisibilityManager::acceptableStruts()
 {
     QRect calcs;
 
     int screenEdgeMargin = (m_latteView->behaveAsPlasmaPanel() && m_latteView->screenEdgeMarginEnabled()) ? m_latteView->screenEdgeMargin() : 0;
     int shownThickness = m_latteView->normalThickness() + screenEdgeMargin;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge: {
         calcs = QRect(m_latteView->x(), m_latteView->y(), m_latteView->width(), shownThickness);
         break;
     }
 
     case Plasma::Types::BottomEdge: {
         int y = m_latteView->y() + m_latteView->height() - shownThickness;
         calcs = QRect(m_latteView->x(), y, m_latteView->width(), shownThickness);
         break;
     }
 
     case Plasma::Types::LeftEdge: {
         calcs = QRect(m_latteView->x(), m_latteView->y(), shownThickness, m_latteView->height());
         break;
     }
 
     case Plasma::Types::RightEdge: {
         int x = m_latteView->x() + m_latteView->width() - shownThickness;
         calcs = QRect(x, m_latteView->y(), shownThickness, m_latteView->height());
         break;
     }
     }
 
     return calcs;
 }
 
 bool VisibilityManager::raiseOnDesktop() const
 {
     return m_raiseOnDesktopChange;
 }
 
 void VisibilityManager::setRaiseOnDesktop(bool enable)
 {
     if (enable == m_raiseOnDesktopChange)
         return;
 
     m_raiseOnDesktopChange = enable;
     emit raiseOnDesktopChanged();
 }
 
 bool VisibilityManager::raiseOnActivity() const
 {
     return m_raiseOnActivityChange;
 }
 
 void VisibilityManager::setRaiseOnActivity(bool enable)
 {
     if (enable == m_raiseOnActivityChange)
         return;
 
     m_raiseOnActivityChange = enable;
     emit raiseOnActivityChanged();
 }
 
 bool VisibilityManager::isBelowLayer() const
 {
     return m_isBelowLayer;
 }
 
 void VisibilityManager::setIsBelowLayer(bool below)
 {
     if (m_isBelowLayer == below) {
         return;
     }
 
     m_isBelowLayer = below;
 
-    if (m_mode == Latte::Types::WindowsCanCover) {
-        updateGhostWindowState();
-    }
+    updateGhostWindowState();
 
     emit isBelowLayerChanged();
 }
 
 bool VisibilityManager::isHidden() const
 {
     return m_isHidden;
 }
 
 void VisibilityManager::setIsHidden(bool isHidden)
 {
     if (m_isHidden == isHidden)
         return;
 
     if (m_blockHiding && isHidden) {
         qWarning() << "isHidden property is blocked, ignoring update";
         return;
     }
 
     m_isHidden = isHidden;
 
-    updateGhostWindowState();
+    if (!m_latteView->behaveAsPlasmaPanel()) {
+        updateGhostWindowState();
+    }
 
     emit isHiddenChanged();
 }
 
 bool VisibilityManager::blockHiding() const
 {
     return m_blockHiding;
 }
 
 void VisibilityManager::setBlockHiding(bool blockHiding)
 {
     if (m_blockHiding == blockHiding) {
         return;
     }
 
     m_blockHiding = blockHiding;
     // qDebug() << "blockHiding:" << blockHiding;
 
     if (m_blockHiding) {
         m_timerHide.stop();
 
         if (m_isHidden) {
             emit mustBeShown();
         }
     } else {
         updateHiddenState();
     }
 
     emit blockHidingChanged();
 }
 
 int VisibilityManager::timerShow() const
 {
     return m_timerShow.interval();
 }
 
 void VisibilityManager::setTimerShow(int msec)
 {
     if (m_timerShow.interval() == msec) {
         return;
     }
 
     m_timerShow.setInterval(msec);
     emit timerShowChanged();
 }
 
 int VisibilityManager::timerHide() const
 {
     return m_timerHide.interval();
 }
 
 void VisibilityManager::setTimerHide(int msec)
 {
     int interval = qMax(HIDEMINIMUMINTERVAL, msec);
 
     if (m_timerHide.interval() == interval) {
         return;
     }
 
     m_timerHide.setInterval(interval);
     emit timerHideChanged();
 }
 
 bool VisibilityManager::supportsKWinEdges() const
 {
     return (m_edgeGhostWindow != nullptr);
 }
 
 void VisibilityManager::updateGhostWindowState()
 {
     if (supportsKWinEdges()) {
         bool inCurrentLayout = (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout ||
                                 (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts
                                  && m_latteView->layout() && !m_latteView->positioner()->inLocationChangeAnimation()
                                  && m_latteView->layout()->isCurrent()));
 
         if (inCurrentLayout) {
             if (m_mode == Latte::Types::WindowsCanCover) {
                 m_wm->setEdgeStateFor(m_edgeGhostWindow, m_isBelowLayer && !m_containsMouse);
             } else {
                 m_wm->setEdgeStateFor(m_edgeGhostWindow, m_isHidden && !m_containsMouse);
             }
         } else {
             m_wm->setEdgeStateFor(m_edgeGhostWindow, false);
         }
     }
 }
 
 void VisibilityManager::hide()
 {
     if (KWindowSystem::isPlatformX11()) {
         m_latteView->hide();
     }
 }
 
 void VisibilityManager::show()
 {
     if (KWindowSystem::isPlatformX11()) {
         m_latteView->show();
     }
 }
 
 
 void VisibilityManager::raiseView(bool raise)
 {
     if (m_blockHiding)
         return;
 
     if (raise) {
         m_timerHide.stop();
 
         if (!m_timerShow.isActive()) {
             m_timerShow.start();
         }
     } else if (!m_dragEnter) {
         m_timerShow.stop();
 
         if (m_hideNow) {
             m_hideNow = false;
             emit mustBeHide();
         } else if (!m_timerHide.isActive()) {
             m_timerHide.start();
         }
     }
 }
 
 void VisibilityManager::raiseViewTemporarily()
 {
     if (m_raiseTemporarily)
         return;
 
     m_raiseTemporarily = true;
     m_timerHide.stop();
     m_timerShow.stop();
 
     if (m_isHidden)
         emit mustBeShown();
 
     QTimer::singleShot(qBound(1800, 2 * m_timerHide.interval(), 3000), this, [&]() {
         m_raiseTemporarily = false;
         m_hideNow = true;
         updateHiddenState();
     });
 }
 
 void VisibilityManager::updateHiddenState()
 {
     if (m_dragEnter)
         return;
 
     switch (m_mode) {
     case Types::AutoHide:
     case Types::WindowsCanCover:
         raiseView(m_containsMouse);
         break;
 
     case Types::DodgeActive:
         dodgeActive();
         break;
 
     case Types::DodgeMaximized:
         dodgeMaximized();
         break;
 
     case Types::DodgeAllWindows:
         dodgeAllWindows();
         break;
 
     default:
         break;
     }
 }
 
 void VisibilityManager::applyActivitiesToHiddenWindows(const QStringList &activities)
 {
     if (m_edgeGhostWindow) {
         m_wm->setWindowOnActivities(*m_edgeGhostWindow, activities);
     }
 }
 
 void VisibilityManager::dodgeActive()
 {
     if (m_raiseTemporarily)
         return;
 
     //!don't send false raiseView signal when containing mouse
     if (m_containsMouse) {
         raiseView(true);
         return;
     }
 
     raiseView(!m_latteView->windowsTracker()->currentScreen()->activeWindowTouching());
 }
 
 void VisibilityManager::dodgeMaximized()
 {
     if (m_raiseTemporarily)
         return;
 
     //!don't send false raiseView signal when containing mouse
     if (m_containsMouse) {
         raiseView(true);
         return;
     }
 
     raiseView(!m_latteView->windowsTracker()->currentScreen()->activeWindowMaximized());
 }
 
 void VisibilityManager::dodgeAllWindows()
 {
     if (m_raiseTemporarily)
         return;
 
     if (m_containsMouse) {
         raiseView(true);
     }
 
     bool windowIntersects{m_latteView->windowsTracker()->currentScreen()->activeWindowTouching() || m_latteView->windowsTracker()->currentScreen()->existsWindowTouching()};
 
     raiseView(!windowIntersects);
 }
 
 void VisibilityManager::saveConfig()
 {
     if (!m_latteView->containment())
         return;
 
     auto config = m_latteView->containment()->config();
 
     config.writeEntry("enableKWinEdges", m_enableKWinEdgesFromUser);
     config.writeEntry("timerShow", m_timerShow.interval());
     config.writeEntry("timerHide", m_timerHide.interval());
     config.writeEntry("raiseOnDesktopChange", m_raiseOnDesktopChange);
     config.writeEntry("raiseOnActivityChange", m_raiseOnActivityChange);
 
     m_latteView->containment()->configNeedsSaving();
 }
 
 void VisibilityManager::restoreConfig()
 {
     if (!m_latteView || !m_latteView->containment()){
         return;
     }
 
     auto config = m_latteView->containment()->config();
     m_timerShow.setInterval(config.readEntry("timerShow", 0));
     m_timerHide.setInterval(qMax(HIDEMINIMUMINTERVAL, config.readEntry("timerHide", 700)));
     emit timerShowChanged();
     emit timerHideChanged();
 
     m_enableKWinEdgesFromUser = config.readEntry("enableKWinEdges", true);
     emit enableKWinEdgesChanged();
 
     setRaiseOnDesktop(config.readEntry("raiseOnDesktopChange", false));
     setRaiseOnActivity(config.readEntry("raiseOnActivityChange", false));
 
     auto storedMode = static_cast<Types::Visibility>(m_latteView->containment()->config().readEntry("visibility", static_cast<int>(Types::DodgeActive)));
 
     if (storedMode == Types::AlwaysVisible) {
         qDebug() << "Loading visibility mode: Always Visible , on startup...";
         setMode(Types::AlwaysVisible);
     } else {
         connect(&m_timerStartUp, &QTimer::timeout, this, [&]() {
             if (!m_latteView || !m_latteView->containment()) {
                 return;
             }
 
             auto fMode = static_cast<Types::Visibility>(m_latteView->containment()->config().readEntry("visibility", static_cast<int>(Types::DodgeActive)));
             qDebug() << "Loading visibility mode:" << fMode << " on startup...";
             setMode(fMode);
         });
         connect(m_latteView->containment(), &Plasma::Containment::userConfiguringChanged
                 , this, [&](bool configuring) {
             if (configuring && m_timerStartUp.isActive())
                 m_timerStartUp.start(100);
         });
 
         m_timerStartUp.start();
     }
 
     connect(m_latteView->containment(), &Plasma::Containment::userConfiguringChanged
             , this, [&](bool configuring) {
         if (!configuring) {
             saveConfig();
         }
     });
 }
 
 bool VisibilityManager::containsMouse() const
 {
     return m_containsMouse;
 }
 
 void VisibilityManager::setContainsMouse(bool contains)
 {
     if (m_containsMouse == contains) {
         return;
     }
 
     m_containsMouse = contains;
     emit containsMouseChanged();
 
     if (contains && m_mode != Types::AlwaysVisible) {
         raiseView(true);
     }
 }
 
 void VisibilityManager::viewEventManager(QEvent *ev)
 {
     switch (ev->type()) {
     case QEvent::Enter:
         setContainsMouse(true);
         break;
 
     case QEvent::Leave:
         m_dragEnter = false;
         setContainsMouse(false);
         break;
 
     case QEvent::DragEnter:
         m_dragEnter = true;
 
         if (m_isHidden) {
             emit mustBeShown();
         }
 
         break;
 
     case QEvent::DragLeave:
     case QEvent::Drop:
         m_dragEnter = false;
         updateHiddenState();
         break;
 
     default:
         break;
     }
 }
 
 //! KWin Edges Support functions
 bool VisibilityManager::enableKWinEdges() const
 {
     return m_enableKWinEdgesFromUser;
 }
 
 void VisibilityManager::setEnableKWinEdges(bool enable)
 {
     if (m_enableKWinEdgesFromUser == enable) {
         return;
     }
 
     m_enableKWinEdgesFromUser = enable;
 
     emit enableKWinEdgesChanged();
 }
 
 void VisibilityManager::updateKWinEdgesSupport()
 {
     if ((m_mode == Types::AutoHide
          || m_mode == Types::DodgeActive
          || m_mode == Types::DodgeAllWindows
          || m_mode == Types::DodgeMaximized)
             && !m_latteView->byPassWM()) {
 
         if (m_enableKWinEdgesFromUser) {
             createEdgeGhostWindow();
         } else if (!m_enableKWinEdgesFromUser) {
             deleteEdgeGhostWindow();
         }
 
     } else if (m_mode == Types::WindowsCanCover) {
         createEdgeGhostWindow();
     } else {
         deleteEdgeGhostWindow();
     }
 }
 
 void VisibilityManager::createEdgeGhostWindow()
 {
     if (!m_edgeGhostWindow) {
         m_edgeGhostWindow = new ScreenEdgeGhostWindow(m_latteView);
 
         connect(m_edgeGhostWindow, &ScreenEdgeGhostWindow::containsMouseChanged, this, [ = ](bool contains) {
             if (contains) {
                 raiseView(true);
             } else {
                 m_timerShow.stop();
                 updateGhostWindowState();
             }
         });
 
         connect(m_edgeGhostWindow, &ScreenEdgeGhostWindow::dragEntered, this, [&]() {
             if (m_isHidden) {
                 emit mustBeShown();
             }
         });
 
         m_connectionsKWinEdges[0] = connect(m_wm, &WindowSystem::AbstractWindowInterface::currentActivityChanged,
                                             this, [&]() {
             bool inCurrentLayout = (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout ||
                                     (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts
                                      && m_latteView->layout() && !m_latteView->positioner()->inLocationChangeAnimation()
                                      && m_latteView->layout()->isCurrent()));
 
             if (m_edgeGhostWindow) {
                 if (inCurrentLayout) {
                     m_wm->setEdgeStateFor(m_edgeGhostWindow, m_isHidden);
                 } else {
                     m_wm->setEdgeStateFor(m_edgeGhostWindow, false);
                 }
             }
         });
 
         emit supportsKWinEdgesChanged();
     }
 }
 
 void VisibilityManager::deleteEdgeGhostWindow()
 {
     if (m_edgeGhostWindow) {
         m_edgeGhostWindow->deleteLater();
         m_edgeGhostWindow = nullptr;
 
         for (auto &c : m_connectionsKWinEdges) {
             disconnect(c);
         }
 
         emit supportsKWinEdgesChanged();
     }
 }
 
 //! END: VisibilityManager implementation
 
 }
 }
diff --git a/containment/package/contents/ui/VisibilityManager.qml b/containment/package/contents/ui/VisibilityManager.qml
index 8666fb92..a920fb58 100644
--- a/containment/package/contents/ui/VisibilityManager.qml
+++ b/containment/package/contents/ui/VisibilityManager.qml
@@ -1,814 +1,818 @@
 /*
 *  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 0.2 as Latte
 
 Item{
     id: manager
 
     anchors.fill: parent
 
     property QtObject window
 
     property bool debugMagager: 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 && (root.themePanelThickness >= (root.iconSize + root.thickMargin))
 
     property int animationSpeed: Latte.WindowSystem.compositingActive ?
                                      (editModeVisual.inEditMode ? editModeVisual.speed * 0.8 : root.appliedDurationTime * 1.4 * units.longDuration) : 0
 
     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: ((plasmoid.location===PlasmaCore.Types.LeftEdge)||(plasmoid.location===PlasmaCore.Types.TopEdge)) ?
                                       -thicknessNormal : thicknessNormal;
 
     property int thicknessAutoHidden: Latte.WindowSystem.compositingActive ?  2 : 1
     property int thicknessMid: root.screenEdgeMargin + (1 + (0.65 * (root.maxZoomFactor-1)))*(root.iconSize+root.thickMargins+extraThickMask) //needed in some animations
     property int thicknessNormal: root.screenEdgeMargin + Math.max(root.iconSize + root.thickMargins + extraThickMask + 1, root.realPanelSize + root.panelShadow)
 
     property int thicknessZoom: root.screenEdgeMargin + ((root.iconSize+root.thickMargins+extraThickMask) * root.maxZoomFactor) + 2
     //it is used to keep thickness solid e.g. when iconSize changes from auto functions
     property int thicknessMidOriginal: root.screenEdgeMargin + Math.max(thicknessNormalOriginal,extraThickMask + (1 + (0.65 * (root.maxZoomFactor-1)))*(root.maxIconSize+root.maxThickMargin)) //needed in some animations
     property int thicknessNormalOriginal: root.screenEdgeMargin + root.maxIconSize + (root.maxThickMargin * 2) //this way we always have the same thickness published at all states
     /*property int thicknessNormalOriginal: !root.behaveAsPlasmaPanel || root.editMode ?
                                                thicknessNormalOriginalValue : root.realPanelSize + root.panelShadow*/
 
     property int thicknessNormalOriginalValue: root.screenEdgeMargin + root.maxIconSize + (root.maxThickMargin * 2) + extraThickMask + 1
     property int thicknessZoomOriginal:root.screenEdgeMargin + Math.max( ((root.maxIconSize+(root.maxThickMargin * 2)) * root.maxZoomFactor) + extraThickMask + 2,
                                                                            root.realPanelSize + root.panelShadow,
                                                                           (Latte.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: root.iconSize + root.thickMargins
 
     //! 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 (Latte.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 && root.maxThickMargin < shadowMaxNeededMargin) {
             return shadowMaxNeededMargin - root.maxThickMargin;
         }
 
         return 0;
     }
 
     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: (root.iconSize===root.maxIconSize || root.iconSize === automaticItemSizer.automaticIconSizeBasedSize)
     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
     }
 
     Binding{
         target: latteView
         property: "screenEdgeMargin"
         when: latteView
         value: !root.screenEdgeMarginEnabled || root.hideThickScreenGap ? -1 : plasmoid.configuration.screenEdgeMargin
     }
 
     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 && panelBoxBackground.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 && panelBoxBackground.isShown;
         }
     }
 
     //! View::Effects bindings
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "backgroundOpacity"
         when: latteView && latteView.effects
         value: root.currentPanelTransparency
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "drawEffects"
         when: latteView && latteView.effects
         value: Latte.WindowSystem.compositingActive &&
                (((root.blurEnabled && root.useThemePanel)
                  || (root.blurEnabled && root.forceSolidPanel && Latte.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)
     }
 
     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 root.panelShadow;
             }
         }
     }
 
     Binding{
         target: latteView && latteView.effects ? latteView.effects : null
         property: "settingsMaskSubtracted"
         when: latteView && latteView.effects
         value: {
             if (Latte.WindowSystem.compositingActive
                     && root.editMode
                     && editModeVisual.editAnimationEnded
                     && (root.animationsNeedBothAxis === 0 || root.zoomFactor===1) ) {
                 return true;
             } else {
                 return false;
             }
         }
     }
 
     //! 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 === Latte.Types.AlwaysVisible /* Visibility */
                      || latteView.visibility.mode === Latte.Types.WindowsGoBelow
                      || latteView.visibility.mode === Latte.Types.AutoHide))
                || root.appletsNeedWindowsTracking > 0                        /*Applets Neew Windows Tracking */
                || root.dragActiveWindowEnabled                               /*Dragging Active Window(Empty Areas)*/
                || ((root.backgroundOnlyOnMaximized                           /*Dynamic Background */
                     || plasmoid.configuration.solidBackgroundForMaximized
                     || root.disablePanelShadowMaximized
                     || root.windowColors !== Latte.Types.NoneWindowColors))
                || (root.screenEdgeMarginsEnabled                             /*Dynamic Screen Edge Margin*/
                    && plasmoid.configuration.hideScreenGapForMaximized)
     }
 
     Connections{
         target:root
         onPanelShadowChanged: updateMaskArea();
         onPanelThickMarginHighChanged: updateMaskArea();
     }
 
     Connections{
         target: layoutsManager
         onCurrentLayoutIsSwitching: {
             if (Latte.WindowSystem.compositingActive && latteView && latteView.layout && latteView.layout.name === layoutName) {
                 manager.inTempHiding = true;
                 manager.inForceHiding = true;
                 root.clearZoom();
                 manager.slotMustBeHide();
             }
         }
     }
 
     Connections{
         target: themeExtended ? themeExtended : null
         onRoundnessChanged: latteView.effects.forceMaskRedraw();
         onThemeChanged: latteView.effects.forceMaskRedraw();
     }
 
     onNormalStateChanged: {
         if (normalState) {
             automaticItemSizer.updateAutomaticIconSize();
             root.updateSizeForAppletsInFill();
         }
     }
 
     onThicknessZoomOriginalChanged: {
         updateMaskArea();
     }
 
     function slotContainsMouseChanged() {
         if(latteView.visibility.containsMouse) {
             updateMaskArea();
 
             if (slidingAnimationAutoHiddenOut.running && !inTempHiding && !inForceHiding) {
                 slotMustBeShown();
             }
         }
     }
 
     function slotMustBeShown() {
         //! WindowsCanCover case
         if (latteView && latteView.visibility.mode === Latte.Types.WindowsCanCover) {
             latteView.visibility.setViewOnFrontLayer();
             return;
         }
 
         //! Normal Dodge/AutoHide case
         if (!slidingAnimationAutoHiddenIn.running && !inTempHiding && !inForceHiding){
             slidingAnimationAutoHiddenIn.init();
         }
     }
 
     function slotMustBeHide() {
         if (latteView && latteView.visibility.mode === Latte.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) || inForceHiding) {
             slidingAnimationAutoHiddenOut.init();
         }
     }
 
     //! functions used for sliding out/in during location/screen changes
     function slotHideDockDuringLocationChange() {
         inTempHiding = true;
         blockUpdateMask = true;
         slotMustBeHide();
     }
 
     function slotShowDockAfterLocationChange() {
         slidingAnimationAutoHiddenIn.init();
     }
 
     function sendHideDockDuringLocationChangeFinished(){
         blockUpdateMask = false;
         latteView.positioner.hideDockDuringLocationChangeFinished();
     }
 
     function sendSlidingOutAnimationEnded() {
         latteView.visibility.hide();
         latteView.visibility.isHidden = true;
 
         if (visibilityManager.debugMagager) {
             console.log("hiding animation ended...");
         }
 
         sendHideDockDuringLocationChangeFinished();
     }
 
     ///test maskArea
     function updateMaskArea() {
         if (!latteView || blockUpdateMask) {
             return;
         }
 
         var localX = 0;
         var localY = 0;
 
         normalState = ((root.animationsNeedBothAxis === 0) && (root.animationsNeedLength === 0))
                 || (latteView.visibility.isHidden && !latteView.visibility.containsMouse && root.animationsNeedThickness == 0);
 
 
         // debug maskArea criteria
         if (debugMagager) {
             console.log(root.animationsNeedBothAxis + ", " + root.animationsNeedLength + ", " +
                         root.animationsNeedThickness + ", " + 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 space = 0;
 
         if (Latte.WindowSystem.compositingActive) {
             if (root.useThemePanel){
                 space = root.totalPanelEdgeSpacing + root.panelMarginLength + 1;
             } else {
                 space = root.totalPanelEdgeSpacing + 1;
             }
         } else {
             space = root.totalPanelEdgeSpacing + root.panelMarginLength;
         }
 
         var noCompositingEdit = !Latte.WindowSystem.compositingActive && root.editMode;
 
         if (Latte.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 {
                     if(root.isHorizontal) {
                         tempLength = plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                     layoutsContainer.width + space : layoutsContainer.mainLayout.width + space;
                     } else {
                         tempLength = plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                     layoutsContainer.height + space : layoutsContainer.mainLayout.height + space;
                     }
                 }
 
                 tempThickness = thicknessNormal;
 
                 if (root.animationsNeedThickness > 0) {
                     tempThickness = Latte.WindowSystem.compositingActive ? thicknessZoom : thicknessNormal;
                 }
 
                 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) {
                         localY = latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges ?
                                     latteView.height + tempThickness : latteView.height - tempThickness;
                     } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                         localY = latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges ?
                                     -tempThickness : 0;
                     }
 
                     if (noCompositingEdit) {
                         localX = 0;
                     } else if (plasmoid.configuration.panelPosition === Latte.Types.Justify) {
                         localX = (latteView.width/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Types.Left) {
                         localX = root.offset;
                     } else if (root.panelAlignment === Latte.Types.Center) {
                         localX = (latteView.width/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Types.Right) {
                         localX = latteView.width - layoutsContainer.mainLayout.width - space - root.offset;
                     }
                 } else if ((plasmoid.location === PlasmaCore.Types.LeftEdge) || (plasmoid.location === PlasmaCore.Types.RightEdge)){
                     if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                         localX = latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges ?
                                     -tempThickness : 0;
                     } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                         localX = latteView.visibility.isHidden && latteView.visibility.supportsKWinEdges ?
                                     latteView.width + tempThickness : latteView.width - tempThickness;
                     }
 
                     if (noCompositingEdit) {
                         localY = 0;
                     } else if (plasmoid.configuration.panelPosition === Latte.Types.Justify) {
                         localY = (latteView.height/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Types.Top) {
                         localY = root.offset;
                     } else if (root.panelAlignment === Latte.Types.Center) {
                         localY = (latteView.height/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Types.Bottom) {
                         localY = latteView.height - layoutsContainer.mainLayout.height - space - root.offset;
                     }
                 }
             } else {
                 if(root.isHorizontal)
                     tempLength = Screen.width; //screenGeometry.width;
                 else
                     tempLength = Screen.height; //screenGeometry.height;
 
                 //grow only on length and not thickness
                 if(root.animationsNeedLength>0 && root.animationsNeedBothAxis === 0) {
 
                     //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 (root.animationsNeedThickness > 0) {
                         tempThickness = thicknessZoomOriginal;
                     }
                 } else{
                     //use all thickness space
                     if (latteView.visibility.isHidden && !slidingAnimationAutoHiddenOut.running ) {
                         tempThickness = Latte.WindowSystem.compositingActive ? thicknessAutoHidden : thicknessNormalOriginal;
                     } else {
                         tempThickness = thicknessZoomOriginal;
                     }
                 }
 
                 //configure the x,y position based on thickness
                 if(plasmoid.location === PlasmaCore.Types.RightEdge)
                     localX = Math.max(0,latteView.width - tempThickness);
                 else if(plasmoid.location === PlasmaCore.Types.BottomEdge)
                     localY = Math.max(0,latteView.height - tempThickness);
             }
         } // end of compositing calculations
 
         var maskArea = latteView.effects.mask;
 
         if (Latte.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 (!Latte.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 = (root.iconSize===root.maxIconSize || root.iconSize === automaticItemSizer.automaticIconSizeBasedSize);
 
         //console.log("reached updating geometry ::: "+dock.maskArea);
         if(inPublishingState && (normalState || root.editMode)) {
             var tempGeometry = Qt.rect(latteView.effects.mask.x, latteView.effects.mask.y, latteView.effects.mask.width, latteView.effects.mask.height);
 
             //the shadows size must be removed from the maskArea
             //before updating the localDockGeometry
             if (!latteView.behaveAsPlasmaPanel || root.editMode) {
                 var fixedThickness = root.editMode ? root.iconSize + root.thickMargins + root.screenEdgeMargin : root.realPanelThickness;
 
                 if (plasmoid.formFactor === PlasmaCore.Types.Vertical) {
                     tempGeometry.width = fixedThickness;
                 } else {
                     tempGeometry.height = fixedThickness;
                 }
 
                 if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                     tempGeometry.y = latteView.height - fixedThickness;
                 } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                     tempGeometry.x = latteView.width - fixedThickness;
                 }
 
                 //set the boundaries for latteView local geometry
                 //qBound = qMax(min, qMin(value, max)).
                 tempGeometry.x = Math.max(0, Math.min(tempGeometry.x, latteView.width));
                 tempGeometry.y = Math.max(0, Math.min(tempGeometry.y, latteView.height));
                 tempGeometry.width = Math.min(tempGeometry.width, latteView.width);
                 tempGeometry.height = Math.min(tempGeometry.height, latteView.height);
             }
 
             //console.log("update geometry ::: "+tempGeometry);
             latteView.localGeometry = tempGeometry;
         }
     }
 
     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: layoutsContainer
-            property: root.isVertical ? "x" : "y"
+            target: !root.behaveAsPlasmaPanel ? layoutsContainer : latteView.positioner
+            property: !root.behaveAsPlasmaPanel ? (root.isVertical ? "x" : "y") : "slideOffset"
             to: {
+                if (root.behaveAsPlasmaPanel) {
+                    return slidingOutToPos;
+                }
+
                 if (Latte.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;
             }
         }
 
         onStarted: {
             if (manager.debugMagager) {
                 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 (!latteView.visibility.blockHiding) {
                 start();
             }
         }
     }
 
     SequentialAnimation{
         id: slidingAnimationAutoHiddenIn
 
         PauseAnimation{
             duration: manager.inTempHiding && animationsEnabled ? 500 : 0
         }
 
         PropertyAnimation {
-            target: layoutsContainer
-            property: root.isVertical ? "x" : "y"
+            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.debugMagager) {
                 console.log("showing animation started...");
             }
         }
 
         onStopped: {
             inSlidingIn = false;
 
             if (manager.inTempHiding) {
                 manager.inTempHiding = false;
                 automaticItemSizer.updateAutomaticIconSize();
             }
 
             manager.inTempHiding = false;
             automaticItemSizer.updateAutomaticIconSize();
 
             if (manager.debugMagager) {
                 console.log("showing animation ended...");
             }
 
             latteView.visibility.slideInFinished();
 
             if (!Latte.WindowSystem.compositingActive) {
                 //! this is needed in order to update dock absolute geometry correctly in the end
                 updateMaskArea();
             }
         }
 
         function init() {
             // if (!latteView.visibility.blockHiding)
             inSlidingIn = true;
 
             if (slidingAnimationAutoHiddenOut.running) {
                 slidingAnimationAutoHiddenOut.stop();
             }
 
             latteView.visibility.isHidden = false;
             updateMaskArea();
 
             start();
         }
     }
 }
diff --git a/containment/package/contents/ui/layouts/LayoutsContainer.qml b/containment/package/contents/ui/layouts/LayoutsContainer.qml
index 39bc6685..8103f3f5 100644
--- a/containment/package/contents/ui/layouts/LayoutsContainer.qml
+++ b/containment/package/contents/ui/layouts/LayoutsContainer.qml
@@ -1,279 +1,287 @@
 /*
 *  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 0.2 as Latte
 
 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.panelPosition === Latte.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
     property int hoveredIndex: -1
 
     readonly property int fillApplets: _startLayout.fillApplets + _mainLayout.fillApplets + _endLayout.fillApplets
 
     property Item startLayout : _startLayout
     property Item mainLayout: _mainLayout
     property Item endLayout: _endLayout
 
     Binding {
         target: layoutsContainer
         property: "x"
         value: {
+            if (root.behaveAsPlasmaPanel) {
+                return 0;
+            }
+
             if ( latteView && root.isHorizontal && useMaxLength ){
                 return ((latteView.width/2) - (root.maxLength/2) + root.offset);
             } else {
                 if ((visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) && root.isVertical){
                     return;
                 }
 
                 if (layoutsContainer.isHidden && root.isVertical) {
                     if (Latte.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"
         value: {
+            if (root.behaveAsPlasmaPanel) {
+                return 0;
+            }
+
             if ( latteView && root.isVertical && useMaxLength ) {
                 return ((latteView.height/2) - (root.maxLength/2) + root.offset);
             } else {
                 if ((visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) && root.isHorizontal){
                     return;
                 }
 
                 if (layoutsContainer.isHidden && root.isHorizontal) {
                     if (Latte.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.panelPosition === Latte.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)) {
                 automaticItemSizer.updateAutomaticIconSize();
             }
 
             if (!animationSent) {
                 animationSent = true;
                 slotAnimationsNeedLength(1);
             }
 
             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)) {
                 automaticItemSizer.updateAutomaticIconSize();
             }
 
             if (!animationSent) {
                 animationSent = true;
                 slotAnimationsNeedLength(1);
             }
 
             layoutsContainer.updateSizeForAppletsInFill();
 
             delayUpdateMaskArea.start();
         }
     }
 
     onXChanged: root.updateEffectsArea();
     onYChanged: root.updateEffectsArea();
 
     EnvironmentActions {
         active: root.scrollAction !== Latte.Types.ScrollNone || root.dragActiveWindowEnabled
     }
 
     AppletsContainer {
         id: _startLayout
         beginIndex: 0
         offset: root.totalPanelEdgeSpacing/2
         alignment: {
             switch(plasmoid.location) {
             case PlasmaCore.Types.BottomEdge: return Latte.Types.BottomEdgeLeftAlign;
             case PlasmaCore.Types.TopEdge: return Latte.Types.TopEdgeLeftAlign;
             case PlasmaCore.Types.LeftEdge: return Latte.Types.LeftEdgeTopAlign;
             case PlasmaCore.Types.RightEdge: return Latte.Types.RightEdgeTopAlign;
             }
 
             return Latte.Types.BottomEdgeLeftAlign;
         }
     }
 
     AppletsContainer {
         id: _mainLayout
         beginIndex: 100
         offset: centered ? appliedOffset : root.offsetFixed
 
         readonly property bool centered: (root.panelAlignment === Latte.Types.Center) || (root.panelAlignment === Latte.Types.Justify)
         readonly property bool reversed: Qt.application.layoutDirection === Qt.RightToLeft
         readonly property int appliedOffset: root.panelAlignment === Latte.Types.Justify ? 0 : root.offset
 
         alignment: {
             if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                 if (centered) return Latte.Types.LeftEdgeCenterAlign;
                 if (root.panelAlignment === Latte.Types.Top) return Latte.Types.LeftEdgeTopAlign;
                 if (root.panelAlignment === Latte.Types.Bottom) return Latte.Types.LeftEdgeBottomAlign;
             }
 
             if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                 if (centered) return Latte.Types.RightEdgeCenterAlign;
                 if (root.panelAlignment === Latte.Types.Top) return Latte.Types.RightEdgeTopAlign;
                 if (root.panelAlignment === Latte.Types.Bottom) return Latte.Types.RightEdgeBottomAlign;
             }
 
             if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                 if (centered) return Latte.Types.BottomEdgeCenterAlign;
 
                 if ((root.panelAlignment === Latte.Types.Left && !reversed)
                         || (root.panelAlignment === Latte.Types.Right && reversed)) {
                     return Latte.Types.BottomEdgeLeftAlign;
                 }
 
                 if ((root.panelAlignment === Latte.Types.Right && !reversed)
                         || (root.panelAlignment === Latte.Types.Left && reversed)) {
                     return Latte.Types.BottomEdgeRightAlign;
                 }
             }
 
             if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                 if (centered) return Latte.Types.TopEdgeCenterAlign;
 
                 if ((root.panelAlignment === Latte.Types.Left && !reversed)
                         || (root.panelAlignment === Latte.Types.Right && reversed)) {
                     return Latte.Types.TopEdgeLeftAlign;
                 }
 
                 if ((root.panelAlignment === Latte.Types.Right && !reversed)
                         || (root.panelAlignment === Latte.Types.Left && reversed)) {
                     return Latte.Types.TopEdgeRightAlign;
                 }
             }
 
             return Latte.Types.BottomEdgeCenterAlign;
         }
 
         transitions: Transition {
             enabled: editModeVisual.plasmaEditMode
             AnchorAnimation {
                 duration: 0.8 * root.animationTime
                 easing.type: Easing.OutCubic
             }
         }
     }
 
     AppletsContainer {
         id: _endLayout
         beginIndex: 200
         offset: root.totalPanelEdgeSpacing/2
         alignment: {
             switch(plasmoid.location) {
             case PlasmaCore.Types.BottomEdge: return Latte.Types.BottomEdgeRightAlign;
             case PlasmaCore.Types.TopEdge: return Latte.Types.TopEdgeRightAlign;
             case PlasmaCore.Types.LeftEdge: return Latte.Types.LeftEdgeBottomAlign;
             case PlasmaCore.Types.RightEdge: return Latte.Types.RightEdgeBottomAlign;
             }
 
             return Latte.Types.BottomEdgeLeftAlign;
         }
     }
 
     function updateSizeForAppletsInFill() {
         if (!updateSizeForAppletsInFillTimer.running) {
             updateSizeForAppletsInFillTimer.start();
         }
     }
 
     //! This timer is needed in order to reduce the calls to heavy cpu function
     //! HeuristicTools.updateSizeForAppletsInFill()
     Timer{
         id: updateSizeForAppletsInFillTimer
         interval: 10
         onTriggered: HeuristicTools.updateSizeForAppletsInFill();
     }
 }
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index 23827f01..03de0fc4 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1954 +1,1954 @@
 /*
 *  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 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "applet" as Applet
 import "colorizer" as Colorizer
 import "editmode" as EditMode
 import "indicators" as Indicators
 import "layouts" as Layouts
 import "../code/LayoutManager.js" as LayoutManager
 
 Item {
     id: root
     objectName: "containmentViewLayout"
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.isVertical
     LayoutMirroring.childrenInherit: true
 
     //// BEGIN SIGNALS
     signal clearZoomSignal();
     signal destroyInternalViewSplitters();
     signal emptyAreasWheel(QtObject wheel);
     signal separatorsUpdated();
     signal signalActivateEntryAtIndex(int entryIndex);
     signal signalNewInstanceForEntryAtIndex(int entryIndex);
     signal updateEffectsArea();
     signal updateIndexes();
     signal updateScale(int delegateIndex, real newScale, real step);
 
     signal broadcastedToApplet(string pluginName, string action, variant value);
     //// END SIGNALS
 
     ////BEGIN properties
     property bool debugMode: Qt.application.arguments.indexOf("--graphics")>=0
     property bool 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: Latte.WindowSystem.makeVersion(0,9,4)
 
     property bool globalDirectRender: false //it is used as a globalDirectRender for all elements in the dock
     property int directRenderAnimationTime: 0
 
     property bool addLaunchersMessage: false
     property bool addLaunchersInTaskManager: plasmoid.configuration.addLaunchersInTaskManager
     property bool backgroundOnlyOnMaximized: plasmoid.configuration.backgroundOnlyOnMaximized
     property bool behaveAsPlasmaPanel: {
         if (!latteView || !latteView.visibility) {
             return false;
         }
 
         if (screenEdgeMarginEnabled && plasmoid.configuration.fittsLawIsRequested) {
             //! dont use when floating views are requesting Fitt's Law
             return false;
         }
 
         return (visibilityManager.panelIsBiggerFromIconSize && (maxZoomFactor === 1.0)
-                && (latteView.visibility.mode === Latte.Types.AlwaysVisible || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
+                //&& (latteView.visibility.mode === Latte.Types.AlwaysVisible || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
                 && (plasmoid.configuration.panelPosition === Latte.Types.Justify)
                 && !root.editMode);
     }
 
     property int viewType: {
         if ((plasmoid.configuration.panelPosition === Latte.Types.Justify)
                 && (plasmoid.configuration.useThemePanel)
                 && (plasmoid.configuration.panelSize === 100)
                 && (maxZoomFactor === 1.0)) {
             return Latte.Types.PanelView;
         }
 
         return Latte.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 && Latte.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
                                     && Latte.WindowSystem.compositingActive
                                     && !inConfigureAppletsMode
                                     && userShowPanelBackground
                                     && ( (plasmoid.configuration.solidBackgroundForMaximized
                                           && !(hasExpandedApplet && !plasmaBackgroundForPopups)
                                           && latteView.windowsTracker.currentScreen.existsWindowTouching)
                                         || (hasExpandedApplet && plasmaBackgroundForPopups) ))
                                    || solidBusyForTouchingBusyVerticalView
                                    || plasmaStyleBusyForTouchingBusyVerticalView
                                    || !Latte.WindowSystem.compositingActive
 
     property bool forceTransparentPanel: root.backgroundOnlyOnMaximized
                                          && latteView && latteView.visibility
                                          && Latte.WindowSystem.compositingActive
                                          && !inConfigureAppletsMode
                                          && !forceSolidPanel
                                          && !latteView.windowsTracker.currentScreen.existsWindowTouching
                                          && !(windowColors === Latte.Types.ActiveWindowColors && selectedWindowsTracker.existsWindowActive)
 
     property bool forcePanelForBusyBackground: userShowPanelBackground && (root.themeColors === Latte.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 === Latte.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 === Latte.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 === Latte.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 === Latte.Types.AlwaysVisible
                                             || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
                                         && (plasmoid.configuration.panelPosition === Latte.Types.Justify)
                                         && plasmoid.configuration.maxLength>85
                                         && !root.editMode
 
 
 
     property int themeColors: plasmoid.configuration.themeColors
     property int windowColors: plasmoid.configuration.windowColors
 
     property bool colorizerEnabled: themeColors !== Latte.Types.PlasmaThemeColors || windowColors !== Latte.Types.NoneWindowColors
 
     property bool plasmaBackgroundForPopups: plasmoid.configuration.plasmaBackgroundForPopups
 
     readonly property bool hasExpandedApplet: plasmoid.applets.some(function (item) {
         return (item.status >= PlasmaCore.Types.NeedsAttentionStatus && item.status !== PlasmaCore.Types.HiddenStatus
                 && item.pluginName !== root.plasmoidName
                 && item.pluginName !== "org.kde.plasma.appmenu"
                 && item.pluginName !== "org.kde.windowappmenu"
                 && item.pluginName !== "org.kde.activeWindowControl");
     })
 
     readonly property bool hasUserSpecifiedBackground: (latteView && latteView.layout && latteView.layout.background.startsWith("/")) ?
                                                            true : false
 
     readonly property bool inConfigureAppletsMode: root.editMode && (plasmoid.configuration.inConfigureAppletsMode || !Latte.WindowSystem.compositingActive)
     readonly property bool parabolicEffectEnabled: zoomFactor>1 && !inConfigureAppletsMode
 
     property bool dockIsShownCompletely: !(dockIsHidden || inSlidingIn || inSlidingOut) && !root.editMode
     property bool dragActiveWindowEnabled: plasmoid.configuration.dragActiveWindowEnabled
     property bool immutable: plasmoid.immutable
     property bool inFullJustify: (plasmoid.configuration.panelPosition === Latte.Types.Justify) && (maxLengthPerCentage===100)
     property bool inSlidingIn: visibilityManager ? visibilityManager.inSlidingIn : false
     property bool inSlidingOut: visibilityManager ? visibilityManager.inSlidingOut : false
     property bool inStartup: true
     property bool isHalfShown: false //is used to disable the zoom hovering effect at sliding in-out the dock
     property bool isHorizontal: plasmoid.formFactor === PlasmaCore.Types.Horizontal
     property bool isReady: !(dockIsHidden || inSlidingIn || inSlidingOut)
     property bool isVertical: !isHorizontal
     property bool isHovered: latteApplet ? ((latteAppletHoveredIndex !== -1) || (layoutsContainer.hoveredIndex !== -1)) //|| wholeArea.containsMouse
                                          : (layoutsContainer.hoveredIndex !== -1) //|| wholeArea.containsMouse
     property bool mouseWheelActions: plasmoid.configuration.mouseWheelActions
     property bool onlyAddingStarup: true //is used for the initialization phase in startup where there aren't removals, this variable provides a way to grow icon size
     property bool shrinkThickMargins: plasmoid.configuration.shrinkThickMargins
     property bool showLatteShortcutBadges: false
     property bool showAppletShortcutBadges: false
     property bool showMetaBadge: false
     property int applicationLauncherId: -1
 
     //FIXME: possibly this is going to be the default behavior, this user choice
     //has been dropped from the Dock Configuration Window
     //property bool smallAutomaticIconJumps: plasmoid.configuration.smallAutomaticIconJumps
     property bool smallAutomaticIconJumps: true
 
     property bool userShowPanelBackground: Latte.WindowSystem.compositingActive ? plasmoid.configuration.useThemePanel : true
     property bool useThemePanel: noApplets === 0 || !Latte.WindowSystem.compositingActive ?
                                      true : (plasmoid.configuration.useThemePanel || plasmoid.configuration.solidBackgroundForMaximized)
 
     property alias hoveredIndex: layoutsContainer.hoveredIndex
     property alias directRenderDelayerIsRunning: directRenderDelayerForEnteringTimer.running
 
     property int actionsBlockHiding: 0 //actions that block hiding
 
     property int animationsNeedBothAxis:0 //animations need space in both axes, e.g zooming a task
     property int animationsNeedLength: 0 // animations need length, e.g. adding a task
     property int animationsNeedThickness: 0 // animations need thickness, e.g. bouncing animation
     readonly property bool thickAnimated: animationsNeedBothAxis>0 || animationsNeedThickness>0
 
     property int animationTime: durationTime*2.8*units.longDuration
 
     property int appletsNeedWindowsTracking: 0
 
     //what is the highest icon size based on what icon size is used, screen calculated or user specified
     property int maxIconSize: proportionIconSize!==-1 ? proportionIconSize : plasmoid.configuration.iconSize
     property int iconSize: automaticItemSizer.automaticIconSizeBasedSize > 0 && automaticItemSizer.isActive ?
                                Math.min(automaticItemSizer.automaticIconSizeBasedSize, root.maxIconSize) :
                                root.maxIconSize
 
     property int proportionIconSize: { //icon size based on screen height
         if ((plasmoid.configuration.proportionIconSize===-1) || !latteView)
             return -1;
 
         return Math.max(16,Math.round(latteView.screenGeometry.height * plasmoid.configuration.proportionIconSize/100/8)*8);
     }
 
     property int latteAppletPos: -1
     property int maxLengthPerCentage: hideLengthScreenGaps ? 100 : plasmoid.configuration.maxLength
 
     property int maxLength: {
         if (root.isHorizontal) {
             return behaveAsPlasmaPanel ? width : width * (maxLengthPerCentage/100)
         } else {
             return behaveAsPlasmaPanel ? height : height * (maxLengthPerCentage/100)
         }
     }
 
     property int leftClickAction: plasmoid.configuration.leftClickAction
     property int middleClickAction: plasmoid.configuration.middleClickAction
     property int hoverAction: plasmoid.configuration.hoverAction
     property int modifier: plasmoid.configuration.modifier
     property int modifierClickAction: plasmoid.configuration.modifierClickAction
     property int modifierClick: plasmoid.configuration.modifierClick
     property int scrollAction: plasmoid.configuration.scrollAction
 
     property bool panelOutline: plasmoid.configuration.panelOutline
     property int panelEdgeSpacing: Math.max(panelBoxBackground.lengthMargins, 1.5*appShadowSize)
     property int panelTransparency: plasmoid.configuration.panelTransparency //user set
     property int currentPanelTransparency: 0 //application override
 
     readonly property real currentPanelOpacity: currentPanelTransparency/100
 
     property bool panelShadowsActive: {
         if (!userShowPanelBackground) {
             return false;
         }
 
         if (inConfigureAppletsMode) {
             return plasmoid.configuration.panelShadows;
         }
 
         var forcedNoShadows = (plasmoid.configuration.panelShadows && disablePanelShadowMaximized
                                && latteView && latteView.windowsTracker && latteView.windowsTracker.currentScreen.activeWindowMaximized);
 
         if (forcedNoShadows) {
             return false;
         }
 
         var transparencyCheck = (blurEnabled || (!blurEnabled && currentPanelTransparency>20));
 
         //! Draw shadows for isBusy state only when current panelTransparency is greater than 10%
         if (plasmoid.configuration.panelShadows && root.forcePanelForBusyBackground && transparencyCheck) {
             return true;
         }
 
         if (( (plasmoid.configuration.panelShadows && !root.backgroundOnlyOnMaximized)
              || (plasmoid.configuration.panelShadows && root.backgroundOnlyOnMaximized && !root.forceTransparentPanel))
                 && !forcedNoShadows) {
             return true;
         }
 
         if (hasExpandedApplet && plasmaBackgroundForPopups) {
             return true;
         }
 
         return false;
     }
 
     property int appShadowOpacity: (plasmoid.configuration.shadowOpacity/100) * 255
     property int appShadowSize: enableShadows ? (0.5*root.iconSize) * (plasmoid.configuration.shadowSize/100) : 0
     property int appShadowSizeOriginal: enableShadows ? (0.5*maxIconSize) * (plasmoid.configuration.shadowSize/100) : 0
 
     property string appChosenShadowColor: {
         if (plasmoid.configuration.shadowColorType === Latte.Types.ThemeColorShadow) {
             var strC = String(theme.textColor);
             return strC.indexOf("#") === 0 ? strC.substr(1) : strC;
         } else if (plasmoid.configuration.shadowColorType === Latte.Types.UserColorShadow) {
             return plasmoid.configuration.shadowColor;
         }
 
         // default shadow color
         return "080808";
     }
 
     property string appShadowColor: "#" + decimalToHex(appShadowOpacity) + appChosenShadowColor
     property string appShadowColorSolid: "#" + appChosenShadowColor
 
     property int totalPanelEdgeSpacing: 0 //this is set by PanelBox
     property int offset: {
         if (behaveAsPlasmaPanel) {
             return 0;
         }
 
         if (root.isHorizontal) {
             return width * (plasmoid.configuration.offset/100);
         } else {
             height * (plasmoid.configuration.offset/100)
         }
     }
 
     //center the layout correctly when the user uses an offset
     property int offsetFixed: (offset===0 || panelAlignment === Latte.Types.Center || plasmoid.configuration.panelPosition === Latte.Types.Justify)?
                                   offset : offset+panelMarginLength/2+totalPanelEdgeSpacing/2
 
     property int realPanelSize: 0
     property int realPanelLength: 0
     property int realPanelThickness: 0
     //this is set by the PanelBox
     property int panelThickMarginBase: 0
     property int panelThickMarginHigh: 0
     property int panelMarginLength: 0
     property int panelShadow: 0 //shadowsSize
     property int editShadow: {
         if (!Latte.WindowSystem.compositingActive) {
             return 0;
         } else if (latteView && latteView.screenGeometry) {
             return latteView.screenGeometry.height/90;
         } else {
             return 7;
         }
     }
 
     property int themePanelThickness: {
         var panelBase = root.panelThickMarginHigh;
         var margin = shrinkThickMargins ? 0 : thickMargins + localScreenEdgeMargin;
         var maxPanelSize = (iconSize + margin) - panelBase;
         var percentage = Latte.WindowSystem.compositingActive ? plasmoid.configuration.panelSize/100 : 1;
         return Math.max(panelBase, panelBase + percentage*maxPanelSize);
     }
 
     property int lengthIntMargin: lengthIntMarginFactor * root.iconSize
     property int lengthExtMargin: lengthExtMarginFactor * root.iconSize
     property real lengthIntMarginFactor: indicators.isEnabled ? indicators.padding : 0
     property real lengthExtMarginFactor: plasmoid.configuration.lengthExtMargin / 100
 
     property real lengthAppletIntMarginFactor: indicators.infoLoaded ? indicators.info.appletLengthPadding : -1
 
     property real thickMarginFactor: {
         if (shrinkThickMargins) {
             return indicators.info.minThicknessPadding;
         }
 
         //0.075 old statesLineSize and 0.06 old default thickMargin
         return  Math.max(indicators.info.minThicknessPadding, plasmoid.configuration.thickMargin / 100)
     }
     property int thickMargin: thickMarginFactor * root.iconSize
 
     property bool screenEdgeMarginEnabled: plasmoid.configuration.screenEdgeMargin >= 0 && !plasmoid.configuration.shrinkThickMargins
     property int screenEdgeMargin: {
         //! is used for window geometry calculations
         if (!screenEdgeMarginEnabled
                 || (hideThickScreenGap && localScreenEdgeMargin === 0)) {
                 /*window geometry is updated after the local screen margin animation was zeroed*/
             return 0;
         }
 
         return plasmoid.configuration.screenEdgeMargin;
     }
     property int localScreenEdgeMargin: (screenEdgeMarginEnabled && behaveAsPlasmaPanel)
                                         || !screenEdgeMarginEnabled
                                         || hideThickScreenGap ? 0 : plasmoid.configuration.screenEdgeMargin
 
     //! thickness margins are always two and equal in order for items
     //! to be always correctly centered
     property int thickMargins: 2 * thickMargin
 
     //it is used in order to not break the calculations for the thickness placement
     //especially in automatic icon sizes calculations
     property int maxThickMargin: thickMarginFactor * maxIconSize
 
     property int lengthMargin: lengthIntMargin + lengthExtMargin
     property int lengthMargins: 2 * lengthMargin
 
     property int widthMargins: root.isVertical ? thickMargins : lengthMargins
     property int heightMargins: root.isHorizontal ? thickMargins : lengthMargins
 
     ///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 ? Latte.Types.Center : (root.isVertical ? Latte.Types.Top : Latte.Types.Left)
     //property int panelAlignment: plasmoid.configuration.panelPosition !== Latte.Types.Justify ? plasmoid.configuration.panelPosition : layoutsContainer.mainLayoutPosition
 
     property int panelAlignment: !root.inConfigureAppletsMode ? plasmoid.configuration.panelPosition :
                                                                 ( plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                                                      Latte.Types.Center : plasmoid.configuration.panelPosition )
 
     property int panelUserSetAlignment: plasmoid.configuration.panelPosition
 
     property real zoomFactor: Latte.WindowSystem.compositingActive && root.animationsEnabled ? ( 1 + (plasmoid.configuration.zoomLevel / 20) ) : 1
 
     readonly property string plasmoidName: "org.kde.latte.plasmoid"
 
     property var badgesForActivate: {
         if (!shortcutsEngine) {
             return ['1','2','3','4','5','6','7','8','9','0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.'];
         }
 
         return shortcutsEngine.badgesForActivate;
     }
 
     property var iconsArray: [16, 22, 32, 48, 64, 96, 128, 256]
 
     property Item dragOverlay
     property Item toolBox
     property Item latteAppletContainer
     property Item latteApplet
     readonly property Item indicatorsManager: indicators
     readonly property Item parabolicManager: _parabolicManager
     readonly property Item maskManager: visibilityManager
     readonly property Item layoutsContainerItem: layoutsContainer
 
     property QtObject latteView: null
     property QtObject shortcutsEngine: null
     property QtObject themeExtended: null
     property QtObject universalSettings: null
     property QtObject layoutsManager: null
     property QtObject viewLayout: latteView && latteView.layout ? latteView.layout : null
     property QtObject selectedWindowsTracker: {
         if (latteView && latteView.windowsTracker) {
             switch(plasmoid.configuration.activeWindowFilter) {
             case Latte.Types.ActiveInCurrentScreen:
                 return latteView.windowsTracker.currentScreen;
             case Latte.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.shadows || (root.forceTransparentPanel && plasmoid.configuration.shadows>0)
     property bool dockIsHidden: latteView ? latteView.visibility.isHidden : true
     property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
 
     property bool showInfoBadge: plasmoid.configuration.showInfoBadge
     property bool showProgressBadge: plasmoid.configuration.showProgressBadge
     property bool showAudioBadge: plasmoid.configuration.showAudioBadge
     property bool audioBadgeActionsEnabled: plasmoid.configuration.audioBadgeActionsEnabled
     property bool infoBadgeProminentColorEnabled: plasmoid.configuration.infoBadgeProminentColorEnabled
 
     property bool scrollTasksEnabled: plasmoid.configuration.scrollTasksEnabled
     property bool autoScrollTasksEnabled: plasmoid.configuration.autoScrollTasksEnabled
     property int manualScrollTasksType: plasmoid.configuration.manualScrollTasksType
 
     property bool showWindowActions: plasmoid.configuration.showWindowActions
     property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers
     property bool showOnlyCurrentScreen: plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: plasmoid.configuration.showOnlyCurrentActivity
 
     property bool titleTooltips: plasmoid.configuration.titleTooltips
     property bool unifiedGlobalShortcuts: plasmoid.configuration.unifiedGlobalShortcuts
 
     readonly property bool hasInternalSeparator: latteApplet ? latteApplet.hasInternalSeparator : false
 
     property int animationStep: {
         if (!universalSettings || universalSettings.mouseSensitivity === Latte.Types.HighSensitivity) {
             return 1;
         } else if (universalSettings.mouseSensitivity === Latte.Types.MediumSensitivity) {
             return Math.max(3, root.iconSize / 18);
         } else if (universalSettings.mouseSensitivity === Latte.Types.LowSensitivity) {
             return Math.max(5, root.iconSize / 10);
         }
     }
 
     property int latteAppletHoveredIndex: latteApplet ? latteApplet.hoveredIndex : -1
     property int launchersGroup: plasmoid.configuration.launchersGroup
     property int tasksCount: latteApplet ? latteApplet.tasksCount : 0
 
     //! Animations
     property bool animationsEnabled: plasmoid.configuration.animationsEnabled && Latte.WindowSystem.compositingActive
     property bool animationLauncherBouncing: animationsEnabled && latteApplet && plasmoid.configuration.animationLauncherBouncing
     property bool animationWindowInAttention: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowInAttention
     property bool animationNewWindowSliding: animationsEnabled && latteApplet && plasmoid.configuration.animationNewWindowSliding
     property bool animationWindowAddedInGroup: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowAddedInGroup
     property bool animationWindowRemovedFromGroup: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowRemovedFromGroup
 
     property real appliedDurationTime: animationsEnabled ? durationTime : 2
     property real durationTime: {
         if (!animationsEnabled) {
             return 0;
         }
 
         /*if ((latteView && latteView.effects && latteView.effects.animationsBlocked)
                 || !animationsEnabled) {
             return 0;
         }*/
 
         if (plasmoid.configuration.durationTime === 0 || plasmoid.configuration.durationTime === 2 )
             return plasmoid.configuration.durationTime;
 
         if (plasmoid.configuration.durationTime === 1)
             return 1.65;
         else if (plasmoid.configuration.durationTime === 3)
             return 2.35;
 
         return 2;
     }
 
     property real animationsZoomFactor : {
         if (!animationsEnabled) {
             return 1;
         }
 
         if (latteApplet && (animationLauncherBouncing || animationWindowInAttention || animationWindowAddedInGroup)) {
             return 1.65;
         }
 
         return 1;
     }
 
     property real maxZoomFactor: Math.max(zoomFactor, animationsZoomFactor)
 
     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] === iconSize){
                 return i;
             }
         }
         return 3;
     }
 
     //// END properties in functions
 
     ////////////////END properties
 
     //// BEGIN OF Behaviors
     Behavior on thickMargin {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on lengthIntMargin {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on lengthExtMargin {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on localScreenEdgeMargin {
         enabled: !behaveAsPlasmaPanel
 
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on iconSize {
         enabled: !(root.editMode && root.behaveAsPlasmaPanel)
         NumberAnimation {
             duration: 0.8 * root.animationTime
 
             onRunningChanged: {
                 if (!running) {
                     delayUpdateMaskArea.start();
                 }
             }
         }
     }
 
     Behavior on offset {
         enabled: editModeVisual.editAnimationInFullThickness
         NumberAnimation {
             id: offsetAnimation
 
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
     //// END OF Behaviors
 
     //////////////START OF CONNECTIONS
     onEditModeChanged: {
         if (editMode) {
             visibilityManager.updateMaskArea();
             clearZoom();
         } else {
             layoutsContainer.updateSizeForAppletsInFill();
         }
 
         //! This is used in case the dndspacer has been left behind
         //! e.g. the user drops a folder and a context menu is appearing
         //! but the user decides to not make a choice for the applet type
         if (dndSpacer.parent !== root) {
             dndSpacer.parent = root;
         }
     }
 
     onInConfigureAppletsModeChanged: {
         if (inConfigureAppletsMode && panelUserSetAlignment===Latte.Types.Justify) {
             joinLayoutsToMainLayout();
         } else if (!inConfigureAppletsMode) {
             splitMainLayoutToLayouts();
         }
 
         updateIndexes();
     }
 
     //! It is used only when the user chooses different alignment types
     //! and not during startup
     onPanelUserSetAlignmentChanged: {
         if (!root.editMode) {
             return;
         }
 
         if (!inConfigureAppletsMode){
             if (panelUserSetAlignment===Latte.Types.Justify) {
                 addInternalViewSplitters();
                 splitMainLayoutToLayouts();
             } else {
                 joinLayoutsToMainLayout();
                 root.destroyInternalViewSplitters();
             }
         } else {
             if (panelUserSetAlignment===Latte.Types.Justify) {
                 addInternalViewSplitters();
             } else {
                 root.destroyInternalViewSplitters();
             }
         }
 
         LayoutManager.save();
         updateIndexes();
     }
 
     onLatteViewChanged: {
         if (latteView) {
             latteView.onXChanged.connect(visibilityManager.updateMaskArea);
             latteView.onYChanged.connect(visibilityManager.updateMaskArea);
             latteView.onWidthChanged.connect(visibilityManager.updateMaskArea);
             latteView.onHeightChanged.connect(visibilityManager.updateMaskArea);
 
             latteView.positioner.hideDockDuringLocationChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
 
 
             latteView.visibility.onContainsMouseChanged.connect(visibilityManager.slotContainsMouseChanged);
             latteView.visibility.onMustBeHide.connect(visibilityManager.slotMustBeHide);
             latteView.visibility.onMustBeShown.connect(visibilityManager.slotMustBeShown);
 
             updateContainsOnlyPlasmaTasks();
         }
     }
 
     onDockContainsMouseChanged: {
         if (!dockContainsMouse) {
             initializeHoveredIndexes();
         }
     }
 
     onMaxLengthChanged: {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     onToolBoxChanged: {
         if (toolBox) {
             toolBox.visible = false;
         }
     }
 
     onIsReadyChanged: {
         if (isReady && !titleTooltipDialog.visible && titleTooltipDialog.activeItemHovered){
             titleTooltipDialog.show(titleTooltipDialog.activeItem, titleTooltipDialog.activeItemText);
         }
     }
 
     onIsVerticalChanged: {
         if (isVertical) {
             if (plasmoid.configuration.panelPosition === Latte.Types.Left)
                 plasmoid.configuration.panelPosition = Latte.Types.Top;
             else if (plasmoid.configuration.panelPosition === Latte.Types.Right)
                 plasmoid.configuration.panelPosition = Latte.Types.Bottom;
         } else {
             if (plasmoid.configuration.panelPosition === Latte.Types.Top)
                 plasmoid.configuration.panelPosition = Latte.Types.Left;
             else if (plasmoid.configuration.panelPosition === Latte.Types.Bottom)
                 plasmoid.configuration.panelPosition = Latte.Types.Right;
         }
     }
 
     //  onIconSizeChanged: console.log("Icon Size Changed:"+iconSize);
 
     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.restore();
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         inStartupTimer.start();
     }
 
     Component.onDestruction: {
         console.debug("Destroying Latte Dock Containment ui...");
 
         if (latteView) {
             latteView.onXChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onYChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onWidthChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onHeightChanged.disconnect(visibilityManager.updateMaskArea);
 
             latteView.positioner.hideDockDuringLocationChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
 
             if (latteView.visibility) {
                 latteView.visibility.onContainsMouseChanged.disconnect(visibilityManager.slotContainsMouseChanged);
                 latteView.visibility.onMustBeHide.disconnect(visibilityManager.slotMustBeHide);
                 latteView.visibility.onMustBeShown.disconnect(visibilityManager.slotMustBeShown);
             }
         }
     }
 
     Containment.onAppletAdded: {
         addApplet(applet, x, y);
         console.log(applet.pluginName);
         LayoutManager.save();
         updateIndexes();
     }
 
     Containment.onAppletRemoved: {
         LayoutManager.removeApplet(applet);
         var flexibleFound = false;
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var applet = layoutsContainer.mainLayout.children[i].applet;
             if (applet && ((root.isHorizontal && applet.Layout.fillWidth) ||
                            (!root.isHorizontal && applet.Layout.fillHeight)) &&
                     applet.visible) {
                 flexibleFound = true;
                 break
             }
         }
         if (!flexibleFound) {
             lastSpacer.parent = layoutsContainer.mainLayout;
         }
 
         console.log(applet.pluginName);
         LayoutManager.save();
 
         updateIndexes();
         updateContainsOnlyPlasmaTasks();
     }
 
     Plasmoid.onUserConfiguringChanged: {
         if (plasmoid.immutable) {
             if (dragOverlay) {
                 dragOverlay.destroy();
             }
             return;
         }
 
         // console.debug("user configuring", plasmoid.userConfiguring)
 
         if (plasmoid.userConfiguring) {
             latteView.setBlockHiding(true);
 
             //  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 {
             latteView.setBlockHiding(false);
 
             if (latteView.visibility.isHidden) {
                 latteView.visibility.mustBeShown();
             }
 
             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.panelPosition === Latte.Types.Justify ?
                                                   layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin);
             } else {
                 root.Layout.preferredHeight = (plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                                    layoutsContainer.height + 0.5*iconMargin : layoutsContainer.mainLayout.height + iconMargin);
             }
         } else {
             if (root.isHorizontal) {
                 root.Layout.preferredWidth = Screen.width;
             } else {
                 root.Layout.preferredHeight = Screen.height;
             }
         }*/
 
         visibilityManager.updateMaskArea();
     }
     //////////////END OF CONNECTIONS
 
     //////////////START OF FUNCTIONS
     function addApplet(applet, x, y) {
         var container = appletContainerComponent.createObject(dndSpacer.parent)
 
         container.applet = applet;
         applet.parent = container.appletWrapper;
 
         applet.anchors.fill = container.appletWrapper;
 
         applet.visible = true;
 
 
         // don't show applet if it chooses to be hidden but still make it
         // accessible in the panelcontroller
         container.visible = Qt.binding(function() {
             return applet.status !== PlasmaCore.Types.HiddenStatus || (!plasmoid.immutable && root.inConfigureAppletsMode)
         })
 
         addContainerInLayout(container, applet, x, y);
 
         updateContainsOnlyPlasmaTasks();
     }
 
     function addContainerInLayout(container, applet, x, y){
         // Is there a DND placeholder? Replace it!
         if ( (dndSpacer.parent === layoutsContainer.mainLayout)
                 || (dndSpacer.parent === layoutsContainer.startLayout)
                 || (dndSpacer.parent===layoutsContainer.endLayout)) {
             LayoutManager.insertBeforeForLayout(dndSpacer.parent, dndSpacer, container);
             dndSpacer.parent = root;
             return;
             // If the provided position is valid, use it.
         } else if (x >= 0 && y >= 0) {
             var index = LayoutManager.insertAtCoordinates2(container, x , y);
 
             // Fall through to determining an appropriate insert position.
         } else {
             var before = null;
             container.animationsEnabled = false;
 
             if (lastSpacer.parent === layoutsContainer.mainLayout) {
                 before = lastSpacer;
             }
 
             // Insert icons to the left of whatever is at the center (usually a Task Manager),
             // if it exists.
             // FIXME TODO: This is a real-world fix to produce a sensible initial position for
             // launcher icons added by launcher menu applets. The basic approach has been used
             // since Plasma 1. However, "add launcher to X" is a generic-enough concept and
             // frequent-enough occurrence that we'd like to abstract it further in the future
             // and get rid of the ugliness of parties external to the containment adding applets
             // of a specific type, and the containment caring about the applet type. In a better
             // system the containment would be informed of requested launchers, and determine by
             // itself what it wants to do with that information.
             if (applet.pluginName == "org.kde.plasma.icon") {
                 var middle = layoutsContainer.mainLayout.childAt(root.width / 2, root.height / 2);
 
                 if (middle) {
                     before = middle;
                 }
 
                 // Otherwise if lastSpacer is here, enqueue before it.
             }
 
             if (before) {
                 LayoutManager.insertBefore(before, container);
 
                 // Fall through to adding at the end.
             } else {
                 container.parent = layoutsContainer.mainLayout;
             }
         }
 
         //Important, removes the first children of the layoutsContainer.mainLayout after the first
         //applet has been added
         lastSpacer.parent = root;
 
         updateIndexes();
     }
 
     function addInternalViewSplitters(){
         if (internalViewSplittersCount() === 0) {
             addInternalViewSplitter(plasmoid.configuration.splitterPosition);
             addInternalViewSplitter(plasmoid.configuration.splitterPosition2);
         }
     }
 
     function addInternalViewSplitter(pos){
         var splittersCount = internalViewSplittersCount();
         if(splittersCount<2){
             var container = appletContainerComponent.createObject(root);
 
             container.internalSplitterId = splittersCount+1;
             container.visible = true;
 
             if(pos>=0 ){
                 LayoutManager.insertAtIndex(container, pos);
             } else {
                 LayoutManager.insertAtIndex(container, Math.floor(layoutsContainer.mainLayout.count / 2));
             }
         }
     }
 
     //! it is used in order to check the right click position
     //! the only way to take into account the visual appearance
     //! of the applet (including its spacers)
     function appletContainsPos(appletId, pos){
         for (var i = 0; i < layoutsContainer.startLayout.children.length; ++i) {
             var child = layoutsContainer.startLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var child = layoutsContainer.mainLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.endLayout.children.length; ++i) {
             var child = layoutsContainer.endLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         return false;
     }
 
     function checkLastSpacer() {
         lastSpacer.parent = root
 
         var expands = false;
 
         if (isHorizontal) {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillWidth) {
                     expands = true;
                 }
             }
         } else {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillHeight) {
                     expands = true;
                 }
             }
         }
         if (!expands) {
             lastSpacer.parent = layoutsContainer.mainLayout
         }
     }
 
     function clearZoom(){
         if (latteApplet){
             latteApplet.clearZoom();
         }
 
         root.clearZoomSignal();
     }
 
     function containmentActions(){
         return latteView.containmentActions();
     }
 
     function decimalToHex(d, padding) {
         var hex = Number(d).toString(16);
         padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
 
         while (hex.length < padding) {
             hex = "0" + hex;
         }
 
         return hex;
     }
 
 
     function disableDirectRender(){
         //  root.globalDirectRender = false;
     }
 
     function internalViewSplittersCount(){
         var splitters = 0;
         for (var container in layoutsContainer.startLayout.children) {
             var item = layoutsContainer.startLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.mainLayout.children) {
             var item = layoutsContainer.mainLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.endLayout.children) {
             var item = layoutsContainer.endLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         return splitters;
     }
 
     function initializeHoveredIndexes() {
         layoutsContainer.hoveredIndex = -1;
         layoutsContainer.currentSpot = -1000;
         if (latteApplet) {
             latteApplet.initializeHoveredIndex();
         }
     }
 
     function layoutManager() {
         return LayoutManager;
     }
 
     function layoutManagerInsertBefore(place, item) {
         LayoutManager.insertBefore(place, item);
     }
 
     function layoutManagerInsertAfter(place, item) {
         LayoutManager.insertAfter(place, item);
     }
 
     function layoutManagerSave() {
         LayoutManager.save();
     }
 
     function layoutManagerSaveOptions() {
         LayoutManager.saveOptions();
     }
 
     function mouseInCanBeHoveredApplet(){
         if (latteApplet && latteApplet.containsMouse())
             return true;
 
         var applets = layoutsContainer.startLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         applets = layoutsContainer.mainLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         ///check second layout also
         applets = layoutsContainer.endLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         return false;
     }
 
     function mouseInHoverableArea() {
         return (latteView.visibility.containsMouse && !rootMouseArea.containsMouse && mouseInCanBeHoveredApplet());
     }
 
     function setHoveredIndex(ind) {
         layoutsContainer.hoveredIndex = ind;
     }
 
     function hideTooltipLabel(debug){
         titleTooltipDialog.hide(debug);
     }
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletShortcutBadges(showLatteShortcuts, showShortcuts, showMeta, applicationLauncher){
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.setShowTaskShortcutBadges(showLatteShortcuts);
         }
 
         showLatteShortcutBadges = showLatteShortcuts;
         showAppletShortcutBadges = showShortcuts;
         showMetaBadge = showMeta;
         applicationLauncherId = applicationLauncher;
 
         if (latteApplet) {
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function activateEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalActivateEntryAtIndex(index);
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function newInstanceForEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalNewInstanceForEntryAtIndex(index);
     }
 
     //! this is called from Latte::View::ContainmentInterface
     function appletIdForIndex(index) {
         if (!root.unifiedGlobalShortcuts || parabolicManager.pseudoIndexBelongsToLatteApplet(index)) {
             return -1;
         }
 
         for (var i=0; i<layoutsContainer.startLayout.children.length; ++i){
             var appletItem = layoutsContainer.startLayout.children[i];
 
             if (appletItem && appletItem.refersEntryIndex(index)) {
                 return appletItem.applet.id;
             }
         }
 
         for (var j=0; j<layoutsContainer.mainLayout.children.length; ++j){
             var appletItem2 = layoutsContainer.mainLayout.children[j];
 
             if (appletItem2 && appletItem2.refersEntryIndex(index)) {
                 return appletItem2.applet.id;
             }
         }
 
         for (var k=0; j<layoutsContainer.endLayout.children.length; ++k){
             var appletItem3 = layoutsContainer.endLayout.children[k];
 
             if (appletItem3 && appletItem3.refersEntryIndex(index)) {
                 return appletItem3.applet.id;
             }
         }
 
         return -1;
     }
 
 
     function showTooltipLabel(taskItem, text){
         titleTooltipDialog.show(taskItem, text);
     }
 
     function sizeIsFromAutomaticMode(size){
 
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === size){
                 return true;
             }
         }
 
         return false;
     }
 
     function slotAnimationsNeedBothAxis(step) {
         if (step === 0) {
             return;
         }
 
         animationsNeedBothAxis = Math.max(animationsNeedBothAxis + step, 0);
 
         visibilityManager.updateMaskArea();
     }
 
     function slotAnimationsNeedLength(step) {
         if (step === 0) {
             return;
         }
 
         animationsNeedLength = Math.max(animationsNeedLength + step, 0);
 
         //when need length animations are ended it would be a good idea
         //to update the tasks geometries in the plasmoid
         if(animationsNeedLength === 0 && latteApplet) {
             latteApplet.publishTasksGeometries();
         }
 
         visibilityManager.updateMaskArea();
     }
 
     function slotAnimationsNeedThickness(step) {
         if (step === 0) {
             return;
         }
 
         animationsNeedThickness = Math.max(animationsNeedThickness + step, 0);
 
         visibilityManager.updateMaskArea();
     }
 
     function slotAppletsNeedWindowsTracking(step) {
         if (step === 0) {
             return;
         }
 
         appletsNeedWindowsTracking = Math.max(appletsNeedWindowsTracking + step, 0);
     }
 
     //this is used when dragging a task in order to not hide the dock
     //and also by the menu appearing from tasks for the same reason
     function slotActionsBlockHiding(step) {
         //if (root.editMode) {
         //    return;
         // }
 
         if ((step === 0) || (!latteView)) {
             return;
         }
 
         actionsBlockHiding = Math.max(actionsBlockHiding + step, 0);
 
         if (actionsBlockHiding > 0){
             latteView.setBlockHiding(true);
         } else {
             if (!root.editMode)
                 latteView.setBlockHiding(false);
         }
     }
 
     function slotPreviewsShown(){
         if (latteView) {
             latteView.deactivateApplets();
         }
     }
 
     function startCheckRestoreZoomTimer(){
         checkRestoreZoom.start();
     }
 
     function stopCheckRestoreZoomTimer(){
         checkRestoreZoom.stop();
     }
 
     function startDirectRenderDelayerDuringEntering(){
         directRenderDelayerForEnteringTimer.start();
     }
 
     function setGlobalDirectRender(value) {
         if (latteApplet && latteApplet.tasksExtendedManager.waitingLaunchersLength() > 0)
             return;
 
         if (value === true) {
             if (mouseInCanBeHoveredApplet()) {
                 root.globalDirectRender = true;
             } else {
                 //    console.log("direct render true ignored...");
             }
         } else {
             root.globalDirectRender = false;
         }
     }
 
     function updateContainsOnlyPlasmaTasks() {
         if (latteView) {
             root.containsOnlyPlasmaTasks = (latteView.tasksPresent() && !latteApplet);
         } else {
             root.containsOnlyPlasmaTasks = false;
         }
     }
 
     function updateSizeForAppletsInFill() {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     function splitMainLayoutToLayouts() {
         if (internalViewSplittersCount() === 2) {
             console.log("LAYOUTS: Moving applets from MAIN to THREE Layouts mode...");
             var splitter = -1;
             var splitter2 = -1;
 
             var totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=0; i<totalChildren; ++i) {
                 var item = layoutsContainer.mainLayout.children[i];
 
                 if(item.isInternalViewSplitter && splitter === -1) {
                     splitter = i;
                 } else if (item.isInternalViewSplitter && splitter>=0 && splitter2 === -1) {
                     splitter2 = i;
                 }
             }
 
             // console.log("update layouts 1:"+splitter + " - "+splitter2);
             for (var i=0; i<=splitter; ++i){
                 var item = layoutsContainer.mainLayout.children[0];
                 item.parent = layoutsContainer.startLayout;
             }
 
             splitter2 = splitter2 - splitter - 1;
             // console.log("update layouts 2:"+splitter + " - "+splitter2);
 
             totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=splitter2+1; i<totalChildren; ++i){
                 var item = layoutsContainer.mainLayout.children[splitter2+1];
                 item.parent = layoutsContainer.endLayout;
             }
         }
     }
 
     function joinLayoutsToMainLayout() {
         console.log("LAYOUTS: Moving applets from THREE to MAIN Layout mode...");
         var totalChildren1 = layoutsContainer.mainLayout.children.length;
         for (var i=totalChildren1-1; i>=0; --i) {
             var item1 = layoutsContainer.mainLayout.children[0];
             item1.parent = layoutsContainer.startLayout;
         }
 
         var totalChildren2 = layoutsContainer.endLayout.children.length;
 
         for (var i=totalChildren2-1; i>=0; --i) {
             var item2 = layoutsContainer.endLayout.children[0];
             item2.parent = layoutsContainer.startLayout;
         }
 
         var totalChildrenL = layoutsContainer.startLayout.children.length;
         for (var i=totalChildrenL-1; i>=0; --i) {
             var itemL = layoutsContainer.startLayout.children[0];
             itemL.parent = layoutsContainer.mainLayout;
         }
     }
     //END functions
 
 
     ////BEGIN interfaces
 
     Connections {
         target: Latte.WindowSystem
 
         onCompositingActiveChanged: {
             visibilityManager.updateMaskArea();
         }
     }
 
     Connections {
         target: latteView
 
         onContextMenuIsShownChanged: {
             if (!latteView.contextMenuIsShown) {
                 checkRestoreZoom.start();
             } else {
                 root.setGlobalDirectRender(false);
             }
         }
     }
 
     Connections{
         target: latteView && latteView.visibility ? latteView.visibility : root
 
         ignoreUnknownSignals : true
 
         onContainsMouseChanged: {
             if (mouseInHoverableArea()) {
                 stopCheckRestoreZoomTimer();
             } else {
                 startCheckRestoreZoomTimer();
             }
         }
     }
 
     Connections{
         target: layoutsContainer
 
         onHoveredIndexChanged: {
             if (latteApplet && layoutsContainer.hoveredIndex>-1){
                 latteApplet.setHoveredIndex(-1);
             }
 
             if (latteApplet && latteApplet.windowPreviewIsShown && layoutsContainer.hoveredIndex>-1) {
                 latteApplet.hidePreview();
             }
         }
     }
 
     ////END interfaces
 
     /////BEGIN: Title Tooltip///////////
     PlasmaCore.Dialog{
         id: titleTooltipDialog
 
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: plasmoid.location
         mainItem: RowLayout{
             Layout.fillWidth: true
             Layout.fillHeight: true
             PlasmaComponents.Label{
                 id:titleLbl
                 Layout.leftMargin: 4
                 Layout.rightMargin: 4
                 Layout.topMargin: 2
                 Layout.bottomMargin: 2
                 text: titleTooltipDialog.title
             }
         }
 
         visible: false
 
         property string title: ""
 
         property bool activeItemHovered: false
         property Item activeItem: null
         property Item activeItemTooltipParent: null
         property string activeItemText: ""
 
 
         Component.onCompleted: {
             root.clearZoomSignal.connect(titleTooltipDialog.hide);
         }
 
         Component.onDestruction: {
             root.clearZoomSignal.disconnect(titleTooltipDialog.hide);
         }
 
         function hide(debug){
             if (!root.titleTooltips)
                 return;
 
             activeItemHovered = false;
             hideTitleTooltipTimer.start();
         }
 
         function show(taskItem, text){
             if (!root.titleTooltips || (latteApplet && latteApplet.contextMenu)){
                 return;
             }
 
             activeItemHovered = true;
 
             if (activeItem !== taskItem) {
                 activeItem = taskItem;
                 activeItemTooltipParent = taskItem.tooltipVisualParent;
                 activeItemText = text;
             }
 
             if (isReady) {
                 showTitleTooltipTimer.start();
             }
 
         }
 
         function update() {
             activeItemHovered = true
             title = activeItemText;
             visualParent = activeItemTooltipParent;
             if (latteApplet && latteApplet.windowPreviewIsShown) {
                 latteApplet.hidePreview();
             }
 
             visible = true;
         }
     }
 
     Timer {
         id: showTitleTooltipTimer
         interval: 100
         onTriggered: {
             if (latteView && latteView.visibility && latteView.visibility.containsMouse) {
                 titleTooltipDialog.update();
             }
 
             if (titleTooltipDialog.visible) {
                 titleTooltipCheckerToNotShowTimer.start();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: showTitleTooltipTimer called...");
             }
         }
     }
 
     Timer {
         id: hideTitleTooltipTimer
         interval: 200
         onTriggered: {
             if (!titleTooltipDialog.activeItemHovered) {
                 titleTooltipDialog.visible = false;
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: hideTitleTooltipTimer called...");
             }
 
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown
     Timer {
         id: titleTooltipCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (titleTooltipDialog.visible && latteApplet && (latteApplet.contextMenu || latteApplet.windowPreviewIsShown)) {
                 titleTooltipDialog.visible = false;
             }
         }
     }
     /////END: Title Tooltip///////////
 
     ///////////////BEGIN components
     Component {
         id: appletContainerComponent
         Applet.AppletItem{}
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     Indicators.Manager{
         id: indicators
     }
 
     Item {
         id: graphicsSystem
         readonly property bool isAccelerated: (GraphicsInfo.api !== GraphicsInfo.Software)
                                               && (GraphicsInfo.api !== GraphicsInfo.Unknown)
     }
 
     ///////////////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{}
     }
 
     //! Load a sepia background in order to avoid black background
     Loader{
         anchors.fill: parent
         active: !Latte.WindowSystem.compositingActive
         sourceComponent: Image{
             anchors.fill: parent
             fillMode: Image.Tile
             source: root.hasUserSpecifiedBackground ? latteView.layout.background : "../icons/wheatprint.jpg"
         }
     }
 
     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
             }
         }
     }
 
     AutomaticItemSizer {
         id: automaticItemSizer
     }
 
     VisibilityManager{ id: visibilityManager }
 
     DragDropArea {
         id: backDropArea
         anchors.fill: parent
         readonly property bool higherPriority: latteView && latteView.containsDrag
                                                && ((root.dragInfo.isPlasmoid && root.dragInfo.isSeparator)
                                                    || (foreDropArea.dragInfo.computationsAreValid && !root.dragInfo.isPlasmoid && !root.dragInfo.onlyLaunchers))
 
         Item{
             id: panelBox
             anchors.fill: layoutsContainer
 
             PanelBox{
                 id: panelBoxBackground
             }
         }
 
         Layouts.LayoutsContainer {
             id: layoutsContainer
         }
 
         DragDropArea {
             id: foreDropArea
             anchors.fill: parent
             visible: !backDropArea.higherPriority
             isForeground: true
 
             /* Rectangle {
                 anchors.fill: parent
                 color: "blue"
                 opacity: 0.5
             }*/
         }
     }
 
     Colorizer.Manager {
         id: colorizerManager
     }
 
     Item {
         id: dndSpacer
 
         width: root.isHorizontal ? length : thickness
         height: root.isHorizontal ? thickness : length
 
         readonly property int length: root.iconSize + root.lengthMargins
         readonly property int thickness: root.iconSize + root.thickMargins + root.localScreenEdgeMargin
 
         Layout.preferredWidth: width
         Layout.preferredHeight: height
         opacity: 0
         z:1500
 
         LatteComponents.AddItem{
             id: dndSpacerAddItem
             width: root.isHorizontal ? parent.width : parent.width - root.localScreenEdgeMargin
             height: root.isHorizontal ? parent.height - root.localScreenEdgeMargin : parent.height
 
             states:[
                 State{
                     name: "bottom"
                     when: plasmoid.location === PlasmaCore.Types.BottomEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                         anchors.right: undefined; anchors.left: undefined; anchors.top: undefined; anchors.bottom: parent.bottom;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: root.localScreenEdgeMargin;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "top"
                     when: plasmoid.location === PlasmaCore.Types.TopEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: parent.horizontalCenter; anchors.verticalCenter: undefined;
                         anchors.right: undefined; anchors.left: undefined; anchors.top: parent.top; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: 0;     anchors.topMargin: root.localScreenEdgeMargin;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "left"
                     when: plasmoid.location === PlasmaCore.Types.LeftEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                         anchors.right: undefined; anchors.left: parent.left; anchors.top: undefined; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: root.localScreenEdgeMargin;    anchors.rightMargin: 0;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 },
                 State{
                     name: "right"
                     when: plasmoid.location === PlasmaCore.Types.RightEdge
 
                     AnchorChanges{
                         target: dndSpacerAddItem;
                         anchors.horizontalCenter: undefined; anchors.verticalCenter: parent.verticalCenter;
                         anchors.right: parent.right; anchors.left: undefined; anchors.top: undefined; anchors.bottom: undefined;
                     }
                     PropertyChanges{
                         target: dndSpacerAddItem;
                         anchors.leftMargin: 0;    anchors.rightMargin: root.localScreenEdgeMargin;     anchors.topMargin:0;    anchors.bottomMargin: 0;
                         anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
                     }
                 }
             ]
         }
     }
 
     ///////////////END UI elements
 
     ///////////////BEGIN TIMER elements
 
 
     //Timer to check if the mouse is still outside the latteView in order to restore zooms to 1.0
     Timer{
         id:checkRestoreZoom
         interval: 90
 
         onTriggered: {
             if (latteApplet && (latteApplet.previewContainsMouse() || latteApplet.contextMenu))
                 return;
 
             if (latteView.contextMenuIsShown)
                 return;
 
             if (!mouseInHoverableArea()) {
                 setGlobalDirectRender(false);
                 root.initializeHoveredIndexes();
                 root.clearZoom();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: checkRestoreZoom called...");
             }
         }
     }
 
     //! Delayer in order to not activate directRendering when the mouse
     //! enters until the timer has ended. This way we make sure that the
     //! zoom-in animations will have ended.
     Timer{
         id:directRenderDelayerForEnteringTimer
         interval: 3.2 * root.durationTime * units.shortDuration
     }
 
     //this is a delayer to update mask area, it is used in cases
     //that animations can not catch up with animations signals
     //e.g. the automaicIconSize case
     Timer{
         id:delayUpdateMaskArea
         repeat:false;
         interval:300;
 
         onTriggered: {
             if (layoutsContainer.animationSent) {
                 root.slotAnimationsNeedLength(-1);
                 layoutsContainer.animationSent = false;
             }
 
             visibilityManager.updateMaskArea();
 
             if (root.debugModeTimers) {
                 console.log("containment timer: delayUpdateMaskArea called...");
             }
         }
     }
 
     //! 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
 }