diff --git a/app/CMakeLists.txt b/app/CMakeLists.txt
index 0e0c2b80..fdeaf028 100644
--- a/app/CMakeLists.txt
+++ b/app/CMakeLists.txt
@@ -1,79 +1,80 @@
 set(lattedock-app_SRCS
     ../liblattedock/dock.cpp
     windowinfowrap.cpp
     abstractwindowinterface.cpp
     xwindowinterface.cpp
     waylandinterface.cpp
     windowinfowrap.cpp
     screenpool.cpp
     packageplugins/shell/dockpackage.cpp
     alternativeshelper.cpp
     dockcorona.cpp
     globalshortcuts.cpp
+    sortedactivitiesmodel.cpp
     universalsettings.cpp
     layoutmanager.cpp
     layout.cpp
     settingsdialog.cpp
     importer.cpp
     infoview.cpp
     launcherssignals.cpp
     layoutsDelegates/checkboxdelegate.cpp
     layoutsDelegates/colorcmbboxdelegate.cpp
     layoutsDelegates/colorcmbboxitemdelegate.cpp
     layoutsDelegates/activitycmbboxdelegate.cpp
     dock/dockmenumanager.cpp
     dock/dockview.cpp
     dock/dockconfigview.cpp
     dock/docksecconfigview.cpp
     dock/panelshadows.cpp
     dock/visibilitymanager.cpp
     main.cpp
 )
 
 set(latte_dbusXML dbus/org.kde.LatteDock.xml)
 qt5_add_dbus_adaptor(lattedock-app_SRCS ${latte_dbusXML} dockcorona.h Latte::DockCorona lattedockadaptor)
 ki18n_wrap_ui(lattedock-app_SRCS settingsdialog.ui)
 
 add_executable(latte-dock ${lattedock-app_SRCS})
 
 include(FakeTarget.cmake)
 
 target_link_libraries(latte-dock
     Qt5::DBus
     Qt5::Quick
     Qt5::Qml
     KF5::I18n
     KF5::DBusAddons
     KF5::Declarative
     KF5::CoreAddons
     KF5::GlobalAccel
     KF5::Archive
     KF5::Crash
     KF5::XmlGui
     KF5::Plasma
     KF5::PlasmaQuick
     KF5::Activities
     KF5::Notifications
     KF5::NewStuff
     KF5::QuickAddons
     KF5::WaylandClient
 )
 
 if(HAVE_X11)
     target_link_libraries(latte-dock
         Qt5::X11Extras
         KF5::WindowSystem
         ${X11_LIBRARIES}
         ${XCB_LIBRARIES}
     )
 endif()
 
 configure_file(org.kde.latte-dock.desktop.cmake org.kde.latte-dock.desktop)
 configure_file(org.kde.latte-dock.appdata.xml.cmake org.kde.latte-dock.appdata.xml)
 
 install(TARGETS latte-dock ${KDE_INSTALL_TARGETS_DEFAULT_ARGS})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.kde.latte-dock.desktop DESTINATION ${KDE_INSTALL_APPDIR})
 install(FILES ${CMAKE_CURRENT_BINARY_DIR}/org.kde.latte-dock.appdata.xml DESTINATION ${KDE_INSTALL_METAINFODIR})
 install(FILES dbus/org.kde.LatteDock.xml DESTINATION ${KDE_INSTALL_DBUSINTERFACEDIR})
 install(FILES lattedock.notifyrc DESTINATION ${KNOTIFYRC_INSTALL_DIR})
 install(FILES latte-layouts.knsrc DESTINATION  ${CONFIG_INSTALL_DIR})
diff --git a/app/dock/dockview.cpp b/app/dock/dockview.cpp
index 8b4d9675..9a456945 100644
--- a/app/dock/dockview.cpp
+++ b/app/dock/dockview.cpp
@@ -1,1917 +1,1932 @@
 /*
 *  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);
 
 
     auto *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
     if (dockCorona) {
         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();
             }
         });
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(2000);
     connect(&m_screenSyncTimer, &QTimer::timeout, this, &DockView::reconsiderScreen);
 }
 
 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::updateAbsDockGeometry);
     connect(this, &QQuickWindow::yChanged, this, &DockView::yChanged);
     connect(this, &QQuickWindow::yChanged, this, &DockView::updateAbsDockGeometry);
     connect(this, &QQuickWindow::widthChanged, this, &DockView::widthChanged);
     connect(this, &QQuickWindow::widthChanged, this, &DockView::updateAbsDockGeometry);
     connect(this, &QQuickWindow::heightChanged, this, &DockView::heightChanged);
     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();
             });
         }
     });
 
     //! 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();
             });
         }
     });
 
     //! 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);
     }
 }
 
 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()
 {
     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)
 {
     if (formFactor() == Plasma::Types::Vertical) {
         //qDebug() << "MAXIMUM RECT :: " << maximumRect << " - AVAILABLE RECT :: " << availableRect;
         QSize size{maxThickness(), availableScreenRect.height()};
 
         if (m_behaveAsPlasmaPanel) {
             size.setWidth(normalThickness());
             size.setHeight(static_cast<int>(maxLength() * availableScreenRect.height()));
         }
 
         setMinimumSize(size);
         setMaximumSize(size);
         resize(size);
     } else {
         QSize screenSize = this->screen()->size();
         QSize size{screenSize.width(), maxThickness()};
 
         if (m_behaveAsPlasmaPanel) {
             size.setWidth(static_cast<int>(maxLength() * screenSize.width()));
             size.setHeight(normalThickness());
         }
 
         setMinimumSize(size);
         setMaximumSize(size);
         resize(size);
 
         if (corona())
             emit corona()->availableScreenRectChanged();
     }
 }
 
 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();
     }
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 }
 
 inline void DockView::syncGeometry()
 {
     if (!(this->screen() && this->containment()))
         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 incosistent!!!!";
         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)
 {
     if (m_effectsArea == area) {
         return;
     }
 
     m_effectsArea = area;
     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);
             }
         }
     }
 }
 
 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) {
                 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) {
                 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()
 {
     //! CRASH: Dont update effects under wayland
     //! because they arent supported yet
     if (KWindowSystem::isPlatformWayland()) {
         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());
 
             //! fix 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(),
                 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);
     }
 
     return false;
 }
 
 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::closeApplication()
 {
     //! this code must be called asynchronously because it is called
     //! also from qml (Settings window).
     QTimer::singleShot(50, [this]() {
         DockCorona *dockCorona = qobject_cast<DockCorona *>(this->corona());
 
         DockConfigView *configView = qobject_cast<DockConfigView *>(m_configView);
 
         if (configView) {
             configView->hideConfigWindow();
         } else if (m_configView) {
             m_configView->close();
         }
 
         if (dockCorona) {
             dockCorona->layoutManager()->hideAllDocks();
         }
 
         if (dockCorona)
             dockCorona->closeApplication();
     });
 }
 
 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/app/dock/dockview.h b/app/dock/dockview.h
index dd9d5c3f..1b3c6179 100644
--- a/app/dock/dockview.h
+++ b/app/dock/dockview.h
@@ -1,372 +1,378 @@
 /*
 *  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/>.
 */
 
 #ifndef DOCKVIEW_H
 #define DOCKVIEW_H
 
 #include "dockconfigview.h"
 #include "visibilitymanager.h"
 #include "../layout.h"
 #include "../plasmaquick/containmentview.h"
 #include "../plasmaquick/configview.h"
 #include "../../liblattedock/dock.h"
 
 #include <QQuickView>
 #include <QQmlListProperty>
 #include <QMenu>
 #include <QMimeData>
 #include <QScreen>
 #include <QPointer>
 #include <QTimer>
 
 #include <Plasma/Theme>
 
 namespace Plasma {
 class Types;
 class Corona;
 class Containment;
 }
 
 namespace KWayland {
 namespace Client {
 class PlasmaShellSurface;
 }
 }
 
 namespace Latte {
 class DockMenuManager;
 class Layout;
 }
 
 namespace Latte {
 
 class DockView : public PlasmaQuick::ContainmentView {
     Q_OBJECT
     Q_PROPERTY(bool alternativesIsShown READ alternativesIsShown NOTIFY alternativesIsShownChanged)
     Q_PROPERTY(bool behaveAsPlasmaPanel READ behaveAsPlasmaPanel WRITE setBehaveAsPlasmaPanel NOTIFY behaveAsPlasmaPanelChanged)
     Q_PROPERTY(bool blockAnimations READ blockAnimations WRITE setBlockAnimations NOTIFY blockAnimationsChanged)
+    Q_PROPERTY(bool colorizerSupport READ colorizerSupport WRITE setColorizerSupport NOTIFY colorizerSupportChanged)
     Q_PROPERTY(bool contextMenuIsShown READ contextMenuIsShown NOTIFY contextMenuIsShownChanged)
     Q_PROPERTY(bool dockWinBehavior READ dockWinBehavior WRITE setDockWinBehavior NOTIFY dockWinBehaviorChanged)
     Q_PROPERTY(bool drawShadows READ drawShadows WRITE setDrawShadows NOTIFY drawShadowsChanged)
     Q_PROPERTY(bool drawEffects READ drawEffects WRITE setDrawEffects NOTIFY drawEffectsChanged)
     //! Because Latte uses animations, changing to edit mode it may be different than
     //! when the isUserConfiguring changes value
     Q_PROPERTY(bool inEditMode READ inEditMode WRITE setInEditMode NOTIFY inEditModeChanged)
     Q_PROPERTY(bool onPrimary READ onPrimary WRITE setOnPrimary NOTIFY onPrimaryChanged)
 
     Q_PROPERTY(int alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
     Q_PROPERTY(int docksCount READ docksCount NOTIFY docksCountChanged)
     Q_PROPERTY(int dockTransparency READ dockTransparency WRITE setDockTransparency NOTIFY dockTransparencyChanged)
     Q_PROPERTY(int fontPixelSize READ fontPixelSize WRITE setFontPixelSize NOTIFY fontPixelSizeChanged)
     Q_PROPERTY(int totalDocksCount READ totalDocksCount NOTIFY totalDocksCountChanged)
     Q_PROPERTY(int x READ x NOTIFY xChanged)
     Q_PROPERTY(int y READ y NOTIFY yChanged)
     Q_PROPERTY(int width READ width NOTIFY widthChanged)
     Q_PROPERTY(int height READ height NOTIFY heightChanged)
     Q_PROPERTY(int maxThickness READ maxThickness WRITE setMaxThickness NOTIFY maxThicknessChanged)
     Q_PROPERTY(int normalThickness READ normalThickness WRITE setNormalThickness NOTIFY normalThicknessChanged)
     Q_PROPERTY(int offset READ offset WRITE setOffset NOTIFY offsetChanged)
     Q_PROPERTY(int shadow READ shadow WRITE setShadow NOTIFY shadowChanged)
 
     Q_PROPERTY(QString currentScreen READ currentScreen NOTIFY currentScreenChanged)
 
     Q_PROPERTY(float maxLength READ maxLength WRITE setMaxLength NOTIFY maxLengthChanged)
 
     Q_PROPERTY(Plasma::FrameSvg::EnabledBorders enabledBorders READ enabledBorders NOTIFY enabledBordersChanged)
 
     Q_PROPERTY(VisibilityManager *visibility READ visibility NOTIFY visibilityChanged)
     Q_PROPERTY(Layout *managedLayout READ managedLayout WRITE setManagedLayout NOTIFY managedLayoutChanged)
     Q_PROPERTY(QQmlListProperty<QScreen> screens READ screens)
 
     Q_PROPERTY(QRect effectsArea READ effectsArea WRITE setEffectsArea NOTIFY effectsAreaChanged)
     Q_PROPERTY(QRect localGeometry READ localGeometry WRITE setLocalGeometry NOTIFY localGeometryChanged)
     Q_PROPERTY(QRect maskArea READ maskArea WRITE setMaskArea NOTIFY maskAreaChanged)
     Q_PROPERTY(QRect screenGeometry READ screenGeometry NOTIFY screenGeometryChanged)
 
 public:
     DockView(Plasma::Corona *corona, QScreen *targetScreen = nullptr, bool dockWindowBehavior = false);
     virtual ~DockView();
 
     void init();
 
     void setScreenToFollow(QScreen *screen, bool updateScreenId = true);
 
     void resizeWindow(QRect availableScreenRect = QRect());
     void syncGeometry();
 
     bool alternativesIsShown() const;
     void setAlternativesIsShown(bool show);
 
     bool onPrimary() const;
     void setOnPrimary(bool flag);
 
     int currentThickness() const;
 
     int docksCount() const;
     int totalDocksCount() const;
 
     bool behaveAsPlasmaPanel() const;
     void setBehaveAsPlasmaPanel(bool behavior);
 
     bool blockAnimations() const;
     void setBlockAnimations(bool block);
 
+    bool colorizerSupport() const;
+    void setColorizerSupport(bool support);
+
     bool contextMenuIsShown() const;
 
     bool dockWinBehavior() const;
     void setDockWinBehavior(bool dock);
 
     bool drawShadows() const;
     void setDrawShadows(bool draw);
 
     bool drawEffects() const;
     void setDrawEffects(bool draw);
 
     bool inEditMode() const;
     void setInEditMode(bool edit);
 
     float maxLength() const;
     void setMaxLength(float length);
 
     int dockTransparency() const;
     void setDockTransparency(int transparency);
 
     int fontPixelSize() const;
     void setFontPixelSize(int size);
 
     int maxThickness() const;
     void setMaxThickness(int thickness);
 
     int normalThickness() const;
     void setNormalThickness(int thickness);
 
     int offset() const;
     void setOffset(int offset);
 
     int shadow() const;
     void setShadow(int shadow);
 
     int alignment() const;
     void setAlignment(int alignment);
 
     QRect maskArea() const;
     void setMaskArea(QRect area);
 
     QRect effectsArea() const;
     void setEffectsArea(QRect area);
 
     QRect absGeometry() const;
     QRect screenGeometry() const;
 
     bool inLocationChangeAnimation();
 
     Plasma::FrameSvg::EnabledBorders enabledBorders() const;
 
     QString currentScreen() const;
 
     QRect localGeometry() const;
     void setLocalGeometry(const QRect &geometry);
 
     bool settingsWindowIsShown();
     void showSettingsWindow();
 
     VisibilityManager *visibility() const;
 
     Layout *managedLayout() const;
     void setManagedLayout(Layout *layout);
 
     QQmlListProperty<QScreen> screens();
     static int countScreens(QQmlListProperty<QScreen> *property);
     static QScreen *atScreens(QQmlListProperty<QScreen> *property, int index);
     void reconsiderScreen();
 
     //! these are signals that create crashes, such a example is the availableScreenRectChanged from corona
     //! when its containment is destroyed
     void disconnectSensitiveSignals();
 
 public slots:
     Q_INVOKABLE void addNewDock();
     Q_INVOKABLE void removeDock();
     Q_INVOKABLE void copyDock();
 
     Q_INVOKABLE QList<int> freeEdges() const;
     Q_INVOKABLE QVariantList containmentActions();
 
     Q_INVOKABLE void deactivateApplets();
     Q_INVOKABLE void moveToLayout(QString layoutName);
     Q_INVOKABLE void removeTasksPlasmoid();
     Q_INVOKABLE void setBlockHiding(bool block);
     Q_INVOKABLE void toggleAppletExpanded(const int id);
     Q_INVOKABLE void updateEnabledBorders();
 
     Q_INVOKABLE void hideDockDuringLocationChange(int goToLocation);
     Q_INVOKABLE void hideDockDuringMovingToLayout(QString layoutName);
 
     Q_INVOKABLE int docksWithTasks();
 
     Q_INVOKABLE bool mimeContainsPlasmoid(QMimeData *mimeData, QString name);
     Q_INVOKABLE bool setCurrentScreen(const QString id);
     Q_INVOKABLE bool tasksPresent();
     Q_INVOKABLE bool latteTasksPresent();
 
     Q_INVOKABLE void closeApplication();
 
     void updateAbsDockGeometry(bool bypassChecks = false);
 
 protected slots:
     void showConfigurationInterface(Plasma::Applet *applet) override;
 
 protected:
     bool event(QEvent *ev) override;
     void mousePressEvent(QMouseEvent *event) override;
 
 signals:
     void addInternalViewSplitter();
     void removeInternalViewSplitter();
     void eventTriggered(QEvent *ev);
 
     //! these two signals are used from config ui and containment ui
     //! in order to orchestrate an animated hiding/showing of dock
     //! during changing location
     void hideDockDuringLocationChangeStarted();
     void hideDockDuringLocationChangeFinished();
     void hideDockDuringScreenChangeStarted();
     void hideDockDuringScreenChangeFinished();
     void hideDockDuringMovingToLayoutStarted();
     void hideDockDuringMovingToLayoutFinished();
     void showDockAfterLocationChangeFinished();
     void showDockAfterScreenChangeFinished();
     void showDockAfterMovingToLayoutFinished();
 
     void activitiesChanged();
     void alternativesIsShownChanged();
     void alignmentChanged();
     void behaveAsPlasmaPanelChanged();
     void blockAnimationsChanged();
+    void colorizerSupportChanged();
     void contextMenuIsShownChanged();
     void currentScreenChanged();
     void dockLocationChanged();
     void docksCountChanged();
     void dockTransparencyChanged();
     void dockWinBehaviorChanged();
     void drawShadowsChanged();
     void drawEffectsChanged();
     void effectsAreaChanged();
     void enabledBordersChanged();
     void fontPixelSizeChanged();
     void widthChanged();
     void heightChanged();
     void inEditModeChanged();
     void localGeometryChanged();
     void managedLayoutChanged();
     void maxLengthChanged();
     void maxThicknessChanged();
     void normalThicknessChanged();
     void offsetChanged();
     void onPrimaryChanged();
     void visibilityChanged();
     void maskAreaChanged();
     void screenGeometryChanged();
     void shadowChanged();
     void themeChanged();
     void totalDocksCountChanged();
     void xChanged();
     void yChanged();
 
     void absGeometryChanged(const QRect &geometry);
 
 private slots:
     void availableScreenRectChanged();
     void hideWindowsForSlidingOut();
     void statusChanged(Plasma::Types::ItemStatus);
     void screenChanged(QScreen *screen);
     void updateEffects();
 
     void restoreConfig();
     void saveConfig();
 
 private:
     void applyActivitiesToWindows();
     void initSignalingForLocationChangeSliding();
     void setupWaylandIntegration();
     void updatePosition(QRect availableScreenRect = QRect());
     void updateFormFactor();
     void updateAppletContainsMethod();
 
     QRect maximumNormalGeometry();
 
 private:
     Plasma::Containment *containmentById(uint id);
 
     bool m_alternativesIsShown{false};
     bool m_behaveAsPlasmaPanel{false};
     bool m_blockAnimations{false};
-    bool m_forceDrawCenteredBorders{false};
+    bool m_colorizerSupport{false};
     bool m_dockWinBehavior{true};
     bool m_drawShadows{true};
     bool m_drawEffects{false};
+    bool m_forceDrawCenteredBorders{false};
     bool m_inDelete{false};
     bool m_inEditMode{false};
     bool m_onPrimary{true};
     int m_dockTransparency{100};
-    int m_fontPixelSize{-1};
+    int m_fontPixelSize{ -1};
     int m_maxThickness{24};
     int m_normalThickness{24};
     int m_offset{0};
     int m_shadow{0};
     float m_maxLength{1};
 
     Dock::Alignment m_alignment{Dock::Center};
 
     QRect m_effectsArea;
     QRect m_localGeometry;
     QRect m_absGeometry;
     QRect m_maskArea;
     Layout *m_managedLayout{nullptr};
     QPointer<PlasmaQuick::ConfigView> m_configView;
 
     QPointer<VisibilityManager> m_visibility;
     QPointer<DockMenuManager> m_menuManager;
     QPointer<QScreen> m_screenToFollow;
 
     QString m_screenToFollowId;
 
     QTimer m_screenSyncTimer;
 
     //! Connections to release and bound for the managed layout
     std::array<QMetaObject::Connection, 4> connectionsManagedLayout;
 
     //!used at sliding out/in animation
     QString m_moveToLayout;
     Plasma::Types::Location m_goToLocation{Plasma::Types::Floating};
     QScreen *m_goToScreen{nullptr};
 
     Plasma::Theme m_theme;
     //only for the mask on disabled compositing, not to actually paint
     Plasma::FrameSvg *m_background{nullptr};
 
     //only for the mask, not to actually paint
     Plasma::FrameSvg::EnabledBorders m_enabledBorders{Plasma::FrameSvg::AllBorders};
     KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
 };
 
 }
 
 #endif
diff --git a/app/layout.cpp b/app/layout.cpp
index ff822362..e76ec4ef 100644
--- a/app/layout.cpp
+++ b/app/layout.cpp
@@ -1,1602 +1,1609 @@
 /*
 *  Copyright 2017  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 "layout.h"
 
 #include "dockcorona.h"
 #include "importer.h"
 #include "layoutmanager.h"
 #include "screenpool.h"
 #include "dock/dockview.h"
 
 #include <QDir>
 #include <QFile>
 
 #include <Plasma>
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 
 #include <KSharedConfig>
 #include <KActivities/Consumer>
 
 namespace Latte {
 
 const QString Layout::MultipleLayoutsName = ".multiple-layouts_hidden";
 
 Layout::Layout(QObject *parent, QString layoutFile, QString assignedName)
     : QObject(parent)
 {
     qDebug() << "Layout file to create object: " << layoutFile << " with name: " << assignedName;
 
     if (QFile(layoutFile).exists()) {
         if (assignedName.isEmpty()) {
             assignedName =  layoutName(layoutFile);
         }
 
         //!this order is important because setFile initializes also the m_layoutGroup
         setFile(layoutFile);
         setName(assignedName);
         loadConfig();
         init();
     }
 }
 
 Layout::~Layout()
 {
     if (!m_layoutFile.isEmpty()) {
         m_layoutGroup.sync();
     }
 }
 
 void Layout::syncToLayoutFile()
 {
     if (!m_corona) {
         return;
     }
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(m_layoutFile);
 
     KConfigGroup oldContainments = KConfigGroup(filePtr, "Containments");
     oldContainments.deleteGroup();
     oldContainments.sync();
 
     qDebug() << " LAYOUT :: " << m_layoutName << " is syncing its original file.";
 
     foreach (auto containment, m_containments) {
         containment->config().writeEntry("layoutId", "");
         KConfigGroup newGroup = oldContainments.group(QString::number(containment->id()));
         containment->config().copyTo(&newGroup);
     }
 
     oldContainments.sync();
 }
 
 void Layout::unloadContainments()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "Layout - " + name() + " unload: containments ... size ::: " << m_containments.size()
              << " ,dockViews in memory ::: " << m_dockViews.size()
              << " ,hidden dockViews in memory :::  " << m_waitingDockViews.size();
 
     foreach (auto view, m_dockViews) {
         view->disconnectSensitiveSignals();
     }
 
     foreach (auto view, m_waitingDockViews) {
         view->disconnectSensitiveSignals();
     }
 
     m_unloadedContainmentsIds.clear();
 
     QList<Plasma::Containment *> systrays;
 
     //!identify systrays and unload them first
     foreach (auto containment, m_containments) {
         if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
             systrays.append(containment);
         }
     }
 
     while (!systrays.isEmpty()) {
         Plasma::Containment *systray = systrays.at(0);
         m_unloadedContainmentsIds << QString::number(systray->id());
         systrays.removeFirst();
         m_containments.removeAll(systray);
         delete systray;
     }
 
     while (!m_containments.isEmpty()) {
         Plasma::Containment *containment = m_containments.at(0);
         m_unloadedContainmentsIds << QString::number(containment->id());
         m_containments.removeFirst();
         delete containment;
     }
 }
 
 void Layout::unloadDockViews()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "Layout - " + name() + " unload: dockViews ... size: " << m_dockViews.size();
 
     qDeleteAll(m_dockViews);
     qDeleteAll(m_waitingDockViews);
     m_dockViews.clear();
     m_waitingDockViews.clear();
 }
 
 void Layout::init()
 {
     connect(this, &Layout::activitiesChanged, this, &Layout::saveConfig);
     connect(this, &Layout::backgroundChanged, this, &Layout::saveConfig);
     connect(this, &Layout::versionChanged, this, &Layout::saveConfig);
     connect(this, &Layout::colorChanged, this, &Layout::textColorChanged);
     connect(this, &Layout::showInMenuChanged, this, &Layout::saveConfig);
     connect(this, &Layout::textColorChanged, this, &Layout::saveConfig);
     connect(this, &Layout::launchersChanged, this, &Layout::saveConfig);
     connect(this, &Layout::lastUsedActivityChanged, this, &Layout::saveConfig);
 }
 
 void Layout::initToCorona(DockCorona *corona)
 {
     m_corona = corona;
 
+    connect(this, &Layout::dockColorizerSupportChanged, m_corona->layoutManager(), &LayoutManager::updateColorizerSupport);
+
     foreach (auto containment, m_corona->containments()) {
         if (m_corona->layoutManager()->memoryUsage() == Dock::SingleLayout) {
             addContainment(containment);
         } else if (m_corona->layoutManager()->memoryUsage() == Dock::MultipleLayouts) {
             QString layoutId = containment->config().readEntry("layoutId", QString());
 
             if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
                 addContainment(containment);
             }
         }
     }
 
     qDebug() << "Layout ::::: " << name() << " added contaiments ::: " << m_containments.size();
 
     if (m_layoutName != MultipleLayoutsName) {
         updateLastUsedActivity();
     }
 
     connect(m_corona, &Plasma::Corona::containmentAdded, this, &Layout::addContainment);
 
     if (m_layoutName != MultipleLayoutsName) {
         connect(m_corona->m_activityConsumer, &KActivities::Consumer::currentActivityChanged,
                 this, &Layout::updateLastUsedActivity);
     }
 }
 
 int Layout::version() const
 {
     return m_version;
 }
 
 void Layout::setVersion(int ver)
 {
     if (m_version == ver) {
         return;
     }
 
     m_version = ver;
 
     emit versionChanged();
 }
 
 bool Layout::showInMenu() const
 {
     return m_showInMenu;
 }
 
 void Layout::setShowInMenu(bool show)
 {
     if (m_showInMenu == show) {
         return;
     }
 
     m_showInMenu = show;
     emit showInMenuChanged();
 }
 
 QString Layout::background() const
 {
     return m_background;
 }
 
 void Layout::setBackground(QString path)
 {
     if (path == m_background) {
         return;
     }
 
     if (!path.isEmpty() && !QFileInfo(path).exists()) {
         return;
     }
 
     m_background = path;
 
     //! initialize the text color also
     if (path.isEmpty()) {
         setTextColor(QString());
     }
 
     emit backgroundChanged();
 }
 
 QString Layout::name() const
 {
     return m_layoutName;
 }
 
 void Layout::setName(QString name)
 {
     if (m_layoutName == name) {
         return;
     }
 
     qDebug() << "Layout name:" << name;
 
     m_layoutName = name;
 
     emit nameChanged();
 }
 
 void Layout::renameLayout(QString newName)
 {
     if (m_layoutFile != Importer::layoutFilePath(newName)) {
         setFile(Importer::layoutFilePath(newName));
     }
 
     if (m_layoutName != newName) {
         setName(newName);
     }
 
     //! thus this is a linked file
     if (m_corona) {
         foreach (auto containment, m_containments) {
             containment->config().writeEntry("layoutId", m_layoutName);
         }
     }
 }
 
 QString Layout::color() const
 {
     return m_color;
 }
 
 void Layout::setColor(QString color)
 {
     if (m_color == color) {
         return;
     }
 
     m_color = color;
     emit colorChanged();
 }
 
 QString Layout::textColor() const
 {
     //! the user is in default layout theme
     if (m_background.isEmpty()) {
         if (m_color == "blue") {
             return "#D7E3FF";
         } else if (m_color == "brown") {
             return "#F1DECB";
         } else if (m_color == "darkgrey") {
             return "#ECECEC";
         } else if (m_color == "gold") {
             return "#7C3636";
         } else if (m_color == "green") {
             return "#4D7549";
         } else if (m_color == "lightskyblue") {
             return "#0C2A43";
         } else if (m_color == "orange") {
             return "#6F3902";
         } else if (m_color == "pink") {
             return "#743C46";
         } else if (m_color == "purple") {
             return "#ECD9FF";
         }  else if (m_color == "red") {
             return "#F3E4E4";
         }  else if (m_color == "wheat") {
             return "#6A4E25";
         }  else {
             return "#FCFCFC";
         }
     }
 
     return "#" + m_textColor;
 }
 
 void Layout::setTextColor(QString color)
 {
     //! remove # if someone is trying to set it this way
     if (color.startsWith("#")) {
         color.remove(0, 1);
     }
 
     if (m_textColor == color) {
         return;
     }
 
     m_textColor = color;
     emit textColorChanged();
 }
 
 QString Layout::file() const
 {
     return m_layoutFile;
 }
 
 void Layout::setFile(QString file)
 {
     if (m_layoutFile == file) {
         return;
     }
 
     qDebug() << "Layout file:" << file;
 
     m_layoutFile = file;
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(m_layoutFile);
     m_layoutGroup = KConfigGroup(filePtr, "LayoutSettings");
 
     emit fileChanged();
 }
 
 QStringList Layout::launchers() const
 {
     return m_launchers;
 }
 
 void Layout::setLaunchers(QStringList launcherList)
 {
     if (m_launchers == launcherList)
         return;
 
     m_launchers = launcherList;
 
     emit launchersChanged();
 }
 
 QStringList Layout::activities() const
 {
     return m_activities;
 }
 
 void Layout::setActivities(QStringList activities)
 {
     if (m_activities == activities) {
         return;
     }
 
     m_activities = activities;
 
     emit activitiesChanged();
 }
 
 QStringList Layout::unloadedContainmentsIds()
 {
     return m_unloadedContainmentsIds;
 }
 
 bool Layout::isActiveLayout() const
 {
     if (!m_corona) {
         return false;
     }
 
     Layout *activeLayout = m_corona->layoutManager()->activeLayout(m_layoutName);
 
     if (activeLayout) {
         return true;
     } else {
         return false;
     }
 }
 
 bool Layout::isOriginalLayout() const
 {
     return m_layoutName != MultipleLayoutsName;
 }
 
 bool Layout::layoutIsBroken() const
 {
     if (m_layoutFile.isEmpty() || !QFile(m_layoutFile).exists()) {
         return false;
     }
 
     QStringList ids;
     QStringList conts;
     QStringList applets;
 
     KSharedConfigPtr lFile = KSharedConfig::openConfig(m_layoutFile);
 
 
     if (!m_corona) {
         KConfigGroup containmentsEntries = KConfigGroup(lFile, "Containments");
         ids << containmentsEntries.groupList();
         conts << ids;
 
         foreach (auto cId, containmentsEntries.groupList()) {
             auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
             ids << appletsEntries.groupList();
             applets << appletsEntries.groupList();
         }
     } else {
         foreach (auto containment, m_containments) {
             ids << QString::number(containment->id());
             conts << ids;
 
             foreach (auto applet, containment->applets()) {
                 ids << QString::number(applet->id());
                 applets << QString::number(applet->id());
             }
         }
     }
 
     QSet<QString> idsSet = QSet<QString>::fromList(ids);
 
     /* a different way to count duplicates
     QMap<QString, int> countOfStrings;
 
     for (int i = 0; i < ids.count(); i++) {
         countOfStrings[ids[i]]++;
     }*/
 
     if (idsSet.count() != ids.count()) {
         qDebug() << "   ----   ERROR - BROKEN LAYOUT :: " << m_layoutName << " ----";
 
         if (!m_corona) {
             qDebug() << "   ---- file : " << m_layoutFile;
         } else {
             qDebug() << "   ---- in multiple layouts hidden file : " << Importer::layoutFilePath(Layout::MultipleLayoutsName);
         }
 
         qDebug() << "Contaiments :: " << conts;
         qDebug() << "Applets :: " << applets;
 
         foreach (QString c, conts) {
             if (applets.contains(c)) {
                 qDebug() << "Error: Same applet and containment id found ::: " << c;
             }
         }
 
         for (int i = 0; i < ids.count(); ++i) {
             for (int j = i + 1; j < ids.count(); ++j) {
                 if (ids[i] == ids[j]) {
                     qDebug() << "Error: Applets with same id ::: " << ids[i];
                 }
             }
         }
 
         qDebug() << "  -- - -- - -- - -- - - -- - - - - -- - - - - ";
 
         if (!m_corona) {
             KConfigGroup containmentsEntries = KConfigGroup(lFile, "Containments");
 
             foreach (auto cId, containmentsEntries.groupList()) {
                 auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
                 qDebug() << " CONTAINMENT : " << cId << " APPLETS : " << appletsEntries.groupList();
             }
         } else {
             foreach (auto containment, m_containments) {
                 QStringList appletsIds;
 
                 foreach (auto applet, containment->applets()) {
                     appletsIds << QString::number(applet->id());
                 }
 
                 qDebug() << " CONTAINMENT : " << containment->id() << " APPLETS : " << appletsIds.join(",");
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 QString Layout::layoutName(const QString &fileName)
 {
     int lastSlash = fileName.lastIndexOf("/");
     QString tempLayoutFile = fileName;
     QString layoutName = tempLayoutFile.remove(0, lastSlash + 1);
 
     int ext = layoutName.lastIndexOf(".layout.latte");
     layoutName = layoutName.remove(ext, 13);
 
     return layoutName;
 }
 
 void Layout::loadConfig()
 {
     m_version = m_layoutGroup.readEntry("version", 2);
     m_color = m_layoutGroup.readEntry("color", QString("blue"));
     m_showInMenu = m_layoutGroup.readEntry("showInMenu", false);
     m_textColor = m_layoutGroup.readEntry("textColor", QString("fcfcfc"));
     m_activities = m_layoutGroup.readEntry("activities", QStringList());
     m_launchers = m_layoutGroup.readEntry("launchers", QStringList());
     m_lastUsedActivity = m_layoutGroup.readEntry("lastUsedActivity", QString());
 
     QString back = m_layoutGroup.readEntry("background", "");
 
     if (!back.isEmpty()) {
         if (QFileInfo(back).exists()) {
             m_background = back;
         } else {
             m_layoutGroup.writeEntry("background", QString());
         }
     }
 
     emit activitiesChanged();
 }
 
 void Layout::saveConfig()
 {
     qDebug() << "layout is saving... for layout:" << m_layoutName;
     m_layoutGroup.writeEntry("version", m_version);
     m_layoutGroup.writeEntry("showInMenu", m_showInMenu);
     m_layoutGroup.writeEntry("color", m_color);
     m_layoutGroup.writeEntry("launchers", m_launchers);
     m_layoutGroup.writeEntry("background", m_background);
     m_layoutGroup.writeEntry("activities", m_activities);
     m_layoutGroup.writeEntry("lastUsedActivity", m_lastUsedActivity);
     m_layoutGroup.writeEntry("textColor", m_textColor);
 
     m_layoutGroup.sync();
 }
 
 //! Containments Actions
 
 void Layout::addContainment(Plasma::Containment *containment)
 {
     if (!containment || m_containments.contains(containment)) {
         return;
     }
 
     bool containmentInLayout{false};
 
     if (m_corona->layoutManager()->memoryUsage() == Dock::SingleLayout) {
         m_containments.append(containment);
         containmentInLayout = true;
     } else if (m_corona->layoutManager()->memoryUsage() == Dock::MultipleLayouts) {
         QString layoutId = containment->config().readEntry("layoutId", QString());
 
         if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
             m_containments.append(containment);
             containmentInLayout = true;
         }
     }
 
     if (containmentInLayout) {
         addDock(containment);
         connect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
     }
 }
 
 QHash<const Plasma::Containment *, DockView *> *Layout::dockViews()
 {
     return &m_dockViews;
 }
 
 QList<Plasma::Containment *> *Layout::containments()
 {
     return &m_containments;
 }
 
 const QStringList Layout::appliedActivities()
 {
     if (!m_corona) {
         return {};
     }
 
     if (m_corona->layoutManager()->memoryUsage() == Dock::SingleLayout) {
         return {"0"};
     } else if (m_corona->layoutManager()->memoryUsage() == Dock::MultipleLayouts) {
         if (m_activities.isEmpty()) {
             return m_corona->layoutManager()->orphanedActivities();
         } else {
             return m_activities;
         }
     }
 }
 
 QString Layout::lastUsedActivity()
 {
     return m_lastUsedActivity;
 }
 
 void Layout::clearLastUsedActivity()
 {
     m_lastUsedActivity = "";
     emit lastUsedActivityChanged();
 }
 
 void Layout::updateLastUsedActivity()
 {
     if (!m_corona) {
         return;
     }
 
     if (!m_lastUsedActivity.isEmpty() && !m_corona->layoutManager()->activities().contains(m_lastUsedActivity)) {
         clearLastUsedActivity();
     }
 
     QString currentId = m_corona->activitiesConsumer()->currentActivity();
 
     if (appliedActivities().contains(currentId) && m_lastUsedActivity != currentId) {
         m_lastUsedActivity = currentId;
 
         emit lastUsedActivityChanged();
     }
 }
 
 void Layout::destroyedChanged(bool destroyed)
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "dock containment destroyed changed!!!!";
     Plasma::Containment *sender = qobject_cast<Plasma::Containment *>(QObject::sender());
 
     if (!sender) {
         return;
     }
 
     if (destroyed) {
         m_waitingDockViews[sender] = m_dockViews.take(static_cast<Plasma::Containment *>(sender));
     } else {
         m_dockViews[sender] = m_waitingDockViews.take(static_cast<Plasma::Containment *>(sender));
     }
 
     emit m_corona->docksCountChanged();
     emit m_corona->availableScreenRectChanged();
     emit m_corona->availableScreenRegionChanged();
 }
 
 void Layout::containmentDestroyed(QObject *cont)
 {
     if (!m_corona) {
         return;
     }
 
     Plasma::Containment *containment = static_cast<Plasma::Containment *>(cont);
 
     if (containment) {
         int containmentIndex = m_containments.indexOf(containment);
 
         if (containmentIndex >= 0) {
             m_containments.removeAt(containmentIndex);
         }
 
         qDebug() << "Layout " << name() << " :: containment destroyed!!!!";
         auto view = m_dockViews.take(containment);
 
         if (!view) {
             view = m_waitingDockViews.take(containment);
         }
 
         if (view) {
             view->disconnectSensitiveSignals();
             view->deleteLater();
 
             emit m_corona->docksCountChanged();
             emit m_corona->availableScreenRectChanged();
             emit m_corona->availableScreenRegionChanged();
+            emit dockColorizerSupportChanged();
         }
     }
 }
 
 void Layout::addDock(Plasma::Containment *containment, bool forceLoading, int expDockScreen)
 {
     qDebug() << "Layout :::: " << m_layoutName << " ::: addDock was called... m_containments :: " << m_containments.size();
 
     if (!containment || !m_corona || !containment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto metadata = containment->kPackage().metadata();
 
     qDebug() << "step 1...";
 
     if (metadata.pluginId() != "org.kde.latte.containment")
         return;
 
     qDebug() << "step 2...";
 
     for (auto *dock : m_dockViews) {
         if (dock->containment() == containment)
             return;
     }
 
     qDebug() << "step 3...";
 
     QScreen *nextScreen{qGuiApp->primaryScreen()};
 
     bool onPrimary = containment->config().readEntry("onPrimary", true);
     int id = containment->screen();
 
     if (id == -1 && expDockScreen == -1) {
         id = containment->lastScreen();
     }
 
     if (expDockScreen > -1) {
         id = expDockScreen;
     }
 
     qDebug() << "add dock - containment id: " << containment->id() << " ,screen id : " << id << " ,onprimary:" << onPrimary << " ,forceDockLoad:" << forceLoading;
 
     if (id >= 0 && !onPrimary && !forceLoading) {
         QString connector = m_corona->screenPool()->connector(id);
         qDebug() << "add dock - connector : " << connector;
         bool found{false};
 
         foreach (auto scr, qGuiApp->screens()) {
             if (scr && scr->name() == connector) {
                 found = true;
                 nextScreen = scr;
                 break;
             }
         }
 
         if (!found) {
             qDebug() << "adding dock rejected, screen not available ! : " << connector;
             return;
         }
     } else if (onPrimary) {
         if (explicitDockOccupyEdge(m_corona->screenPool()->primaryScreenId(), containment->location())) {
             qDebug() << "CORONA ::: adding dock rejected, the edge is occupied by explicit dock ! : " <<  containment->location();
             //we must check that an onPrimary dock should never catch up the same edge on
             //the same screen with an explicit dock
             return;
         }
     }
 
     qDebug() << "Adding dock for container...";
     qDebug() << "onPrimary: " << onPrimary << "screen!!! :" << nextScreen->name();
 
     //! it is used to set the correct flag during the creation
     //! of the window... This of course is also used during
     //! recreations of the window between different visibility modes
     auto mode = static_cast<Dock::Visibility>(containment->config().readEntry("visibility", static_cast<int>(Dock::DodgeActive)));
     bool dockWin{true};
 
     if (mode == Dock::AlwaysVisible || mode == Dock::WindowsGoBelow) {
         dockWin = true;
     } else {
         dockWin = containment->config().readEntry("dockWindowBehavior", true);
     }
 
     auto dockView = new DockView(m_corona, nextScreen, dockWin);
+
     dockView->init();
     dockView->setContainment(containment);
     dockView->setManagedLayout(this);
 
     //! force this special dock case to become primary
     //! even though it isnt
     if (forceLoading) {
         dockView->setOnPrimary(true);
     }
 
     //  connect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
     connect(containment, &Plasma::Applet::destroyedChanged, this, &Layout::destroyedChanged);
     connect(containment, &Plasma::Applet::locationChanged, m_corona, &DockCorona::dockLocationChanged);
     connect(containment, &Plasma::Containment::appletAlternativesRequested
             , m_corona, &DockCorona::showAlternativesForApplet, Qt::QueuedConnection);
 
     if (m_corona->layoutManager()->memoryUsage() == Dock::MultipleLayouts) {
         connect(containment, &Plasma::Containment::appletCreated, this, &Layout::appletCreated);
     }
 
+    connect(dockView, &DockView::colorizerSupportChanged, this, &Layout::dockColorizerSupportChanged);
+
     //! Qt 5.9 creates a crash for this in wayland, that is why the check is used
     //! but on the other hand we need this for copy to work correctly and show
     //! the copied dock under X11
     //if (!KWindowSystem::isPlatformWayland()) {
     dockView->show();
     //}
 
     m_dockViews[containment] = dockView;
 
+    emit dockColorizerSupportChanged();
     emit m_corona->docksCountChanged();
 }
 
 void Layout::copyDock(Plasma::Containment *containment)
 {
     if (!containment || !m_corona)
         return;
 
     qDebug() << "copying containment layout";
     //! Settting mutable for create a containment
     m_corona->setImmutability(Plasma::Types::Mutable);
 
     QString temp1File = QDir::homePath() + "/.config/lattedock.copy1.bak";
 
     //! WE NEED A WAY TO COPY A CONTAINMENT!!!!
     QFile copyFile(temp1File);
 
     if (copyFile.exists())
         copyFile.remove();
 
 
     KSharedConfigPtr newFile = KSharedConfig::openConfig(temp1File);
     KConfigGroup copied_conts = KConfigGroup(newFile, "Containments");
     KConfigGroup copied_c1 = KConfigGroup(&copied_conts, QString::number(containment->id()));
     KConfigGroup copied_systray;
 
     // toCopyContainmentIds << QString::number(containment->id());
     //  toCopyAppletIds << containment->config().group("Applets").groupList();
     containment->config().copyTo(&copied_c1);
 
     //!investigate if there is a systray in the containment to copy also
     int systrayId = -1;
     QString systrayAppletId;
     auto applets = containment->config().group("Applets");
 
     foreach (auto applet, applets.groupList()) {
         KConfigGroup appletSettings = applets.group(applet).group("Configuration");
 
         int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
         if (tSysId != -1) {
             systrayId = tSysId;
             systrayAppletId = applet;
             qDebug() << "systray was found in the containment... ::: " << tSysId;
             break;
         }
     }
 
     if (systrayId != -1) {
         Plasma::Containment *systray{nullptr};
 
         foreach (auto containment, m_corona->containments()) {
             if (containment->id() == systrayId) {
                 systray = containment;
                 break;
             }
         }
 
         if (systray) {
             copied_systray = KConfigGroup(&copied_conts, QString::number(systray->id()));
             //  toCopyContainmentIds << QString::number(systray->id());
             //  toCopyAppletIds << systray->config().group("Applets").groupList();
             systray->config().copyTo(&copied_systray);
         }
     }
 
     //! end of systray specific code
 
     //! update ids to unique ones
     QString temp2File = newUniqueIdsLayoutFromFile(temp1File);
 
 
     //! Finally import the configuration
     QList<Plasma::Containment *> importedDocks = importLayoutFile(temp2File);
 
     Plasma::Containment *newContainment{nullptr};
 
     if (importedDocks.size() == 1) {
         newContainment = importedDocks[0];
     }
 
     if (!newContainment || !newContainment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto config = newContainment->config();
 
     //in multi-screen environment the copied dock is moved to alternative screens first
     const auto screens = qGuiApp->screens();
     auto dock = m_dockViews[containment];
 
     bool setOnExplicitScreen = false;
 
     int dockScrId = -1;
     int copyScrId = -1;
 
     if (dock) {
         dockScrId = m_corona->screenPool()->id(dock->currentScreen());
         qDebug() << "COPY DOCK SCREEN ::: " << dockScrId;
 
         if (dockScrId != -1 && screens.count() > 1) {
             foreach (auto scr, screens) {
                 copyScrId = m_corona->screenPool()->id(scr->name());
 
                 //the screen must exist and not be the same with the original dock
                 if (copyScrId > -1 && copyScrId != dockScrId) {
                     QList<Plasma::Types::Location> fEdges = freeEdges(copyScrId);
 
                     if (fEdges.contains((Plasma::Types::Location)containment->location())) {
                         ///set this containment to an explicit screen
                         config.writeEntry("onPrimary", false);
                         config.writeEntry("lastScreen", copyScrId);
                         newContainment->setLocation(containment->location());
 
                         qDebug() << "COPY DOCK SCREEN NEW SCREEN ::: " << copyScrId;
 
                         setOnExplicitScreen = true;
                         break;
                     }
                 }
             }
         }
     }
 
     if (!setOnExplicitScreen) {
         QList<Plasma::Types::Location> edges = freeEdges(newContainment->screen());
 
         if (edges.count() > 0) {
             newContainment->setLocation(edges.at(0));
         } else {
             newContainment->setLocation(Plasma::Types::BottomEdge);
         }
 
         config.writeEntry("onPrimary", false);
         config.writeEntry("lastScreen", dockScrId);
     }
 
     newContainment->config().sync();
 
     if (setOnExplicitScreen && copyScrId > -1) {
         qDebug() << "Copy Dock in explicit screen ::: " << copyScrId;
         addDock(newContainment, copyScrId);
         newContainment->reactToScreenChange();
     } else {
         qDebug() << "Copy Dock in current screen...";
         addDock(newContainment, dockScrId);
     }
 }
 
 void Layout::appletCreated(Plasma::Applet *applet)
 {
     //! In Multiple Layout the orphaned systrays must be assigned to layouts
     //! when the user adds them
     KConfigGroup appletSettings = applet->containment()->config().group("Applets").group(QString::number(applet->id())).group("Configuration");
 
     int systrayId = appletSettings.readEntry("SystrayContainmentId", -1);
 
     if (systrayId != -1) {
         uint sId = (uint)systrayId;
 
         foreach (auto containment, m_corona->containments()) {
             if (containment->id() == sId) {
                 containment->config().writeEntry("layoutId", m_layoutName);
             }
 
             addContainment(containment);
         }
     }
 }
 
 void Layout::importToCorona()
 {
     if (!m_corona) {
         return;
     }
 
     //! Settting mutable for create a containment
     m_corona->setImmutability(Plasma::Types::Mutable);
 
     QString temp1File = QDir::homePath() + "/.config/lattedock.copy1.bak";
 
     //! WE NEED A WAY TO COPY A CONTAINMENT!!!!
     QFile copyFile(temp1File);
 
     if (copyFile.exists())
         copyFile.remove();
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(m_layoutFile);
     KSharedConfigPtr newFile = KSharedConfig::openConfig(temp1File);
     KConfigGroup copyGroup = KConfigGroup(newFile, "Containments");
     KConfigGroup current_containments = KConfigGroup(filePtr, "Containments");
 
     current_containments.copyTo(&copyGroup);
 
     copyGroup.sync();
 
     //! update ids to unique ones
     QString temp2File = newUniqueIdsLayoutFromFile(temp1File);
 
 
     //! Finally import the configuration
     importLayoutFile(temp2File);
 }
 
 QString Layout::availableId(QStringList all, QStringList assigned, int base)
 {
     bool found = false;
 
     int i = base;
 
     while (!found && i < 32000) {
         QString iStr = QString::number(i);
 
         if (!all.contains(iStr) && !assigned.contains(iStr)) {
             return iStr;
         }
 
         i++;
     }
 
     return QString("");
 }
 
 QString Layout::newUniqueIdsLayoutFromFile(QString file)
 {
     if (!m_corona) {
         return QString();
     }
 
     QString tempFile = QDir::homePath() + "/.config/lattedock.copy2.bak";
 
     QFile copyFile(tempFile);
 
     if (copyFile.exists())
         copyFile.remove();
 
     //! BEGIN updating the ids in the temp file
     QStringList allIds;
     allIds << m_corona->containmentsIds();
     allIds << m_corona->appletsIds();
 
     QStringList toInvestigateContainmentIds;
     QStringList toInvestigateAppletIds;
     QStringList toInvestigateSystrayContIds;
 
     //! first is the systray containment id
     QHash<QString, QString> systrayParentContainmentIds;
     QHash<QString, QString> systrayAppletIds;
 
     //qDebug() << "Ids:" << allIds;
 
     //qDebug() << "to copy containments: " << toCopyContainmentIds;
     //qDebug() << "to copy applets: " << toCopyAppletIds;
 
     QStringList assignedIds;
     QHash<QString, QString> assigned;
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(file);
     KConfigGroup investigate_conts = KConfigGroup(filePtr, "Containments");
     //KConfigGroup copied_c1 = KConfigGroup(&copied_conts, QString::number(containment->id()));
 
     //! Record the containment and applet ids
     foreach (auto cId, investigate_conts.groupList()) {
         toInvestigateContainmentIds << cId;
         auto appletsEntries = investigate_conts.group(cId).group("Applets");
         toInvestigateAppletIds << appletsEntries.groupList();
 
         //! investigate for systrays
         foreach (auto appletId, appletsEntries.groupList()) {
             KConfigGroup appletSettings = appletsEntries.group(appletId).group("Configuration");
 
             int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
             //! It is a systray !!!
             if (tSysId != -1) {
                 QString tSysIdStr = QString::number(tSysId);
                 toInvestigateSystrayContIds << tSysIdStr;
                 systrayParentContainmentIds[tSysIdStr] = cId;
                 systrayAppletIds[tSysIdStr] = appletId;
                 qDebug() << "systray was found in the containment...";
             }
         }
     }
 
     //! Reassign containment and applet ids to unique ones
     foreach (auto contId, toInvestigateContainmentIds) {
         QString newId = availableId(allIds, assignedIds, 12);
 
         assignedIds << newId;
         assigned[contId] = newId;
     }
 
     foreach (auto appId, toInvestigateAppletIds) {
         QString newId = availableId(allIds, assignedIds, 40);
 
         assignedIds << newId;
         assigned[appId] = newId;
     }
 
     qDebug() << "ALL CORONA IDS ::: " << allIds;
     qDebug() << "FULL ASSIGNMENTS ::: " << assigned;
 
     foreach (auto cId, toInvestigateContainmentIds) {
         QString value = assigned[cId];
 
         if (assigned.contains(value)) {
             QString value2 = assigned[value];
 
             if (cId != assigned[cId] && !value2.isEmpty() && cId == value2) {
                 qDebug() << "PROBLEM APPEARED !!!! FOR :::: " << cId << " .. fixed ..";
                 assigned[cId] = cId;
                 assigned[value] = value;
             }
         }
     }
 
     foreach (auto aId, toInvestigateAppletIds) {
         QString value = assigned[aId];
 
         if (assigned.contains(value)) {
             QString value2 = assigned[value];
 
             if (aId != assigned[aId] && !value2.isEmpty() && aId == value2) {
                 qDebug() << "PROBLEM APPEARED !!!! FOR :::: " << aId << " .. fixed ..";
                 assigned[aId] = aId;
                 assigned[value] = value;
             }
         }
     }
 
     qDebug() << "FIXED FULL ASSIGNMENTS ::: " << assigned;
 
     //! update applet ids in their contaiment order and in MultipleLayouts update also the layoutId
     foreach (auto cId, investigate_conts.groupList()) {
         //! Update (appletOrder) and (lockedZoomApplets)
         for (int i = 1; i <= 2; ++i) {
             QString settingStr = (i == 1) ? "appletOrder" : "lockedZoomApplets";
             QString order1 = investigate_conts.group(cId).group("General").readEntry(settingStr, QString());
 
             if (!order1.isEmpty()) {
                 QStringList order1Ids = order1.split(";");
                 QStringList fixedOrder1Ids;
 
                 for (int i = 0; i < order1Ids.count(); ++i) {
                     fixedOrder1Ids.append(assigned[order1Ids[i]]);
                 }
 
                 QString fixedOrder1 = fixedOrder1Ids.join(";");
                 investigate_conts.group(cId).group("General").writeEntry(settingStr, fixedOrder1);
             }
         }
 
         if (m_corona->layoutManager()->memoryUsage() == Dock::MultipleLayouts) {
             investigate_conts.group(cId).writeEntry("layoutId", m_layoutName);
         }
     }
 
     //! must update also the systray id in its applet
     foreach (auto systrayId, toInvestigateSystrayContIds) {
         KConfigGroup systrayParentContainment = investigate_conts.group(systrayParentContainmentIds[systrayId]);
         systrayParentContainment.group("Applets").group(systrayAppletIds[systrayId]).group("Configuration").writeEntry("SystrayContainmentId", assigned[systrayId]);
         systrayParentContainment.sync();
     }
 
     investigate_conts.sync();
 
     //! Copy To Temp 2 File And Update Correctly The Ids
     KSharedConfigPtr file2Ptr = KSharedConfig::openConfig(tempFile);
     KConfigGroup fixedNewContainmets = KConfigGroup(file2Ptr, "Containments");
 
     foreach (auto contId, investigate_conts.groupList()) {
         QString pluginId = investigate_conts.group(contId).readEntry("plugin", "");
 
         if (pluginId != "org.kde.desktopcontainment") { //!dont add ghost containments
             KConfigGroup newContainmentGroup = fixedNewContainmets.group(assigned[contId]);
             investigate_conts.group(contId).copyTo(&newContainmentGroup);
 
             newContainmentGroup.group("Applets").deleteGroup();
 
             foreach (auto appId, investigate_conts.group(contId).group("Applets").groupList()) {
                 KConfigGroup appletGroup = investigate_conts.group(contId).group("Applets").group(appId);
                 KConfigGroup newAppletGroup = fixedNewContainmets.group(assigned[contId]).group("Applets").group(assigned[appId]);
                 appletGroup.copyTo(&newAppletGroup);
             }
         }
     }
 
     fixedNewContainmets.sync();
 
     return tempFile;
 }
 
 QList<Plasma::Containment *> Layout::importLayoutFile(QString file)
 {
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(file);
     auto newContainments = m_corona->importLayout(KConfigGroup(filePtr, ""));
 
     ///Find latte and systray containments
     qDebug() << " imported containments ::: " << newContainments.length();
 
     QList<Plasma::Containment *> importedDocks;
     //QList<Plasma::Containment *> systrays;
 
     foreach (auto containment, newContainments) {
         KPluginMetaData meta = containment->kPackage().metadata();
 
         if (meta.pluginId() == "org.kde.latte.containment") {
             qDebug() << "new latte containment id: " << containment->id();
             importedDocks << containment;
         }
     }
 
     ///after systrays were found we must update in latte the relevant ids
     /*if (!systrays.isEmpty()) {
         foreach (auto systray, systrays) {
             qDebug() << "systray found with id : " << systray->id();
             Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(systray->parent());
 
             if (parentApplet) {
                 KConfigGroup appletSettings = parentApplet->config().group("Configuration");
 
                 if (appletSettings.hasKey("SystrayContainmentId")) {
                     qDebug() << "!!! updating systray id to : " << systray->id();
                     appletSettings.writeEntry("SystrayContainmentId", systray->id());
                 }
             }
         }
     }*/
 
     return importedDocks;
 }
 
 void Layout::recreateDock(Plasma::Containment *containment)
 {
     if (!m_corona) {
         return;
     }
 
     //! give the time to config window to close itself first and then recreate the dock
     //! step:1 remove the dockview
     QTimer::singleShot(350, [this, containment]() {
         auto view = m_dockViews.take(containment);
 
         if (view) {
             qDebug() << "recreate - step 1: removing dock for containment:" << containment->id();
 
             //! step:2 add the new dockview
             connect(view, &QObject::destroyed, this, [this, containment]() {
                 QTimer::singleShot(250, this, [this, containment]() {
                     if (!m_dockViews.contains(containment)) {
                         qDebug() << "recreate - step 2: adding dock for containment:" << containment->id();
                         addDock(containment);
                     }
                 });
             });
 
             view->deleteLater();
 
         }
     });
 }
 
 //! the central functions that updates loading/unloading dockviews
 //! concerning screen changed (for multi-screen setups mainly)
 void Layout::syncDockViewsToScreens()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "LAYOUT ::: " << name();
     qDebug() << "screen count changed -+-+ " << qGuiApp->screens().size();
 
     qDebug() << "adding consideration....";
     qDebug() << "dock view running : " << m_dockViews.count();
 
     foreach (auto scr, qGuiApp->screens()) {
         qDebug() << "Found screen: " << scr->name();
 
         foreach (auto cont, m_containments) {
             int id = cont->screen();
 
             if (id == -1) {
                 id = cont->lastScreen();
             }
 
             bool onPrimary = cont->config().readEntry("onPrimary", true);
             Plasma::Types::Location location = static_cast<Plasma::Types::Location>((int)cont->config().readEntry("location", (int)Plasma::Types::BottomEdge));
 
             //! two main situations that a dock must be added when it is not already running
             //! 1. when a dock is primary, not running and the edge for which is associated is free
             //! 2. when a dock in explicit, not running and the associated screen currently exists
             //! e.g. the screen has just been added
             if (((onPrimary && freeEdges(qGuiApp->primaryScreen()).contains(location)) || (!onPrimary && (m_corona->screenPool()->connector(id) == scr->name())))
                 && (!m_dockViews.contains(cont))) {
                 qDebug() << "screen Count signal: view must be added... for:" << scr->name();
                 addDock(cont);
             }
         }
     }
 
     qDebug() << "removing consideration & updating screen for always on primary docks....";
 
     //! this code tries to find a containment that must not be deleted by
     //! automatic algorithm. Currently the containment with the minimum id
     //! containing tasks plasmoid wins
     int preserveContainmentId{ -1};
     bool dockWithTasksWillBeShown{false};
 
     //! associate correct values for preserveContainmentId and
     //! dockWithTasksWillBeShown
     foreach (auto view, m_dockViews) {
         bool found{false};
 
         foreach (auto scr, qGuiApp->screens()) {
             if (scr->name() == view->currentScreen()
                 || (view->onPrimary() && scr == qGuiApp->primaryScreen())) {
                 found = true;
                 break;
             }
         }
 
         //!check if a tasks dock will be shown (try to prevent its deletion)
         if (found && view->tasksPresent()) {
             dockWithTasksWillBeShown = true;
         }
 
         if (!found && !view->onPrimary() && (m_dockViews.size() > 1) && m_dockViews.contains(view->containment())
             && !(view->tasksPresent() && noDocksWithTasks() == 1)) { //do not delete last dock containing tasks
             if (view->tasksPresent()) {
                 if (preserveContainmentId == -1)
                     preserveContainmentId = view->containment()->id();
                 else if (view->containment()->id() < preserveContainmentId)
                     preserveContainmentId = view->containment()->id();
             }
         }
     }
 
     //! check which docks must be deleted e.g. when the corresponding
     //! screen does not exist any more.
     //! The code is smart enough in order
     //! to never delete the last tasks dock and also it makes sure that
     //! the last tasks dock which will exist in the end will be the one
     //! with the lowest containment id
     foreach (auto view, m_dockViews) {
         bool found{false};
 
         foreach (auto scr, qGuiApp->screens()) {
             if (scr->name() == view->currentScreen()
                 || (view->onPrimary() && scr == qGuiApp->primaryScreen())) {
                 found = true;
                 break;
             }
         }
 
 
         //! which explicit docks can be deleted
         if (!found && !view->onPrimary() && (m_dockViews.size() > 1) && m_dockViews.contains(view->containment())
             && !(view->tasksPresent() && noDocksWithTasks() == 1)) {
             //do not delete last dock containing tasks
             if (dockWithTasksWillBeShown || preserveContainmentId != view->containment()->id()) {
                 qDebug() << "screen Count signal: view must be deleted... for:" << view->currentScreen();
                 auto viewToDelete = m_dockViews.take(view->containment());
                 viewToDelete->deleteLater();
             }
 
             //!which primary docks can be deleted
         } else if (view->onPrimary() && !found
                    && !freeEdges(qGuiApp->primaryScreen()).contains(view->location())) {
             qDebug() << "screen Count signal: primary view must be deleted... for:" << view->currentScreen();
             auto viewToDelete = m_dockViews.take(view->containment());
             viewToDelete->deleteLater();
         } else {
             //! if the dock will not be deleted its a very good point to reconsider
             //! if the screen in which is running is the correct one
             view->reconsiderScreen();
         }
     }
 
     qDebug() << "end of screens count change....";
 }
 
 void Layout::assignToLayout(DockView *dockView, QList<Plasma::Containment *> containments)
 {
     if (!m_corona) {
         return;
     }
 
     if (dockView) {
         m_dockViews[dockView->containment()] = dockView;
         m_containments << containments;
 
         foreach (auto containment, containments) {
             containment->config().writeEntry("layoutId", name());
 
             connect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
             connect(containment, &Plasma::Applet::destroyedChanged, this, &Layout::destroyedChanged);
             connect(containment, &Plasma::Containment::appletCreated, this, &Layout::appletCreated);
         }
 
         dockView->setManagedLayout(this);
 
         emit m_corona->docksCountChanged();
         emit m_corona->availableScreenRectChanged();
         emit m_corona->availableScreenRegionChanged();
     }
 }
 
 QList<Plasma::Containment *> Layout::unassignFromLayout(DockView *dockView)
 {
     QList<Plasma::Containment *> containments;
 
     if (!m_corona) {
         return containments;
     }
 
     containments << dockView->containment();
 
     foreach (auto containment, m_containments) {
         Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent());
 
         //! add systrays from that dockView
         if (parentApplet && parentApplet->containment() && parentApplet->containment() == dockView->containment()) {
             containments << containment;
             disconnect(containment, &QObject::destroyed, this, &Layout::containmentDestroyed);
             disconnect(containment, &Plasma::Applet::destroyedChanged, this, &Layout::destroyedChanged);
             disconnect(containment, &Plasma::Containment::appletCreated, this, &Layout::appletCreated);
         }
     }
 
     foreach (auto containment, containments) {
         m_containments.removeAll(containment);
     }
 
     if (containments.size() > 0) {
         m_dockViews.remove(dockView->containment());
     }
 
     return containments;
 }
 
 QList<Plasma::Types::Location> Layout::freeEdges(QScreen *screen) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                  Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     foreach (auto view, m_dockViews) {
         if (view && view->currentScreen() == screen->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 QList<Plasma::Types::Location> Layout::freeEdges(int screen) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                  Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     QScreen *scr = m_corona->screenPool()->screenForId(screen);
 
     foreach (auto view, m_dockViews) {
         if (view && scr && view->currentScreen() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 bool Layout::explicitDockOccupyEdge(int screen, Plasma::Types::Location location) const
 {
     if (!m_corona) {
         return false;
     }
 
     foreach (auto containment, m_containments) {
         if (containment->pluginMetaData().pluginId() == "org.kde.latte.containment") {
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             int id = containment->lastScreen();
             Plasma::Types::Location contLocation = containment->location();
 
             if (!onPrimary && id == screen && contLocation == location) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 
 int Layout::noDocksWithTasks() const
 {
     if (!m_corona) {
         return 0;
     }
 
     int result = 0;
 
     foreach (auto view, m_dockViews) {
         if (view->tasksPresent()) {
             result++;
         }
     }
 
     return result;
 }
 
 int Layout::docksCount(int screen) const
 {
     if (!m_corona) {
         return 0;
     }
 
     QScreen *scr = m_corona->screenPool()->screenForId(screen);
 
     int docks{0};
 
     foreach (auto view, m_dockViews) {
         if (view && view->screen() == scr && !view->containment()->destroyed()) {
             ++docks;
         }
     }
 
     return docks;
 }
 
 int Layout::docksCount() const
 {
     if (!m_corona) {
         return 0;
     }
 
     int docks{0};
 
     foreach (auto view, m_dockViews) {
         if (view && view->containment() && !view->containment()->destroyed()) {
             ++docks;
         }
     }
 
     return docks;
 }
 
 int Layout::docksCount(QScreen *screen) const
 {
     if (!m_corona) {
         return 0;
     }
 
     int docks{0};
 
     foreach (auto view, m_dockViews) {
         if (view && view->screen() == screen && !view->containment()->destroyed()) {
             ++docks;
         }
     }
 
     return docks;
 }
 
 }
diff --git a/app/layout.h b/app/layout.h
index 460bc79a..7cd511f9 100644
--- a/app/layout.h
+++ b/app/layout.h
@@ -1,204 +1,206 @@
 /*
 *  Copyright 2017  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/>.
 */
 
 #ifndef LAYOUT_H
 #define LAYOUT_H
 
 #include <QObject>
 #include <QScreen>
 
 #include <Plasma>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 namespace Plasma {
 class Applet;
 class Containment;
 class Types;
 }
 
 namespace Latte {
 class DockCorona;
 class DockView;
 }
 
 namespace Latte {
 
 //! This class is responsible to hold the settings for a specific layout.
 //! It also updates always the relevant layout configuration concerning
 //! its general settings (no the containments)
 class Layout : public QObject {
     Q_OBJECT
     Q_PROPERTY(bool showInMenu READ showInMenu WRITE setShowInMenu NOTIFY showInMenuChanged)
     Q_PROPERTY(QString background READ background NOTIFY backgroundChanged)
     Q_PROPERTY(QString color READ color WRITE setColor NOTIFY colorChanged)
+    Q_PROPERTY(QString lastUsedActivity READ lastUsedActivity NOTIFY lastUsedActivityChanged)
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
     Q_PROPERTY(QString textColor READ textColor NOTIFY textColorChanged)
     Q_PROPERTY(QStringList launchers READ launchers WRITE setLaunchers NOTIFY launchersChanged)
     Q_PROPERTY(QStringList activities READ activities WRITE setActivities NOTIFY activitiesChanged)
 
 public:
     Layout(QObject *parent, QString layoutFile, QString layoutName = QString());
     ~Layout() override;
 
     static const QString MultipleLayoutsName;
 
     void initToCorona(DockCorona *corona);
     void syncToLayoutFile();
     void unloadContainments();
     void unloadDockViews();
 
     bool showInMenu() const;
     void setShowInMenu(bool show);
 
     bool layoutIsBroken() const;
 
     //!this layout is loaded and running
     bool isActiveLayout() const;
     //!it is original layout compared to pseudo-layouts that are combinations of multiple-original layouts
     bool isOriginalLayout() const;
 
     int version() const;
     void setVersion(int ver);
 
     QString background() const;
     void setBackground(QString path);
 
     QString color() const;
     void setColor(QString color);
 
     QString lastUsedActivity();
     void clearLastUsedActivity(); //!e.g. when we export a layout
 
     QString name() const;
     QString file() const;
 
     QString textColor() const;
     void setTextColor(QString color);
 
     QStringList activities() const;
     void setActivities(QStringList activities);
 
     QStringList launchers() const;
     void setLaunchers(QStringList launcherList);
 
     static QString layoutName(const QString &fileName);
 
     void renameLayout(QString newName);
 
     QStringList unloadedContainmentsIds();
 
     //! this function needs the layout to have first set the corona through initToCorona() function
     void addDock(Plasma::Containment *containment, bool forceLoading = false, int expDockScreen = -1);
     void copyDock(Plasma::Containment *containment);
     void recreateDock(Plasma::Containment *containment);
 
     void syncDockViewsToScreens();
     void importToCorona();
 
     const QStringList appliedActivities();
 
     QList<Plasma::Containment *> *containments();
     QHash<const Plasma::Containment *, DockView *> *dockViews();
 
     //! Bind this dockView and its relevant containments(including systrays)
     //! to this layout. It is used for moving a dockView from layout to layout)
     void assignToLayout(DockView *dockView, QList<Plasma::Containment *> containments);
 
     //! Unassign that dockView from this layout (this is used for moving a dockView
     //! from layout to layout) and returns all the containments relevant to
     //! that dockView
     QList<Plasma::Containment *> unassignFromLayout(DockView *dockView);
 
     QList<Plasma::Types::Location> freeEdges(QScreen *screen) const;
     QList<Plasma::Types::Location> freeEdges(int screen) const;
 
     int noDocksWithTasks() const;
     int docksCount() const;
     int docksCount(int screen) const;
     int docksCount(QScreen *screen) const;
 
 signals:
     void activitiesChanged();
     void backgroundChanged();
     void colorChanged();
+    void dockColorizerSupportChanged();
     void fileChanged();
     void lastUsedActivityChanged();
     void launchersChanged();
     void nameChanged();
     void versionChanged();
     void showInMenuChanged();
     void textColorChanged();
 
 private slots:
     void loadConfig();
     void saveConfig();
 
     void addContainment(Plasma::Containment *containment);
     void appletCreated(Plasma::Applet *applet);
     void destroyedChanged(bool destroyed);
     void containmentDestroyed(QObject *cont);
     void updateLastUsedActivity();
 
 private:
     void importLocalLayout(QString file);
     void init();
     void setName(QString name);
     void setFile(QString file);
 
     bool explicitDockOccupyEdge(int screen, Plasma::Types::Location location) const;
 
     QString availableId(QStringList all, QStringList assigned, int base);
     //! provides a new file path based the provided file. The new file
     //! has updated ids for containments and applets based on the corona
     //! loaded ones
     QString newUniqueIdsLayoutFromFile(QString file);
     //! imports a layout file and returns the containments for the docks
     QList<Plasma::Containment *> importLayoutFile(QString file);
 
 private:
     bool m_showInMenu{false};
     //if version doesnt exist it is and old layout file
     int m_version{2};
 
     QString m_background;
     QString m_color;
     QString m_lastUsedActivity; //the last used activity for this layout
     QString m_layoutFile;
     QString m_layoutName;
     QString m_textColor;
     QStringList m_activities;
     QStringList m_launchers;
 
     QStringList m_unloadedContainmentsIds;
 
     DockCorona *m_corona{nullptr};
     KConfigGroup m_layoutGroup;
 
     QList<Plasma::Containment *> m_containments;
 
     QHash<const Plasma::Containment *, DockView *> m_dockViews;
     QHash<const Plasma::Containment *, DockView *> m_waitingDockViews;
 };
 
 }
 
 #endif // LAYOUT_H
diff --git a/app/layoutmanager.cpp b/app/layoutmanager.cpp
index ee8cb244..dc7eef1c 100644
--- a/app/layoutmanager.cpp
+++ b/app/layoutmanager.cpp
@@ -1,1185 +1,1210 @@
 /*
 *  Copyright 2017  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 "layoutmanager.h"
 
 #include "importer.h"
 #include "infoview.h"
 #include "settingsdialog.h"
 #include "launcherssignals.h"
 #include "layout.h"
 #include "screenpool.h"
 #include "universalsettings.h"
+#include "dock/dockview.h"
 
 #include <QDir>
 #include <QFile>
 #include <QMessageBox>
 #include <QQmlProperty>
 #include <QtDBus/QtDBus>
 
 #include <KActivities/Consumer>
 #include <KActivities/Controller>
 #include <KLocalizedString>
 #include <KNotification>
 
 namespace Latte {
 
 const int MultipleLayoutsPresetId = 10;
 
 LayoutManager::LayoutManager(QObject *parent)
     : QObject(parent),
       m_importer(new Importer(this)),
       m_launchersSignals(new LaunchersSignals(this)),
       m_activitiesController(new KActivities::Controller(this))
 {
     m_corona = qobject_cast<DockCorona *>(parent);
 
     if (m_corona) {
         connect(m_corona->universalSettings(), &UniversalSettings::currentLayoutNameChanged, this, &LayoutManager::currentLayoutNameChanged);
         connect(m_corona->universalSettings(), &UniversalSettings::showInfoWindowChanged, this, &LayoutManager::showInfoWindowChanged);
 
         m_dynamicSwitchTimer.setSingleShot(true);
         showInfoWindowChanged();
         connect(&m_dynamicSwitchTimer, &QTimer::timeout, this, &LayoutManager::confirmDynamicSwitch);
     }
 }
 
 LayoutManager::~LayoutManager()
 {
     m_importer->deleteLater();
     m_launchersSignals->deleteLater();
 
     while (!m_activeLayouts.isEmpty()) {
         Layout *layout = m_activeLayouts.at(0);
         m_activeLayouts.removeFirst();
         layout->unloadContainments();
         layout->unloadDockViews();
         layout->deleteLater();
     }
 
     m_activitiesController->deleteLater();
 }
 
 void LayoutManager::load()
 {
     int configVer = m_corona->universalSettings()->version();
     qDebug() << "Universal Settings version : " << configVer;
 
     if (configVer < 2 && QFile(QDir::homePath() + "/.config/lattedockrc").exists()) {
         qDebug() << "Latte must update its configuration...";
         m_importer->updateOldConfiguration();
         importPresets(false);
     } else if (!QFile(QDir::homePath() + "/.config/lattedockrc").exists()) {
         //startup create what is necessary....
         QDir layoutDir(QDir::homePath() + "/.config/latte");
 
         if (!layoutDir.exists()) {
             QDir(QDir::homePath() + "/.config").mkdir("latte");
         }
 
         newLayout(i18n("My Layout"));
         importPresets(false);
         m_corona->universalSettings()->setCurrentLayoutName(i18n("My Layout"));
         m_corona->universalSettings()->setVersion(2);
     }
 
     //! Check if the multiple-layouts hidden file is present, add it if it isnt
     if (!QFile(QDir::homePath() + "/.config/latte/" + Layout::MultipleLayoutsName + ".layout.latte").exists()) {
         importPreset(MultipleLayoutsPresetId, false);
     }
 
     qDebug() << "Latte is loading  its layouts...";
 
     connect(m_corona->m_activityConsumer, &KActivities::Consumer::currentActivityChanged,
             this, &LayoutManager::currentActivityChanged);
 
     connect(m_corona->m_activityConsumer, &KActivities::Consumer::runningActivitiesChanged,
     this, [&]() {
         if (memoryUsage() == Dock::MultipleLayouts) {
             syncMultipleLayoutsToActivities();
         }
     });
 
     loadLayouts();
 }
 
 void LayoutManager::unload()
 {
     //! Unload all Layouts
     foreach (auto layout, m_activeLayouts) {
         if (memoryUsage() == Dock::MultipleLayouts && layout->isOriginalLayout()) {
             layout->syncToLayoutFile();
         }
 
         layout->unloadContainments();
         layout->unloadDockViews();
 
         if (memoryUsage() == Dock::MultipleLayouts && layout->isOriginalLayout()) {
             clearUnloadedContainmentsFromLinkedFile(layout->unloadedContainmentsIds());
         }
 
         layout->deleteLater();
     }
 
     //! Cleanup pseudo-layout from Containments
     if (memoryUsage() == Dock::MultipleLayouts) {
         //    auto containmentsEntries = m_corona->config()->group("Containments");
         //  containmentsEntries.deleteGroup();
         //  containmentsEntries.sync();
     }
 
 
     //! Remove no-needed temp files
     QString temp1File = QDir::homePath() + "/.config/lattedock.copy1.bak";
     QString temp2File = QDir::homePath() + "/.config/lattedock.copy2.bak";
 
     QFile file1(temp1File);
     QFile file2(temp2File);
 
     if (file1.exists())
         file1.remove();
 
     if (file2.exists())
         file2.remove();
 }
 
 DockCorona *LayoutManager::corona()
 {
     return m_corona;
 }
 
 Importer *LayoutManager::importer()
 {
     return m_importer;
 }
 
 LaunchersSignals *LayoutManager::launchersSignals()
 {
     return m_launchersSignals;
 }
 
 QString LayoutManager::currentLayoutName() const
 {
     if (memoryUsage() == Dock::SingleLayout) {
         return m_corona->universalSettings()->currentLayoutName();
     } else if (memoryUsage() == Dock::MultipleLayouts) {
         return m_currentLayoutNameInMultiEnvironment;
     }
 
     return QString();
 }
 
 QString LayoutManager::defaultLayoutName() const
 {
     QByteArray presetNameOrig = QString("preset" + QString::number(1)).toUtf8();
     QString presetPath = m_corona->kPackage().filePath(presetNameOrig);
     QString presetName = Layout::layoutName(presetPath);
     QByteArray presetNameChars = presetName.toUtf8();
     presetName = i18n(presetNameChars);
 
     return presetName;
 }
 
 bool LayoutManager::layoutExists(QString layoutName) const
 {
     return m_layouts.contains(layoutName);
 }
 
 QStringList LayoutManager::layouts() const
 {
     return m_layouts;
 }
 
 QStringList LayoutManager::menuLayouts() const
 {
     QStringList fixedMenuLayouts = m_menuLayouts;
 
     //! in case the current layout isnt checked to be shown in the menus
     //! we must add it on top
     if (!fixedMenuLayouts.contains(currentLayoutName()) && memoryUsage() == Dock::SingleLayout) {
         fixedMenuLayouts.prepend(currentLayoutName());
     } else if (memoryUsage() == Dock::MultipleLayouts) {
         foreach (auto layout, m_activeLayouts) {
             if (layout->isOriginalLayout() && !fixedMenuLayouts.contains(layout->name())) {
                 fixedMenuLayouts.prepend(layout->name());
             }
         }
     }
 
     return fixedMenuLayouts;
 }
 
 void LayoutManager::setMenuLayouts(QStringList layouts)
 {
     if (m_menuLayouts == layouts) {
         return;
     }
 
     m_menuLayouts = layouts;
     emit menuLayoutsChanged();
 }
 
 QStringList LayoutManager::activities()
 {
     return m_corona->m_activityConsumer->activities();
 }
 
 QStringList LayoutManager::runningActivities()
 {
     return m_corona->m_activityConsumer->runningActivities();
 }
 
 QStringList LayoutManager::orphanedActivities()
 {
     QStringList orphans;
 
     foreach (auto activity, activities()) {
         if (m_assignedLayouts[activity].isEmpty()) {
             orphans.append(activity);
         }
     }
 
     return orphans;
 }
 
 QStringList LayoutManager::presetsPaths() const
 {
     return m_presetsPaths;
 }
 
 QString LayoutManager::layoutPath(QString layoutName)
 {
     QString path = QDir::homePath() + "/.config/latte/" + layoutName + ".layout.latte";
 
     if (!QFile(path).exists()) {
         path = "";
     }
 
     return path;
 }
 
 Dock::LayoutsMemoryUsage LayoutManager::memoryUsage() const
 {
     return m_corona->universalSettings()->layoutsMemoryUsage();
 }
 
 int LayoutManager::layoutsMemoryUsage()
 {
     return (int)m_corona->universalSettings()->layoutsMemoryUsage();
 }
 
 void LayoutManager::setMemoryUsage(Dock::LayoutsMemoryUsage memoryUsage)
 {
     m_corona->universalSettings()->setLayoutsMemoryUsage(memoryUsage);
 }
 
 void LayoutManager::addDock(Plasma::Containment *containment, bool forceLoading, int expDockScreen)
 {
     if (memoryUsage() == Dock::SingleLayout) {
         m_activeLayouts.at(0)->addDock(containment, forceLoading, expDockScreen);
     } else if (memoryUsage() == Dock::MultipleLayouts) {
         QString layoutId = containment->config().readEntry("layoutId", QString());
 
         if (!layoutId.isEmpty()) {
             auto layout = activeLayout(layoutId);
 
             if (layout) {
                 layout->addDock(containment, forceLoading, expDockScreen);
             }
         }
     }
 }
 
 void LayoutManager::recreateDock(Plasma::Containment *containment)
 {
     if (memoryUsage() == Dock::SingleLayout) {
         m_activeLayouts.at(0)->recreateDock(containment);
     } else if (memoryUsage() == Dock::MultipleLayouts) {
         QString layoutId = containment->config().readEntry("layoutId", QString());
 
         if (!layoutId.isEmpty()) {
             auto layout = activeLayout(layoutId);
 
             if (layout) {
                 layout->recreateDock(containment);
             }
         }
     }
 }
 
 QHash<const Plasma::Containment *, DockView *> *LayoutManager::currentDockViews() const
 {
     if (memoryUsage() == Dock::SingleLayout) {
         return m_activeLayouts.at(0)->dockViews();
     } else {
         foreach (auto layout, m_activeLayouts) {
             if (layout->activities().contains(m_corona->m_activityConsumer->currentActivity())) {
                 return layout->dockViews();
             }
         }
 
         foreach (auto layout, m_activeLayouts) {
             if ((layout->name() != Layout::MultipleLayoutsName) && (layout->activities().isEmpty())) {
                 return layout->dockViews();
             }
         }
     }
 
     return nullptr;
 }
 
 QHash<const Plasma::Containment *, DockView *> *LayoutManager::layoutDockViews(const QString &layoutName) const
 {
     Layout *layout = activeLayout(layoutName);
 
     if (layout) {
         return layout->dockViews();
     }
 
     return nullptr;
 }
 
 QStringList LayoutManager::activeLayoutsNames()
 {
     QStringList names;
 
     if (memoryUsage() == Dock::SingleLayout) {
         names << currentLayoutName();
     } else {
         for (int i = 0; i < m_activeLayouts.size(); ++i) {
             Layout *layout = m_activeLayouts.at(i);
 
             if (layout->isOriginalLayout()) {
                 names << layout->name();
             }
         }
     }
 
     return names;
 
 }
 
 
 Layout *LayoutManager::activeLayout(QString id) const
 {
     for (int i = 0; i < m_activeLayouts.size(); ++i) {
         Layout *layout = m_activeLayouts.at(i);
 
         if (layout->name() == id) {
 
             return layout;
         }
     }
 
     return nullptr;
 }
 
 int LayoutManager::activeLayoutPos(QString id) const
 {
     for (int i = 0; i < m_activeLayouts.size(); ++i) {
         Layout *layout = m_activeLayouts.at(i);
 
         if (layout->name() == id) {
 
             return i;
         }
     }
 
     return -1;
 }
 
 void LayoutManager::updateCurrentLayoutNameInMultiEnvironment()
 {
     foreach (auto layout, m_activeLayouts) {
         if (layout->isOriginalLayout() && layout->activities().contains(m_corona->activitiesConsumer()->currentActivity())) {
             m_currentLayoutNameInMultiEnvironment = layout->name();
             emit currentLayoutNameChanged();
             return;
         }
     }
 
     foreach (auto layout, m_activeLayouts) {
         if (layout->isOriginalLayout() && layout->activities().isEmpty()) {
             m_currentLayoutNameInMultiEnvironment = layout->name();
             emit currentLayoutNameChanged();
             return;
         }
     }
 }
 
 void LayoutManager::currentActivityChanged(const QString &id)
 {
     if (memoryUsage() == Dock::SingleLayout) {
         qDebug() << "activity changed :: " << id;
 
         m_shouldSwitchToLayout = shouldSwitchToLayout(id);
 
         m_dynamicSwitchTimer.start();
     } else if (memoryUsage() == Dock::MultipleLayouts) {
         updateCurrentLayoutNameInMultiEnvironment();
     }
 }
 
 void LayoutManager::showInfoWindowChanged()
 {
     if (m_corona->universalSettings()->showInfoWindow()) {
         m_dynamicSwitchTimer.setInterval(1800);
     } else {
         m_dynamicSwitchTimer.setInterval(2300);
     }
 }
 
 QString LayoutManager::shouldSwitchToLayout(QString activityId)
 {
     if (m_assignedLayouts.contains(activityId) && m_assignedLayouts[activityId] != currentLayoutName()) {
         return m_assignedLayouts[activityId];
     } else if (!m_assignedLayouts.contains(activityId) && !m_corona->universalSettings()->lastNonAssignedLayoutName().isEmpty()
                && m_corona->universalSettings()->lastNonAssignedLayoutName() != currentLayoutName()) {
         return m_corona->universalSettings()->lastNonAssignedLayoutName();
     }
 
     return QString();
 }
 
 void LayoutManager::confirmDynamicSwitch()
 {
     QString tempShouldSwitch = shouldSwitchToLayout(m_corona->m_activityConsumer->currentActivity());
 
     if (tempShouldSwitch.isEmpty()) {
         return;
     }
 
     if (m_shouldSwitchToLayout == tempShouldSwitch && m_shouldSwitchToLayout != currentLayoutName()) {
         qDebug() << "dynamic switch to layout :: " << m_shouldSwitchToLayout;
 
         emit currentLayoutIsSwitching(currentLayoutName());
 
         if (m_corona->universalSettings()->showInfoWindow()) {
             showInfoWindow(i18n("Switching to layout <b>%0</b> ...").arg(m_shouldSwitchToLayout), 4000);
         }
 
         QTimer::singleShot(500, [this, tempShouldSwitch]() {
             switchToLayout(tempShouldSwitch);
         });
     } else {
         m_shouldSwitchToLayout = tempShouldSwitch;
         m_dynamicSwitchTimer.start();
     }
 }
 
 void LayoutManager::loadLayouts()
 {
     m_layouts.clear();
     m_menuLayouts.clear();
     m_presetsPaths.clear();
     m_assignedLayouts.clear();
 
     QDir layoutDir(QDir::homePath() + "/.config/latte");
     QStringList filter;
     filter.append(QString("*.layout.latte"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
 
     foreach (auto layout, files) {
         Layout layoutSets(this, layoutDir.absolutePath() + "/" + layout);
 
         QStringList validActivityIds = validActivities(layoutSets.activities());
         layoutSets.setActivities(validActivityIds);
 
         foreach (auto activity, validActivityIds) {
             m_assignedLayouts[activity] = layoutSets.name();
         }
 
         m_layouts.append(layoutSets.name());
 
         if (layoutSets.showInMenu()) {
             m_menuLayouts.append(layoutSets.name());
         }
     }
 
     m_presetsPaths.append(m_corona->kPackage().filePath("preset1"));
     m_presetsPaths.append(m_corona->kPackage().filePath("preset2"));
     m_presetsPaths.append(m_corona->kPackage().filePath("preset3"));
     m_presetsPaths.append(m_corona->kPackage().filePath("preset4"));
 
     emit layoutsChanged();
     emit menuLayoutsChanged();
 }
 
 void LayoutManager::loadLayoutOnStartup(QString layoutName)
 {
     // if (memoryUsage() == Dock::MultipleLayouts) {
     QStringList layouts = m_importer->checkRepairMultipleLayoutsLinkedFile();
 
     //! Latte didnt close correctly, maybe a crash
     if (layouts.size() > 0) {
         QMessageBox *msg = new QMessageBox();
         msg->setAttribute(Qt::WA_DeleteOnClose);
         msg->setIcon(QMessageBox::Warning);
         msg->setWindowTitle(i18n("Multiple Layouts Warning"));
         msg->setText(i18n("Latte did not close properly in the previous session. The following layout(s) <b>[%0]</b> were updated for consistency!!!").arg(layouts.join(",")));
         msg->setStandardButtons(QMessageBox::Ok);
 
         msg->open();
     }
 
     //}
 
     switchToLayout(layoutName);
 }
 
 void LayoutManager::loadLatteLayout(QString layoutPath)
 {
     qDebug() << " -------------------------------------------------------------------- ";
     qDebug() << " -------------------------------------------------------------------- ";
 
     if (m_corona->containments().size() > 0) {
         qDebug() << "LOAD LATTE LAYOUT ::: There are still containments present !!!! :: " << m_corona->containments().size();
     }
 
     if (!layoutPath.isEmpty() && m_corona->containments().size() == 0) {
         cleanupOnStartup(layoutPath);
         qDebug() << "LOADING CORONA LAYOUT:" << layoutPath;
         m_corona->loadLayout(layoutPath);
 
         //! ~~~ ADDING DOCKVIEWS AND ENFORCE LOADING IF TASKS ARENT PRESENT BASED ON SCREENS ~~~ !//
 
         //! this is used to record the first dock having tasks in it. It is used
         //! to specify which dock will be loaded on startup if a case that no "dock
         //! with tasks" will be loaded otherwise. Currently the older one dock wins
         int firstContainmentWithTasks = -1;
 
         //! this is used to check if a dock with tasks in it will be loaded on startup
         bool tasksWillBeLoaded =  heuresticForLoadingDockWithTasks(&firstContainmentWithTasks);
 
         qDebug() << "TASKS WILL BE PRESENT AFTER LOADING ::: " << tasksWillBeLoaded;
 
         foreach (auto containment, m_corona->containments()) {
             //! forceDockLoading is used when a latte configuration based on the
             //! current running screens does not provide a dock containing tasks.
             //! in such case the lowest latte containment containing tasks is loaded
             //! and it forcefully becomes primary dock
             if (!tasksWillBeLoaded && firstContainmentWithTasks == containment->id()) {
                 tasksWillBeLoaded = true; //this protects by loading more than one dock at startup
                 addDock(containment, true);
             } else {
                 addDock(containment);
             }
         }
     }
 }
 
 void LayoutManager::cleanupOnStartup(QString path)
 {
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(path);
 
     KConfigGroup actionGroups = KConfigGroup(filePtr, "ActionPlugins");
 
     QStringList deprecatedActionGroup;
 
     foreach (auto actId, actionGroups.groupList()) {
         QString pluginId = actionGroups.group(actId).readEntry("RightButton;NoModifier", "");
 
         if (pluginId == "org.kde.contextmenu") {
             deprecatedActionGroup << actId;
         }
     }
 
     foreach (auto pId, deprecatedActionGroup) {
         qDebug() << "!!!!!!!!!!!!!!!!  !!!!!!!!!!!! !!!!!!! REMOVING :::: " << pId;
         actionGroups.group(pId).deleteGroup();
     }
 
     KConfigGroup containmentGroups = KConfigGroup(filePtr, "Containments");
 
     QStringList removeContaimentsList;
 
     foreach (auto cId, containmentGroups.groupList()) {
         QString pluginId = containmentGroups.group(cId).readEntry("plugin", "");
 
         if (pluginId == "org.kde.desktopcontainment") { //!must remove ghost containments first
             removeContaimentsList << cId;
         }
     }
 
     foreach (auto cId, removeContaimentsList) {
         containmentGroups.group(cId).deleteGroup();
     }
 
 
     actionGroups.sync();
     containmentGroups.sync();
 }
 
 
 void LayoutManager::showAboutDialog()
 {
     m_corona->aboutApplication();
 }
 
 void LayoutManager::importLatteLayout(QString layoutPath)
 {
     //! This might not be needed as it is Layout responsibility
 }
 
 void LayoutManager::hideAllDocks()
 {
     foreach (auto layout, m_activeLayouts) {
         if (layout->isOriginalLayout()) {
             emit currentLayoutIsSwitching(layout->name());
         }
     }
 }
 
 bool LayoutManager::switchToLayout(QString layoutName, int previousMemoryUsage)
 {
     if (m_activeLayouts.size() > 0 && currentLayoutName() == layoutName && previousMemoryUsage == -1) {
         return false;
     }
 
     //! First Check If that Layout is already present
     if (memoryUsage() == Dock::MultipleLayouts && previousMemoryUsage == -1) {
         Layout *layout = activeLayout(layoutName);
 
         if (layout) {
 
             QStringList appliedActivities = layout->appliedActivities();
             QString nextActivity = !layout->lastUsedActivity().isEmpty() ? layout->lastUsedActivity() : appliedActivities[0];
 
             //! it means we are at a foreign activity
             if (!appliedActivities.contains(m_corona->activitiesConsumer()->currentActivity())) {
                 m_activitiesController->setCurrentActivity(nextActivity);
                 return true;
             }
         }
     }
 
     //! When going from memory usage to different memory usage we first
     //! send the layouts that will be changed. This signal creates the
     //! nice animation that hides these docks/panels
     if (previousMemoryUsage != -1) {
         foreach (auto layout, m_activeLayouts) {
             if (layout->isOriginalLayout()) {
                 emit currentLayoutIsSwitching(layout->name());
             }
         }
     }
 
     QString lPath = layoutPath(layoutName);
 
     if (lPath.isEmpty() && layoutName == i18n("Alternative")) {
         lPath = newLayout(i18n("Alternative"), i18n("Default"));
     }
 
     if (!lPath.isEmpty()) {
         if (memoryUsage() == Dock::SingleLayout) {
             emit currentLayoutIsSwitching(currentLayoutName());
         } else if (memoryUsage() == Dock::MultipleLayouts && layoutName != Layout::MultipleLayoutsName) {
             Layout toLayout(this, lPath);
 
             QStringList toActivities = toLayout.activities();
 
             Layout *activeForOrphans{nullptr};
 
             foreach (auto fromLayout, m_activeLayouts) {
                 if (fromLayout->isOriginalLayout() && fromLayout->activities().isEmpty()) {
                     activeForOrphans = fromLayout;
                     break;
                 }
             }
 
             if (toActivities.isEmpty() &&  activeForOrphans && (toLayout.name() != activeForOrphans->name())) {
                 emit currentLayoutIsSwitching(activeForOrphans->name());
             }
         }
 
         //! this code must be called asynchronously because it is called
         //! also from qml (Tasks plasmoid). This change fixes a very important
         //! crash when switching sessions through the Tasks plasmoid Context menu
         //! Latte was unstable and was crashing very often during changing
         //! sessions.
         QTimer::singleShot(250, [this, layoutName, lPath, previousMemoryUsage]() {
             qDebug() << layoutName << " - " << lPath;
             QString fixedLPath = lPath;
             QString fixedLayoutName = layoutName;
 
             bool initializingMultipleLayouts{false};
 
             if (memoryUsage() == Dock::MultipleLayouts && !activeLayout(Layout::MultipleLayoutsName)) {
                 initializingMultipleLayouts = true;
             }
 
             if (memoryUsage() == Dock::SingleLayout || initializingMultipleLayouts || previousMemoryUsage == Dock::MultipleLayouts) {
                 while (!m_activeLayouts.isEmpty()) {
                     Layout *layout = m_activeLayouts.at(0);
                     m_activeLayouts.removeFirst();
 
                     if (layout->isOriginalLayout() && previousMemoryUsage == Dock::MultipleLayouts) {
                         layout->syncToLayoutFile();
                     }
 
                     layout->unloadContainments();
                     layout->unloadDockViews();
 
                     if (layout->isOriginalLayout() && previousMemoryUsage == Dock::MultipleLayouts) {
                         clearUnloadedContainmentsFromLinkedFile(layout->unloadedContainmentsIds(), true);
                     }
 
                     delete layout;
                 }
 
                 if (initializingMultipleLayouts) {
                     fixedLayoutName = QString(Layout::MultipleLayoutsName);
                     fixedLPath = layoutPath(fixedLayoutName);
                 }
 
                 Layout *newLayout = new Layout(this, fixedLPath, fixedLayoutName);
                 m_activeLayouts.append(newLayout);
                 newLayout->initToCorona(m_corona);
 
                 loadLatteLayout(fixedLPath);
 
                 emit activeLayoutsChanged();
             }
 
             if (memoryUsage() == Dock::MultipleLayouts) {
                 if (!initializingMultipleLayouts && !activeLayout(layoutName)) {
                     //! When we are in Multiple Layouts Environment and the user activates
                     //! a Layout that is assigned to specific activities but this
                     //! layout isnt loaded (this means neither of its activities are running)
                     //! is such case we just activate these Activities
                     Layout layout(this, Importer::layoutFilePath(layoutName));
 
                     int i = 0;
                     bool lastUsedActivityFound{false};
                     QString lastUsedActivity = layout.lastUsedActivity();
 
                     bool orphanedLayout = !layoutIsAssigned(layoutName);
 
                     QStringList assignedActivities = orphanedLayout ? orphanedActivities() : layout.activities();
 
                     if (!orphanedLayout) {
                         foreach (auto assignedActivity, assignedActivities) {
                             //! Starting the activities must be done asynchronous because otherwise
                             //! the activity manager cant close multiple activities
                             QTimer::singleShot(i * 1000, [this, assignedActivity, lastUsedActivity]() {
                                 m_activitiesController->startActivity(assignedActivity);
 
                                 if (lastUsedActivity == assignedActivity) {
                                     m_activitiesController->setCurrentActivity(lastUsedActivity);
                                 }
                             });
 
                             if (lastUsedActivity == assignedActivity) {
                                 lastUsedActivityFound = true;
                             }
 
                             i = i + 1;
                         }
                     } else {
                         //! orphaned layout
                         foreach (auto assignedActivity, assignedActivities) {
                             if (lastUsedActivity == assignedActivity) {
                                 lastUsedActivityFound = true;
                             }
                         }
 
                         if ((!lastUsedActivityFound && assignedActivities.count() == 0)
                             || !assignedActivities.contains(m_corona->m_activityConsumer->currentActivity())) {
 
                             //! Starting the activities must be done asynchronous because otherwise
                             //! the activity manager cant close multiple activities
                             QTimer::singleShot(1000, [this, lastUsedActivity, lastUsedActivityFound]() {
                                 m_activitiesController->startActivity(lastUsedActivity);
                                 m_activitiesController->setCurrentActivity(lastUsedActivity);
                             });
                         }
                     }
 
                     if (orphanedLayout) {
                         syncMultipleLayoutsToActivities(layoutName);
                     } else if (!orphanedLayout && !lastUsedActivityFound) {
                         m_activitiesController->setCurrentActivity(layout.activities()[0]);
                     }
                 } else {
                     syncMultipleLayoutsToActivities(layoutName);
                 }
             }
 
             m_corona->universalSettings()->setCurrentLayoutName(layoutName);
 
             if (!layoutIsAssigned(layoutName)) {
                 m_corona->universalSettings()->setLastNonAssignedLayoutName(layoutName);
             }
         });
     } else {
         qDebug() << "Layout : " << layoutName << " was not found...";
     }
 
     return true;
 }
 
 void LayoutManager::syncMultipleLayoutsToActivities(QString layoutForOrphans)
 {
     qDebug() << "   ----  --------- ------    syncMultipleLayoutsToActivities       -------   ";
     qDebug() << "   ----  --------- ------    -------------------------------       -------   ";
 
     QStringList layoutsToUnload;
     QStringList layoutsToLoad;
     layoutsToLoad << Layout::MultipleLayoutsName;
 
     bool allRunningActivitiesWillBeReserved{true};
 
     if (layoutForOrphans.isEmpty() || m_assignedLayouts.values().contains(layoutForOrphans)) {
         layoutForOrphans = m_corona->universalSettings()->lastNonAssignedLayoutName();
     }
 
     foreach (auto activity, runningActivities()) {
         if (!m_assignedLayouts[activity].isEmpty()) {
             if (!layoutsToLoad.contains(m_assignedLayouts[activity])) {
                 layoutsToLoad.append(m_assignedLayouts[activity]);
             }
         } else {
             allRunningActivitiesWillBeReserved = false;
         }
     }
 
     foreach (auto layout, m_activeLayouts) {
         QString tempLayoutName;
 
         if (!layoutsToLoad.contains(layout->name()) && layout->name() != layoutForOrphans) {
             tempLayoutName = layout->name();
         } else if (layout->activities().isEmpty() && allRunningActivitiesWillBeReserved) {
             //! in such case the layout for the orphaned must be unloaded
             tempLayoutName = layout->name();
         }
 
         if (!tempLayoutName.isEmpty() && !layoutsToUnload.contains(tempLayoutName)) {
             layoutsToUnload << tempLayoutName;
         }
     }
 
     //! Unload no needed Layouts
     foreach (auto layoutName, layoutsToUnload) {
         if (layoutName != Layout::MultipleLayoutsName) {
             Layout *layout = activeLayout(layoutName);
             int posLayout = activeLayoutPos(layoutName);
 
             if (posLayout >= 0) {
                 qDebug() << "REMOVING LAYOUT ::::: " << layoutName;
                 m_activeLayouts.removeAt(posLayout);
 
                 if (layout->isOriginalLayout()) {
                     layout->syncToLayoutFile();
                 }
 
                 layout->unloadContainments();
                 layout->unloadDockViews();
                 clearUnloadedContainmentsFromLinkedFile(layout->unloadedContainmentsIds());
                 delete layout;
             }
         }
     }
 
     //! Add Layout for orphan activities
     if (!allRunningActivitiesWillBeReserved) {
         if (!activeLayout(layoutForOrphans)) {
             Layout *newLayout = new Layout(this, layoutPath(layoutForOrphans), layoutForOrphans);
 
             if (newLayout) {
                 qDebug() << "ADDING ORPHANED LAYOUT ::::: " << layoutForOrphans;
 
                 m_activeLayouts.append(newLayout);
                 newLayout->initToCorona(m_corona);
                 newLayout->importToCorona();
             }
         }
     }
 
     //! Add needed Layouts based on Activities
     foreach (auto layoutName, layoutsToLoad) {
         if (!activeLayout(layoutName)) {
             Layout *newLayout = new Layout(this, QString(layoutPath(layoutName)), layoutName);
 
             if (newLayout) {
                 qDebug() << "ADDING LAYOUT ::::: " << layoutName;
                 m_activeLayouts.append(newLayout);
                 newLayout->initToCorona(m_corona);
                 newLayout->importToCorona();
 
                 if (newLayout->isOriginalLayout() && m_corona->universalSettings()->showInfoWindow()) {
                     showInfoWindow(i18n("Adding layout: <b>%0</b> ...").arg(newLayout->name()), 5000, newLayout->appliedActivities());
                 }
             }
         }
     }
 
     updateCurrentLayoutNameInMultiEnvironment();
     emit activeLayoutsChanged();
 }
 
 void LayoutManager::pauseLayout(QString layoutName)
 {
     if (memoryUsage() == Dock::MultipleLayouts) {
         Layout *layout = activeLayout(layoutName);
 
         if (layout && !layout->activities().isEmpty()) {
             int i = 0;
 
             foreach (auto activityId, layout->activities()) {
                 //! Stopping the activities must be done asynchronous because otherwise
                 //! the activity manager cant close multiple activities
                 QTimer::singleShot(i * 1000, [this, activityId]() {
                     m_activitiesController->stopActivity(activityId);
                 });
 
                 i = i + 1;
             }
         }
     }
 }
 
 void LayoutManager::syncActiveLayoutsToOriginalFiles()
 {
     if (memoryUsage() == Dock::MultipleLayouts) {
         foreach (auto layout, m_activeLayouts) {
             if (layout->isOriginalLayout()) {
                 layout->syncToLayoutFile();
             }
         }
     }
 }
 
 void LayoutManager::clearUnloadedContainmentsFromLinkedFile(QStringList containmentsIds, bool bypassChecks)
 {
     if (!m_corona || (memoryUsage() == Dock::SingleLayout && !bypassChecks)) {
         return;
     }
 
     auto containments = m_corona->config()->group("Containments");
 
     foreach (auto conId, containmentsIds) {
         qDebug() << "unloads ::: " << conId;
         KConfigGroup containment = containments.group(conId);
         containment.deleteGroup();
     }
 
     containments.sync();
 }
 
 
 void LayoutManager::syncDockViewsToScreens()
 {
     foreach (auto layout, m_activeLayouts) {
         layout->syncDockViewsToScreens();
     }
 }
 
 QString LayoutManager::newLayout(QString layoutName, QString preset)
 {
     QDir layoutDir(QDir::homePath() + "/.config/latte");
     QStringList filter;
     filter.append(QString(layoutName + "*.layout.latte"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
 
     //! if the newLayout already exists provide a newName that doesnt
     if (files.count() >= 1) {
         int newCounter = files.count() + 1;
 
         layoutName = layoutName + "-" + QString::number(newCounter);
     }
 
     QString newLayoutPath = layoutDir.absolutePath() + "/" + layoutName + ".layout.latte";
 
     qDebug() << "adding layout : " << layoutName << " based on preset:" << preset;
 
     if (preset == i18n("Default") && !QFile(newLayoutPath).exists()) {
         qDebug() << "adding layout : succeed";
         QFile(m_corona->kPackage().filePath("preset1")).copy(newLayoutPath);
     }
 
     return newLayoutPath;
 }
 
 //! This function figures in the beginning if a dock with tasks
 //! in it will be loaded taking into account also the screens are present.
 bool LayoutManager::heuresticForLoadingDockWithTasks(int *firstContainmentWithTasks)
 {
     foreach (auto containment, m_corona->containments()) {
         QString plugin = containment->pluginMetaData().pluginId();
 
         if (plugin == "org.kde.latte.containment") {
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             int lastScreen =  containment->lastScreen();
 
             qDebug() << "containment values: " << onPrimary << " - " << lastScreen;
 
 
             bool containsTasks = false;
 
             foreach (auto applet, containment->applets()) {
                 const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
                 if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
                     containsTasks = true;
                     break;
                 }
             }
 
             if (containsTasks) {
                 *firstContainmentWithTasks = containment->id();
 
                 if (onPrimary) {
                     return true;
                 } else {
                     if (lastScreen >= 0) {
                         QString connector = m_corona->screenPool()->connector(lastScreen);
 
                         foreach (auto scr, qGuiApp->screens()) {
                             if (scr && scr->name() == connector) {
                                 return true;
                                 break;
                             }
                         }
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 
 void LayoutManager::importDefaultLayout(bool newInstanceIfPresent)
 {
     importPreset(1, newInstanceIfPresent);
 
     if (newInstanceIfPresent) {
         loadLayouts();
     }
 }
 
 void LayoutManager::importPresets(bool includeDefault)
 {
     int start = 1;
 
     if (!includeDefault) {
         start = 2;
     }
 
     for (int i = start; i <= 4; ++i) {
         importPreset(i, false);
     }
 }
 
 void LayoutManager::importPreset(int presetNo, bool newInstanceIfPresent)
 {
     QByteArray presetNameOrig = QString("preset" + QString::number(presetNo)).toUtf8();
     QString presetPath = m_corona->kPackage().filePath(presetNameOrig);
     QString presetName = Layout::layoutName(presetPath);
     QByteArray presetNameChars = presetName.toUtf8();
     presetName = i18n(presetNameChars);
 
     //! hide the multiple layouts layout file from user
     presetName = (presetNo == MultipleLayoutsPresetId) ? "." + presetName : presetName;
 
     QString newLayoutFile = "";
 
     if (newInstanceIfPresent) {
         newLayoutFile = QDir::homePath() + "/.config/latte/" + m_importer->uniqueLayoutName(presetName) + ".layout.latte";
     } else {
         newLayoutFile = QDir::homePath() + "/.config/latte/" + presetName + ".layout.latte";
     }
 
     if (!QFile(newLayoutFile).exists()) {
         QFile(presetPath).copy(newLayoutFile);
     }
 }
 
 QStringList LayoutManager::validActivities(QStringList currentList)
 {
     QStringList validIds;
 
     foreach (auto activity, currentList) {
         if (activities().contains(activity)) {
             validIds.append(activity);
         }
     }
 
     return validIds;
 }
 
 bool LayoutManager::layoutIsAssigned(QString layoutName)
 {
     QHashIterator<const QString, QString> i(m_assignedLayouts);
 
     while (i.hasNext()) {
         i.next();
 
         if (i.value() == layoutName) {
             return true;
         }
     }
 
     return false;
 }
 
 void LayoutManager::showLatteSettingsDialog(int page)
 {
     if (!m_latteSettingsDialog) {
         m_latteSettingsDialog = new SettingsDialog(nullptr, m_corona);
     }
 
     m_latteSettingsDialog->show();
 
     if (m_latteSettingsDialog->isMinimized()) {
         m_latteSettingsDialog->showNormal();
     }
 
     Dock::LatteConfigPage configPage = static_cast<Dock::LatteConfigPage>(page);
     m_latteSettingsDialog->setCurrentPage(configPage);
 
     m_latteSettingsDialog->activateWindow();
 }
 
 void LayoutManager::showInfoWindow(QString info, int duration, QStringList activities)
 {
     foreach (auto screen, qGuiApp->screens()) {
         InfoView *infoView = new InfoView(m_corona, info, screen);
 
         infoView->show();
         infoView->setOnActivities(activities);
 
         QTimer::singleShot(duration, [this, infoView]() {
             infoView->deleteLater();
         });
     }
 }
 
+void LayoutManager::updateColorizerSupport()
+{
+    bool enable{false};
+
+    foreach (auto layout, m_activeLayouts) {
+        for (const auto *view : *layout->dockViews()) {
+            if (view->colorizerSupport()) {
+                enable = true;
+                break;
+            }
+        }
+
+        if (enable) {
+            break;
+        }
+    }
+
+    if (enable) {
+        m_corona->universalSettings()->enableActivitiesModel();
+    } else {
+        m_corona->universalSettings()->disableActivitiesModel();
+    }
+}
+
 //! it is used just in order to provide translations for the presets
 void LayoutManager::ghostForTranslatedPresets()
 {
     QString preset1 = i18n("Default");
     QString preset2 = i18n("Plasma");
     QString preset3 = i18n("Unity");
     QString preset4 = i18n("Extended");
 }
 
 }
diff --git a/app/layoutmanager.h b/app/layoutmanager.h
index 3d154044..4fa5f357 100644
--- a/app/layoutmanager.h
+++ b/app/layoutmanager.h
@@ -1,193 +1,195 @@
 /*
 *  Copyright 2017  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/>.
 */
 
 #ifndef LAYOUTMANAGER_H
 #define LAYOUTMANAGER_H
 
 #include "launcherssignals.h"
 #include "settingsdialog.h"
 
 #include <QAction>
 #include <QObject>
 #include <QPointer>
 
 #include <KLocalizedString>
 
 namespace Plasma {
 class Containment;
 class Types;
 }
 
 namespace KActivities {
 class Controller;
 }
 
 namespace Latte {
 class DockCorona;
 class DockView;
 class Importer;
 class Layout;
 class LaunchersSignals;
 }
 
 namespace Latte {
 
 //! This class is responsible to manipulate all layouts.
 //! add,remove,rename, update configurations etc.
 class LayoutManager : public QObject {
     Q_OBJECT
 
     Q_PROPERTY(QString currentLayoutName READ currentLayoutName NOTIFY currentLayoutNameChanged)
 
     Q_PROPERTY(QStringList layouts READ layouts NOTIFY layoutsChanged)
     Q_PROPERTY(QStringList menuLayouts READ menuLayouts NOTIFY menuLayoutsChanged)
 
     Q_PROPERTY(LaunchersSignals *launchersSignals READ launchersSignals NOTIFY launchersSignalsChanged)
 
 public:
     LayoutManager(QObject *parent = nullptr);
     ~LayoutManager() override;
 
     DockCorona *corona();
     Importer *importer();
 
     void load();
     void loadLayoutOnStartup(QString layoutName);
     void unload();
     void addDock(Plasma::Containment *containment, bool forceLoading = false, int expDockScreen = -1);
     void hideAllDocks();
     void pauseLayout(QString layoutName);
     void recreateDock(Plasma::Containment *containment);
     void syncDockViewsToScreens();
     void syncActiveLayoutsToOriginalFiles();
 
     bool layoutExists(QString layoutName) const;
 
     QString shouldSwitchToLayout(QString activityId);
 
     QString currentLayoutName() const;
     QString defaultLayoutName() const;
 
     QStringList layouts() const;
     QStringList menuLayouts() const;
     QStringList presetsPaths() const;
 
     Dock::LayoutsMemoryUsage memoryUsage() const;
     void setMemoryUsage(Dock::LayoutsMemoryUsage memoryUsage);
 
     QHash<const Plasma::Containment *, DockView *> *currentDockViews() const;
     QHash<const Plasma::Containment *, DockView *> *layoutDockViews(const QString &layoutName) const;
     //! returns an active layout with that #id (name), it returns null if such
     //! layout cant be found
     Layout *activeLayout(QString id) const;
     int activeLayoutPos(QString id) const;
 
     LaunchersSignals *launchersSignals();
 
     QStringList activities();
     QStringList runningActivities();
     QStringList orphanedActivities(); //! These are activities that havent been assigned to specific layout
 
     void importDefaultLayout(bool newInstanceIfPresent = false);
     void importPresets(bool includeDefault = false);
 
 public slots:
     void showAboutDialog();
+    void updateColorizerSupport();
+
     Q_INVOKABLE void showLatteSettingsDialog(int page = Latte::Dock::LayoutPage);
 
     //! switch to specified layout, default previousMemoryUsage means that it didnt change
     Q_INVOKABLE bool switchToLayout(QString layoutName, int previousMemoryUsage = -1);
 
     Q_INVOKABLE int layoutsMemoryUsage();
 
     //! creates a new layout with layoutName based on the preset
     Q_INVOKABLE QString newLayout(QString layoutName, QString preset = i18n("Default"));
 
     Q_INVOKABLE QStringList activeLayoutsNames();
 
 signals:
     void activeLayoutsChanged();
     void currentLayoutChanged();
     void currentLayoutNameChanged();
     void launchersSignalsChanged();
     void layoutsChanged();
     void menuLayoutsChanged();
 
     void currentLayoutIsSwitching(QString layoutName);
 
 private slots:
     void currentActivityChanged(const QString &id);
     void showInfoWindowChanged();
     void syncMultipleLayoutsToActivities(QString layoutForOrphans = QString());
 
 private:
     void cleanupOnStartup(QString path); //!remove deprecated or oldstyle config options
     void clearUnloadedContainmentsFromLinkedFile(QStringList containmentsIds, bool bypassChecks = false);
     void confirmDynamicSwitch();
     //! it is used just in order to provide translations for the presets
     void ghostForTranslatedPresets();
     //! This function figures in the beginning if a dock with tasks
     //! in it will be loaded taking into account also the screens are present.
     //! returns true if it will be loaded, false otherwise
     //! firstContainmentWithTasks = the first containment containing a taskmanager plasmoid
     bool heuresticForLoadingDockWithTasks(int *firstContainmentWithTasks);
     void importLatteLayout(QString layoutPath);
     void importPreset(int presetNo, bool newInstanceIfPresent = false);
     void loadLatteLayout(QString layoutPath);
     void loadLayouts();
     void setMenuLayouts(QStringList layouts);
     void showInfoWindow(QString info, int duration, QStringList activities = {"0"});
     void updateCurrentLayoutNameInMultiEnvironment();
 
     bool layoutIsAssigned(QString layoutName);
 
     QString layoutPath(QString layoutName);
 
     QStringList validActivities(QStringList currentList);
 
 private:
     QString m_currentLayoutNameInMultiEnvironment;
     QString m_shouldSwitchToLayout;
 
     QStringList m_layouts;
     QStringList m_menuLayouts;
     QStringList m_presetsPaths;
 
     QHash<const QString, QString> m_assignedLayouts;
 
     QTimer m_dynamicSwitchTimer;
 
     QPointer<Latte::SettingsDialog> m_latteSettingsDialog;
 
     DockCorona *m_corona{nullptr};
     Importer *m_importer{nullptr};
     LaunchersSignals *m_launchersSignals{nullptr};
 
     QList<Layout *> m_activeLayouts;
 
     KActivities::Controller *m_activitiesController;
 
 
     friend class SettingsDialog;
 };
 
 }
 
 #endif // LAYOUTMANAGER_H
diff --git a/app/sortedactivitiesmodel.cpp b/app/sortedactivitiesmodel.cpp
new file mode 100644
index 00000000..2983ec07
--- /dev/null
+++ b/app/sortedactivitiesmodel.cpp
@@ -0,0 +1,439 @@
+/*
+ *   Copyright (C) 2016 Ivan Cukic <ivan.cukic(at)kde.org>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License version 2,
+ *   or (at your option) any later version, as published by the Free
+ *   Software Foundation
+ *
+ *   This program 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, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+// Self
+#include "sortedactivitiesmodel.h"
+
+// C++
+#include <functional>
+
+// Qt
+#include <QColor>
+#include <QFileInfo>
+#include <QImage>
+#include <QObject>
+#include <QTimer>
+
+// KDE
+#include <KSharedConfig>
+#include <KConfigGroup>
+#include <KDirWatch>
+#include <KLocalizedString>
+#include <KActivities/Consumer>
+
+#include <Plasma>
+
+#define PLASMACONFIG "plasma-org.kde.plasma.desktop-appletsrc"
+
+namespace {
+
+class BackgroundCache: public QObject {
+public:
+    BackgroundCache()
+        : initialized(false)
+        , plasmaConfig(KSharedConfig::openConfig(PLASMACONFIG)) {
+        using namespace std::placeholders;
+
+        const auto configFile = QStandardPaths::writableLocation(
+                                    QStandardPaths::GenericConfigLocation) +
+                                QLatin1Char('/') + PLASMACONFIG;
+
+        KDirWatch::self()->addFile(configFile);
+
+        QObject::connect(KDirWatch::self(), &KDirWatch::dirty,
+                         this, &BackgroundCache::settingsFileChanged,
+                         Qt::QueuedConnection);
+        QObject::connect(KDirWatch::self(), &KDirWatch::created,
+                         this, &BackgroundCache::settingsFileChanged,
+                         Qt::QueuedConnection);
+
+    }
+
+    void settingsFileChanged(const QString &file) {
+        if (!file.endsWith(PLASMACONFIG)) {
+            return;
+        }
+
+        if (initialized) {
+            plasmaConfig->reparseConfiguration();
+            reload();
+        }
+    }
+
+    void subscribe(SortedActivitiesModel *model) {
+        if (!initialized) {
+            reload();
+        }
+
+        models << model;
+    }
+
+    void unsubscribe(SortedActivitiesModel *model) {
+        models.removeAll(model);
+
+        if (models.isEmpty()) {
+            initialized = false;
+            forActivity.clear();
+        }
+    }
+
+    QString backgroundFromConfig(const KConfigGroup &config) const {
+        auto wallpaperPlugin = config.readEntry("wallpaperplugin");
+        auto wallpaperConfig = config.group("Wallpaper").group(wallpaperPlugin).group("General");
+
+        if (wallpaperConfig.hasKey("Image")) {
+            // Trying for the wallpaper
+            auto wallpaper = wallpaperConfig.readEntry("Image", QString());
+
+            if (!wallpaper.isEmpty()) {
+                return wallpaper;
+            }
+        }
+
+        if (wallpaperConfig.hasKey("Color")) {
+            auto backgroundColor = wallpaperConfig.readEntry("Color", QColor(0, 0, 0));
+            return backgroundColor.name();
+        }
+
+        return QString();
+    }
+
+    void reload() {
+        auto newForActivity = forActivity;
+        QHash<QString, int> lastScreenForActivity;
+
+        // contains activities for which the wallpaper
+        // has updated
+        QStringList changedActivities;
+
+        // Contains activities not covered by any containment
+        QStringList ghostActivities = forActivity.keys();
+
+        // Traversing through all containments in search for
+        // containments that define activities in plasma
+        for (const auto &containmentId : plasmaConfigContainments().groupList()) {
+            const auto containment = plasmaConfigContainments().group(containmentId);
+            const auto lastScreen  = containment.readEntry("lastScreen", 0);
+            const auto activity    = containment.readEntry("activityId", QString());
+
+            // Ignore the containment if the activity is not defined
+            if (activity.isEmpty()) continue;
+
+            // If we have already found the same activity from another
+            // containment, we are using the new one only if
+            // the previous one was a color and not a proper wallpaper,
+            // or if the screen ID is closer to zero
+            const bool processed = !ghostActivities.contains(activity) &&
+                                   newForActivity.contains(activity) &&
+                                   (lastScreenForActivity[activity] <= lastScreen);
+
+            // qDebug() << "GREPME Searching containment " << containmentId
+            //          << "for the wallpaper of the " << activity << " activity - "
+            //          << "currently, we think that the wallpaper is " << processed << (processed ? newForActivity[activity] : QString())
+            //          << "last screen is" << lastScreen
+            //          ;
+
+            if (processed &&
+                newForActivity[activity][0] != '#') continue;
+
+            // Marking the current activity as processed
+            ghostActivities.removeAll(activity);
+
+            const auto returnedBackground = backgroundFromConfig(containment);
+
+            QString background = returnedBackground;
+
+            if (background.startsWith("file://")) {
+                background = returnedBackground.mid(7);
+            }
+
+            // qDebug() << "        GREPME Found wallpaper: " << background;
+
+            if (background.isEmpty()) continue;
+
+            // If we got this far and we already had a new wallpaper for
+            // this activity, it means we now have a better one
+            bool foundBetterWallpaper = changedActivities.contains(activity);
+
+            if (foundBetterWallpaper || newForActivity[activity] != background) {
+                if (!foundBetterWallpaper) {
+                    changedActivities << activity;
+                }
+
+                // qDebug() << "        GREPME Setting: " << activity << " = " << background << "," << lastScreen;
+
+                newForActivity[activity] = background;
+                lastScreenForActivity[activity] = lastScreen;
+            }
+        }
+
+        initialized = true;
+
+        // Removing the activities from the list if we haven't found them
+        // while traversing through the containments
+        for (const auto &activity : ghostActivities) {
+            newForActivity.remove(activity);
+        }
+
+        // If we have detected the changes, lets notify everyone
+        if (!changedActivities.isEmpty()) {
+            forActivity = newForActivity;
+
+            for (auto model : models) {
+                model->onBackgroundsUpdated(changedActivities);
+            }
+        }
+    }
+
+    KConfigGroup plasmaConfigContainments() {
+        return plasmaConfig->group("Containments");
+    }
+
+    QHash<QString, QString> forActivity;
+    QList<SortedActivitiesModel *> models;
+
+    bool initialized;
+    KSharedConfig::Ptr plasmaConfig;
+};
+
+static BackgroundCache &backgrounds()
+{
+    // If you convert this to a shared pointer,
+    // fix the connections to KDirWatcher
+    static BackgroundCache cache;
+    return cache;
+}
+
+}
+
+SortedActivitiesModel::SortedActivitiesModel(const QVector<KActivities::Info::State> &states, QObject *parent)
+    : QSortFilterProxyModel(parent)
+    , m_activitiesModel(new KActivities::ActivitiesModel(states, this))
+    , m_activities(new KActivities::Consumer(this))
+{
+    setSourceModel(m_activitiesModel);
+
+    setDynamicSortFilter(true);
+    setSortRole(KActivities::ActivitiesModel::ActivityId);
+    sort(0, Qt::DescendingOrder);
+
+    backgrounds().subscribe(this);
+}
+
+SortedActivitiesModel::~SortedActivitiesModel()
+{
+    backgrounds().unsubscribe(this);
+}
+
+bool SortedActivitiesModel::inhibitUpdates() const
+{
+    return m_inhibitUpdates;
+}
+
+void SortedActivitiesModel::setInhibitUpdates(bool inhibitUpdates)
+{
+    if (m_inhibitUpdates != inhibitUpdates) {
+        m_inhibitUpdates = inhibitUpdates;
+        emit inhibitUpdatesChanged(m_inhibitUpdates);
+
+        setDynamicSortFilter(!inhibitUpdates);
+    }
+}
+
+/*QHash<int, QByteArray> SortedActivitiesModel::roleNames() const
+{
+    if (!sourceModel()) return QHash<int, QByteArray>();
+
+    auto roleNames = sourceModel()->roleNames();
+
+    roleNames[LastTimeUsed]       = "lastTimeUsed";
+    roleNames[LastTimeUsedString] = "lastTimeUsedString";
+    roleNames[WindowCount]        = "windowCount";
+    roleNames[HasWindows]         = "hasWindows";
+
+    return roleNames;
+}*/
+
+QVariant SortedActivitiesModel::data(const QModelIndex &index, int role) const
+{
+    if (role == KActivities::ActivitiesModel::ActivityBackground) {
+        const auto activity = activityIdForIndex(index);
+
+        return backgrounds().forActivity[activity];
+
+    } else {
+        return QSortFilterProxyModel::data(index, role);
+    }
+}
+
+QString SortedActivitiesModel::activityIdForIndex(const QModelIndex &index) const
+{
+    return data(index, KActivities::ActivitiesModel::ActivityId).toString();
+}
+
+QString SortedActivitiesModel::activityIdForRow(int row) const
+{
+    return activityIdForIndex(index(row, 0));
+}
+
+int SortedActivitiesModel::rowForActivityId(const QString &activity) const
+{
+    int position = -1;
+
+    for (int row = 0; row < rowCount(); ++row) {
+        if (activity == activityIdForRow(row)) {
+            position = row;
+        }
+    }
+
+    return position;
+}
+
+QString SortedActivitiesModel::relativeActivity(int relative) const
+{
+    const auto currentActivity = m_activities->currentActivity();
+
+    if (!sourceModel()) return QString();
+
+    const auto currentRowCount = sourceModel()->rowCount();
+
+    //x % 0 is undefined in c++
+    if (currentRowCount == 0) {
+        return QString();
+    }
+
+    int currentActivityRow = 0;
+
+    for (; currentActivityRow < currentRowCount; currentActivityRow++) {
+        if (activityIdForRow(currentActivityRow) == currentActivity) break;
+    }
+
+    currentActivityRow = currentActivityRow + relative;
+
+    //wrap to within bounds for both positive and negative currentActivityRows
+    currentActivityRow = (currentRowCount + (currentActivityRow % currentRowCount)) % currentRowCount;
+
+    return activityIdForRow(currentActivityRow);
+}
+
+void SortedActivitiesModel::onCurrentActivityChanged(const QString &currentActivity)
+{
+    if (m_previousActivity == currentActivity) return;
+
+    const int previousActivityRow = rowForActivityId(m_previousActivity);
+//    emit rowChanged(previousActivityRow);
+
+    m_previousActivity = currentActivity;
+
+    const int currentActivityRow = rowForActivityId(m_previousActivity);
+    //  emit rowChanged(currentActivityRow);
+}
+
+void SortedActivitiesModel::onBackgroundsUpdated(const QStringList &activities)
+{
+    for (const auto &activity : activities) {
+        const int row = rowForActivityId(activity);
+        emit rowChanged(row, { KActivities::ActivitiesModel::ActivityBackground });
+    }
+}
+
+
+void SortedActivitiesModel::rowChanged(int row, const QVector<int> &roles)
+{
+    if (row == -1) return;
+
+    emit dataChanged(index(row, 0), index(row, 0), roles);
+}
+
+float SortedActivitiesModel::luminasFromFile(QString imageFile, int edge)
+{
+    QImage image(imageFile);
+
+    Plasma::Types::Location location = static_cast<Plasma::Types::Location>(edge);
+
+    if (m_luminasCache.keys().contains(imageFile)) {
+        if (m_luminasCache[imageFile].keys().contains(location)) {
+            return m_luminasCache[imageFile].value(location);
+        }
+    }
+
+    if (image.format() != QImage::Format_Invalid) {
+        int maskHeight = (0.08 * image.height());
+        int maskWidth = (0.05 * image.width());
+
+        float areaLumin = -1000;
+
+        int firstRow = 0;
+        int firstColumn = 0;
+        int endRow = 0;
+        int endColumn = 0;
+
+        if (location == Plasma::Types::TopEdge) {
+            firstRow = 0;
+            endRow = maskHeight;
+            firstColumn = 0;
+            endColumn = image.width() - 1;
+        } else if (location == Plasma::Types::BottomEdge) {
+            firstRow = image.height() - maskHeight - 1;
+            endRow = image.height() - 1;
+            firstColumn = 0;
+            endColumn = image.width() - 1;
+        } else if (location == Plasma::Types::LeftEdge) {
+            firstRow = 0;
+            endRow = image.height() - 1;
+            firstColumn = 0;
+            endColumn = maskWidth;
+        } else if (location == Plasma::Types::RightEdge) {
+            firstRow = 0;
+            endRow = image.height() - 1;
+            firstColumn = image.width() - 1 - maskWidth;
+            endColumn = image.width() - 1;
+        }
+
+        for (int row = firstRow; row < endRow; ++row) {
+            QRgb *line = (QRgb *)image.scanLine(row);
+
+            for (int col = firstColumn; col < endColumn ; ++col) {
+                QRgb pixelData = line[col];
+                int r = qRed(pixelData);
+                int g = qGreen(pixelData);
+                int b = qBlue(pixelData);
+
+                float pixelLuminosity = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+
+                areaLumin = (areaLumin == -1000) ? pixelLuminosity : (areaLumin + pixelLuminosity);
+            }
+        }
+
+        float areaSize = (endRow - firstRow) * (endColumn - firstColumn);
+        areaLumin = areaLumin / areaSize;
+        areaLumin = areaLumin / 255;
+
+        if (!m_luminasCache.keys().contains(imageFile)) {
+            m_luminasCache[imageFile] = EdgesHash();
+        }
+
+        m_luminasCache[imageFile].insert(location, areaLumin);
+
+        return areaLumin;
+    }
+
+    //! didnt find anything
+    return -1000;
+}
diff --git a/app/sortedactivitiesmodel.h b/app/sortedactivitiesmodel.h
new file mode 100644
index 00000000..b9b862f0
--- /dev/null
+++ b/app/sortedactivitiesmodel.h
@@ -0,0 +1,84 @@
+/*
+ *   Copyright (C) 2016 Ivan Cukic <ivan.cukic(at)kde.org>
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License version 2,
+ *   or (at your option) any later version, as published by the Free
+ *   Software Foundation
+ *
+ *   This program 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, write to the
+ *   Free Software Foundation, Inc.,
+ *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
+ */
+
+#ifndef SORTED_ACTIVITY_MODEL
+#define SORTED_ACTIVITY_MODEL
+
+// Qt
+#include <QSortFilterProxyModel>
+
+#include <Plasma>
+
+// KDE
+#include <KActivities/Consumer>
+#include <KActivities/Info>
+#include <KActivities/ActivitiesModel>
+
+typedef QHash<Plasma::Types::Location, float> EdgesHash;
+
+class SortedActivitiesModel : public QSortFilterProxyModel {
+    Q_OBJECT
+
+    Q_PROPERTY(bool inhibitUpdates READ inhibitUpdates WRITE setInhibitUpdates NOTIFY inhibitUpdatesChanged)
+
+public:
+    SortedActivitiesModel(const QVector<KActivities::Info::State> &states, QObject *parent = nullptr);
+    ~SortedActivitiesModel() override;
+
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+    float luminasFromFile(QString imageFile, int edge);
+    QString relativeActivity(int relative) const;
+
+protected:
+    /*enum AdditionalRoles {
+        LastTimeUsed       = KActivities::ActivitiesModel::UserRole,
+        LastTimeUsedString = KActivities::ActivitiesModel::UserRole + 1,
+        WindowCount        = KActivities::ActivitiesModel::UserRole + 2,
+        HasWindows         = KActivities::ActivitiesModel::UserRole + 3
+    };*/
+
+public Q_SLOTS:
+    bool inhibitUpdates() const;
+    void setInhibitUpdates(bool sortByLastUsedTime);
+
+    void onBackgroundsUpdated(const QStringList &changedBackgrounds);
+    void onCurrentActivityChanged(const QString &currentActivity);
+
+    QString activityIdForRow(int row) const;
+    QString activityIdForIndex(const QModelIndex &index) const;
+    int rowForActivityId(const QString &activity) const;
+
+    void rowChanged(int row, const QVector<int> &roles);
+
+Q_SIGNALS:
+    void inhibitUpdatesChanged(bool inhibitUpdates);
+
+private:
+    bool m_inhibitUpdates;
+
+    QString m_previousActivity;
+
+    KActivities::ActivitiesModel *m_activitiesModel = nullptr;
+    KActivities::Consumer *m_activities = nullptr;
+
+    QHash<QString, EdgesHash> m_luminasCache;
+};
+
+#endif // SORTED_ACTIVITY_MODEL
diff --git a/app/universalsettings.cpp b/app/universalsettings.cpp
index 3ab23198..7e61bb03 100644
--- a/app/universalsettings.cpp
+++ b/app/universalsettings.cpp
@@ -1,296 +1,345 @@
 /*
 *  Copyright 2017  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 "universalsettings.h"
 #include "dockcorona.h"
 
+#include "sortedactivitiesmodel.h"
+
 #include <QDir>
 
+#include <KActivities/Consumer>
+
 namespace Latte {
 
 UniversalSettings::UniversalSettings(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_config(config),
       m_universalGroup(KConfigGroup(config, QStringLiteral("UniversalSettings")))
 {
     connect(this, &UniversalSettings::currentLayoutNameChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::lastNonAssignedLayoutNameChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::launchersChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsColumnWidthsChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsMemoryUsageChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsWindowSizeChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::mouseSensitivityChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::showInfoWindowChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::versionChanged, this, &UniversalSettings::saveConfig);
 }
 
 UniversalSettings::~UniversalSettings()
 {
     saveConfig();
     cleanupSettings();
+
+    if (m_runningActivitiesModel) {
+        m_runningActivitiesModel->deleteLater();
+    }
 }
 
 void UniversalSettings::load()
 {
     //! check if user has set the autostart option
     bool autostartUserSet = m_universalGroup.readEntry("userConfiguredAutostart", false);
 
     if (!autostartUserSet && !autostart()) {
         setAutostart(true);
     }
 
     //! load configuration
     loadConfig();
 }
 
 bool UniversalSettings::showInfoWindow() const
 {
     return m_showInfoWindow;
 }
 
 void UniversalSettings::setShowInfoWindow(bool show)
 {
     if (m_showInfoWindow == show) {
         return;
     }
 
     m_showInfoWindow = show;
     emit showInfoWindowChanged();
 }
 
 int UniversalSettings::version() const
 {
     return m_version;
 }
 
 void UniversalSettings::setVersion(int ver)
 {
     if (m_version == ver) {
         return;
     }
 
     m_version = ver;
 
     emit versionChanged();
 }
 
 QString UniversalSettings::currentLayoutName() const
 {
     return m_currentLayoutName;
 }
 
 void UniversalSettings::setCurrentLayoutName(QString layoutName)
 {
     if (m_currentLayoutName == layoutName) {
         return;
     }
 
     m_currentLayoutName = layoutName;
     emit currentLayoutNameChanged();
 }
 
 QString UniversalSettings::lastNonAssignedLayoutName() const
 {
     return m_lastNonAssignedLayoutName;
 }
 
 void UniversalSettings::setLastNonAssignedLayoutName(QString layoutName)
 {
     if (m_lastNonAssignedLayoutName == layoutName) {
         return;
     }
 
     m_lastNonAssignedLayoutName = layoutName;
     emit lastNonAssignedLayoutNameChanged();
 }
 
 QSize UniversalSettings::layoutsWindowSize() const
 {
     return m_layoutsWindowSize;
 }
 
 void UniversalSettings::setLayoutsWindowSize(QSize size)
 {
     if (m_layoutsWindowSize == size) {
         return;
     }
 
     m_layoutsWindowSize = size;
     emit layoutsWindowSizeChanged();
 }
 
 QStringList UniversalSettings::layoutsColumnWidths() const
 {
     return m_layoutsColumnWidths;
 }
 
 void UniversalSettings::setLayoutsColumnWidths(QStringList widths)
 {
     if (m_layoutsColumnWidths == widths) {
         return;
     }
 
     m_layoutsColumnWidths = widths;
     emit layoutsColumnWidthsChanged();
 }
 
 QStringList UniversalSettings::launchers() const
 {
     return m_launchers;
 }
 
 void UniversalSettings::setLaunchers(QStringList launcherList)
 {
     if (m_launchers == launcherList) {
         return;
     }
 
     m_launchers = launcherList;
     emit launchersChanged();
 }
 
 
 bool UniversalSettings::autostart() const
 {
     QFile autostartFile(QDir::homePath() + "/.config/autostart/org.kde.latte-dock.desktop");
     return autostartFile.exists();
 }
 
 void UniversalSettings::setAutostart(bool state)
 {
     //! remove old autostart file
     QFile oldAutostartFile(QDir::homePath() + "/.config/autostart/latte-dock.desktop");
 
     if (oldAutostartFile.exists()) {
         oldAutostartFile.remove();
     }
 
     //! end of removal of old autostart file
 
     QFile autostartFile(QDir::homePath() + "/.config/autostart/org.kde.latte-dock.desktop");
     QFile metaFile("/usr/share/applications/org.kde.latte-dock.desktop");
 
     if (!state && autostartFile.exists()) {
         //! the first time that the user disables the autostart, this is recorded
         //! and from now own it will not be recreated it in the beginning
         if (!m_universalGroup.readEntry("userConfiguredAutostart", false)) {
             m_universalGroup.writeEntry("userConfiguredAutostart", true);
         }
 
         autostartFile.remove();
         emit autostartChanged();
     } else if (state && metaFile.exists()) {
         metaFile.copy(autostartFile.fileName());
         //! I havent added the flag "OnlyShowIn=KDE;" into the autostart file
         //! because I fall onto a Plasma 5.8 case that this flag
         //! didnt let the plasma desktop to start
         emit autostartChanged();
     }
 }
 
 Dock::LayoutsMemoryUsage UniversalSettings::layoutsMemoryUsage() const
 {
     return m_memoryUsage;
 }
 
 void UniversalSettings::setLayoutsMemoryUsage(Dock::LayoutsMemoryUsage layoutsMemoryUsage)
 {
     if (m_memoryUsage == layoutsMemoryUsage) {
         return;
     }
 
     m_memoryUsage = layoutsMemoryUsage;
     emit layoutsMemoryUsageChanged();
 }
 
 Dock::MouseSensitivity UniversalSettings::mouseSensitivity() const
 {
     return m_mouseSensitivity;
 }
 
 void UniversalSettings::setMouseSensitivity(Dock::MouseSensitivity sensitivity)
 {
     if (m_mouseSensitivity == sensitivity) {
         return;
     }
 
     m_mouseSensitivity = sensitivity;
     emit mouseSensitivityChanged();
 }
 
 void UniversalSettings::loadConfig()
 {
     m_version = m_universalGroup.readEntry("version", 1);
     m_currentLayoutName = m_universalGroup.readEntry("currentLayout", QString());
     m_lastNonAssignedLayoutName = m_universalGroup.readEntry("lastNonAssignedLayout", QString());
     m_layoutsWindowSize = m_universalGroup.readEntry("layoutsWindowSize", QSize(700, 450));
     m_layoutsColumnWidths = m_universalGroup.readEntry("layoutsColumnWidths", QStringList());
     m_launchers = m_universalGroup.readEntry("launchers", QStringList());
     m_showInfoWindow = m_universalGroup.readEntry("showInfoWindow", true);
     m_memoryUsage = static_cast<Dock::LayoutsMemoryUsage>(m_universalGroup.readEntry("memoryUsage", (int)Dock::SingleLayout));
     m_mouseSensitivity = static_cast<Dock::MouseSensitivity>(m_universalGroup.readEntry("mouseSensitivity", (int)Dock::HighSensitivity));
 }
 
 void UniversalSettings::saveConfig()
 {
     m_universalGroup.writeEntry("version", m_version);
     m_universalGroup.writeEntry("currentLayout", m_currentLayoutName);
     m_universalGroup.writeEntry("lastNonAssignedLayout", m_lastNonAssignedLayoutName);
     m_universalGroup.writeEntry("layoutsWindowSize", m_layoutsWindowSize);
     m_universalGroup.writeEntry("layoutsColumnWidths", m_layoutsColumnWidths);
     m_universalGroup.writeEntry("launchers", m_launchers);
     m_universalGroup.writeEntry("showInfoWindow", m_showInfoWindow);
     m_universalGroup.writeEntry("memoryUsage", (int)m_memoryUsage);
     m_universalGroup.writeEntry("mouseSensitivity", (int)m_mouseSensitivity);
 
     m_universalGroup.sync();
 }
 
 void UniversalSettings::cleanupSettings()
 {
     KConfigGroup containments = KConfigGroup(m_config, QStringLiteral("Containments"));
     containments.deleteGroup();
 
     containments.sync();
 }
 
 QString UniversalSettings::splitterIconPath()
 {
     auto *dockCorona = qobject_cast<DockCorona *>(parent());
 
     if (dockCorona) {
         return dockCorona->kPackage().filePath("splitter");
     }
 
     return "";
 }
 
 QString UniversalSettings::trademarkIconPath()
 {
     auto *dockCorona = qobject_cast<DockCorona *>(parent());
 
     if (dockCorona) {
         return dockCorona->kPackage().filePath("trademark");
     }
 
     return "";
 }
 
+QAbstractItemModel *UniversalSettings::runningActivitiesModel() const
+{
+    return m_runningActivitiesModel;
+}
+
+void UniversalSettings::setRunningActivitiesModel(SortedActivitiesModel *model)
+{
+    if (m_runningActivitiesModel == model) {
+        return;
+    }
+
+    if (m_runningActivitiesModel) {
+        m_runningActivitiesModel->deleteLater();
+    }
+
+    m_runningActivitiesModel = model;
+
+    emit runningActivitiesModelChanged();
+}
+
+void UniversalSettings::enableActivitiesModel()
+{
+    if (!m_runningActivitiesModel) {
+        setRunningActivitiesModel(new SortedActivitiesModel({KActivities::Info::Running, KActivities::Info::Stopping}, this));
+    }
+}
+
+void UniversalSettings::disableActivitiesModel()
+{
+    if (m_runningActivitiesModel) {
+        setRunningActivitiesModel(nullptr);
+    }
+}
+
+float UniversalSettings::luminasFromFile(QString imageFile, int edge)
+{
+    enableActivitiesModel();
+
+    return m_runningActivitiesModel->luminasFromFile(imageFile, edge);
+}
+
 }
diff --git a/app/universalsettings.h b/app/universalsettings.h
index 0fda3261..36c9ceeb 100644
--- a/app/universalsettings.h
+++ b/app/universalsettings.h
@@ -1,131 +1,146 @@
 /*
 *  Copyright 2017  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/>.
 */
 
 #ifndef UNIVERSALSETTINGS_H
 #define UNIVERSALSETTINGS_H
 
 #include <QObject>
+#include <QAbstractItemModel>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include "../liblattedock/dock.h"
 
+class SortedActivitiesModel;
+
 namespace Latte {
 
 class LayoutManager;
 
 //! This class holds all the settings that are universally available
 //! independent of layouts
 class UniversalSettings : public QObject {
     Q_OBJECT
     Q_PROPERTY(bool autostart READ autostart WRITE setAutostart NOTIFY autostartChanged)
     Q_PROPERTY(bool showInfoWindow READ showInfoWindow WRITE setShowInfoWindow NOTIFY showInfoWindowChanged)
 
     Q_PROPERTY(QString currentLayoutName READ currentLayoutName WRITE setCurrentLayoutName NOTIFY currentLayoutNameChanged)
 
     Q_PROPERTY(QStringList launchers READ launchers WRITE setLaunchers NOTIFY launchersChanged)
 
     Q_PROPERTY(Latte::Dock::MouseSensitivity mouseSensitivity READ mouseSensitivity WRITE setMouseSensitivity NOTIFY mouseSensitivityChanged)
+
+    Q_PROPERTY(QAbstractItemModel *runningActivitiesModel  READ runningActivitiesModel NOTIFY runningActivitiesModelChanged)
 public:
     UniversalSettings(KSharedConfig::Ptr config, QObject *parent = nullptr);
     ~UniversalSettings() override;
 
     void load();
 
     bool autostart() const;
     void setAutostart(bool state);
 
     bool showInfoWindow() const;
     void setShowInfoWindow(bool show);
 
     int version() const;
     void setVersion(int ver);
 
     QString currentLayoutName() const;
     void setCurrentLayoutName(QString layoutName);
 
     QString lastNonAssignedLayoutName() const;
     void setLastNonAssignedLayoutName(QString layoutName);
 
     QSize layoutsWindowSize() const;
     void setLayoutsWindowSize(QSize);
 
     QStringList layoutsColumnWidths() const;
     void setLayoutsColumnWidths(QStringList widths);
 
     QStringList launchers() const;
     void setLaunchers(QStringList launcherList);
 
     Dock::MouseSensitivity mouseSensitivity() const;
     void setMouseSensitivity(Dock::MouseSensitivity sensitivity);
 
+    QAbstractItemModel *runningActivitiesModel() const;
+    void setRunningActivitiesModel(SortedActivitiesModel *model);
+    void enableActivitiesModel();
+    void disableActivitiesModel();
+
 public slots:
     Q_INVOKABLE QString splitterIconPath();
     Q_INVOKABLE QString trademarkIconPath();
 
+    Q_INVOKABLE float luminasFromFile(QString imageFile, int edge);
+
 signals:
     void autostartChanged();
     void currentLayoutNameChanged();
     void lastNonAssignedLayoutNameChanged();
     void layoutsColumnWidthsChanged();
     void layoutsWindowSizeChanged();
     void launchersChanged();
     void layoutsMemoryUsageChanged();
     void mouseSensitivityChanged();
+    void runningActivitiesModelChanged();
     void showInfoWindowChanged();
     void versionChanged();
 
 private slots:
     void loadConfig();
     void saveConfig();
 
 private:
     void cleanupSettings();
 
     Dock::LayoutsMemoryUsage layoutsMemoryUsage() const;
     void setLayoutsMemoryUsage(Dock::LayoutsMemoryUsage layoutsMemoryUsage);
 
 private:
     bool m_showInfoWindow{true};
 
     //when there isnt a version it is an old universal file
     int m_version{1};
 
     QString m_currentLayoutName;
     QString m_lastNonAssignedLayoutName;
     QSize m_layoutsWindowSize{700, 450};
 
     QStringList m_layoutsColumnWidths;
     QStringList m_launchers;
 
     Dock::LayoutsMemoryUsage m_memoryUsage;
     Dock::MouseSensitivity m_mouseSensitivity{Dock::HighSensitivity};
 
     KConfigGroup m_universalGroup;
     KSharedConfig::Ptr m_config;
 
+    SortedActivitiesModel *m_runningActivitiesModel{nullptr};
+
     friend class LayoutManager;
     friend class DockCorona;
 };
 
 }
 
 #endif //UNIVERSALSETTINGS_H
diff --git a/containment/package/contents/ui/ColorizerManager.qml b/containment/package/contents/ui/ColorizerManager.qml
new file mode 100644
index 00000000..3e45534f
--- /dev/null
+++ b/containment/package/contents/ui/ColorizerManager.qml
@@ -0,0 +1,116 @@
+/*
+*  Copyright 2018 Michail Vourlakos <mvourlakos@gmail.com>
+*
+*  This file is part of Latte-Dock
+*
+*  Latte-Dock is free software; you can redistribute it and/or
+*  modify it under the terms of the GNU General Public License as
+*  published by the Free Software Foundation; either version 2 of
+*  the License, or (at your option) any later version.
+*
+*  Latte-Dock is distributed in the hope that it will be useful,
+*  but WITHOUT ANY WARRANTY; without even the implied warranty of
+*  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+*  GNU General Public License for more details.
+*
+*  You should have received a copy of the GNU General Public License
+*  along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+import QtQuick 2.7
+import QtGraphicalEffects 1.0
+
+import org.kde.plasma.plasmoid 2.0
+import org.kde.plasma.core 2.0 as PlasmaCore
+
+
+Item{
+    ColorOverlay {
+        id: colorizer
+        anchors.fill: parent
+        color: colorizerLoader.applyColor
+        source: layoutsContainer
+        opacity: colorizerLoader.isShown ? 1 : 0
+
+        Behavior on opacity {
+            NumberAnimation {
+                duration: 0.8 * root.animationTime
+                easing.type: Easing.OutCubic
+            }
+        }
+    }
+
+    ///Shadow in applets
+    Loader{
+        id: colorizedAppletShadow
+        anchors.fill: colorizer
+
+        active: colorizerLoader.isShown && (plasmoid.configuration.shadows >= 1) && (colorizer.opacity > 0)
+
+        sourceComponent: DropShadow{
+            anchors.fill: parent
+            color: root.appShadowColor
+            fast: true
+            samples: 2 * radius
+            source: colorizer
+            radius: shadowSize
+            verticalOffset: forcedShadow ? 0 : 2
+
+            property int shadowSize : root.appShadowSize
+
+            property bool forcedShadow: root.forceTransparentPanel && plasmoid.configuration.shadows>0 && applet.pluginName !== root.plasmoidName ? true : false
+        }
+    }
+
+    Connections{
+        target: plasmoid
+        onLocationChanged:{
+            colorizerLoader.currentBackgroundLuminas = universalSettings.luminasFromFile(activitiesList.currentLayoutBackground, plasmoid.location);
+        }
+    }
+
+    Repeater {
+        id: activitiesList
+        model: universalSettings.runningActivitiesModel
+
+        property string currentLayoutBackground: ""
+
+        onCurrentLayoutBackgroundChanged: {
+            colorizerLoader.currentBackgroundLuminas = universalSettings.luminasFromFile(currentLayoutBackground, plasmoid.location);
+        }
+
+        Item {
+            id: activityItem
+            visible: false
+
+            property string activityId: model.id
+            property string title: model.name
+            property string background: model.background
+            property bool current: model.isCurrent
+
+            Component.onCompleted: {
+                if (dockManagedLayout && forceColorizer && dockManagedLayout.lastUsedActivity === activityId) {
+                    activitiesList.currentLayoutBackground = background;
+                }
+            }
+
+            onBackgroundChanged: {
+                if (dockManagedLayout && forceColorizer && dockManagedLayout.lastUsedActivity === activityId) {
+                    activitiesList.currentLayoutBackground = background;
+                }
+            }
+
+            Connections{
+                target: dockManagedLayout
+
+                onLastUsedActivityChanged:{
+                    if (dockManagedLayout && forceColorizer && dockManagedLayout.lastUsedActivity === activityItem.activityId) {
+                        activitiesList.currentLayoutBackground = activityItem.background;
+                    }
+                }
+            }
+        }
+    }
+
+
+}
diff --git a/containment/package/contents/ui/VisibilityManager.qml b/containment/package/contents/ui/VisibilityManager.qml
index 62a001b6..dde87497 100644
--- a/containment/package/contents/ui/VisibilityManager.qml
+++ b/containment/package/contents/ui/VisibilityManager.qml
@@ -1,610 +1,617 @@
 /*
 *  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
     }
 
     Binding{
         target: dock
         property: "drawShadows"
         when: dock
         value: root.drawShadowsExternal && (!root.inStartup || inForceHiding || inTempHiding)
     }
 
     Binding{
         target: dock
         property: "drawEffects"
         when: dock
         value: ((root.blurEnabled && root.useThemePanel && !root.solidPanel)
                 || (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.height - tempThickness;
                     } else if (plasmoid.location === PlasmaCore.Types.TopEdge) {
                         localY = 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 = 0;
                     } else if (plasmoid.location === PlasmaCore.Types.RightEdge) {
                         localX = 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
             localX = dock.effectsArea.x;
             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 = 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 && !dock.visibility.isHidden)
                 && !(root.behaveAsPlasmaPanel && root.editMode)){
             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: {
                 dock.visibility.isHidden = true;
                 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.OutQuad
         }
 
         onStarted: {
             if (manager.debugMagager) {
                 console.log("hiding animation started...");
             }
         }
 
         onStopped: {
             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
 
         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;
             manager.inTempHiding = false;
 
             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/applet/AppletItemWrapper.qml b/containment/package/contents/ui/applet/AppletItemWrapper.qml
index 5b0274e3..7c22b56c 100644
--- a/containment/package/contents/ui/applet/AppletItemWrapper.qml
+++ b/containment/package/contents/ui/applet/AppletItemWrapper.qml
@@ -1,752 +1,752 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.1
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 
 import org.kde.latte 0.1 as Latte
 
 
 Item{
     id: wrapper
 
     width: {
         if (container.isInternalViewSplitter && !root.editMode)
             return 0;
 
         if (container.isSeparator && !root.editMode) {
             if (!root.isVertical)
                 return -1;
             else
                 return root.iconSize;
         }
 
         if (container.needsFillSpace && (container.sizeForFill>-1) && root.isHorizontal){
             //! in edit mode shrink a bit the fill sizes because the splitters are shown
             return root.editMode && container.needsFillSpace && (container.sizeForFill > 5*root.iconSize) ?
                         container.sizeForFill - 2.5*root.iconSize : container.sizeForFill;
             //return container.sizeForFill;
         }
 
         if (container.latteApplet) {
             //! commented because it was breaking the context menu available area, I dont remember where
             //! we needed this...
 
             // if (container.showZoomed && root.isVertical)
             //   return root.statesLineSize + root.thickMargin + root.iconSize + 1;
             //else
             return latteApplet.tasksWidth;
         } else {
             return scaledWidth;
         }
     }
 
     height: {
         if (container.isInternalViewSplitter && !root.editMode)
             return 0;
 
         if (container.isSeparator && !root.editMode) {
             if (root.isVertical)
                 return -1;
             else
                 return root.iconSize;
         }
 
         if (container.needsFillSpace && (container.sizeForFill>-1) && root.isVertical){
             //! in edit mode shrink a bit the fill sizes because the splitters are shown
             return root.editMode && container.needsFillSpace && (container.sizeForFill > 5*root.iconSize) ?
                         container.sizeForFill - 2.5*root.iconSize : container.sizeForFill;
 
             //return container.sizeForFill;
         }
 
         if (container.latteApplet) {
             //! commented because it was breaking the context menu available area, I dont remember where
             //! we needed this...
 
             //if (container.showZoomed && root.isHorizontal)
             // return root.statesLineSize + root.thickMargin + root.iconSize + 1;
             //  else
             return latteApplet.tasksHeight;
         } else {
             return scaledHeight;
         }
     }
 
     //width: container.isInternalViewSplitter && !root.editMode ? 0 : Math.round( latteApplet ? ((container.showZoomed && root.isVertical) ?
     //                                                                        scaledWidth : latteApplet.tasksWidth) : scaledWidth )
     //height: container.isInternalViewSplitter&& !root.editMode ? 0 : Math.round( latteApplet ? ((container.showZoomed && root.isHorizontal) ?
     //                                                                          scaledHeight : latteApplet.tasksHeight ): scaledHeight )
 
     property bool disableScaleWidth: false
     property bool disableScaleHeight: false
     property bool editMode: root.editMode
 
     property int appletMinimumWidth: applet && applet.Layout ?  applet.Layout.minimumWidth : -1
     property int appletMinimumHeight: applet && applet.Layout ? applet.Layout.minimumHeight : -1
 
     property int appletPreferredWidth: applet && applet.Layout ?  applet.Layout.preferredWidth : -1
     property int appletPreferredHeight: applet && applet.Layout ?  applet.Layout.preferredHeight : -1
 
     property int appletMaximumWidth: applet && applet.Layout ?  applet.Layout.maximumWidth : -1
     property int appletMaximumHeight: applet && applet.Layout ?  applet.Layout.maximumHeight : -1
 
     property int iconSize: root.iconSize
 
     property int marginWidth: root.isVertical ?
                                   (container.isSystray ? root.thickMarginBase : root.thickMargin ) :
                                   (root.inFullJustify && (container.firstChildOfStartLayout || container.lastChildOfEndLayout ) ? 0 : root.iconMargin)  //Fitt's Law
     property int marginHeight: root.isHorizontal ?
                                    (container.isSystray ? root.thickMarginBase : root.thickMargin ) :
                                    (root.inFullJustify && (container.firstChildOfStartLayout || container.lastChildOfEndLayout ) ? 0 : root.iconMargin)  //Fitt's Law
 
     property real scaledWidth: zoomScaleWidth * (layoutWidth + marginWidth)
     property real scaledHeight: zoomScaleHeight * (layoutHeight + marginHeight)
     property real zoomScaleWidth: disableScaleWidth ? 1 : zoomScale
     property real zoomScaleHeight: disableScaleHeight ? 1 : zoomScale
 
     property int layoutWidthResult: 0
 
     property int layoutWidth
     property int layoutHeight
 
     // property int localMoreSpace: root.reverseLinesPosition ? root.statesLineSize + 2 : appletMargin
     property int localMoreSpace: appletMargin
 
     property int moreHeight: (container.isSystray || root.reverseLinesPosition)
                              && root.isHorizontal ? localMoreSpace : 0
     property int moreWidth: (container.isSystray || root.reverseLinesPosition)
                             && root.isVertical ? localMoreSpace : 0
 
     property real center:(width + hiddenSpacerLeft.separatorSpace + hiddenSpacerRight.separatorSpace) / 2
     property real zoomScale: 1
 
     property int index: container.index
 
     property Item wrapperContainer: _wrapperContainer
     property Item clickedEffect: _clickedEffect
     property Item fakeIconItemContainer: _fakeIconItemContainer
 
     // property int pHeight: applet ? applet.Layout.preferredHeight : -10
 
     /*function debugLayouts(){
         if(applet){
             console.log("---------- "+ applet.pluginName +" ----------");
             console.log("MinW "+applet.Layout.minimumWidth);
             console.log("PW "+applet.Layout.preferredWidth);
             console.log("MaxW "+applet.Layout.maximumWidth);
             console.log("FillW "+applet.Layout.fillWidth);
             console.log("-----");
             console.log("MinH "+applet.Layout.minimumHeight);
             console.log("PH "+applet.Layout.preferredHeight);
             console.log("MaxH "+applet.Layout.maximumHeight);
             console.log("FillH "+applet.Layout.fillHeight);
             console.log("-----");
             console.log("LayoutW: " + layoutWidth);
             console.log("LayoutH: " + layoutHeight);
         }
     }
 
     onLayoutWidthChanged: {
         debugLayouts();
     }
 
     onLayoutHeightChanged: {
         debugLayouts();
     }*/
 
     onAppletMinimumWidthChanged: {
         if(zoomScale == 1)
             checkCanBeHovered();
 
         updateLayoutWidth();
     }
 
     onAppletMinimumHeightChanged: {
         if(zoomScale == 1)
             checkCanBeHovered();
 
         updateLayoutHeight();
     }
 
     onAppletPreferredWidthChanged: updateLayoutWidth();
     onAppletPreferredHeightChanged: updateLayoutHeight();
 
     onAppletMaximumWidthChanged: updateLayoutWidth();
     onAppletMaximumHeightChanged: updateLayoutHeight();
 
     onIconSizeChanged: {
         updateLayoutWidth();
         updateLayoutHeight();
     }
 
     onEditModeChanged: {
         updateLayoutWidth();
         updateLayoutHeight();
     }
 
     onZoomScaleChanged: {
         if ((zoomScale === root.zoomFactor) && !root.globalDirectRender) {
             root.setGlobalDirectRender(true);
         }
 
         if ((zoomScale > 1) && !container.isZoomed) {
             container.isZoomed = true;
             if (!root.editMode && !animationWasSent) {
                 root.slotAnimationsNeedBothAxis(1);
                 animationWasSent = true;
             }
         } else if ((zoomScale == 1) && container.isZoomed) {
             container.isZoomed = false;
             if (animationWasSent) {
                 root.slotAnimationsNeedBothAxis(-1);
                 animationWasSent = false;
             }
         }
     }
 
     Connections {
         target: root
         onIsVerticalChanged: {
             if (container.latteApplet) {
                 return;
             }
 
             wrapper.disableScaleWidth = false;
             wrapper.disableScaleHeight = false;
 
             if (root.isVertical)  {
                 wrapper.updateLayoutHeight();
                 wrapper.updateLayoutWidth();
             } else {
                 wrapper.updateLayoutWidth();
                 wrapper.updateLayoutHeight();
             }
         }
     }
 
     function updateLayoutHeight(){
 
         if(container.isInternalViewSplitter){
             if(!root.editMode)
                 layoutHeight = 0;
             else
                 layoutHeight = root.iconSize + moreHeight + root.statesLineSize;
         }
         else if(applet && applet.pluginName === "org.kde.plasma.panelspacer"){
             layoutHeight = root.iconSize + moreHeight;
         }
         else if(container.isSystray && root.isHorizontal){
             layoutHeight = root.statesLineSize + root.iconSize;
         }
         else{
             if(applet && (applet.Layout.minimumHeight > root.iconSize) && root.isVertical && !canBeHovered && !container.fakeIconItem){
                 // return applet.Layout.minimumHeight;
                 layoutHeight = applet.Layout.minimumHeight;
             } //it is used for plasmoids that need to scale only one axis... e.g. the Weather Plasmoid
             else if(applet
                     && ( (applet.Layout.maximumHeight < root.iconSize) || (applet.Layout.preferredHeight > root.iconSize))
                     && root.isVertical
                     && !disableScaleWidth
                     && !container.fakeIconItem) {
                 //&& !root.editMode ){
                 disableScaleHeight = true;
                 //this way improves performance, probably because during animation the preferred sizes update a lot
                 if((applet.Layout.maximumHeight < root.iconSize)){
                     layoutHeight = applet.Layout.maximumHeight;
                 }
                 else if (applet.Layout.minimumHeight > root.iconSize){
                     layoutHeight = applet.Layout.minimumHeight;
                 }
                 else if ((applet.Layout.preferredHeight > root.iconSize)){
                     layoutHeight = applet.Layout.preferredHeight;
                 }
                 else{
                     layoutHeight = root.iconSize + moreHeight;
                 }
             }
             else
                 layoutHeight = root.iconSize + moreHeight;
         }
         //return root.iconSize + moreHeight;
     }
 
     function updateLayoutWidth(){
 
         if(container.isInternalViewSplitter){
             if(!root.editMode)
                 layoutWidth = 0;
             else
                 layoutWidth = root.iconSize + moreWidth + root.statesLineSize;
         }
         else if(applet && applet.pluginName === "org.kde.plasma.panelspacer"){
             layoutWidth = root.iconSize + moreWidth;
         }
         else if(container.isSystray && root.isVertical){
             layoutWidth = root.statesLineSize + root.iconSize;
         }
         else{
             if(applet && (applet.Layout.minimumWidth > root.iconSize) && root.isHorizontal && !canBeHovered && !container.fakeIconItem){
                 layoutWidth = applet.Layout.minimumWidth;
             } //it is used for plasmoids that need to scale only one axis... e.g. the Weather Plasmoid
             else if(applet
                     && ( (applet.Layout.maximumWidth < root.iconSize) || (applet.Layout.preferredWidth > root.iconSize))
                     && root.isHorizontal
                     && !disableScaleHeight
                     && !container.fakeIconItem){
                 //  && !root.editMode){
                 disableScaleWidth = true;
                 //this way improves performance, probably because during animation the preferred sizes update a lot
                 if((applet.Layout.maximumWidth < root.iconSize)){
                     //   return applet.Layout.maximumWidth;
                     layoutWidth = applet.Layout.maximumWidth;
                 }
                 else if (applet.Layout.minimumWidth > root.iconSize){
                     layoutWidth = applet.Layout.minimumWidth;
                 }
                 else if (applet.Layout.preferredWidth > root.iconSize){
                     layoutWidth = applet.Layout.preferredWidth;
                 }
                 else{
                     layoutWidth = root.iconSize + moreWidth;
                 }
             }
             else{
                 //return root.iconSize + moreWidth;
                 layoutWidth = root.iconSize + moreWidth;
             }
         }
     }
 
     Loader{
         anchors.fill: parent
         active: root.activeIndicator === Latte.Dock.AllIndicator
                 || (root.activeIndicator === Latte.Dock.InternalsIndicator && fakeIconItem)
 
         sourceComponent: Item{
             anchors.fill: parent
             ActiveIndicator{}
         }
     }
 
     Item{
         id:_wrapperContainer
 
         width:{
             if (container.needsFillSpace && (container.sizeForFill>-1) && root.isHorizontal){
                 return wrapper.width;
             }
 
             if (container.isInternalViewSplitter)
                 return wrapper.layoutWidth;
             else
                 return parent.zoomScaleWidth * wrapper.layoutWidth;
         }
 
         height:{
             if (container.needsFillSpace && (container.sizeForFill>-1) && root.isVertical){
                 return wrapper.height;
             }
 
             if (container.isInternalViewSplitter)
                 return wrapper.layoutHeight;
             else
                 return parent.zoomScaleHeight * wrapper.layoutHeight;
         }
 
         //width: Math.round( container.isInternalViewSplitter ? wrapper.layoutWidth : parent.zoomScaleWidth * wrapper.layoutWidth )
         //height: Math.round( container.isInternalViewSplitter ? wrapper.layoutHeight : parent.zoomScaleHeight * wrapper.layoutHeight )
 
         anchors.rightMargin: plasmoid.location === PlasmaCore.Types.RightEdge ? lowThickUsed : 0
         anchors.leftMargin: plasmoid.location === PlasmaCore.Types.LeftEdge ? lowThickUsed : 0
         anchors.topMargin: plasmoid.location === PlasmaCore.Types.TopEdge ? lowThickUsed : 0
         anchors.bottomMargin: plasmoid.location === PlasmaCore.Types.BottomEdge ? lowThickUsed : 0
 
         opacity: appletShadow.active ? 0 : 1
 
         property int lowThickUsed: root.thickMarginBase
 
         //BEGIN states
         states: [
             State {
                 name: "left"
                 when: (plasmoid.location === PlasmaCore.Types.LeftEdge)
 
                 AnchorChanges {
                     target: _wrapperContainer
                     anchors{ verticalCenter:wrapper.verticalCenter; horizontalCenter:undefined;
                         top:undefined; bottom:undefined; left:parent.left; right:undefined;}
                 }
             },
             State {
                 name: "right"
                 when: (plasmoid.location === PlasmaCore.Types.RightEdge)
 
                 AnchorChanges {
                     target: _wrapperContainer
                     anchors{ verticalCenter:wrapper.verticalCenter; horizontalCenter:undefined;
                         top:undefined; bottom:undefined; left:undefined; right:parent.right;}
                 }
             },
             State {
                 name: "bottom"
                 when: (plasmoid.location === PlasmaCore.Types.BottomEdge)
 
                 AnchorChanges {
                     target: _wrapperContainer
                     anchors{ verticalCenter:undefined; horizontalCenter:wrapper.horizontalCenter;
                         top:undefined; bottom:parent.bottom; left:undefined; right:undefined;}
                 }
             },
             State {
                 name: "top"
                 when: (plasmoid.location === PlasmaCore.Types.TopEdge)
 
                 AnchorChanges {
                     target: _wrapperContainer
                     anchors{  verticalCenter:undefined; horizontalCenter:wrapper.horizontalCenter;
                         top:parent.top; bottom:undefined; left:undefined; right:undefined;}
                 }
             }
         ]
         //END states
 
         ///Secret MouseArea to be used by the folder widget
         Loader{
             anchors.fill: parent
             active: container.fakeIconItem && applet.pluginName === "org.kde.plasma.folder"
             sourceComponent: MouseArea{
                 onClicked: dock.toggleAppletExpanded(applet.id);
             }
         }
 
         Item{
             id: _fakeIconItemContainer
             anchors.centerIn: parent
 
             //we setup as maximum for hidden container of some applets that break
             //the Latte experience the size:96 . This is why after that size
             //the folder widget changes to fullRepresentation instead of compact one
             width: Math.min(96, parent.width)
             height: width
         }
 
         Loader{
             anchors.fill: parent
             active: container.fakeIconItem
             sourceComponent: Latte.IconItem{
                 id: fakeAppletIconItem
                 anchors.fill: parent
                 source: {
                     if (appletIconItem && appletIconItem.visible)
                         return appletIconItem.source;
                     else if (appletImageItem && appletImageItem.visible)
                         return appletImageItem.source;
                 }
 
                 usesPlasmaTheme: appletIconItem && appletIconItem.visible ? appletIconItem.usesPlasmaTheme : false
                 //ActiveIndicator{}
             }
         }
     }
 
     //spacer background
     Loader{
         anchors.fill: _wrapperContainer
         active: applet && (applet.pluginName === "org.kde.plasma.panelspacer") && root.editMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             border.width: 1
             border.color: theme.textColor
             color: "transparent"
             opacity: 0.7
 
             radius: root.iconMargin
             Rectangle{
                 anchors.centerIn: parent
                 color: parent.border.color
 
                 width: parent.width - 1
                 height: parent.height - 1
 
                 opacity: 0.2
             }
         }
     }
 
     Loader{
         anchors.fill: _wrapperContainer
         active: container.isInternalViewSplitter && root.editMode
 
         rotation: root.isVertical ? 90 : 0
 
         sourceComponent: PlasmaCore.SvgItem{
             id:splitterImage
             anchors.fill: parent
 
             svg: PlasmaCore.Svg{
                 imagePath: root.universalSettings.splitterIconPath()
             }
 
             layer.enabled: true
             layer.effect: DropShadow {
                 radius: root.appShadowSize
                 fast: true
                 samples: 2 * radius
                 color: root.appShadowColor
 
                 verticalOffset: 2
             }
 
             Component.onCompleted: {
                 if (root.isVertical)  {
                     wrapper.updateLayoutHeight();
                     wrapper.updateLayoutWidth();
                 } else {
                     wrapper.updateLayoutWidth();
                     wrapper.updateLayoutHeight();
                 }
             }
         }
     }
 
     ///Shadow in applets
     Loader{
         id: appletShadow
         anchors.fill: container.appletWrapper
 
-        active: container.applet
+        active: container.applet && !colorizerLoader.isShown
                 && (((plasmoid.configuration.shadows === 1 /*Locked Applets*/
                       && (!container.canBeHovered || (container.lockZoom && (applet.pluginName !== root.plasmoidName))) )
                      || (plasmoid.configuration.shadows === 2 /*All Applets*/
                          && (applet.pluginName !== root.plasmoidName)))
                     || (root.forceTransparentPanel && plasmoid.configuration.shadows>0 && applet.pluginName !== root.plasmoidName)) /*on forced transparent state*/
 
         onActiveChanged: {
             if (active) {
                 wrapperContainer.opacity = 0;
             } else {
                 wrapperContainer.opacity = 1;
             }
         }
 
         sourceComponent: DropShadow{
             anchors.fill: parent
             color: root.appShadowColor //"#ff080808"
             fast: true
             samples: 2 * radius
             source: container.fakeIconItem ? _wrapperContainer : container.applet
             radius: shadowSize
             verticalOffset: forcedShadow ? 0 : 2
 
             property int shadowSize : root.appShadowSize //Math.ceil(root.iconSize / 12)
 
             property bool forcedShadow: root.forceTransparentPanel && plasmoid.configuration.shadows>0 && applet.pluginName !== root.plasmoidName ? true : false
         }
     }
 
     /// START Applets Number
     Loader{
         id: appletNumberLoader
         anchors.fill: container.appletWrapper
         active: opacityN>0
         asynchronous: true
 
         property int fixedIndex:-1
 
         onActiveChanged: {
             if (active) {
                 fixedIndex = parabolicManager.pseudoAppletIndex(index);
             }
         }
 
         Component.onCompleted: fixedIndex = parabolicManager.pseudoAppletIndex(index);
 
         property real opacityN: root.showAppletsNumbers && container.canShowAppletNumberBadge && fixedIndex<20 ? 1 : 0
 
         Behavior on opacityN {
             NumberAnimation { duration: root.durationTime*2*units.longDuration }
         }
 
         sourceComponent: Item{
             Loader{
                 anchors.fill: appletNumber
                 active: root.enableShadows
 
                 sourceComponent: DropShadow{
                     color: root.appShadowColor
                     fast: true
                     samples: 2 * radius
                     source: appletNumber
                     radius: root.appShadowSize/2
                     verticalOffset: 2
                 }
             }
 
             Latte.BadgeText {
                 id: appletNumber
                 anchors.centerIn: parent
 
                 width: 0.4 * (root.iconSize)
                 height: width
                 numberValue: appletNumberLoader.fixedIndex < 10 ? appletNumberLoader.fixedIndex : 0
                 textValue: (keysArrayIndex>=0 && keysArrayIndex<10) ? keysAboveTen[keysArrayIndex] : ''
 
                 showNumber: appletNumberLoader.fixedIndex < 10
                 showText: appletNumberLoader.fixedIndex>=10 && appletNumberLoader.fixedIndex<20
 
                 proportion: 0
                 radiusPerCentage: 50
 
                 property int keysArrayIndex: appletNumberLoader.fixedIndex-10;
                 property var keysAboveTen: ['0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.']
             }
         }
     }
     //END of Applets number
 
 
     BrightnessContrast{
         id:hoveredImage
         anchors.fill: _wrapperContainer
         source: _wrapperContainer
 
         enabled: opacity != 0 ? true : false
         opacity: appletMouseArea.containsMouse ? 1 : 0
         brightness: 0.25
         contrast: 0.15
 
         Behavior on opacity {
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
     }
 
     BrightnessContrast {
         id: _clickedEffect
         anchors.fill: _wrapperContainer
         source: _wrapperContainer
 
         visible: clickedAnimation.running
     }
 
     /*   onHeightChanged: {
         if ((index == 1)|| (index==3)){
             console.log("H: "+index+" ("+zoomScale+"). "+currentLayout.children[1].height+" - "+currentLayout.children[3].height+" - "+(currentLayout.children[1].height+currentLayout.children[3].height));
         }
     }
 
     onZoomScaleChanged:{
         if ((index == 1)|| (index==3)){
             console.log(index+" ("+zoomScale+"). "+currentLayout.children[1].height+" - "+currentLayout.children[3].height+" - "+(currentLayout.children[1].height+currentLayout.children[3].height));
         }
     }*/
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             color: "transparent"
             //! red visualizer, in debug mode for the applets that use fillWidth or fillHeight
             //! green, for the rest
             border.color:  (container.needsFillSpace && (container.sizeForFill>-1) && root.isHorizontal) ? "red" : "green"
             border.width: 1
         }
     }
 
     Behavior on zoomScale {
         enabled: !root.globalDirectRender
         NumberAnimation {
             duration: 3 * container.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on zoomScale {
         enabled: root.globalDirectRender && !restoreAnimation.running
         NumberAnimation { duration: root.directRenderAnimationTime }
     }
 
     function calculateScales( currentMousePosition ){
         if (root.editMode || root.zoomFactor===1 || root.durationTime===0) {
             return;
         }
 
         var distanceFromHovered = Math.abs(index - layoutsContainer.hoveredIndex);
 
         // A new algorithm tryig to make the zoom calculation only once
         // and at the same time fixing glitches
         if ((distanceFromHovered == 0)&&
                 (currentMousePosition  > 0) ){
 
             //use the new parabolicManager in order to handle all parabolic effect messages
             var scales = parabolicManager.applyParabolicEffect(index, currentMousePosition, center);
 
             /*if (root.latteApplet && Math.abs(index - root.latteAppletPos) > 2){
                 root.latteApplet.clearZoom();
             }*/
 
             //Left hiddenSpacer
             if(container.startEdge){
                 hiddenSpacerLeft.nScale = scales.leftScale - 1;
             }
 
             //Right hiddenSpacer  ///there is one more item in the currentLayout ????
             if(container.endEdge){
                 hiddenSpacerRight.nScale =  scales.rightScale - 1;
             }
 
             zoomScale = root.zoomFactor;
         }
 
     } //scale
 
 
     function signalUpdateScale(nIndex, nScale, step){
         if(container && !container.containsMouse && (container.index === nIndex)){
             if ( ((canBeHovered && !lockZoom ) || container.latteApplet)
                     && (applet && applet.status !== PlasmaCore.Types.HiddenStatus)
                     //&& (index != currentLayout.hoveredIndex)
                     ){
                 if(!container.latteApplet){
                     if(nScale >= 0)
                         zoomScale = nScale + step;
                     else
                         zoomScale = zoomScale + step;
                 }
             }
         }
     }
 
     Component.onCompleted: {
         root.updateScale.connect(signalUpdateScale);
     }
 
     Component.onDestruction: {
         root.updateScale.disconnect(signalUpdateScale);
     }
 }// Main task area // id:wrapper
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index f1177adf..6ad378f7 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1732 +1,1744 @@
 /*
 *  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 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 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: plasmoid.configuration.colorizeTransparentPanels
 
     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 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 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(iconSize / 3, 1.5*appShadowSize)
     property int panelTransparency: plasmoid.configuration.panelTransparency
     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 || (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 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 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
     ///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) {
             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;
                 }
             }
         }
 
         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) {
             return;
         }
 
         if (latteApplet) {
             if (latteApplet.launchersDrop(event)) {
                 root.addLaunchersMessage = true;
                 if (root.addLaunchersInTaskManager) {
                     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: {
         //var relevantLayout = layoutsContainer.mainLayout.mapFromItem(root, event.x, event.y);
         //plasmoid.processMimeData(event.mimeData, relevantLayout.x, relevantLayout.y);
         //launchersDropped
         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(root)
 
         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 hideTooltipLabel(debug){
         titleTooltipDialog.hide(debug);
     }
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletsNumbers(showNumbers){
         if (latteApplet) {
             var base = parabolicManager.pseudoAppletIndex(latteAppletPos);
             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 = parabolicManager.pseudoAppletIndex(latteAppletPos);
             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 = parabolicManager.pseudoAppletIndex(latteAppletPos);
             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 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.normalState || root.editMode) && !visibilityManager.inTempHiding
                     && (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();
             }
         }
     }
 
     ////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
                 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{}
     }
 
     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: !layoutsColorizer.isShown ? 1 : 0
+        opacity: colorizerLoader.isShown ? 0 : 1
 
         Behavior on opacity {
             NumberAnimation {
                 duration: 0.8 * root.animationTime
                 easing.type: Easing.OutCubic
             }
         }
     }
 
     Loader{
-        id: layoutsColorizer
-        anchors.fill: layoutsContainer
+        id: colorizerLoader
+
         active: forceColorizer
+        anchors.fill: layoutsContainer
         z: layoutsContainer.z + 1
 
+        readonly property real themeBackgroundColorLuma: 0.2126*theme.backgroundColor.r + 0.7152*theme.backgroundColor.g + 0.0722*theme.backgroundColor.b
+        readonly property real themeTextColorLuma: 0.2126*theme.textColor.r + 0.7152*theme.textColor.g + 0.0722*theme.textColor.b
+
         property bool isShown: active && !forceSolidPanel && plasmoid.configuration.solidBackgroundForMaximized && !root.editMode
 
-        sourceComponent: ColorOverlay {
-            source: layoutsContainer
-            opacity: layoutsColorizer.isShown ? 1 : 0
+        property real currentBackgroundLuminas: -1000
 
-            color: theme.backgroundColor
-        }
-    }
+        property color applyColor: {
+            if (currentBackgroundLuminas>=0) {
+                var textAbs = Math.abs(themeTextColorLuma - currentBackgroundLuminas);
+                var backAbs = Math.abs(themeBackgroundColorLuma - currentBackgroundLuminas);
 
+                if (textAbs > backAbs) {
+                    return theme.textColor;
+                }
+            }
 
+            return theme.backgroundColor;
+        }
+
+        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...");
             }
         }
     }
 
     //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
 }
diff --git a/shell/package/contents/configuration/TweaksConfig.qml b/shell/package/contents/configuration/TweaksConfig.qml
index b74526a9..d6560ca1 100644
--- a/shell/package/contents/configuration/TweaksConfig.qml
+++ b/shell/package/contents/configuration/TweaksConfig.qml
@@ -1,271 +1,271 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 import QtQuick 2.0
 import QtQuick.Controls 1.4
 import QtQuick.Layouts 1.3
 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.plasma.plasmoid 2.0
 
 import org.kde.latte 0.1 as Latte
 
 PlasmaComponents.Page {
     Layout.maximumWidth: content.width + content.Layout.leftMargin * 2
     Layout.maximumHeight: content.height + units.smallSpacing * 2
 
     ColumnLayout {
         id: content
 
         width: dialog.maxWidth - Layout.leftMargin * 2
         spacing: dialog.subGroupSpacing
         anchors.horizontalCenter: parent.horizontalCenter
         Layout.leftMargin: units.smallSpacing * 2
         Layout.rightMargin: units.smallSpacing * 2
 
         //! BEGIN: Appearance
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             Layout.topMargin: units.smallSpacing
 
             Header {
                 text: i18n("Appearance")
             }
 
             PlasmaComponents.CheckBox {
                 id: blurPanel
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Blur for panel background")
                 checked: plasmoid.configuration.blurEnabled
 
                 onClicked: {
                     plasmoid.configuration.blurEnabled = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: titleTooltipsChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Show applets/task title tooltips on hovering")
                 checked: plasmoid.configuration.titleTooltips
 
                 onClicked: {
                     plasmoid.configuration.titleTooltips = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: shrinkThickness
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Shrink thickness margins to minimum")
                 checked: plasmoid.configuration.shrinkThickMargins
 
                 onClicked: {
                     plasmoid.configuration.shrinkThickMargins = checked
                 }
             }
         }
         //! END: Appearance
 
         //! BEGIN: Dynamic Background
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
             enabled: Latte.WindowSystem.compositingActive
 
             Header {
                 text: i18n("Dynamic Background")
             }
 
             PlasmaComponents.CheckBox {
                 id: solidForMaximizedChk
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.maximumWidth: dialog.maxWidth - 3*units.smallSpacing
                 text: i18n("Force solid background for maximized or snapped windows")
                 checked: plasmoid.configuration.solidBackgroundForMaximized
                 tooltip: i18n("The panel background removes its transparency setting \n when there is a maximized or snapped window")
                 style: LatteCheckBoxStyle{}
 
                 onClicked: {
                     plasmoid.configuration.solidBackgroundForMaximized = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: colorizeTransparentPanelsChk
                 Layout.leftMargin: units.smallSpacing * 2
                 Layout.bottomMargin: units.smallSpacing
                 Layout.maximumWidth: dialog.maxWidth - 3*units.smallSpacing
-                text: i18n("Background color for contents when panel is transparent")
+                text: i18n("Improve contents visibility when panel is transparent")
                 checked: plasmoid.configuration.colorizeTransparentPanels
                 tooltip: i18n("The panel contents are colorized in order to improve contrast \nwith the underlying desktop background when the panel is transparent")
                 style: LatteCheckBoxStyle{}
 
                 enabled: solidForMaximizedChk.checked
 
                 onClicked: {
                     plasmoid.configuration.colorizeTransparentPanels = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: onlyOnMaximizedChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Hide background for not maximized windows")
                 checked: plasmoid.configuration.backgroundOnlyOnMaximized
                 tooltip: i18n("The panel background becomes transparent except if \nthere is a maximized or snapped window")
 
                 onClicked: {
                     plasmoid.configuration.backgroundOnlyOnMaximized = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 id: hideShadowsOnMaximizedChk
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Hide panel shadow for maximized windows")
                 checked: plasmoid.configuration.disablePanelShadowForMaximized
 
                 onClicked: {
                     plasmoid.configuration.disablePanelShadowForMaximized = checked;
                 }
             }
         }
         //! END: Dynamic Background
 
         //! BEGIN: Behavior
         ColumnLayout {
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
 
             Header {
                 text: i18n("Behavior")
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Decrease applets size when it is needed")
                 checked: plasmoid.configuration.autoDecreaseIconSize
                 tooltip: i18n("Applets size is decreased automatically when the contents \nexceed the maximum length \n\nHint: this option is disabled when only plasma taskmanagers are present")
                 enabled: !(dock.tasksPresent() && !dock.latteTasksPresent());
 
                 onClicked: {
                     plasmoid.configuration.autoDecreaseIconSize = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Add launchers only in the corresponding area")
                 checked: plasmoid.configuration.addLaunchersInTaskManager
                 tooltip: i18n("Launchers are added only in the taskmanager and not as plasma applets")
 
                 onClicked: {
                     plasmoid.configuration.addLaunchersInTaskManager = checked;
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Behave as a normal dock window")
                 checked: dock.dockWinBehavior
                 enabled: !(dock.visibility.mode === Latte.Dock.AlwaysVisible
                            || dock.visibility.mode === Latte.Dock.WindowsGoBelow)
 
                 tooltip: i18n("Remove the BypassWindowManagerHint flag from the window.\nThe dock wont be above windows which are set at 'Always On Top'")
 
                 onCheckedChanged: {
                     dock.dockWinBehavior = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Raise dock on desktop change")
                 checked: dock.visibility.raiseOnDesktop
                 enabled: dock.visibility.mode !== Latte.Dock.AlwaysVisible
 
                 onClicked: {
                     dock.visibility.raiseOnDesktop = checked
                 }
             }
 
             PlasmaComponents.CheckBox {
                 Layout.leftMargin: units.smallSpacing * 2
                 text: i18n("Raise dock on activity change")
                 checked: dock.visibility.raiseOnActivity
                 enabled: dock.visibility.mode !== Latte.Dock.AlwaysVisible
 
                 onClicked: {
                     dock.visibility.raiseOnActivity = checked
                 }
             }
         }
         //! END: Behavior
 
         //! BEGIN: Extra Actions
         ColumnLayout {
             Layout.fillWidth: true
             spacing: units.smallSpacing
             Layout.rightMargin: units.smallSpacing * 2
 
             Header {
                 text: i18n("Extra Actions")
             }
 
             RowLayout {
                 Layout.fillWidth: true
                 Layout.leftMargin: units.smallSpacing * 2
                 spacing: units.smallSpacing * 2
 
                 PlasmaComponents.Button {
                     iconSource: "distribute-horizontal-x"
                     text: i18n("Add Spacer")
                     Layout.fillWidth: true
                     Layout.alignment: Qt.AlignLeft
                     tooltip: i18n("Add a spacer to separate applets")
 
                     onClicked: {
                         dockConfig.addPanelSpacer()
                     }
                 }
 
                 PlasmaComponents.Button {
                     iconSource: "edit-delete"
                     text: i18n("Remove Tasks")
                     enabled: dock.tasksPresent()
                     tooltip: i18n("Remove Latte plasmoid")
 
                     onClicked: {
                         dock.removeTasksPlasmoid();
                     }
                 }
             }
         }
         //! END: Extra Actions
 
         PlasmaComponents.Label{
             id: bottomMarginSpacer
             text:" "
         }
     }
 }