diff --git a/app/dock/dockview.cpp b/app/dock/dockview.cpp
index 270ec891..dd131038 100644
--- a/app/dock/dockview.cpp
+++ b/app/dock/dockview.cpp
@@ -1,1952 +1,1955 @@
 /*
 *  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 "dockview.h"
 
 #include "dockconfigview.h"
 #include "dockmenumanager.h"
 
 #include "panelshadows_p.h"
 #include "visibilitymanager.h"
 #include "../dockcorona.h"
 #include "../layout.h"
 #include "../layoutmanager.h"
 #include "../screenpool.h"
 #include "../universalsettings.h"
 #include "../../liblattedock/extras.h"
 
 #include <QAction>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QQmlProperty>
 #include <QQuickItem>
 #include <QMenu>
 #include <QMetaEnum>
 #include <QVersionNumber>
 
 #include <KActionCollection>
 #include <KAuthorized>
 #include <KLocalizedContext>
 #include <KLocalizedString>
 #include <KWindowEffects>
 #include <KWindowSystem>
 
 #include <KActivities/Consumer>
 
 #include <Plasma/Containment>
 #include <Plasma/ContainmentActions>
 #include <PlasmaQuick/AppletQuickItem>
 
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 
 namespace Latte {
 
 //! both alwaysVisible and dockWinBehavior are passed through corona because
 //! during the dock window creation containment hasnt been set, but these variables
 //! are needed in order for window flags to be set correctly
 DockView::DockView(Plasma::Corona *corona, QScreen *targetScreen, bool dockWindowBehavior)
     : PlasmaQuick::ContainmentView(corona),
       m_menuManager(new DockMenuManager(this))
 {
     setTitle(corona->kPackage().metadata().name());
     setIcon(qGuiApp->windowIcon());
     setResizeMode(QuickViewSharedEngine::SizeRootObjectToView);
     setColor(QColor(Qt::transparent));
     setClearBeforeRendering(true);
 
     const auto flags = Qt::FramelessWindowHint
                        | Qt::WindowStaysOnTopHint
                        | Qt::NoDropShadowWindowHint
                        | Qt::WindowDoesNotAcceptFocus;
 
     if (dockWindowBehavior) {
         setFlags(flags);
     } else {
         setFlags(flags | Qt::BypassWindowManagerHint);
     }
 
     KWindowSystem::setOnAllDesktops(winId(), true);
 
     if (targetScreen)
         setScreenToFollow(targetScreen);
     else
         setScreenToFollow(qGuiApp->primaryScreen());
 
     connect(this, &DockView::containmentChanged
     , this, [ &, dockWindowBehavior]() {
         qDebug() << "dock view c++ containment changed 1...";
 
         if (!this->containment())
             return;
 
         qDebug() << "dock view c++ containment changed 2...";
 
         setDockWinBehavior(dockWindowBehavior);
 
         restoreConfig();
         reconsiderScreen();
 
         if (!m_visibility) {
             m_visibility = new VisibilityManager(this);
 
             connect(m_visibility, &VisibilityManager::isHiddenChanged, this, [&]() {
                 if (m_visibility->isHidden()) {
                     deactivateApplets();
                 }
             });
         }
 
         connect(this->containment(), SIGNAL(statusChanged(Plasma::Types::ItemStatus)), SLOT(statusChanged(Plasma::Types::ItemStatus)));
     }, Qt::DirectConnection);
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(2000);
     connect(&m_screenSyncTimer, &QTimer::timeout, this, &DockView::reconsiderScreen);
 
     //! under X11 it was identified that windows many times especially under screen changes
     //! dont end up at the correct position and size. This timer will enforce repositionings
     //! and resizes every 500ms if the window hasnt end up to correct values and until this
     //! is achieved
     m_validateGeometryTimer.setSingleShot(true);
     m_validateGeometryTimer.setInterval(500);
     connect(&m_validateGeometryTimer, &QTimer::timeout, this, &DockView::syncGeometry);
 
     auto *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
     if (dockCorona) {
         m_screenSyncTimer.setInterval(qMax(dockCorona->universalSettings()->screenTrackerInterval() - 500, 1000));
         connect(dockCorona->universalSettings(), &UniversalSettings::screenTrackerIntervalChanged, this, [this, dockCorona]() {
             m_screenSyncTimer.setInterval(qMax(dockCorona->universalSettings()->screenTrackerInterval() - 500, 1000));
         });
 
         connect(dockCorona, &DockCorona::docksCountChanged, this, &DockView::docksCountChanged);
         connect(this, &DockView::docksCountChanged, this, &DockView::totalDocksCountChanged);
         connect(dockCorona, &DockCorona::dockLocationChanged, this, &DockView::dockLocationChanged);
         connect(dockCorona, &DockCorona::dockLocationChanged, this, [&]() {
             //! check if an edge has been freed for a primary dock
             //! from another screen
             if (m_onPrimary) {
                 m_screenSyncTimer.start();
             }
         });
     }
 }
 
 DockView::~DockView()
 {
     m_inDelete = true;
 
     disconnect(corona(), &Plasma::Corona::availableScreenRectChanged, this, &DockView::availableScreenRectChanged);
     disconnect(containment(), SIGNAL(statusChanged(Plasma::Types::ItemStatus)), this, SLOT(statusChanged(Plasma::Types::ItemStatus)));
 
     m_screenSyncTimer.stop();
 
     qDebug() << "dock view deleting...";
     rootContext()->setContextProperty(QStringLiteral("dock"), nullptr);
 
     //! this disconnect does not free up connections correctly when
     //! dockView is deleted. A crash for this example is the following:
     //! switch to Alternative Session and disable compositing,
     //! the signal creating the crash was probably from deleted
     //! windows.
     //! this->disconnect();
 
     if (m_configView) {
         m_configView->setVisible(false);//hide();
     }
 
     if (m_menuManager) {
         m_menuManager->deleteLater();
     }
 
     if (m_visibility)
         delete m_visibility;
 }
 
 void DockView::init()
 {
     connect(this, &QQuickWindow::screenChanged, this, &DockView::screenChanged);
     connect(this, &QQuickWindow::screenChanged, this, &DockView::docksCountChanged);
     connect(qGuiApp, &QGuiApplication::screenAdded, this, &DockView::screenChanged);
     connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &DockView::screenChanged);
     connect(this, &DockView::screenGeometryChanged, this, &DockView::syncGeometry);
 
     connect(this, &QQuickWindow::xChanged, this, &DockView::xChanged);
     connect(this, &QQuickWindow::xChanged, this, &DockView::validateDockGeometry);
     connect(this, &QQuickWindow::xChanged, this, &DockView::updateAbsDockGeometry);
     connect(this, &QQuickWindow::yChanged, this, &DockView::yChanged);
     connect(this, &QQuickWindow::yChanged, this, &DockView::validateDockGeometry);
     connect(this, &QQuickWindow::yChanged, this, &DockView::updateAbsDockGeometry);
     connect(this, &QQuickWindow::widthChanged, this, &DockView::widthChanged);
     connect(this, &QQuickWindow::widthChanged, this, &DockView::validateDockGeometry);
     connect(this, &QQuickWindow::widthChanged, this, &DockView::updateAbsDockGeometry);
     connect(this, &QQuickWindow::heightChanged, this, &DockView::heightChanged);
     connect(this, &QQuickWindow::heightChanged, this, &DockView::validateDockGeometry);
     connect(this, &QQuickWindow::heightChanged, this, &DockView::updateAbsDockGeometry);
 
     connect(corona(), &Plasma::Corona::availableScreenRectChanged, this, &DockView::availableScreenRectChanged);
 
     connect(this, &DockView::behaveAsPlasmaPanelChanged, this, &DockView::syncGeometry);
     connect(this, &DockView::drawShadowsChanged, this, &DockView::syncGeometry);
     connect(this, &DockView::maxLengthChanged, this, &DockView::syncGeometry);
     connect(this, &DockView::offsetChanged, this, &DockView::syncGeometry);
     connect(this, &DockView::alignmentChanged, this, &DockView::updateEnabledBorders);
     connect(this, &DockView::dockWinBehaviorChanged, this, &DockView::saveConfig);
     connect(this, &DockView::onPrimaryChanged, this, &DockView::saveConfig);
 
     connect(this, &DockView::locationChanged, this, [&]() {
         updateFormFactor();
         syncGeometry();
     });
     connect(this, &DockView::dockTransparencyChanged, this, &DockView::updateEffects);
     connect(this, &DockView::drawEffectsChanged, this, &DockView::updateEffects);
     connect(this, &DockView::effectsAreaChanged, this, &DockView::updateEffects);
 
     connect(&m_theme, &Plasma::Theme::themeChanged, this, &DockView::themeChanged);
 
     connect(this, &DockView::normalThicknessChanged, this, [&]() {
         if (m_behaveAsPlasmaPanel) {
             syncGeometry();
         }
     });
 
     connect(this, SIGNAL(normalThicknessChanged()), corona(), SIGNAL(availableScreenRectChanged()));
     connect(this, SIGNAL(shadowChanged()), corona(), SIGNAL(availableScreenRectChanged()));
 
     connect(m_menuManager, &DockMenuManager::contextMenuChanged, this, &DockView::contextMenuIsShownChanged);
 
     initSignalingForLocationChangeSliding();
 
     ///!!!!!
     rootContext()->setContextProperty(QStringLiteral("dock"), this);
 
     auto *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
     if (dockCorona) {
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), dockCorona->universalSettings());
         rootContext()->setContextProperty(QStringLiteral("layoutManager"), dockCorona->layoutManager());
     }
 
     setSource(corona()->kPackage().filePath("lattedockui"));
     // setVisible(true);
     syncGeometry();
 
     if (!KWindowSystem::isPlatformWayland()) {
         setVisible(true);
     }
 
     qDebug() << "SOURCE:" << source();
 }
 
 void DockView::hideWindowsForSlidingOut()
 {
     setBlockHiding(false);
 
     if (m_configView) {
         auto configDialog = qobject_cast<DockConfigView *>(m_configView);
 
         if (configDialog) {
             configDialog->hideConfigWindow();
         }
     }
 }
 
 void DockView::initSignalingForLocationChangeSliding()
 {
     //! signals to handle the sliding-in/out during location changes
     connect(this, &DockView::hideDockDuringLocationChangeStarted, this, [&]() {
         hideWindowsForSlidingOut();
     });
 
     connect(this, &DockView::locationChanged, this, [&]() {
         if (m_goToLocation != Plasma::Types::Floating) {
             m_goToLocation = Plasma::Types::Floating;
             QTimer::singleShot(100, [this]() {
                 setBlockAnimations(false);
                 emit showDockAfterLocationChangeFinished();
                 showSettingsWindow();
 
                 if (m_managedLayout) {
                     m_managedLayout->syncDockViewsToScreens();
                 }
             });
         }
     });
 
     //! signals to handle the sliding-in/out during screen changes
     connect(this, &DockView::hideDockDuringScreenChangeStarted, this, [&]() {
         hideWindowsForSlidingOut();
     });
 
     connect(this, &DockView::currentScreenChanged, this, [&]() {
         if (m_goToScreen) {
             m_goToScreen = nullptr;
             QTimer::singleShot(100, [this]() {
                 setBlockAnimations(false);
                 emit showDockAfterScreenChangeFinished();
                 showSettingsWindow();
 
                 if (m_managedLayout) {
                     m_managedLayout->syncDockViewsToScreens();
                 }
             });
         }
     });
 
     //! signals to handle the sliding-in/out during moving to another layout
     connect(this, &DockView::hideDockDuringMovingToLayoutStarted, this, [&]() {
         hideWindowsForSlidingOut();
     });
 
     connect(this, &DockView::managedLayoutChanged, this, [&]() {
         if (!m_moveToLayout.isEmpty() && m_managedLayout) {
             m_moveToLayout = "";
             QTimer::singleShot(100, [this]() {
                 setBlockAnimations(false);
                 emit showDockAfterMovingToLayoutFinished();
                 showSettingsWindow();
             });
         }
     });
 
     //!    ----  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, &DockView::hideDockDuringLocationChangeFinished, this, [&]() {
         setBlockAnimations(true);
 
         if (m_goToLocation != Plasma::Types::Floating) {
             setLocation(m_goToLocation);
         } else if (m_goToScreen) {
             setScreenToFollow(m_goToScreen);
         } else if (!m_moveToLayout.isEmpty()) {
             moveToLayout(m_moveToLayout);
         }
     });
 }
 
 void DockView::disconnectSensitiveSignals()
 {
     disconnect(corona(), &Plasma::Corona::availableScreenRectChanged, this, &DockView::availableScreenRectChanged);
     setManagedLayout(nullptr);
 
     if (visibility()) {
         visibility()->setEnabledDynamicBackground(false);
     }
 }
 
 void DockView::availableScreenRectChanged()
 {
     if (m_inDelete)
         return;
 
     if (formFactor() == Plasma::Types::Vertical)
         syncGeometry();
 }
 
 void DockView::setupWaylandIntegration()
 {
     if (m_shellSurface)
         return;
 
     if (DockCorona *c = qobject_cast<DockCorona *>(corona())) {
         using namespace KWayland::Client;
         PlasmaShell *interface {c->waylandDockCoronaInterface()};
 
         if (!interface)
             return;
 
         Surface *s{Surface::fromWindow(this)};
 
         if (!s)
             return;
 
         m_shellSurface = interface->createSurface(s, this);
         qDebug() << "WAYLAND dock window surface was created...";
 
         m_shellSurface->setSkipTaskbar(true);
         m_shellSurface->setRole(PlasmaShellSurface::Role::Panel);
         m_shellSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::WindowsGoBelow);
     }
 }
 
 KWayland::Client::PlasmaShellSurface *DockView::surface()
 {
     return m_shellSurface;
 }
 
 bool DockView::setCurrentScreen(const QString id)
 {
     QScreen *nextScreen{qGuiApp->primaryScreen()};
 
     if (id != "primary") {
         foreach (auto scr, qGuiApp->screens()) {
             if (scr && scr->name() == id) {
                 nextScreen = scr;
                 break;
             }
         }
     }
 
     if (m_screenToFollow == nextScreen) {
         return true;
     }
 
     if (nextScreen) {
         if (m_managedLayout) {
             auto freeEdges = m_managedLayout->freeEdges(nextScreen);
 
             if (!freeEdges.contains(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 DockView::setScreenToFollow(QScreen *screen, bool updateScreenId)
 {
     if (!screen || m_screenToFollow == screen) {
         return;
     }
 
     m_screenToFollow = screen;
 
     if (updateScreenId) {
         m_screenToFollowId = screen->name();
     }
 
     qDebug() << "adapting to screen...";
     setScreen(screen);
 
     if (this->containment())
         this->containment()->reactToScreenChange();
 
     connect(screen, &QScreen::geometryChanged, this, &DockView::screenGeometryChanged);
     syncGeometry();
     updateAbsDockGeometry(true);
     emit screenGeometryChanged();
     emit currentScreenChanged();
 }
 
 //! the main function which decides if this dock is at the
 //! correct screen
 void DockView::reconsiderScreen()
 {
     if (m_inDelete) {
         return;
     }
 
     qDebug() << "  Delayer  ";
 
     foreach (auto scr, qGuiApp->screens()) {
         qDebug() << "      D, found screen: " << scr->name();
     }
 
     bool screenExists{false};
 
     //!check if the associated screen is running
     foreach (auto scr, qGuiApp->screens()) {
         if (m_screenToFollowId == scr->name()
             || (onPrimary() && scr == qGuiApp->primaryScreen())) {
             screenExists = true;
         }
     }
 
     qDebug() << "dock screen exists  ::: " << screenExists;
 
     int docksWithTasks = m_managedLayout ? m_managedLayout->noDocksWithTasks() : 0;
 
     //! 1.a primary dock must be always on the primary screen
     //! 2.the last tasks dock must also always on the primary screen
     //! even though it has been configured as an explicit
     if ((m_onPrimary || (tasksPresent() && docksWithTasks == 1 && !screenExists))
         && (m_screenToFollowId != qGuiApp->primaryScreen()->name()
             || m_screenToFollow != qGuiApp->primaryScreen())) {
         using Plasma::Types;
         QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                      Types::TopEdge, Types::RightEdge};
 
         edges = m_managedLayout ? m_managedLayout->freeEdges(qGuiApp->primaryScreen()) : 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:" << location();
 
         if (edges.contains(location())) {
             //! case 2
             if (!m_onPrimary && !screenExists && tasksPresent() && (docksWithTasks == 1)) {
                 qDebug() << "reached case 2 of updating dock primary screen...";
                 setScreenToFollow(qGuiApp->primaryScreen(), false);
             } else {
                 //! case 1
                 qDebug() << "reached case 1 of updating dock primary screen...";
                 setScreenToFollow(qGuiApp->primaryScreen());
             }
 
             syncGeometry();
         }
     } else if (!m_onPrimary) {
         //! 3.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
         foreach (auto scr, qGuiApp->screens()) {
             if (scr && scr->name() == m_screenToFollowId) {
                 qDebug() << "updating the explicit screen for dock...";
                 setScreenToFollow(scr);
                 syncGeometry();
                 break;
             }
         }
     }
 
     emit docksCountChanged();
 }
 
 void DockView::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_visibility && m_visibility->mode() == Latte::Dock::AlwaysVisible) {
         updateAbsDockGeometry(true);
     }
 }
 
 void DockView::addNewDock()
 {
     auto *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
     if (dockCorona) {
         dockCorona->loadDefaultLayout();
     }
 }
 
 void DockView::copyDock()
 {
     m_managedLayout->copyDock(containment());
 }
 
 void DockView::removeDock()
 {
     if (totalDocksCount() > 1) {
         QAction *removeAct = this->containment()->actions()->action(QStringLiteral("remove"));
 
         if (removeAct) {
             removeAct->trigger();
         }
     }
 }
 
 QQmlListProperty<QScreen> DockView::screens()
 {
     return QQmlListProperty<QScreen>(this, nullptr, &countScreens, &atScreens);
 }
 
 int DockView::countScreens(QQmlListProperty<QScreen> *property)
 {
     Q_UNUSED(property)
     return qGuiApp->screens().count();
 }
 
 QScreen *DockView::atScreens(QQmlListProperty<QScreen> *property, int index)
 {
     Q_UNUSED(property)
     return qGuiApp->screens().at(index);
 }
 
 QString DockView::currentScreen() const
 {
     return m_screenToFollowId;
 }
 
 bool DockView::settingsWindowIsShown()
 {
     auto configView = qobject_cast<DockConfigView *>(m_configView);
 
     return (configView != nullptr);
 }
 
 void DockView::showSettingsWindow()
 {
     showConfigurationInterface(containment());
     applyActivitiesToWindows();
 }
 
 void DockView::showConfigurationInterface(Plasma::Applet *applet)
 {
     if (!applet || !applet->containment())
         return;
 
     Plasma::Containment *c = qobject_cast<Plasma::Containment *>(applet);
 
     if (m_configView && c && c->isContainment() && c == this->containment()) {
         if (m_configView->isVisible()) {
             m_configView->setVisible(false);
             //m_configView->hide();
         } else {
             m_configView->setVisible(true);
             //m_configView->show();
         }
 
         return;
     } else if (m_configView) {
         if (m_configView->applet() == applet) {
             m_configView->setVisible(true);
             //m_configView->show();
             m_configView->requestActivate();
             return;
         } else {
             m_configView->setVisible(false);
             //m_configView->hide();
             m_configView->deleteLater();
         }
     }
 
     bool delayConfigView = false;
 
     if (c && containment() && c->isContainment() && c->id() == this->containment()->id()) {
         m_configView = new DockConfigView(c, this);
         delayConfigView = true;
     } else {
         m_configView = new PlasmaQuick::ConfigView(applet);
     }
 
     m_configView.data()->init();
 
     if (!delayConfigView) {
         m_configView->setVisible(true);
         //m_configView.data()->show();
     } else {
         //add a timer for showing the configuration window the first time it is
         //created in order to give the containmnent's layouts the time to
         //calculate the window's height
         if (!KWindowSystem::isPlatformWayland()) {
             QTimer::singleShot(150, m_configView, SLOT(show()));
         } else {
             QTimer::singleShot(150, [this]() {
                 m_configView->setVisible(true);
             });
         }
     }
 }
 
 //! 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 DockView::maximumNormalGeometry()
 {
     int xPos = 0;
     int yPos = 0;
     int maxHeight = maxLength() * screen()->geometry().height();
     int maxWidth = normalThickness();
     QRect maxGeometry;
     maxGeometry.setRect(0, 0, maxWidth, maxHeight);
 
     switch (location()) {
         case Plasma::Types::LeftEdge:
             xPos = screen()->geometry().x();
 
             switch (alignment()) {
                 case Latte::Dock::Top:
                     yPos = screen()->geometry().y();
                     break;
 
                 case Latte::Dock::Center:
                 case Latte::Dock::Justify:
                     yPos = qMax(screen()->geometry().center().y() - maxHeight / 2, screen()->geometry().y());
                     break;
 
                 case Latte::Dock::Bottom:
                     yPos = screen()->geometry().bottom() - maxHeight + 1;
                     break;
             }
 
             maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
             break;
 
         case Plasma::Types::RightEdge:
             xPos = screen()->geometry().right() - maxWidth + 1;
 
             switch (alignment()) {
                 case Latte::Dock::Top:
                     yPos = screen()->geometry().y();
                     break;
 
                 case Latte::Dock::Center:
                 case Latte::Dock::Justify:
                     yPos = qMax(screen()->geometry().center().y() - maxHeight / 2, screen()->geometry().y());
                     break;
 
                 case Latte::Dock::Bottom:
                     yPos = screen()->geometry().bottom() - maxHeight + 1;
                     break;
             }
 
             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 hasnt be set,
     //! such a case is the AlwaysVisible mode
     if (location() == Plasma::Types::TopEdge) {
         KWindowSystem::setState(winId(), NET::KeepAbove);
     } else {
         KWindowSystem::clearState(winId(), NET::KeepAbove);
     }
 
     return maxGeometry;
 }
 
 void DockView::resizeWindow(QRect availableScreenRect)
 {
     QSize screenSize = this->screen()->size();
     QSize size = (formFactor() == Plasma::Types::Vertical) ? QSize(maxThickness(), availableScreenRect.height()) : QSize(screenSize.width(), maxThickness());
 
     if (formFactor() == Plasma::Types::Vertical) {
         //qDebug() << "MAXIMUM RECT :: " << maximumRect << " - AVAILABLE RECT :: " << availableRect;
         if (m_behaveAsPlasmaPanel) {
             size.setWidth(normalThickness());
             size.setHeight(static_cast<int>(maxLength() * availableScreenRect.height()));
         }
     } else {
         if (m_behaveAsPlasmaPanel) {
             size.setWidth(static_cast<int>(maxLength() * screenSize.width()));
             size.setHeight(normalThickness());
         }
     }
 
     m_validGeometry.setSize(size);
 
     setMinimumSize(size);
     setMaximumSize(size);
     resize(size);
 
     if (formFactor() == Plasma::Types::Horizontal && corona()) {
         emit corona()->availableScreenRectChanged();
     }
 }
 
 void DockView::validateDockGeometry()
 {
     if (geometry() != m_validGeometry) {
         m_validateGeometryTimer.start();
     }
 }
 
 QRect DockView::localGeometry() const
 {
     return m_localGeometry;
 }
 
 void DockView::setLocalGeometry(const QRect &geometry)
 {
     if (m_localGeometry == geometry) {
         return;
     }
 
     m_localGeometry = geometry;
     emit localGeometryChanged();
     updateAbsDockGeometry();
 }
 
 void DockView::updateAbsDockGeometry(bool bypassChecks)
 {
     //! there was a -1 in height and width here. The reason of this
     //! if I remember correctly was related to multi-screen but I cant
     //! remember exactly the reason, something related to rigth edge in
     //! multi screen environment. BUT this was breaking the entire AlwaysVisible
     //! experience with struts. Removing them in order to restore correct
     //! behavior and keeping this comment in order to check for
     //! multi-screen breakage
     QRect absGeometry {x() + m_localGeometry.x(), y() + m_localGeometry.y()
                        , m_localGeometry.width(), m_localGeometry.height()};
 
     if (m_absGeometry == absGeometry && !bypassChecks)
         return;
 
     m_absGeometry = absGeometry;
     syncGeometry();
     emit absGeometryChanged(m_absGeometry);
 
     //! this is needed in order to update correctly the screenGeometries
     if (visibility() && corona() && visibility()->mode() == Dock::AlwaysVisible) {
         emit corona()->availableScreenRectChanged();
         emit corona()->availableScreenRegionChanged();
     }
 }
 
 void DockView::updatePosition(QRect availableScreenRect)
 {
     QRect screenGeometry{availableScreenRect};
     QPoint position;
     position = {0, 0};
 
     const auto length = [&](int length) -> int {
         float offs = static_cast<float>(offset());
         return static_cast<int>(length * ((1 - maxLength()) / 2) + length * (offs / 100));
     };
     int cleanThickness = normalThickness() - shadow();
 
     switch (location()) {
         case Plasma::Types::TopEdge:
             if (m_behaveAsPlasmaPanel) {
                 position = {screenGeometry.x() + length(screenGeometry.width()), screenGeometry.y()};
             } else {
                 position = {screenGeometry.x(), screenGeometry.y()};
             }
 
             break;
 
         case Plasma::Types::BottomEdge:
             if (m_behaveAsPlasmaPanel) {
                 position = {screenGeometry.x() + length(screenGeometry.width()),
                             screenGeometry.y() + screenGeometry.height() - cleanThickness
                            };
             } else {
                 position = {screenGeometry.x(), screenGeometry.y() + screenGeometry.height() - height()};
             }
 
             break;
 
         case Plasma::Types::RightEdge:
             if (m_behaveAsPlasmaPanel && !mask().isNull()) {
                 position = {availableScreenRect.right() - cleanThickness + 1,
                             availableScreenRect.y() + length(availableScreenRect.height())
                            };
             } else {
                 position = {availableScreenRect.right() - width() + 1, availableScreenRect.y()};
             }
 
             break;
 
         case Plasma::Types::LeftEdge:
             if (m_behaveAsPlasmaPanel && !mask().isNull()) {
                 position = {availableScreenRect.x(), availableScreenRect.y() + length(availableScreenRect.height())};
             } else {
                 position = {availableScreenRect.x(), availableScreenRect.y()};
             }
 
             break;
 
         default:
             qWarning() << "wrong location, couldn't update the panel position"
                        << location();
     }
 
     m_validGeometry.setTopLeft(position);
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 }
 
 inline void DockView::syncGeometry()
 {
     if (!(this->screen() && this->containment()) || m_inDelete)
         return;
 
     bool found{false};
 
     //! before updating the positioning and geometry of the dock
     //! we make sure that the dock is at the correct screen
     if (this->screen() != m_screenToFollow) {
         qDebug() << "Sync Geometry screens inconsistent!!!!";
         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{this->screen()->geometry()};
 
         if (formFactor() == Plasma::Types::Vertical) {
             QString layoutName = m_managedLayout ? m_managedLayout->name() : QString();
             auto dockCorona = qobject_cast<DockCorona *>(corona());
             int fixedScreen = onPrimary() ? dockCorona->screenPool()->primaryScreenId() : this->containment()->screen();
 
             freeRegion = dockCorona->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 (int i = 0; i < availableRegion.rectCount(); ++i) {
                 QRect rect = availableRegion.rects().at(i);
                 //! 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)(rect.width() * rect.height()) / 2500;
 
                 if (tempArea > area) {
                     availableScreenRect = rect;
                     area = tempArea;
                 }
             }
 
             if (availableRegion.rectCount() > 1 && m_behaveAsPlasmaPanel)
                 m_forceDrawCenteredBorders = true;
             else
                 m_forceDrawCenteredBorders = false;
         } else {
             m_forceDrawCenteredBorders = false;
         }
 
         updateEnabledBorders();
         resizeWindow(availableScreenRect);
         updatePosition(availableScreenRect);
     }
 
     // qDebug() << "dock geometry:" << qRectToStr(geometry());
 }
 
 void DockView::statusChanged(Plasma::Types::ItemStatus status)
 {
     if (containment()) {
         if (containment()->status() >= Plasma::Types::NeedsAttentionStatus &&
             containment()->status() != Plasma::Types::HiddenStatus) {
             setBlockHiding(true);
         } else {
             setBlockHiding(false);
         }
     }
 }
 
 bool DockView::alternativesIsShown() const
 {
     return m_alternativesIsShown;
 }
 
 void DockView::setAlternativesIsShown(bool show)
 {
     if (m_alternativesIsShown == show) {
         return;
     }
 
     m_alternativesIsShown = show;
 
     setBlockHiding(show);
     emit alternativesIsShownChanged();
 }
 
 bool DockView::contextMenuIsShown() const
 {
     if (!m_menuManager) {
         return false;
     }
 
     return m_menuManager->contextMenu();
 }
 
 int DockView::currentThickness() const
 {
     if (formFactor() == Plasma::Types::Vertical) {
         return m_maskArea.isNull() ? width() : m_maskArea.width() - m_shadow;
     } else {
         return m_maskArea.isNull() ? height() : m_maskArea.height() - m_shadow;
     }
 }
 
 int DockView::normalThickness() const
 {
     return m_normalThickness;
 }
 
 void DockView::setNormalThickness(int thickness)
 {
     if (m_normalThickness == thickness) {
         return;
     }
 
     m_normalThickness = thickness;
     emit normalThicknessChanged();
 }
 
 int DockView::docksCount() const
 {
     if (!m_managedLayout) {
         return 0;
     }
 
     return m_managedLayout->docksCount(screen());
 }
 
 int DockView::totalDocksCount() const
 {
     if (!m_managedLayout) {
         return 0;
     }
 
     return m_managedLayout->docksCount();
 }
 
 int DockView::docksWithTasks()
 {
     if (!m_managedLayout)
         return 0;
 
     return m_managedLayout->noDocksWithTasks();
 }
 
 void DockView::updateFormFactor()
 {
     if (!this->containment())
         return;
 
     switch (location()) {
         case Plasma::Types::TopEdge:
         case Plasma::Types::BottomEdge:
             this->containment()->setFormFactor(Plasma::Types::Horizontal);
             break;
 
         case Plasma::Types::LeftEdge:
         case Plasma::Types::RightEdge:
             this->containment()->setFormFactor(Plasma::Types::Vertical);
             break;
 
         default:
             qWarning() << "wrong location, couldn't update the panel position" << location();
     }
 }
 
 bool DockView::dockWinBehavior() const
 {
     return m_dockWinBehavior;
 }
 
 void DockView::setDockWinBehavior(bool dock)
 {
     if (m_dockWinBehavior == dock) {
         return;
     }
 
     m_dockWinBehavior = dock;
     emit dockWinBehaviorChanged();
 }
 
 bool DockView::behaveAsPlasmaPanel() const
 {
     return m_behaveAsPlasmaPanel;
 }
 
 void DockView::setBehaveAsPlasmaPanel(bool behavior)
 {
     if (m_behaveAsPlasmaPanel == behavior) {
         return;
     }
 
     m_behaveAsPlasmaPanel = behavior;
 
     if (m_behaveAsPlasmaPanel && m_drawShadows) {
         PanelShadows::self()->addWindow(this, enabledBorders());
     } else {
         PanelShadows::self()->removeWindow(this);
         // m_enabledBorders = Plasma::FrameSvg::AllBorders;
         // emit enabledBordersChanged();
     }
 
     updateEffects();
     emit behaveAsPlasmaPanelChanged();
 }
 
 bool DockView::drawShadows() const
 {
     return m_drawShadows;
 }
 
 void DockView::setDrawShadows(bool draw)
 {
     if (m_drawShadows == draw) {
         return;
     }
 
     m_drawShadows = draw;
 
     if (m_behaveAsPlasmaPanel && m_drawShadows) {
         PanelShadows::self()->addWindow(this, enabledBorders());
     } else {
         PanelShadows::self()->removeWindow(this);
         //m_enabledBorders = Plasma::FrameSvg::AllBorders;
         //emit enabledBordersChanged();
     }
 
     emit drawShadowsChanged();
 }
 
 bool DockView::drawEffects() const
 {
     return m_drawEffects;
 }
 
 void DockView::setDrawEffects(bool draw)
 {
     if (m_drawEffects == draw) {
         return;
     }
 
     m_drawEffects = draw;
 
     emit drawEffectsChanged();
 }
 
 bool DockView::inEditMode() const
 {
     return m_inEditMode;
 }
 
 void DockView::setInEditMode(bool edit)
 {
     if (m_inEditMode == edit) {
         return;
     }
 
     m_inEditMode = edit;
 
     emit inEditModeChanged();
 }
 
 
 bool DockView::onPrimary() const
 {
     return m_onPrimary;
 }
 
 void DockView::setOnPrimary(bool flag)
 {
     if (m_onPrimary == flag) {
         return;
     }
 
     m_onPrimary = flag;
     emit onPrimaryChanged();
 }
 
 float DockView::maxLength() const
 {
     return m_maxLength;
 }
 
 void DockView::setMaxLength(float length)
 {
     if (m_maxLength == length) {
         return;
     }
 
     m_maxLength = length;
     emit maxLengthChanged();
 }
 
 int DockView::maxThickness() const
 {
     return m_maxThickness;
 }
 
 void DockView::setMaxThickness(int thickness)
 {
     if (m_maxThickness == thickness)
         return;
 
     m_maxThickness = thickness;
     syncGeometry();
     emit maxThicknessChanged();
 }
 
 int DockView::alignment() const
 {
     return m_alignment;
 }
 
 void DockView::setAlignment(int alignment)
 {
     Dock::Alignment align = static_cast<Dock::Alignment>(alignment);
 
     if (m_alignment == alignment) {
         return;
     }
 
     m_alignment = align;
     emit alignmentChanged();
 }
 
 bool DockView::blockAnimations() const
 {
     return m_blockAnimations;
 }
 
 void DockView::setBlockAnimations(bool block)
 {
     if (m_blockAnimations == block) {
         return;
     }
 
     m_blockAnimations = block;
     emit blockAnimationsChanged();
 }
 
 bool DockView::colorizerSupport() const
 {
     return m_colorizerSupport;
 }
 
 void DockView::setColorizerSupport(bool support)
 {
     if (m_colorizerSupport == support) {
         return;
     }
 
     m_colorizerSupport = support;
     emit colorizerSupportChanged();
 }
 
 QRect DockView::maskArea() const
 {
     return m_maskArea;
 }
 
 void DockView::setMaskArea(QRect area)
 {
     if (m_maskArea == area)
         return;
 
     m_maskArea = area;
 
     if (KWindowSystem::compositingActive()) {
         if (m_behaveAsPlasmaPanel) {
             setMask(QRect());
         } else {
             setMask(m_maskArea);
         }
     } else {
         //! this is used when compositing is disabled and provides
         //! the correct way for the mask to be painted in order for
         //! rounded corners to be shown correctly
         //! the enabledBorders check was added because there was cases
         //! that the mask region wasnt calculated correctly after location changes
         if (!m_background || m_background->enabledBorders() != enabledBorders()) {
             m_background = new Plasma::FrameSvg(this);
         }
 
         if (m_background->imagePath() != "opaque/dialogs/background") {
             m_background->setImagePath(QStringLiteral("opaque/dialogs/background"));
         }
 
         m_background->setEnabledBorders(enabledBorders());
         m_background->resizeFrame(area.size());
         QRegion fixedMask = m_background->mask();
         fixedMask.translate(m_maskArea.x(), m_maskArea.y());
 
         //! fix for KF5.32 that return empty QRegion's for the mask
         if (fixedMask.isEmpty()) {
             fixedMask = QRegion(m_maskArea);
         }
 
         setMask(fixedMask);
     }
 
     // qDebug() << "dock mask set:" << m_maskArea;
     emit maskAreaChanged();
 }
 
 
 QRect DockView::effectsArea() const
 {
     return m_effectsArea;
 }
 
 void DockView::setEffectsArea(QRect area)
 {
     QRect inWindowRect = area.intersected(QRect(0, 0, width(), height()));
 
     if (m_effectsArea == inWindowRect) {
         return;
     }
 
     m_effectsArea = inWindowRect;
     emit effectsAreaChanged();
 }
 
 QRect DockView::absGeometry() const
 {
     return m_absGeometry;
 }
 
 QRect DockView::screenGeometry() const
 {
     if (this->screen()) {
         QRect geom = this->screen()->geometry();
         return geom;
     }
 
     return QRect();
 }
 
 int DockView::offset() const
 {
     return m_offset;
 }
 
 void DockView::setOffset(int offset)
 {
     if (m_offset == offset) {
         return;
     }
 
     m_offset = offset;
     emit offsetChanged();
 }
 
 int DockView::dockTransparency() const
 {
     return m_dockTransparency;
 }
 
 void DockView::setDockTransparency(int transparency)
 {
     if (m_dockTransparency == transparency) {
         return;
     }
 
     m_dockTransparency = transparency;
     emit dockTransparencyChanged();
 }
 
 int DockView::shadow() const
 {
     return m_shadow;
 }
 
 void DockView::setShadow(int shadow)
 {
     if (m_shadow == shadow)
         return;
 
     m_shadow = shadow;
 
     if (m_behaveAsPlasmaPanel) {
         syncGeometry();
     }
 
     emit shadowChanged();
 }
 
 int DockView::fontPixelSize() const
 {
     return m_fontPixelSize;
 }
 
 void DockView::setFontPixelSize(int size)
 {
     if (m_fontPixelSize == size) {
         return;
     }
 
     m_fontPixelSize = size;
 
     emit fontPixelSizeChanged();
 }
 
 void DockView::applyActivitiesToWindows()
 {
     if (m_visibility) {
         QStringList activities = m_managedLayout->appliedActivities();
         m_visibility->setWindowOnActivities(*this, activities);
 
         if (m_configView) {
             m_visibility->setWindowOnActivities(*m_configView, activities);
 
             auto configView = qobject_cast<DockConfigView *>(m_configView);
 
             if (configView && configView->secondaryWindow()) {
                 m_visibility->setWindowOnActivities(*configView->secondaryWindow(), activities);
             }
         }
 
         if (m_visibility->supportsKWinEdges()) {
             m_visibility->applyActivitiesToHiddenWindows(activities);
         }
     }
 }
 
 Layout *DockView::managedLayout() const
 {
     return m_managedLayout;
 }
 
 void DockView::setManagedLayout(Layout *layout)
 {
     if (m_managedLayout == layout) {
         return;
     }
 
     // clear mode
     for (auto &c : connectionsManagedLayout) {
         disconnect(c);
     }
 
     m_managedLayout = layout;
 
     if (m_managedLayout) {
         //! Sometimes the activity isnt completely ready, by adding a delay
         //! we try to catch up
         QTimer::singleShot(100, [this]() {
             if (m_managedLayout && m_visibility) {
                 qDebug() << "DOCK VIEW FROM LAYOUT ::: " << m_managedLayout->name() << " - activities: " << m_managedLayout->appliedActivities();
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
     }
 
     DockCorona *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
     if (dockCorona->layoutManager()->memoryUsage() == Dock::MultipleLayouts) {
         connectionsManagedLayout[0] = connect(dockCorona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged, this, [&]() {
             if (m_managedLayout && m_visibility) {
                 qDebug() << "DOCK VIEW FROM LAYOUT (runningActivitiesChanged) ::: " << m_managedLayout->name()
                          << " - activities: " << m_managedLayout->appliedActivities();
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         connectionsManagedLayout[1] = connect(m_managedLayout, &Layout::activitiesChanged, this, [&]() {
             if (m_managedLayout) {
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         connectionsManagedLayout[2] = connect(dockCorona->layoutManager(), &LayoutManager::layoutsChanged, this, [&]() {
             if (m_managedLayout) {
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         //!IMPORTANT!!! ::: This fixes a bug when closing an Activity all docks from all Activities are
         //! disappearing! With this they reappear!!!
         connectionsManagedLayout[3] = connect(this, &QWindow::visibleChanged, this, [&]() {
             if (!isVisible() && m_managedLayout) {
                 QTimer::singleShot(100, [this]() {
                     if (m_managedLayout && containment() && !containment()->destroyed()) {
                         setVisible(true);
                         applyActivitiesToWindows();
                         emit activitiesChanged();
                     }
                 });
 
                 QTimer::singleShot(1500, [this]() {
                     if (m_managedLayout && containment() && !containment()->destroyed()) {
                         setVisible(true);
                         applyActivitiesToWindows();
                         emit activitiesChanged();
                     }
                 });
             }
         });
     }
 
     emit managedLayoutChanged();
 }
 
 void DockView::moveToLayout(QString layoutName)
 {
     if (!m_managedLayout) {
         return;
     }
 
     QList<Plasma::Containment *> containments = m_managedLayout->unassignFromLayout(this);
 
     DockCorona *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
     if (dockCorona && containments.size() > 0) {
         Layout *newLayout = dockCorona->layoutManager()->activeLayout(layoutName);
 
         if (newLayout) {
             newLayout->assignToLayout(this, containments);
         }
     }
 }
 
 bool DockView::inLocationChangeAnimation()
 {
     return ((m_goToLocation != Plasma::Types::Floating) || (m_moveToLayout != "") || m_goToScreen);
 }
 
 void DockView::hideDockDuringLocationChange(int goToLocation)
 {
     m_goToLocation = static_cast<Plasma::Types::Location>(goToLocation);
     emit hideDockDuringLocationChangeStarted();
 }
 
 void DockView::hideDockDuringMovingToLayout(QString layoutName)
 {
     m_moveToLayout = layoutName;
     emit hideDockDuringMovingToLayoutStarted();
 }
 
 void DockView::setBlockHiding(bool block)
 {
     if (!block) {
         auto *configView = qobject_cast<DockConfigView *>(m_configView);
 
         if (m_alternativesIsShown || (configView && configView->sticker() && configView->isVisible())) {
             return;
         }
 
         if (m_visibility) {
             m_visibility->setBlockHiding(false);
         }
     } else {
         if (m_visibility) {
             m_visibility->setBlockHiding(true);
         }
     }
 }
 
 void DockView::updateEffects()
 {
     //! Dont apply any effect before the wayland surface is created under wayland
     //! https://bugs.kde.org/show_bug.cgi?id=392890
     if (KWindowSystem::isPlatformWayland() && !m_shellSurface) {
         return;
     }
 
     if (!m_behaveAsPlasmaPanel) {
         if (m_drawEffects && !m_effectsArea.isNull() && !m_effectsArea.isEmpty()) {
             //! this is used when compositing is disabled and provides
             //! the correct way for the mask to be painted in order for
             //! rounded corners to be shown correctly
             if (!m_background) {
                 m_background = new Plasma::FrameSvg(this);
             }
 
             if (m_background->imagePath() != "widgets/panel-background") {
                 m_background->setImagePath(QStringLiteral("widgets/panel-background"));
             }
 
             m_background->setEnabledBorders(enabledBorders());
             m_background->resizeFrame(m_effectsArea.size());
             QRegion fixedMask = m_background->mask();
             fixedMask.translate(m_effectsArea.x(), m_effectsArea.y());
 
             //! fix1, for KF5.32 that return empty QRegion's for the mask
             if (fixedMask.isEmpty()) {
                 fixedMask = QRegion(m_effectsArea);
             }
 
             KWindowEffects::enableBlurBehind(winId(), true, fixedMask);
 
             bool drawBackgroundEffect = m_theme.backgroundContrastEnabled() && (m_dockTransparency == 100);
             //based on Breeze Dark theme behavior the enableBackgroundContrast even though it does accept
             //a QRegion it uses only the first rect. The bug was that for Breeze Dark there was a line
             //at the dock bottom that was distinguishing it from other themes
             KWindowEffects::enableBackgroundContrast(winId(), drawBackgroundEffect,
                     m_theme.backgroundContrast(),
                     m_theme.backgroundIntensity(),
                     m_theme.backgroundSaturation(),
                     fixedMask.boundingRect());
         } else {
             KWindowEffects::enableBlurBehind(winId(), false);
             KWindowEffects::enableBackgroundContrast(winId(), false);
         }
     } else if (m_behaveAsPlasmaPanel && m_drawEffects) {
         KWindowEffects::enableBlurBehind(winId(), true);
-        KWindowEffects::enableBackgroundContrast(winId(), m_theme.backgroundContrastEnabled(),
+
+        bool drawBackgroundEffect = m_theme.backgroundContrastEnabled() && (m_dockTransparency == 100);
+
+        KWindowEffects::enableBackgroundContrast(winId(), drawBackgroundEffect,
                 m_theme.backgroundContrast(),
                 m_theme.backgroundIntensity(),
                 m_theme.backgroundSaturation());
     } else {
         KWindowEffects::enableBlurBehind(winId(), false);
         KWindowEffects::enableBackgroundContrast(winId(), false);
     }
 }
 
 //! remove latte tasks plasmoid
 void DockView::removeTasksPlasmoid()
 {
     if (!tasksPresent() || !containment()) {
         return;
     }
 
     foreach (Plasma::Applet *applet, containment()->applets()) {
         KPluginMetaData meta = applet->kPackage().metadata();
 
         if (meta.pluginId() == "org.kde.latte.plasmoid") {
             QAction *closeApplet = applet->actions()->action(QStringLiteral("remove"));
 
             if (closeApplet) {
                 closeApplet->trigger();
                 //! remove only the first found
                 return;
             }
         }
     }
 }
 
 //! check if the tasks plasmoid exist in the dock
 bool DockView::tasksPresent()
 {
     if (!this->containment()) {
         return false;
     }
 
     foreach (Plasma::Applet *applet, this->containment()->applets()) {
         const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             return true;
         }
     }
 
     return false;
 }
 
 
 //! check if the tasks plasmoid exist in the dock
 bool DockView::latteTasksPresent()
 {
     if (!this->containment()) {
         return false;
     }
 
     foreach (Plasma::Applet *applet, this->containment()->applets()) {
         KPluginMetaData metadata = applet->pluginMetaData();
 
         if (metadata.pluginId() == "org.kde.latte.plasmoid") {
             return true;
         }
     }
 
     return false;
 }
 
 
 //!check if the plasmoid with _name_ exists in the midedata
 bool DockView::mimeContainsPlasmoid(QMimeData *mimeData, QString name)
 {
     if (!mimeData) {
         return false;
     }
 
     if (mimeData->hasFormat(QStringLiteral("text/x-plasmoidservicename"))) {
         QString data = mimeData->data(QStringLiteral("text/x-plasmoidservicename"));
         const QStringList appletNames = data.split('\n', QString::SkipEmptyParts);
 
         foreach (const QString &appletName, appletNames) {
             if (appletName == name)
                 return true;
         }
     }
 
     return false;
 }
 
 
 VisibilityManager *DockView::visibility() const
 {
     return m_visibility;
 }
 
 bool DockView::event(QEvent *e)
 {
     if (!m_inDelete) {
         emit eventTriggered(e);
 
         switch (e->type()) {
             case QEvent::Leave:
                 engine()->trimComponentCache();
                 break;
 
             case QEvent::PlatformSurface:
                 if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
                     switch (pe->surfaceEventType()) {
                         case QPlatformSurfaceEvent::SurfaceCreated:
                             setupWaylandIntegration();
 
                             if (m_shellSurface) {
                                 syncGeometry();
 
                                 if (m_drawShadows) {
                                     PanelShadows::self()->addWindow(this, enabledBorders());
                                 }
                             }
 
                             break;
 
                         case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                             if (m_shellSurface) {
                                 delete m_shellSurface;
                                 m_shellSurface = nullptr;
                                 qDebug() << "WAYLAND dock window surface was deleted...";
                                 PanelShadows::self()->removeWindow(this);
                             }
 
                             break;
                     }
                 }
 
                 break;
 
             default:
                 break;
         }
     }
 
     return ContainmentView::event(e);;
 }
 
 QList<int> DockView::freeEdges() const
 {
     if (!m_managedLayout) {
         const QList<int> emptyEdges;
         return emptyEdges;
     }
 
     const auto edges = m_managedLayout->freeEdges(screen());
     QList<int> edgesInt;
 
     foreach (Plasma::Types::Location edge, edges) {
         edgesInt.append(static_cast<int>(edge));
     }
 
     return edgesInt;
 }
 
 void DockView::deactivateApplets()
 {
     if (!containment()) {
         return;
     }
 
     foreach (auto applet, containment()->applets()) {
         PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (ai) {
             ai->setExpanded(false);
         }
     }
 }
 
 void DockView::toggleAppletExpanded(const int id)
 {
     if (!containment()) {
         return;
     }
 
     foreach (auto applet, containment()->applets()) {
         if (applet->id() == id) {
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 if (!ai->isActivationTogglesExpanded()) {
                     ai->setActivationTogglesExpanded(true);
                 }
 
                 emit applet->activated();
             }
         }
     }
 }
 
 QVariantList DockView::containmentActions()
 {
     QVariantList actions;
     /*if (containment()->corona()->immutability() != Plasma::Types::Mutable) {
         return actions;
     }*/
     //FIXME: the trigger string it should be better to be supported this way
     //const QString trigger = Plasma::ContainmentActions::eventToString(event);
     const QString trigger = "RightButton;NoModifier";
     Plasma::ContainmentActions *plugin = this->containment()->containmentActions().value(trigger);
 
     if (!plugin) {
         return actions;
     }
 
     if (plugin->containment() != this->containment()) {
         plugin->setContainment(this->containment());
         // now configure it
         KConfigGroup cfg(this->containment()->corona()->config(), "ActionPlugins");
         cfg = KConfigGroup(&cfg, QString::number(this->containment()->containmentType()));
         KConfigGroup pluginConfig = KConfigGroup(&cfg, trigger);
         plugin->restore(pluginConfig);
     }
 
     foreach (QAction *ac, plugin->contextualActions()) {
         actions << QVariant::fromValue<QAction *>(ac);
     }
 
     return actions;
 }
 
 
 //!BEGIN overriding context menus behavior
 void DockView::mousePressEvent(QMouseEvent *event)
 {
     bool result = m_menuManager->mousePressEvent(event);
     emit contextMenuIsShownChanged();
 
     if (result) {
         PlasmaQuick::ContainmentView::mousePressEvent(event);
     }
 }
 //!END overriding context menus behavior
 
 //!BEGIN draw panel shadows outside the dock window
 Plasma::FrameSvg::EnabledBorders DockView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void DockView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (location()) {
         case Plasma::Types::TopEdge:
             borders &= ~Plasma::FrameSvg::TopBorder;
             break;
 
         case Plasma::Types::LeftEdge:
             borders &= ~Plasma::FrameSvg::LeftBorder;
             break;
 
         case Plasma::Types::RightEdge:
             borders &= ~Plasma::FrameSvg::RightBorder;
             break;
 
         case Plasma::Types::BottomEdge:
             borders &= ~Plasma::FrameSvg::BottomBorder;
             break;
 
         default:
             break;
     }
 
     if ((location() == Plasma::Types::LeftEdge || location() == Plasma::Types::RightEdge)) {
         if (maxLength() == 1 && m_alignment == Dock::Justify && !m_forceDrawCenteredBorders) {
             borders &= ~Plasma::FrameSvg::TopBorder;
             borders &= ~Plasma::FrameSvg::BottomBorder;
         }
 
         if (m_alignment == Dock::Top && !m_forceDrawCenteredBorders && m_offset == 0) {
             borders &= ~Plasma::FrameSvg::TopBorder;
         }
 
         if (m_alignment == Dock::Bottom && !m_forceDrawCenteredBorders && m_offset == 0) {
             borders &= ~Plasma::FrameSvg::BottomBorder;
         }
     }
 
     if (location() == Plasma::Types::TopEdge || location() == Plasma::Types::BottomEdge) {
         if (maxLength() == 1 && m_alignment == Dock::Justify) {
             borders &= ~Plasma::FrameSvg::LeftBorder;
             borders &= ~Plasma::FrameSvg::RightBorder;
         }
 
         if (m_alignment == Dock::Left && m_offset == 0) {
             borders &= ~Plasma::FrameSvg::LeftBorder;
         }
 
         if (m_alignment == Dock::Right  && m_offset == 0) {
             borders &= ~Plasma::FrameSvg::RightBorder;
         }
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
         emit enabledBordersChanged();
     }
 
     if (!m_behaveAsPlasmaPanel || !m_drawShadows) {
         PanelShadows::self()->removeWindow(this);
     } else {
         PanelShadows::self()->setEnabledBorders(this, borders);
     }
 }
 
 //!END draw panel shadows outside the dock window
 
 //!BEGIN configuration functions
 void DockView::saveConfig()
 {
     if (!this->containment())
         return;
 
     auto config = this->containment()->config();
     config.writeEntry("onPrimary", m_onPrimary);
     config.writeEntry("dockWindowBehavior", m_dockWinBehavior);
     config.sync();
 }
 
 void DockView::restoreConfig()
 {
     if (!this->containment())
         return;
 
     auto config = this->containment()->config();
     setOnPrimary(config.readEntry("onPrimary", true));
     setDockWinBehavior(config.readEntry("dockWindowBehavior", true));
 }
 //!END configuration functions
 
 }
 //!END namespace
diff --git a/containment/package/contents/ui/PanelBox.qml b/containment/package/contents/ui/PanelBox.qml
index 5d880d16..9d57cb8e 100644
--- a/containment/package/contents/ui/PanelBox.qml
+++ b/containment/package/contents/ui/PanelBox.qml
@@ -1,707 +1,713 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.1
 import QtQuick.Layouts 1.1
 import QtQuick.Window 2.2
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 
 import org.kde.latte 0.1 as Latte
 
 Item{
     id:barLine
 
     width: root.isHorizontal ? panelWidth : smallSize
     height: root.isVertical ? panelHeight : smallSize
 
     opacity: root.useThemePanel ? 1 : 0
 
     property int animationTime: 6*root.durationTime*units.shortDuration
 
     property int lengthMargins: {
         return root.isVertical ? shadowsSvgItem.marginsHeight : shadowsSvgItem.marginsWidth
     }
 
     property int panelWidth: {
         if (root.behaveAsPlasmaPanel && !root.editMode) {
             return root.width;
         } else {
             if ((root.panelAlignment === Latte.Dock.Justify) && root.isHorizontal) {
                 return root.maxLength;
             } else {
                 return layoutsContainer.mainLayout.width + spacing;
             }
         }
     }
 
     property int panelHeight: {
         if (root.behaveAsPlasmaPanel && !root.editMode) {
             return root.height;
         } else {
             if ((root.panelAlignment === Latte.Dock.Justify) && root.isVertical) {
                 return root.maxLength;
             } else {
                 return layoutsContainer.mainLayout.height + spacing;
             }
         }
     }
 
     property int spacing: {
         if (!Latte.WindowSystem.compositingActive) {
             return 0;
         } else if (root.panelAlignment === Latte.Dock.Justify && plasmoid.configuration.maxLength === 100) {
             return 0;
         } else if (root.panelAlignment === Latte.Dock.Center || root.panelAlignment === Latte.Dock.Justify || root.offset!==0) {
             return root.panelEdgeSpacing/2;
         } else {
             return root.panelEdgeSpacing/4;
         }
     }
     property int smallSize: Math.max(3.7*root.statesLineSize, 16)
 
     Behavior on opacity{
         enabled: Latte.WindowSystem.compositingActive
         NumberAnimation {
             duration: barLine.animationTime
         }
     }
 
     Behavior on opacity{
         enabled: !Latte.WindowSystem.compositingActive
         NumberAnimation {
             duration: 0
         }
     }
 
     Binding {
         target: root
         property: "realPanelLength"
         value: root.isVertical ? barLine.height : barLine.width
     }
 
     Binding {
         target: root
         property: "totalPanelEdgeSpacing"
         value: spacing
     }
 
     onXChanged: solidBackground.updateEffectsArea();
     onYChanged: solidBackground.updateEffectsArea();
 
     /// plasmoid's default panel
     /*  BorderImage{
             anchors.fill:parent
             source: "../images/panel-west.png"
             border { left:8; right:8; top:8; bottom:8 }
 
             opacity: (!root.useThemePanel) ? 1 : 0
 
             visible: (opacity == 0) ? false : true
 
             horizontalTileMode: BorderImage.Stretch
             verticalTileMode: BorderImage.Stretch
 
             Behavior on opacity{
                 NumberAnimation { duration: 200 }
             }
         }*/
 
     /// the current theme's panel
     PlasmaCore.FrameSvgItem{
         id: shadowsSvgItem
 
         width: root.isVertical ? panelSize + marginsWidth - (solidBackground.leftIncreaser + solidBackground.rightIncreaser) :
                                  Math.min(parent.width + marginsWidth, root.width - marginsWidth)
         height: root.isVertical ? Math.min(parent.height + marginsHeight, root.height - marginsHeight) :
                                   panelSize + marginsHeight - (solidBackground.topIncreaser + solidBackground.bottomIncreaser)
 
         imagePath: root.behaveAsPlasmaPanel || !Latte.WindowSystem.compositingActive || !root.panelShadowsActive ? "" : "widgets/panel-background"
         prefix: root.behaveAsPlasmaPanel || !Latte.WindowSystem.compositingActive || !root.panelShadowsActive ? "" : "shadow"
 
         visible: (opacity == 0) ? false : true
 
         opacity: {
             if (root.forceTransparentPanel || !root.useThemePanel)
                 return 0;
             else
                 return 1;
         }
 
         enabledBorders: dock ? dock.enabledBorders : PlasmaCore.FrameSvg.NoBorder
 
         Behavior on opacity {
             enabled: Latte.WindowSystem.compositingActive
             NumberAnimation { duration: barLine.animationTime }
         }
 
 
         Behavior on opacity{
             enabled: !Latte.WindowSystem.compositingActive
             NumberAnimation { duration: 0 }
         }
 
         property int marginsWidth: {
             if (imagePath === "") {
                 return 0;
             } else {
                 if (root.panelAlignment === Latte.Dock.Left && root.offset===0)
                     return margins.right;
                 else if (root.panelAlignment === Latte.Dock.Right && root.offset===0)
                     return margins.left;
                 else
                     return margins.left+margins.right;
             }
         }
 
         property int marginsHeight: {
             if (imagePath === "") {
                 return 0;
             } else {
                 if (root.panelAlignment === Latte.Dock.Top && root.offset===0)
                     return margins.bottom;
                 else if (root.panelAlignment === Latte.Dock.Bottom && root.offset===0)
                     return margins.top;
                 else
                     return margins.top + margins.bottom;
             }
         }
 
         property int panelSize: automaticPanelSize
         property int automaticPanelSize: {
             if (root.behaveAsPlasmaPanel) {
                 return root.statesLineSize + root.iconSize + root.thickMargin;
             } else {
                 var icons = root.statesLineSize + root.iconSize + root.thickMargin + 1;
                 var panels = root.themePanelSize + root.panelMargin;
 
                 root.realPanelThickness = icons;
                 if (icons > panels) {
                     return panels;
                 } else {
                     return icons;
                 }
             }
         }
 
         property int shadowsSize: 0
 
         Binding{
             target: shadowsSvgItem
             property: "shadowsSize"
             value:{
                 if (shadowsSvgItem && !root.behaveAsPlasmaPanel && root.useThemePanel && root.panelShadowsActive){
                     if (root.isVertical){
                         if (plasmoid.location === PlasmaCore.Types.LeftEdge)
                             return shadowsSvgItem.margins.right;
                         else if (plasmoid.location === PlasmaCore.Types.RightEdge)
                             return shadowsSvgItem.margins.left;
                     } else {
                         if (plasmoid.location === PlasmaCore.Types.BottomEdge)
                             return shadowsSvgItem.margins.top;
                         else if (plasmoid.location === PlasmaCore.Types.TopEdge)
                             return shadowsSvgItem.margins.bottom;
                     }
                 } else {
                     return 0;
                 }
             }
         }
 
         Behavior on opacity{
             enabled: Latte.WindowSystem.compositingActive
             NumberAnimation { duration: barLine.animationTime }
         }
 
         Behavior on opacity{
             enabled: !Latte.WindowSystem.compositingActive
             NumberAnimation { duration: 0 }
         }
 
         Binding {
             target: root
             property: "panelShadow"
             when: shadowsSvgItem
             value: shadowsSvgItem.shadowsSize
         }
 
         Binding {
             target: root
             property: "realPanelSize"
             when: shadowsSvgItem
             value: shadowsSvgItem.panelSize
         }
 
         Binding {
             target: root
             property: "panelMarginLength"
             when: shadowsSvgItem
             value: root.isVertical ? shadowsSvgItem.marginsHeight : shadowsSvgItem.marginsWidth
         }
 
         //! This is used to provide real solidness without any transparency from the plasma theme
         Rectangle{
             id: solidBackgroundRectangle
             anchors.fill: solidBackground
             color: theme.backgroundColor
             opacity: behaveAsPlasmaPanel && solidBackground.forceSolidness && plasmoid.configuration.maxLength === 100 ? 1 : 0
 
             Behavior on opacity{
                 enabled: Latte.WindowSystem.compositingActive
                 NumberAnimation { duration: 2 * barLine.animationTime }
             }
 
             Behavior on opacity{
                 enabled: !Latte.WindowSystem.compositingActive
                 NumberAnimation { duration: 0 }
             }
         }
 
         PlasmaCore.FrameSvgItem{
             id: solidBackground
             anchors.leftMargin: Latte.WindowSystem.compositingActive ? shadowsSvgItem.margins.left - leftIncreaser : 0
             anchors.rightMargin: Latte.WindowSystem.compositingActive ? shadowsSvgItem.margins.right - rightIncreaser : 0
             anchors.topMargin: Latte.WindowSystem.compositingActive ? shadowsSvgItem.margins.top - topIncreaser : 0
             anchors.bottomMargin: Latte.WindowSystem.compositingActive ? shadowsSvgItem.margins.bottom - bottomIncreaser : 0
             anchors.fill:parent
 
             opacity: {
                 if (forceSolidness) {
                     return 1;
                 } else if (!plasmoid.configuration.useThemePanel && plasmoid.configuration.solidBackgroundForMaximized) {
                     return 0;
                 } else {
                     return plasmoid.configuration.panelTransparency / 100;
                 }
             }
 
             readonly property bool forceSolidness: (root.solidPanel && !plasmoid.configuration.solidBackgroundForMaximized) || root.forceSolidPanel
                                                    || !Latte.WindowSystem.compositingActive
 
             property rect efGeometry: Qt.rect(-1,-1,0,0)
 
             imagePath: root.solidPanel ? "opaque/dialogs/background" : "widgets/panel-background"
 
             onWidthChanged: updateEffectsArea();
             onHeightChanged: updateEffectsArea();
 
             Component.onCompleted: root.updateEffectsArea.connect(updateEffectsArea);
             Component.onDestruction: root.updateEffectsArea.disconnect(updateEffectsArea);
 
+            Binding{
+                target: root
+                property: "currentPanelTransparency"
+                value: solidBackground.opacity * 100
+            }
+
             Connections{
                 target: root
 
                 onEditModeChanged: {
                     if (!root.editMode){
                         solidBackground.updateEffectsArea();
                     }
                 }
             }
 
             //! Fix for FrameSvgItem QML version not updating its margins after a theme change
             //! with this hack we enforce such update. I could use the repaintNeeded signal but
             //! it is called more often than the themeChanged one.
             Connections{
                 target: dock
                 onThemeChanged: {
                     plasmoid.configuration.panelShadows = !plasmoid.configuration.panelShadows;
                     plasmoid.configuration.panelShadows = !plasmoid.configuration.panelShadows;
                     updateEffectsArea();
                 }
             }
 
             function updateEffectsArea(){
                 if (!dock || root.editMode)
                     return;
 
                 var rootGeometry = mapToItem(root, 0, 0);
 
                 efGeometry.x = rootGeometry.x;
                 efGeometry.y = rootGeometry.y;
                 efGeometry.width = width;
                 efGeometry.height = height;
 
                 dock.effectsArea = efGeometry;
 
                 if (!Latte.WindowSystem.compositingActive) {
                     visibilityManager.updateMaskArea();
                 }
             }
 
             //! the increases used when the user forces a solid background and the background
             //! must be increased in order to look ok in the corners
             property int rightIncreaser: {
                 if (!(root.solidPanel && root.isVertical && plasmoid.location === PlasmaCore.Types.LeftEdge)
                         || !Latte.WindowSystem.compositingActive)
                     return 0;
                 else
                     return hiddenPanelBackground.margins.right;
             }
 
             property int leftIncreaser: {
                 if (!(root.solidPanel && root.isVertical && plasmoid.location === PlasmaCore.Types.RightEdge)
                         || !Latte.WindowSystem.compositingActive)
                     return 0;
                 else
                     return hiddenPanelBackground.margins.left;
             }
 
             property int topIncreaser: {
                 if (!(root.solidPanel && root.isVertical && plasmoid.location === PlasmaCore.Types.BottomEdge)
                         || !Latte.WindowSystem.compositingActive)
                     return 0;
                 else
                     return hiddenPanelBackground.margins.top;
             }
 
             property int bottomIncreaser: {
                 if (!(root.solidPanel && root.isVertical && plasmoid.location === PlasmaCore.Types.TopEdge)
                         || !Latte.WindowSystem.compositingActive)
                     return 0;
                 else
                     return hiddenPanelBackground.margins.bottom;
             }
 
 
             Binding {
                 target: root
                 property: "panelMargin"
                 value: {
                     if (root.useThemePanel){
                         if (root.isVertical){
                             if (plasmoid.location === PlasmaCore.Types.LeftEdge)
                                 return solidBackground.margins.right;
                             else if (plasmoid.location === PlasmaCore.Types.RightEdge)
                                 return solidBackground.margins.left;
                         } else {
                             if (plasmoid.location === PlasmaCore.Types.BottomEdge)
                                 return solidBackground.margins.top;
                             else if (plasmoid.location === PlasmaCore.Types.TopEdge)
                                 return solidBackground.margins.bottom;
                         }
                     }
                 }
             }
 
             onRepaintNeeded: {
                 if (root.behaveAsPlasmaPanel)
                     adjustPrefix();
             }
 
             enabledBorders: dock ? dock.enabledBorders : PlasmaCore.FrameSvg.NoBorder
 
             Behavior on opacity{
                 enabled: Latte.WindowSystem.compositingActive
                 NumberAnimation { duration: barLine.animationTime }
             }
 
             Behavior on opacity{
                 enabled: !Latte.WindowSystem.compositingActive
                 NumberAnimation { duration: 0 }
             }
 
             function adjustPrefix() {
                 if (!plasmoid) {
                     return "";
                 }
                 var pre;
                 switch (plasmoid.location) {
                 case PlasmaCore.Types.LeftEdge:
                     pre = "west";
                     break;
                 case PlasmaCore.Types.TopEdge:
                     pre = "north";
                     break;
                 case PlasmaCore.Types.RightEdge:
                     pre = "east";
                     break;
                 case PlasmaCore.Types.BottomEdge:
                     pre = "south";
                     break;
                 default:
                     prefix = "";
                 }
                 if (hasElementPrefix(pre)) {
                     prefix = pre;
                 } else {
                     prefix = "";
                 }
             }
         }
 
         PlasmaCore.FrameSvgItem{
             id: hiddenPanelBackground
             imagePath: "widgets/panel-background"
             visible: false
         }
     }
 
     transitions: Transition {
         enabled: editModeVisual.plasmaEditMode
         AnchorAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     //BEGIN states
     //user set Panel Positions
     //0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Left
         State {
             name: "leftCenterOrJustify"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === Latte.Dock.Center || root.panelAlignment === Latte.Dock.Justify)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: (root.panelAlignment === Latte.Dock.Center ? root.offset : 0);
             }
         },
         ///Left
         State {
             name: "leftTop"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === Latte.Dock.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:root.offset;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Left
         State {
             name: "leftBottom"
             when: (plasmoid.location === PlasmaCore.Types.LeftEdge)&&(root.panelAlignment === Latte.Dock.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:root.offset;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Right
         State {
             name: "rightCenterOrJustify"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === Latte.Dock.Center || root.panelAlignment === Latte.Dock.Justify)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: (root.panelAlignment === Latte.Dock.Center ? root.offset : 0);
             }
         },
         State {
             name: "rightTop"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === Latte.Dock.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:root.offset;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "rightBottom"
             when: (plasmoid.location === PlasmaCore.Types.RightEdge)&&(root.panelAlignment === Latte.Dock.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined }
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:root.offset;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Bottom
         State {
             name: "bottomCenterOrJustify"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)&&(root.panelAlignment === Latte.Dock.Center || root.panelAlignment === Latte.Dock.Justify)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: (root.panelAlignment === Latte.Dock.Center ? root.offset : 0); anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "bottomLeft"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
                   &&(((root.panelAlignment === Latte.Dock.Left)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      || ((root.panelAlignment === Latte.Dock.Right)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: root.offset;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
 
         },
         State {
             name: "bottomRight"
             when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
                   &&(((root.panelAlignment === Latte.Dock.Right)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      ||((root.panelAlignment === Latte.Dock.Left)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:root.offset;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         ///Top
         State {
             name: "topCenterOrJustify"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)&&(root.panelAlignment === Latte.Dock.Center || root.panelAlignment === Latte.Dock.Justify)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: (root.panelAlignment === Latte.Dock.Center ? root.offset : 0); anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "topLeft"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
                   &&(((root.panelAlignment === Latte.Dock.Left)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      || ((root.panelAlignment === Latte.Dock.Right)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: root.offset;    anchors.rightMargin:0;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         },
         State {
             name: "topRight"
             when: (plasmoid.location === PlasmaCore.Types.TopEdge)
                   &&(((root.panelAlignment === Latte.Dock.Right)&&(Qt.application.layoutDirection !== Qt.RightToLeft))
                      ||((root.panelAlignment === Latte.Dock.Left)&&(Qt.application.layoutDirection === Qt.RightToLeft)))
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: shadowsSvgItem
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             PropertyChanges{
                 target: barLine
                 anchors.leftMargin: 0;    anchors.rightMargin:root.offset;     anchors.topMargin:0;    anchors.bottomMargin:0;
                 anchors.horizontalCenterOffset: 0; anchors.verticalCenterOffset: 0;
             }
         }
     ]
     //END states
 }
 
 
diff --git a/containment/package/contents/ui/VisibilityManager.qml b/containment/package/contents/ui/VisibilityManager.qml
index bc86340c..23ecc822 100644
--- a/containment/package/contents/ui/VisibilityManager.qml
+++ b/containment/package/contents/ui/VisibilityManager.qml
@@ -1,657 +1,657 @@
 /*
 *  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.1 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.themePanelSize >= root.iconSize)
 
     property int animationSpeed: Latte.WindowSystem.compositingActive ? root.durationTime * 1.2 * 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 statesLineSizeOriginal: root.latteApplet ? Math.ceil( root.maxIconSize/13 ) : 0
     property int thickReverseAndGlowExtraSize: (root.reverseLinesPosition && root.showGlow && !behaveAsPlasmaPanel) ? 2*statesLineSize : 0;
     property int thickReverseAndGlowExtraSizeOriginal: Math.ceil(2*root.maxIconSize/13 )
 
     property int thicknessAutoHidden: Latte.WindowSystem.compositingActive ?  2 : 1
     property int thicknessMid: root.statesLineSize + (1 + (0.65 * (root.zoomFactor-1)))*(root.iconSize+root.thickMargin + thickReverseAndGlowExtraSize) //needed in some animations
     property int thicknessNormal: Math.max(root.statesLineSize + root.iconSize + root.thickMargin + thickReverseAndGlowExtraSize +1,
                                            root.realPanelSize + root.panelShadow)
     property int thicknessZoom: root.statesLineSize + ((root.iconSize+root.thickMargin + thickReverseAndGlowExtraSize) * root.zoomFactor) + 2
     //it is used to keep thickness solid e.g. when iconSize changes from auto functions
     property int thicknessMidOriginal: Math.max(thicknessNormalOriginal, statesLineSizeOriginal + thickReverseAndGlowExtraSizeOriginal + (1 + (0.65 * (root.zoomFactor-1)))*(root.maxIconSize+root.thickMarginOriginal)) //needed in some animations
     property int thicknessNormalOriginal: !root.behaveAsPlasmaPanel || root.editMode ?
                                               thicknessNormalOriginalValue : root.realPanelSize + root.panelShadow
 
     property int thicknessNormalOriginalValue: statesLineSizeOriginal + thickReverseAndGlowExtraSizeOriginal +
                                                root.maxIconSize + root.thickMarginOriginal + 1
     property int thicknessZoomOriginal: Math.max(statesLineSizeOriginal + thickReverseAndGlowExtraSizeOriginal
                                                  + ((root.maxIconSize+root.thickMarginOriginal) * root.zoomFactor) + 2,
                                                  root.realPanelSize + root.panelShadow,
                                                  thicknessEditMode)
 
     property int thicknessEditMode: thicknessNormalOriginalValue + theme.defaultFont.pixelSize + root.editShadow
 
     Binding{
         target: dock
         property:"maxThickness"
         //! prevents updating window geometry during closing window in wayland and such fixes a crash
         when: dock && !inTempHiding && !inForceHiding
         value: thicknessZoomOriginal
     }
 
     Binding{
         target: dock
         property:"normalThickness"
         when: dock
         value: thicknessNormalOriginal
     }
 
     Binding{
         target: dock
         property: "behaveAsPlasmaPanel"
         when: dock
         value: root.editMode ? false : root.behaveAsPlasmaPanel
     }
 
     Binding{
         target: dock
         property: "colorizerSupport"
         when: dock
         value: root.forceColorizer && plasmoid.configuration.solidBackgroundForMaximized
     }
 
     Binding{
         target: dock
         property: "dockTransparency"
         when: dock
-        value: root.panelTransparency
+        value: root.currentPanelTransparency
     }
 
     Binding{
         target: dock
         property: "drawShadows"
         when: dock
         value: root.drawShadowsExternal && (!root.inStartup || inForceHiding || inTempHiding)
     }
 
     Binding{
         target: dock
         property: "drawEffects"
         when: dock
         value: Latte.WindowSystem.compositingActive &&
                (((root.blurEnabled && root.useThemePanel)
                  || (root.blurEnabled && root.forceSolidPanel && dock.visibility.existsWindowMaximized && Latte.WindowSystem.compositingActive))
                 && (!root.inStartup || inForceHiding || inTempHiding))
     }
 
     Binding{
         target: dock
         property: "fontPixelSize"
         when: theme
         value: theme.defaultFont.pixelSize
     }
 
     Binding{
         target: dock
         property:"inEditMode"
         when: dock
         value: root.editMode
     }
 
     Binding{
         target: dock
         property:"shadow"
         when: dock
         value: root.panelShadow
     }
 
     Binding{
         target: dock
         property: "maxLength"
         when: dock
         value: root.editMode ? 1 : plasmoid.configuration.maxLength/100
     }
 
 
     Binding{
         target: dock
         property: "offset"
         when: dock
         value: plasmoid.configuration.offset
     }
 
     Binding{
         target: dock
         property: "alignment"
         when: dock
         value: root.panelAlignment
     }
 
     Binding{
         target: dock && dock.visibility ? dock.visibility : null
         property: "enabledDynamicBackground"
         when: dock && dock.visibility
         value: (root.backgroundOnlyOnMaximized
                 || plasmoid.configuration.solidBackgroundForMaximized
                 || root.disablePanelShadowMaximized)
                && Latte.WindowSystem.compositingActive
     }
 
     Connections{
         target:root
         onPanelShadowChanged: updateMaskArea();
         onPanelMarginChanged: updateMaskArea();
     }
 
     Connections{
         target: universalLayoutManager
         onCurrentLayoutIsSwitching: {
             if (Latte.WindowSystem.compositingActive && root.dockManagedLayout && root.dockManagedLayout.name === layoutName) {
                 manager.inTempHiding = true;
                 manager.inForceHiding = true;
                 root.clearZoom();
                 manager.slotMustBeHide();
             }
         }
     }
 
     onNormalStateChanged: {
         if (normalState) {
             root.updateAutomaticIconSize();
             root.updateSizeForAppletsInFill();
         }
     }
 
     onThicknessZoomOriginalChanged: {
         updateMaskArea();
     }
 
     function slotContainsMouseChanged() {
         if(dock.visibility.containsMouse) {
             updateMaskArea();
         }
     }
 
     function slotMustBeShown() {
         //  console.log("show...");
         if (!slidingAnimationAutoHiddenIn.running && !inTempHiding && !inForceHiding){
             slidingAnimationAutoHiddenIn.init();
         }
     }
 
     function slotMustBeHide() {
         //! prevent sliding-in on startup if the dodge modes have sent a hide signal
         if (inStartupTimer.running && root.inStartup) {
             root.inStartup = false;
         }
 
         // console.log("hide....");
         if((!slidingAnimationAutoHiddenOut.running && !dock.visibility.blockHiding
             && !dock.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;
         dock.hideDockDuringLocationChangeFinished();
     }
 
     ///test maskArea
     function updateMaskArea() {
         if (!dock || blockUpdateMask) {
             return;
         }
 
         var localX = 0;
         var localY = 0;
 
         normalState = ((root.animationsNeedBothAxis === 0) && (root.animationsNeedLength === 0))
                 || (dock.visibility.isHidden && !dock.visibility.containsMouse && root.animationsNeedThickness == 0);
 
         // debug maskArea criteria
         if (debugMagager) {
             console.log(root.animationsNeedBothAxis + ", " + root.animationsNeedLength + ", " +
                         root.animationsNeedThickness + ", " + dock.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;
         }
 
         if (Latte.WindowSystem.compositingActive) {
             if (normalState) {
                 //console.log("entered normal state...");
                 //count panel length
 
                 var noCompositingEdit = !Latte.WindowSystem.compositingActive && root.editMode;
                 //used when !compositing and in editMode
                 if (noCompositingEdit) {
                     tempLength = root.isHorizontal ? root.width : root.height;
                 } else {
                     if(root.isHorizontal) {
                         tempLength = plasmoid.configuration.panelPosition === Latte.Dock.Justify ?
                                     layoutsContainer.width + space : layoutsContainer.mainLayout.width + space;
                     } else {
                         tempLength = plasmoid.configuration.panelPosition === Latte.Dock.Justify ?
                                     layoutsContainer.height + space : layoutsContainer.mainLayout.height + space;
                     }
                 }
 
                 tempThickness = thicknessNormal;
 
                 if (root.animationsNeedThickness > 0) {
                     tempThickness = Latte.WindowSystem.compositingActive ? thicknessZoom : thicknessNormal;
                 }
 
                 if (dock.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 = dock.visibility.isHidden && dock.visibility.supportsKWinEdges ?
                                     dock.height + tempThickness : dock.height - tempThickness;
                     } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                         localY = dock.visibility.isHidden && dock.visibility.supportsKWinEdges ?
                                     -tempThickness : 0;
                     }
 
                     if (noCompositingEdit) {
                         localX = 0;
                     } else if (plasmoid.configuration.panelPosition === Latte.Dock.Justify) {
                         localX = (dock.width/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Dock.Left) {
                         localX = root.offset;
                     } else if (root.panelAlignment === Latte.Dock.Center) {
                         localX = (dock.width/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Dock.Right) {
                         localX = dock.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 = dock.visibility.isHidden && dock.visibility.supportsKWinEdges ?
                                     -tempThickness : 0;
                     } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                         localX = dock.visibility.isHidden && dock.visibility.supportsKWinEdges ?
                                     dock.width + tempThickness : dock.width - tempThickness;
                     }
 
                     if (noCompositingEdit) {
                         localY = 0;
                     } else if (plasmoid.configuration.panelPosition === Latte.Dock.Justify) {
                         localY = (dock.height/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Dock.Top) {
                         localY = root.offset;
                     } else if (root.panelAlignment === Latte.Dock.Center) {
                         localY = (dock.height/2) - tempLength/2 + root.offset;
                     } else if (root.panelAlignment === Latte.Dock.Bottom) {
                         localY = dock.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 ? thicknessNormalOriginal + theme.defaultFont.pixelSize + root.editShadow :
                                                                         thicknessNormalOriginal + theme.defaultFont.pixelSize
 
                     if (dock.visibility.isHidden && !slidingAnimationAutoHiddenOut.running ) {
                         tempThickness = thicknessAutoHidden;
                     } else if (root.animationsNeedThickness > 0) {
                         tempThickness = thicknessZoomOriginal;
                     }
                 } else{
                     //use all thickness space
                     if (dock.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,dock.width - tempThickness);
                 else if(plasmoid.location === PlasmaCore.Types.BottomEdge)
                     localY = Math.max(0,dock.height - tempThickness);
             }
         } // end of compositing calculations
 
         var maskArea = dock.maskArea;
 
         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 {
             //! no compositing case
             if (!dock.visibility.isHidden || !dock.visibility.supportsKWinEdges) {
                 localX = dock.effectsArea.x;
                 localY = dock.effectsArea.y;
             } else {
                 if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                     localX = dock.effectsArea.x;
                     localY = dock.effectsArea.y+dock.effectsArea.height+thicknessAutoHidden;
                 } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                     localX = dock.effectsArea.x;
                     localY = dock.effectsArea.y - thicknessAutoHidden;
                 } else if (plasmoid.location === PlasmaCore.Types.LeftEdge) {
                     localX = dock.effectsArea.x - thicknessAutoHidden;
                     localY = dock.effectsArea.y;
                 } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                     localX = dock.effectsArea.x + dock.effectsArea.width + 1;
                     localY = dock.effectsArea.y;
                 }
             }
 
             if (root.isHorizontal) {
                 tempThickness = dock.effectsArea.height;
                 tempLength = dock.effectsArea.width;
             } else {
                 tempThickness = dock.effectsArea.width;
                 tempLength = dock.effectsArea.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) {
                 dock.maskArea = newMaskArea;//dock.effectsArea;
             } else {
                 if (dock.behaveAsPlasmaPanel && !root.editMode) {
                     dock.maskArea = Qt.rect(0,0,root.width,root.height);
                 } else {
                     dock.maskArea = newMaskArea;
                 }
             }
         }
 
         //console.log("reached updating geometry ::: "+dock.maskArea);
         if(normalState){
 
             var tempGeometry = Qt.rect(dock.maskArea.x, dock.maskArea.y, dock.maskArea.width, dock.maskArea.height);
 
             //the shadows size must be removed from the maskArea
             //before updating the localDockGeometry
             if ((!dock.behaveAsPlasmaPanel || root.editMode)
                     && Latte.WindowSystem.compositingActive) {
                 var fixedThickness = root.realPanelThickness;
 
                 if (plasmoid.formFactor === PlasmaCore.Types.Vertical) {
                     tempGeometry.width = fixedThickness;
                 } else {
                     tempGeometry.height = fixedThickness;
                 }
 
                 if (plasmoid.location === PlasmaCore.Types.BottomEdge) {
                     tempGeometry.y = dock.height - fixedThickness;
                 } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                     tempGeometry.x = dock.width - fixedThickness;
                 }
 
                 //set the boundaries for dock local geometry
                 //qBound = qMax(min, qMin(value, max)).
                 tempGeometry.x = Math.max(0, Math.min(tempGeometry.x, dock.width));
                 tempGeometry.y = Math.max(0, Math.min(tempGeometry.y, dock.height));
                 tempGeometry.width = Math.min(tempGeometry.width, dock.width);
                 tempGeometry.height = Math.min(tempGeometry.height, dock.height);
             }
 
             //console.log("update geometry ::: "+tempGeometry);
             if (!Latte.WindowSystem.compositingActive) {
                 dock.localGeometry = dock.effectsArea;
             } else {
                 dock.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: dock ? dock.maskArea.x : -1
                 y: dock ? dock.maskArea.y : -1
                 height: dock ? dock.maskArea.height : 0
                 width: dock ? dock.maskArea.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"
             to: {
                 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: {
                 dock.visibility.isHidden = true;
             }
         }
 
         onStarted: {
             if (manager.debugMagager) {
                 console.log("hiding animation started...");
             }
         }
 
         onStopped: {
             dock.visibility.isHidden = true;
 
             if (manager.debugMagager) {
                 console.log("hiding animation ended...");
             }
 
             if (!manager.inTempHiding) {
                 updateMaskArea();
             } else if (plasmoid.configuration.durationTime === 0) {
                 sendHideDockDuringLocationChangeFinished();
             }
         }
 
         function init() {
             if (!dock.visibility.blockHiding)
                 start();
         }
     }
 
     SequentialAnimation{
         id: slidingAnimationAutoHiddenIn
 
         PauseAnimation{
             duration: manager.inTempHiding && root.durationTime>0 ? 500 : 0
         }
 
         PropertyAnimation {
             target: layoutsContainer
             property: root.isVertical ? "x" : "y"
             to: 0
             duration: manager.animationSpeed
             easing.type: Easing.OutQuad
         }
 
         ScriptAction{
             script: {
                 root.isHalfShown = false;
                 root.inStartup = false;
             }
         }
 
         onStarted: {
             if (manager.debugMagager) {
                 console.log("showing animation started...");
             }
         }
 
         onStopped: {
             inSlidingIn = false;
 
             if (manager.inTempHiding) {
                 manager.inTempHiding = false;
                 updateAutomaticIconSize();
             }
 
             manager.inTempHiding = false;
             updateAutomaticIconSize();
 
             if (manager.debugMagager) {
                 console.log("showing animation ended...");
             }
         }
 
         function init() {
             // if (!dock.visibility.blockHiding)
             inSlidingIn = true;
 
             if (slidingAnimationAutoHiddenOut.running) {
                 slidingAnimationAutoHiddenOut.stop();
             }
 
             dock.visibility.isHidden = false;
             updateMaskArea();
 
             start();
         }
     }
 }
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index f713ff04..54fe6dd5 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1882 +1,1884 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.1
 import QtQuick.Layouts 1.1
 import QtQuick.Window 2.2
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 import org.kde.draganddrop 2.0 as DragDrop
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte 0.1 as Latte
 
 import "applet" as Applet
 
 import "../code/LayoutManager.js" as LayoutManager
 
 DragDrop.DropArea {
     id: root
     objectName: "dockLayoutView"
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.isVertical
     LayoutMirroring.childrenInherit: true
 
     //// BEGIN SIGNALS
     signal clearZoomSignal();
     signal separatorsUpdated();
     signal signalActivateEntryAtIndex(int entryIndex);
     signal signalNewInstanceForEntryAtIndex(int entryIndex);
     signal updateEffectsArea();
     signal updateIndexes();
     signal updateScale(int delegateIndex, real newScale, real step);
     //// 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
 
     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
     // when there are only plasma style task managers the automatic icon size algorithm should better be disabled
     property bool autoDecreaseIconSize: plasmoid.configuration.autoDecreaseIconSize && !containsOnlyPlasmaTasks && layoutsContainer.fillApplets<=0
     property bool backgroundOnlyOnMaximized: plasmoid.configuration.backgroundOnlyOnMaximized
     property bool behaveAsPlasmaPanel: {
         if (!dock || !dock.visibility)
             return false;
 
         return (visibilityManager.panelIsBiggerFromIconSize && (zoomFactor === 1.0)
                 && (dock.visibility.mode === Latte.Dock.AlwaysVisible || dock.visibility.mode === Latte.Dock.WindowsGoBelow)
                 && (plasmoid.configuration.panelPosition === Latte.Dock.Justify) && !(root.solidPanel && panelShadowsActive));
     }
 
     property bool blurEnabled: plasmoid.configuration.blurEnabled && !root.forceTransparentPanel
                                || (hasExpandedApplet && zoomFactor===1 && plasmoid.configuration.panelSize===100)
 
     property bool confirmedDragEntered: false
     property bool containsOnlyPlasmaTasks: false //this is flag to indicate when from tasks only a plasma based one is found
     property bool dockContainsMouse: dock && dock.visibility ? dock.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: dock && dock.visibility && (dock.visibility.existsWindowMaximized || dock.visibility.existsWindowSnapped || hasExpandedApplet)
 
     property bool forceSemiTransparentPanel: ((!plasmoid.configuration.solidBackgroundForMaximized && plasmoid.configuration.backgroundOnlyOnMaximized && windowIsTouching)
                                              || (plasmoid.configuration.solidBackgroundForMaximized && !plasmoid.configuration.backgroundOnlyOnMaximized && !windowIsTouching))
                                              && Latte.WindowSystem.compositingActive
 
     property bool forceSolidPanel:  plasmoid.configuration.solidBackgroundForMaximized && dock && dock.visibility
                                     && Latte.WindowSystem.compositingActive
                                     &&(dock.visibility.existsWindowMaximized || dock.visibility.existsWindowSnapped || hasExpandedApplet)
     property bool forceTransparentPanel: root.backgroundOnlyOnMaximized
                                          && !(dock.visibility.existsWindowMaximized || dock.visibility.existsWindowSnapped)
                                          && Latte.WindowSystem.compositingActive
                                          && !(hasExpandedApplet && zoomFactor===1 && plasmoid.configuration.panelSize===100)
 
     property bool forceColorizer: Latte.WindowSystem.compositingActive && plasmoid.configuration.colorizeTransparentPanels
 
     property bool maximizedWindowTitleBarBehavesAsPanelBackground: dock && dock.visibility
                                                                    && (!plasmoid.configuration.solidBackgroundForMaximized && plasmoid.configuration.backgroundOnlyOnMaximized)
                                                                    && (dock.visibility.mode === Latte.Dock.WindowsGoBelow)
                                                                    && (plasmoid.location === PlasmaCore.Types.TopEdge)
                                                                    && (!useThemePanel || panelTransparency<40)
                                                                    && dock.visibility.existsWindowMaximized
 
     readonly property bool hasExpandedApplet: plasmoid.applets.some(function (item) {
         return (item.status >= PlasmaCore.Types.NeedsAttentionStatus && item.pluginName !== root.plasmoidName
                 && item.status !== PlasmaCore.Types.HiddenStatus);
     })
 
     readonly property bool hasUserSpecifiedBackground: (dock && dock.managedLayout && dock.managedLayout.background.startsWith("/")) ?
                                                            true : false
 
     property bool dockIsShownCompletely: !(dockIsHidden || inSlidingIn || inSlidingOut) && !root.editMode
     property bool immutable: plasmoid.immutable
     property bool indicateAudioStreams: plasmoid.configuration.indicateAudioStreams
     property bool inFullJustify: (plasmoid.configuration.panelPosition === Latte.Dock.Justify) && (plasmoid.configuration.maxLength===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 normalState : false
     property bool onlyAddingStarup: true //is used for the initialization phase in startup where there arent removals, this variable provides a way to grow icon size
     property bool shrinkThickMargins: plasmoid.configuration.shrinkThickMargins
     property bool showAppletsNumbers: false
     property bool solidPanel: Latte.WindowSystem.compositingActive ? plasmoid.configuration.solidPanel : true
 
     //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 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 activeIndicator: plasmoid.configuration.activeIndicator
 
     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
 
     property int animationTime: durationTime*2.8*units.longDuration
 
     property int automaticIconSizeBasedSize: -1 //it is not set, this is the defautl
 
     //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: automaticIconSizeBasedSize > 0 && autoDecreaseIconSize ?
                                Math.min(automaticIconSizeBasedSize, root.maxIconSize) :
                                root.maxIconSize
 
     property int proportionIconSize: { //icon size based on screen height
         if ((plasmoid.configuration.proportionIconSize===-1) || !dock)
             return -1;
 
         return Math.max(16,Math.round(dock.screenGeometry.height * plasmoid.configuration.proportionIconSize/100/8)*8);
     }
 
     property int iconStep: 8
     property int latteAppletPos: -1
     property int maxLength: root.isHorizontal ? width * (plasmoid.configuration.maxLength/100)
                                               : height * (plasmoid.configuration.maxLength/100)
 
     property int middleClickAction: plasmoid.configuration.middleClickAction
     property int modifier: plasmoid.configuration.modifier
     property int modifierClickAction: plasmoid.configuration.modifierClickAction
     property int modifierClick: plasmoid.configuration.modifierClick
 
     property int panelEdgeSpacing: Math.max(panelBoxBackground.lengthMargins, 1.5*appShadowSize)
-    property int panelTransparency: plasmoid.configuration.panelTransparency
+    property int panelTransparency: plasmoid.configuration.panelTransparency //user set
+    property int currentPanelTransparency: 0 //application override
+
     property bool panelShadowsActive: (( (plasmoid.configuration.panelShadows && !root.backgroundOnlyOnMaximized)
                                         || (plasmoid.configuration.panelShadows &&  root.backgroundOnlyOnMaximized && !root.forceTransparentPanel))
                                        && !(disablePanelShadowMaximized && dock.visibility.existsWindowMaximized))
                                       || (hasExpandedApplet && zoomFactor===1 && plasmoid.configuration.panelSize===100 && !(root.solidPanel && !plasmoid.configuration.panelShadows) )
 
 
     property int appShadowOpacity: (plasmoid.configuration.shadowOpacity/100) * 255
     property int appShadowSize: enableShadows ? (0.4*root.iconSize) * (plasmoid.configuration.shadowSize/100) : 0
     property int appShadowSizeOriginal: enableShadows ? (0.4*maxIconSize) * (plasmoid.configuration.shadowSize/100) : 0
     property string appShadowColor: "#" + decimalToHex(appShadowOpacity) + plasmoid.configuration.shadowColor
     property string appShadowColorSolid: "#" + plasmoid.configuration.shadowColor
 
     property int totalPanelEdgeSpacing: 0 //this is set by PanelBox
     //FIXME: this is not needed any more probably
     property int previousAllTasks: -1    //is used to forbit updateAutomaticIconSize when hovering
     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.Dock.Center || plasmoid.configuration.panelPosition === Latte.Dock.Justify)?
                                   offset : offset+panelMarginLength/2+totalPanelEdgeSpacing/2
 
     property int realSize: iconSize + iconMargin
     property int realPanelSize: 0
     property int realPanelLength: 0
     property int realPanelThickness: 0
     //this is set by the PanelBox
     property int panelMargin: 0
     property int panelMarginLength: 0
     property int panelShadow: 0 //shadowsSize
     property int editShadow: {
         if (!Latte.WindowSystem.compositingActive) {
             return 0;
         } else if (dock && dock.screenGeometry) {
             return (dock.screenGeometry.height/90);
         } else {
             return 7;
         }
     }
 
     property int themePanelSize: {
         //root.statesLineSize + root.iconSize + root.iconMargin + 1
         var panelBase = root.statesLineSize + root.panelMargin;
         var margin = latteApplet ? thickMargin : 0;
         var maxPanelSize = (root.statesLineSize + iconSize + margin + 1) - panelBase;
         var percentage = Latte.WindowSystem.compositingActive ? plasmoid.configuration.panelSize/100 : 1;
         return Math.max(panelBase, panelBase + percentage*maxPanelSize);
     }
 
     //decouple iconMargin which now is used only for length calculations with thickMargins
     //which are used for thickness calculations
     property int thickMarginBase: {
         if (shrinkThickMargins) {
             if (behaveAsPlasmaPanel){
                 return 0;
             } else {
                 return 1;
             }
         } else {
             return Math.ceil(0.06 * iconSize);
         }
     }
 
     property int thickMarginHigh: {
         if (shrinkThickMargins) {
             if (behaveAsPlasmaPanel){
                 return (reverseLinesPosition ? Math.max(root.statesLineSize/2, 1) : 1);
             } else {
                 return Math.max(1, 0.5 * appShadowSize);
             }
         } else {
             if (behaveAsPlasmaPanel) {
                 return (reverseLinesPosition ? Math.max(root.statesLineSize, 4) : 4);
             } else {
                 return Math.max( Math.ceil(0.06 * iconSize), 0.5 * appShadowSize);
             }
         }
     }
     property int thickMargin: thickMarginBase + thickMarginHigh
 
     //it is used in order to not break the calculations for the thickness placement
     //especially in automatic icon sizes calculations
     property int thickMarginOriginal: Math.ceil(0.06 * maxIconSize + Math.max( Math.ceil(0.06 * maxIconSize), 0.5 * appShadowSizeOriginal))
 
     //! iconMargin from configuration is a percentage. The calculation provides a length
     //! for that value between 0.04 - 0.5 of iconSize, this way 100% iconMargin means
     //! equal to the iconSize
     property int iconMargin: Math.ceil( ((0.5 * (plasmoid.configuration.iconMargin))/100) * iconSize)
     property int statesLineSize: (latteApplet && !(root.showWindowsOnlyFromLaunchers && root.activeIndicator === Latte.Dock.NoneIndicator))
                                  || (activeIndicator !== Latte.Dock.NoneIndicator) ?  Math.ceil( root.iconSize/13 ) : 0
 
 
     ///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.Dock.Center : (root.isVertical ? Latte.Dock.Top : Latte.Dock.Left)
     //property int panelAlignment: plasmoid.configuration.panelPosition !== Latte.Dock.Justify ? plasmoid.configuration.panelPosition : layoutsContainer.mainLayoutPosition
 
     property int panelAlignment: !root.editMode ? plasmoid.configuration.panelPosition :
                                                   ( plasmoid.configuration.panelPosition === Latte.Dock.Justify ?
                                                        Latte.Dock.Center : plasmoid.configuration.panelPosition )
 
     property real zoomFactor: (Latte.WindowSystem.compositingActive && durationTime>0) ? ( 1 + (plasmoid.configuration.zoomLevel / 20) ) : 1
 
     readonly property string plasmoidName: "org.kde.latte.plasmoid"
 
     property var iconsArray: [16, 22, 32, 48, 64, 96, 128, 256]
     property var layoutManager: LayoutManager
 
     property Item dragOverlay
     property Item toolBox
     property Item latteAppletContainer
     property Item latteApplet
     property Item parabolicManager: _parabolicManager
 
     property QtObject dock
     property QtObject universalSettings
     property QtObject universalLayoutManager
     property QtObject dockManagedLayout: dock && dock.managedLayout ? dock.managedLayout : 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 dont need it any more
     property bool enableShadows: plasmoid.configuration.shadows || root.forceTransparentPanel
     property bool dockIsHidden: dock ? dock.visibility.isHidden : true
     property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
     property bool dotsOnActive: plasmoid.configuration.dotsOnActive
     property bool highlightWindows: plasmoid.configuration.highlightWindows
     property bool reverseLinesPosition: !latteApplet && plasmoid.configuration.panelSize===100 ?
                                             !plasmoid.configuration.reverseLinesPosition : plasmoid.configuration.reverseLinesPosition
     property bool showGlow: plasmoid.configuration.showGlow
     property bool glow3D: plasmoid.configuration.glow3D
     property bool showToolTips: plasmoid.configuration.showToolTips
     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 smartLaunchersEnabled: plasmoid.configuration.smartLaunchersEnabled
     property bool threeColorsWindows: plasmoid.configuration.threeColorsWindows
     property bool titleTooltips: plasmoid.configuration.titleTooltips
 
     readonly property bool hasInternalSeparator: latteApplet ? latteApplet.hasInternalSeparator : false
 
     property int activeIndicatorType: plasmoid.configuration.activeIndicatorType
     property int animationStep: {
         if (!universalSettings || universalSettings.mouseSensitivity === Latte.Dock.HighSensitivity) {
             return 1;
         } else if (universalSettings.mouseSensitivity === Latte.Dock.MediumSensitivity) {
             return Math.max(3, root.iconSize / 18);
         } else if (universalSettings.mouseSensitivity === Latte.Dock.LowSensitivity) {
             return Math.max(5, root.iconSize / 10);
         }
     }
     property int glowOption: plasmoid.configuration.glowOption
     property real glowOpacity: plasmoid.configuration.glowOpacity/100
 
     property int latteAppletHoveredIndex: latteApplet ? latteApplet.hoveredIndex : -1
     property int launchersGroup: plasmoid.configuration.launchersGroup
     property int tasksCount: latteApplet ? latteApplet.tasksCount : 0
 
     property real durationTime: {
         if ((dock && dock.blockAnimations) || !Latte.WindowSystem.compositingActive) {
             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 rect screenGeometry: dock ? dock.screenGeometry : plasmoid.screenGeometry
 
     readonly property color minimizedDotColor: colorizerLoader.minimizedDotColor
     ///END properties from latteApplet
 
     /* Layout.preferredWidth: plasmoid.immutable ?
                                (plasmoid.configuration.panelPosition === Latte.Dock.Justify ?
                                     layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin) :
                                Screen.width //on unlocked state use the maximum
 
     Layout.preferredHeight: plasmoid.immutable ?
                                (plasmoid.configuration.panelPosition === Latte.Dock.Justify ?
                                     layoutsContainer.height + 0.5*iconMargin : layoutsContainer.mainLayout.height + iconMargin) :
                                Screen.height //on unlocked state use the maximum*/
 
     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 iconMargin {
         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.plasmaEditMode
         NumberAnimation {
             id: offsetAnimation
 
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
     //// END OF Behaviors
 
     //////////////START OF CONNECTIONS
     onContainsOnlyPlasmaTasksChanged: updateAutomaticIconSize();
 
     onEditModeChanged: {
         if (editMode) {
             visibilityManager.updateMaskArea();
             updateAutomaticIconSize();
             clearZoom();
         } else {
             updateAutomaticIconSize();
             layoutsContainer.updateSizeForAppletsInFill();
         }
 
         updateLayouts();
 
         //! 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;
         }
     }
 
     onDockChanged: {
         if (dock) {
             dock.onAddInternalViewSplitter.connect(addInternalViewSplitters);
             dock.onRemoveInternalViewSplitter.connect(removeInternalViewSplitters);
 
             dock.onXChanged.connect(visibilityManager.updateMaskArea);
             dock.onYChanged.connect(visibilityManager.updateMaskArea);
             dock.onWidthChanged.connect(visibilityManager.updateMaskArea);
             dock.onHeightChanged.connect(visibilityManager.updateMaskArea);
 
             dock.hideDockDuringLocationChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             dock.showDockAfterLocationChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             dock.hideDockDuringScreenChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             dock.showDockAfterScreenChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             dock.hideDockDuringMovingToLayoutStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             dock.showDockAfterMovingToLayoutFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
 
 
             dock.visibility.onContainsMouseChanged.connect(visibilityManager.slotContainsMouseChanged);
             dock.visibility.onMustBeHide.connect(visibilityManager.slotMustBeHide);
             dock.visibility.onMustBeShown.connect(visibilityManager.slotMustBeShown);
 
             updateContainsOnlyPlasmaTasks();
         }
     }
 
     onDockContainsMouseChanged: {
         if (!dockContainsMouse) {
             initializeHoveredIndexes();
         }
     }
 
     onDragEnter: {
         if (plasmoid.immutable || dockIsHidden || visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) {
             event.ignore();
             return;
         }
 
         if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") >= 0) {
             return;
         }
 
         if (latteApplet) {
             if (latteApplet.launchersDrop(event)) {
                 root.addLaunchersMessage = true;
                 if (root.addLaunchersInTaskManager) {
                     return;
                 }
             } else if (dock.mimeContainsPlasmoid(event.mimeData, "audoban.applet.separator")
                        && root.latteAppletContainer.containsPos(event)) {
                 confirmedDragEntered = true
                 dndSpacer.opacity = 0;
                 dndSpacer.parent = root;
                 return;
             }
         }
 
         if (!confirmedDragEntered) {
             confirmedDragEntered = true;
             slotAnimationsNeedLength(1);
         }
 
         if (!latteApplet || (latteApplet && !dock.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.plasmoid"))) {
             LayoutManager.insertAtCoordinates2(dndSpacer, event.x, event.y)
             dndSpacer.opacity = 1;
         }
     }
 
     onDragMove: {
         if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") >= 0
                 || dockIsHidden || visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) {
             return;
         }
 
         if (latteApplet) {
             if (latteApplet.launchersDrop(event)) {
                 root.addLaunchersMessage = true;
                 if (root.addLaunchersInTaskManager) {
                     return;
                 }
             } else if (dock.mimeContainsPlasmoid(event.mimeData, "audoban.applet.separator")
                       && root.latteAppletContainer.containsPos(event)) {
                confirmedDragEntered = true
                dndSpacer.opacity = 0;
                dndSpacer.parent = root;
                return;
            }
         }
 
         if (!latteApplet || (latteApplet && !dock.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.plasmoid"))) {
             LayoutManager.insertAtCoordinates2(dndSpacer, event.x, event.y)
             dndSpacer.opacity = 1;
         }
     }
 
     onDragLeave: {
 
         if (confirmedDragEntered) {
             slotAnimationsNeedLength(-1);
             confirmedDragEntered = false;
         }
 
         root.addLaunchersMessage = false;
         dndSpacer.opacity = 0;
         dndSpacer.parent = root;
     }
 
     onDrop: {
         if (dockIsHidden || visibilityManager.inSlidingIn || visibilityManager.inSlidingOut) {
             return;
         }
 
         if (event.mimeData.formats.indexOf("application/x-orgkdeplasmataskmanager_taskbuttonitem") < 0) {
             if (latteApplet && latteApplet.launchersDrop(event) && root.addLaunchersInTaskManager) {
                 latteApplet.launchersDropped(event.mimeData.urls);
             } else if (!latteApplet || (latteApplet && !dock.mimeContainsPlasmoid(event.mimeData, "org.kde.latte.plasmoid"))) {
                 plasmoid.processMimeData(event.mimeData, event.x, event.y);
                 event.accept(event.proposedAction);
             }
         }
 
         if (confirmedDragEntered) {
             slotAnimationsNeedLength(-1);
             confirmedDragEntered = false;
         }
 
         root.addLaunchersMessage = false;
         dndSpacer.opacity = 0;
         //! this line is very important because it positions correctly the new applets
         //dndSpacer.parent = root;
     }
 
     onMaxLengthChanged: {
         layoutsContainer.updateSizeForAppletsInFill();
         if (root.editMode) {
             updateAutomaticIconSize();
         }
     }
 
     onToolBoxChanged: {
         if (toolBox) {
             toolBox.visible = false;
         }
     }
 
     property bool automaticSizeAnimation: false;
     onAutomaticIconSizeBasedSizeChanged: {
         if (!automaticSizeAnimation) {
             automaticSizeAnimation = true;
             slotAnimationsNeedBothAxis(1);
         }
     }
 
     onIconSizeChanged: {
         if (((iconSize === automaticIconSizeBasedSize) || (iconSize === root.maxIconSize)) && automaticSizeAnimation){
             slotAnimationsNeedBothAxis(-1);
             automaticSizeAnimation=false;
         }
     }
 
     onIsReadyChanged: {
         if (isReady && !titleTooltipDialog.visible && titleTooltipDialog.activeItemHovered){
             titleTooltipDialog.show(titleTooltipDialog.activeItem, titleTooltipDialog.activeItemText);
         }
     }
 
     onIsVerticalChanged: {
         if (isVertical) {
             if (plasmoid.configuration.panelPosition === Latte.Dock.Left)
                 plasmoid.configuration.panelPosition = Latte.Dock.Top;
             else if (plasmoid.configuration.panelPosition === Latte.Dock.Right)
                 plasmoid.configuration.panelPosition = Latte.Dock.Bottom;
         } else {
             if (plasmoid.configuration.panelPosition === Latte.Dock.Top)
                 plasmoid.configuration.panelPosition = Latte.Dock.Left;
             else if (plasmoid.configuration.panelPosition === Latte.Dock.Bottom)
                 plasmoid.configuration.panelPosition = Latte.Dock.Right;
         }
     }
 
     onProportionIconSizeChanged: {
         if (proportionIconSize!==-1)
             updateAutomaticIconSize();
     }
 
     //  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 (dock) {
             dock.onAddInternalViewSplitter.disconnect(addInternalViewSplitters);
             dock.onRemoveInternalViewSplitter.disconnect(removeInternalViewSplitters);
 
             dock.onXChanged.disconnect(visibilityManager.updateMaskArea);
             dock.onYChanged.disconnect(visibilityManager.updateMaskArea);
             dock.onWidthChanged.disconnect(visibilityManager.updateMaskArea);
             dock.onHeightChanged.disconnect(visibilityManager.updateMaskArea);
 
             dock.hideDockDuringLocationChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             dock.showDockAfterLocationChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             dock.hideDockDuringScreenChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             dock.showDockAfterScreenChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             dock.hideDockDuringMovingToLayoutStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             dock.showDockAfterMovingToLayoutFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
 
             if (dock.visibility) {
                 dock.visibility.onContainsMouseChanged.disconnect(visibilityManager.slotContainsMouseChanged);
                 dock.visibility.onMustBeHide.disconnect(visibilityManager.slotMustBeHide);
                 dock.visibility.onMustBeShown.disconnect(visibilityManager.slotMustBeShown);
             }
         }
     }
 
     Containment.onAppletAdded: {
         addApplet(applet, x, y);
         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;
         }
 
         LayoutManager.save();
 
         updateIndexes();
         updateContainsOnlyPlasmaTasks();
     }
 
     Plasmoid.onUserConfiguringChanged: {
         if (plasmoid.immutable) {
             if (dragOverlay) {
                 dragOverlay.destroy();
             }
             return;
         }
 
         // console.debug("user configuring", plasmoid.userConfiguring)
 
         if (plasmoid.userConfiguring) {
             dock.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("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 {
             dock.setBlockHiding(false);
 
             if (dock.visibility.isHidden) {
                 dock.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 dock becomes too small
         ///to add applets
         if (plasmoid.immutable) {
             if(root.isHorizontal) {
                 root.Layout.preferredWidth = (plasmoid.configuration.panelPosition === Latte.Dock.Justify ?
                                                   layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin);
             } else {
                 root.Layout.preferredHeight = (plasmoid.configuration.panelPosition === Latte.Dock.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 choses to be hidden but still make it
         // accessible in the panelcontroller
         container.visible = Qt.binding(function() {
             return applet.status !== PlasmaCore.Types.HiddenStatus || (!plasmoid.immutable && plasmoid.userConfiguring)
         })
 
         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 occurence that we'd like to abstract it further in the future
             // and get rid of the uglyness 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(){
         addInternalViewSplitter(-1);
         addInternalViewSplitter(-1);
     }
 
     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));
             }
 
             layoutManager.save();
         }
     }
 
     //! 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 dock.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++;
             }
         }
 
         for (var container in layoutsContainer.mainLayout.children) {
             var item = layoutsContainer.mainLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters++;
             }
         }
 
         for (var container in layoutsContainer.endLayout.children) {
             var item = layoutsContainer.endLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters++;
             }
         }
 
         return splitters;
     }
 
     function initializeHoveredIndexes() {
         layoutsContainer.hoveredIndex = -1;
         layoutsContainer.currentSpot = -1000;
         if (latteApplet) {
             latteApplet.initializeHoveredIndex();
         }
     }
 
     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.lockZoom && 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.lockZoom && 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.lockZoom && applet.canBeHovered){
                 return true;
             }
         }
 
         return false;
     }
 
     function mouseInHoverableArea() {
         return (dock.visibility.containsMouse && !rootMouseArea.containsMouse && mouseInCanBeHoveredApplet());
     }
 
     function removeInternalViewSplitters(){
         for (var container in layoutsContainer.mainLayout.children) {
             var item = layoutsContainer.mainLayout.children[container];
             if(item && item.isInternalViewSplitter)
                 item.destroy();
         }
 
         layoutManager.save();
     }
 
     function setHoveredIndex(ind) {
         layoutsContainer.hoveredIndex = ind;
     }
 
     function hideTooltipLabel(debug){
         titleTooltipDialog.hide(debug);
     }
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletsNumbers(showNumbers){
         if (latteApplet) {
             var base = universalSettings.unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksNumbersBase(base - 1);
             latteApplet.setShowTasksNumbers(showNumbers);
         }
 
         showAppletsNumbers = showNumbers;
     }
 
     // This is called by dockcorona in response to a Meta+number shortcut.
     function activateEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = universalSettings.unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksNumbersBase(base - 1);
         }
 
         signalActivateEntryAtIndex(index);
     }
 
     // This is called by dockcorona in response to a Meta+Alt+number shortcut.
     function newInstanceForEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = universalSettings.unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksNumbersBase(base - 1);
         }
 
         signalNewInstanceForEntryAtIndex(index);
     }
 
 
     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();
     }
 
     //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) || (!dock)) {
             return;
         }
 
         actionsBlockHiding = Math.max(actionsBlockHiding + step, 0);
 
         if (actionsBlockHiding > 0){
             dock.setBlockHiding(true);
         } else {
             if (!root.editMode)
                 dock.setBlockHiding(false);
         }
     }
 
     function slotPreviewsShown(){
         if (dock) {
             dock.deactivateApplets();
         }
     }
 
     function startCheckRestoreZoomTimer(){
         checkRestoreZoom.start();
     }
 
     function stopCheckRestoreZoomTimer(){
         checkRestoreZoom.stop();
     }
 
     function startDirectRenderDelayerDuringEntering(){
         directRenderDelayerForEnteringTimer.start();
     }
 
     function setGlobalDirectRender(value) {
         if (latteApplet && latteApplet.waitingLaunchers.length > 0)
             return;
 
         if (value === true) {
             if (mouseInCanBeHoveredApplet()) {
                 root.globalDirectRender = true;
             } else {
                 //    console.log("direct render true ignored...");
             }
         } else {
             root.globalDirectRender = false;
         }
     }
 
     function updateAutomaticIconSize() {
         if ( !blockAutomaticUpdateIconSize.running && !visibilityManager.inTempHiding
                 && ((visibilityManager.normalState || root.editMode)
                     && (root.autoDecreaseIconSize || (!root.autoDecreaseIconSize && root.iconSize!=root.maxIconSize)))
                 && (iconSize===root.maxIconSize || iconSize === automaticIconSizeBasedSize) ) {
             blockAutomaticUpdateIconSize.start();
 
             var layoutLength;
             var maxLength = root.maxLength;
 
             //console.log("------Entered check-----");
             //console.log("max length: "+ maxLength);
 
             if (root.isVertical) {
                 layoutLength = (plasmoid.configuration.panelPosition === Latte.Dock.Justify) ?
                             layoutsContainer.startLayout.height+layoutsContainer.mainLayout.height+layoutsContainer.endLayout.height : layoutsContainer.mainLayout.height
             } else {
                 layoutLength = (plasmoid.configuration.panelPosition === Latte.Dock.Justify) ?
                             layoutsContainer.startLayout.width+layoutsContainer.mainLayout.width+layoutsContainer.endLayout.width : layoutsContainer.mainLayout.width
             }
 
             var toShrinkLimit = maxLength-((root.zoomFactor-1)*(iconSize+2*iconMargin));
             var toGrowLimit = maxLength-1.5*((root.zoomFactor-1)*(iconSize+2*iconMargin));
 
             var newIconSizeFound = false;
             if (layoutLength > toShrinkLimit) { //must shrink
                 //  console.log("step3");
                 var nextIconSize = root.maxIconSize;
 
                 do {
                     nextIconSize = nextIconSize - iconStep;
                     var factor = nextIconSize / iconSize;
                     var nextLength = factor * layoutLength;
 
                 } while ( (nextLength>toShrinkLimit) && (nextIconSize !== 16));
 
                 automaticIconSizeBasedSize = nextIconSize;
                 newIconSizeFound = true;
                 console.log("Step 3 - found:"+automaticIconSizeBasedSize);
             } else if ((layoutLength<toGrowLimit
                         && (iconSize === automaticIconSizeBasedSize)) ) { //must grow probably
                 //  console.log("step4");
                 var nextIconSize2 = automaticIconSizeBasedSize;
                 var foundGoodSize = -1;
 
                 do {
                     nextIconSize2 = nextIconSize2 + iconStep;
                     var factor2 = nextIconSize2 / automaticIconSizeBasedSize;
                     var nextLength2 = factor2 * layoutLength;
 
                     if (nextLength2 < toGrowLimit) {
                         foundGoodSize = nextIconSize2;
                     }
                 } while ( (nextLength2<toGrowLimit) && (nextIconSize2 !== root.maxIconSize ));
 
                 if (foundGoodSize > 0) {
                     if (foundGoodSize === root.maxIconSize) {
                         automaticIconSizeBasedSize = -1;
                     } else {
                         automaticIconSizeBasedSize = foundGoodSize;
                     }
                     newIconSizeFound = true
                     //        console.log("Step 4 - found:"+automaticIconSizeBasedSize);
                 } else {
                     //       console.log("Step 4 - did not found...");
                 }
             }
         }
     }
 
     function updateContainsOnlyPlasmaTasks() {
         if (dock) {
             root.containsOnlyPlasmaTasks = (dock.tasksPresent() && !dock.latteTasksPresent());
         } else {
             root.containsOnlyPlasmaTasks = false;
         }
     }
 
     function updateSizeForAppletsInFill() {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     function updateLayouts(){
         if(!root.editMode){
             //    console.log("update layout - internal view splitters count:"+internalViewSplittersCount());
             if (internalViewSplittersCount() === 2) {
                 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;
                 }
             }
         }
         else{
             if (internalViewSplittersCount() === 2) {
                 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;
                 }
             }
         }
 
         updateIndexes();
     }
     //END functions
 
 
     ////BEGIN interfaces
 
     Connections {
         target: Latte.WindowSystem
 
         onCompositingActiveChanged: {
             visibilityManager.updateMaskArea();
         }
     }
 
     Connections {
         target: dock
         onWidthChanged:{
             if (root.isHorizontal && proportionIconSize!==-1)
                 updateAutomaticIconSize();
         }
 
         onHeightChanged:{
             if (root.isVertical && proportionIconSize!==-1)
                 updateAutomaticIconSize();
         }
 
         onContextMenuIsShownChanged: {
             if (!dock.contextMenuIsShown) {
                 checkRestoreZoom.start();
             } else {
                 root.setGlobalDirectRender(false);
             }
         }
     }
 
     Connections{
         target: dock && dock.visibility ? dock.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 (dock && dock.visibility && dock.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
     }
 
     ///////////////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
     MouseArea{
         id: rootMouseArea
         anchors.fill: parent
         hoverEnabled: true
 
         onContainsMouseChanged: {
             if (mouseInHoverableArea()) {
                 stopCheckRestoreZoomTimer();
             } else {
                 initializeHoveredIndexes();
                 startCheckRestoreZoomTimer()
             }
         }
     }
 
     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 ? dock.managedLayout.background : "../icons/wheatprint.jpg"
         }
     }
 
     EditModeVisual{
         id:editModeVisual
         //   z: root.behaveAsPlasmaPanel ? 1 : 0
     }
 
     Ruler{id: ruler}
 
     RulerMouseArea{
         id: rulerMouseArea
         anchors.fill: ruler
         z:1100
     }
 
     Item{
         id: panelBox
 
         anchors.fill:layoutsContainer
         // z: root.behaveAsPlasmaPanel ? 0 : 1
 
         PanelBox{
             id: panelBoxBackground
         }
     }
 
     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
         }
     }
 
     Item {
         id: dndSpacer
 
         property int normalSize: root.statesLineSize + root.iconSize + root.thickMargin - 1
         //visibilityManager.statesLineSizeOriginal + root.maxIconSize + visibilityManager.iconMarginOriginal - 1
 
         width: normalSize
         height: normalSize
 
         Layout.preferredWidth: width
         Layout.preferredHeight: height
         opacity: 0
         z:10
 
         AddWidgetVisual{}
     }
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
         z:10
 
         sourceComponent: Item{
             Rectangle{
                 anchors.fill: parent
                 color: "yellow"
                 opacity: 0.30
             }
         }
     }
 
     VisibilityManager{ id: visibilityManager }
 
     LayoutsContainer {
         id: layoutsContainer
         opacity: colorizerLoader.isShown ? 0 : 1
 
         Behavior on opacity {
             NumberAnimation {
                 duration: 0.8 * root.animationTime
                 easing.type: Easing.OutCubic
             }
         }
     }
 
     Loader{
         id: colorizerLoader
 
         active: forceColorizer
         anchors.fill: layoutsContainer
         z: layoutsContainer.z + 1
 
         // formula for luminance according to:
         // https://www.w3.org/TR/2008/REC-WCAG20-20081211/#relativeluminancedef
         property real textColorRs: {
             var color = theme.textColor.r;
             if (color <= 0.03928) {
                 return color / 12.92;
             } else {
                 return Math.pow( ((color + 0.055) / 1.055), 2.4 );
             }
         }
 
         property real textColorGs: {
             var color = theme.textColor.g;
             if (color <= 0.03928) {
                 return color / 12.92;
             } else {
                 return Math.pow( ((color + 0.055) / 1.055), 2.4 );
             }
         }
 
         property real textColorBs: {
             var color = theme.textColor.b;
             if (color <= 0.03928) {
                 return color / 12.92;
             } else {
                 return Math.pow( ((color + 0.055) / 1.055), 2.4 );
             }
         }
 
         //! -------
         property real backColorRs: {
             var color = theme.backgroundColor.r;
             if (color <= 0.03928) {
                 return color / 12.92;
             } else {
                 return Math.pow( ((color + 0.055) / 1.055), 2.4 );
             }
         }
 
         property real backColorGs: {
             var color = theme.backgroundColor.g;
             if (color <= 0.03928) {
                 return color / 12.92;
             } else {
                 return Math.pow( ((color + 0.055) / 1.055), 2.4 );
             }
         }
 
         property real backColorBs: {
             var color = theme.backgroundColor.b;
             if (color <= 0.03928) {
                 return color / 12.92;
             } else {
                 return Math.pow( ((color + 0.055) / 1.055), 2.4 );
             }
         }
 
         readonly property real themeBackgroundColorLuma: 0.2126*backColorRs + 0.7152*backColorGs + 0.0722*backColorBs
         readonly property real themeTextColorLuma: 0.2126*textColorRs + 0.7152*textColorGs + 0.0722*textColorBs
         readonly property color minimizedDotColor: themeTextColorLuma > 0.6 ? Qt.darker(theme.textColor, 1.7) : Qt.lighter(theme.textColor, 7)
 
         property bool isShown: active && !forceSolidPanel
                                   //! when forceSemiTransparentPanel is enabled because of snapped or maximized etc. windows
                                   //! then the colorizer could be enabled for low panel transparency levels (<40%)
                                && (!forceSemiTransparentPanel || (forceSemiTransparentPanel && root.panelTransparency<40))
                                && !maximizedWindowTitleBarBehavesAsPanelBackground
                                && (plasmoid.configuration.solidBackgroundForMaximized || plasmoid.configuration.backgroundOnlyOnMaximized)
                                && !root.editMode && Latte.WindowSystem.compositingActive
 
         property real currentBackgroundLuminas: -1000
 
         property color themeBrightColor: themeBackgroundColorLuma > themeTextColorLuma ? theme.backgroundColor : theme.textColor
         property color themeDarkColor: themeBackgroundColorLuma > themeTextColorLuma ? theme.textColor : theme.backgroundColor
 
         property color applyColor: {
             if (currentBackgroundLuminas>=0) {
                 var textAbs = Math.abs(themeTextColorLuma - currentBackgroundLuminas);
                 var backAbs = Math.abs(themeBackgroundColorLuma - currentBackgroundLuminas);
 
                 if (textAbs > backAbs) {
                     return Qt.rgba(theme.textColor.r, theme.textColor.g, theme.textColor.b , 1); //remove any transparency
                 }
             }
 
             return Qt.rgba(theme.backgroundColor.r, theme.backgroundColor.g, theme.backgroundColor.b, 1); //remove any transparency
         }
 
         sourceComponent: ColorizerManager{}
     }
 
     ///////////////END UI elements
 
     ///////////////BEGIN TIMER elements
 
 
     //Timer to check if the mouse is still outside the dock in order to restore zooms to 1.0
     Timer{
         id:checkRestoreZoom
         interval: 90
 
         onTriggered: {
             if (latteApplet && (latteApplet.previewContainsMouse() || latteApplet.contextMenu))
                 return;
 
             if (dock.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...");
             }
         }
     }
 
     // This function is very costly! This timer makes sure that it can be called
     // only once every 1sec.
     Timer{
         id:blockAutomaticUpdateIconSize
         interval: 1000
         repeat: false
         onTriggered: root.updateAutomaticIconSize();
     }
 
     //! It is used in order to slide-in the dock on startup
     Timer{
         id: inStartupTimer
         interval: 1500
         repeat: false
         onTriggered: {
             if (inStartup) {
                 visibilityManager.slotMustBeShown();
             }
         }
     }
 
     ///////////////END TIMER elements
 }