diff --git a/app/lattecorona.cpp b/app/lattecorona.cpp
index 1faf51b5..26e5504e 100644
--- a/app/lattecorona.cpp
+++ b/app/lattecorona.cpp
@@ -1,1271 +1,1270 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmaibox.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 "lattecorona.h"
 
 // local
 #include <coretypes.h>
 #include "alternativeshelper.h"
 #include "apptypes.h"
 #include "lattedockadaptor.h"
 #include "screenpool.h"
 #include "declarativeimports/interfaces.h"
 #include "indicator/factory.h"
 #include "layout/centrallayout.h"
 #include "layout/genericlayout.h"
 #include "layout/sharedlayout.h"
 #include "layouts/importer.h"
 #include "layouts/manager.h"
 #include "layouts/synchronizer.h"
 #include "layouts/launcherssignals.h"
 #include "shortcuts/globalshortcuts.h"
 #include "package/lattepackage.h"
 #include "plasma/extended/backgroundcache.h"
 #include "plasma/extended/backgroundtracker.h"
 #include "plasma/extended/screengeometries.h"
 #include "plasma/extended/screenpool.h"
 #include "plasma/extended/theme.h"
 #include "settings/universalsettings.h"
 #include "settings/dialogs/settingsdialog.h"
 #include "view/view.h"
 #include "view/windowstracker/windowstracker.h"
 #include "view/windowstracker/allscreenstracker.h"
 #include "view/windowstracker/currentscreentracker.h"
 #include "wm/abstractwindowinterface.h"
 #include "wm/schemecolors.h"
 #include "wm/waylandinterface.h"
 #include "wm/xwindowinterface.h"
 #include "wm/tracker/lastactivewindow.h"
 #include "wm/tracker/schemes.h"
 #include "wm/tracker/windowstracker.h"
 
 // Qt
 #include <QAction>
 #include <QApplication>
 #include <QScreen>
 #include <QDBusConnection>
 #include <QDebug>
 #include <QDesktopWidget>
 #include <QFile>
 #include <QFontDatabase>
 #include <QQmlContext>
 #include <QProcess>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Corona>
 #include <Plasma/Containment>
 #include <PlasmaQuick/ConfigView>
 
 // KDE
 #include <KActionCollection>
 #include <KPluginMetaData>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPackage/Package>
 #include <KPackage/PackageLoader>
 #include <KAboutData>
 #include <KActivities/Consumer>
 #include <KDeclarative/QmlObjectSharedEngine>
 #include <KWindowSystem>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 
 namespace Latte {
 
 Corona::Corona(bool defaultLayoutOnStartup, QString layoutNameOnStartUp, int userSetMemoryUsage, QObject *parent)
     : Plasma::Corona(parent),
       m_defaultLayoutOnStartup(defaultLayoutOnStartup),
       m_userSetMemoryUsage(userSetMemoryUsage),
       m_layoutNameOnStartUp(layoutNameOnStartUp),
       m_activitiesConsumer(new KActivities::Consumer(this)),
       m_screenPool(new ScreenPool(KSharedConfig::openConfig(), this)),
       m_indicatorFactory(new Indicator::Factory(this)),
       m_universalSettings(new UniversalSettings(KSharedConfig::openConfig(), this)),
       m_globalShortcuts(new GlobalShortcuts(this)),
       m_plasmaScreenPool(new PlasmaExtended::ScreenPool(this)),
       m_themeExtended(new PlasmaExtended::Theme(KSharedConfig::openConfig(), this)),
       m_layoutsManager(new Layouts::Manager(this)),
       m_plasmaGeometries(new PlasmaExtended::ScreenGeometries(this)),
       m_dialogShadows(new PanelShadows(this, QStringLiteral("dialogs/background")))
 {
     //! create the window manager
 
     if (KWindowSystem::isPlatformWayland()) {
         m_wm = new WindowSystem::WaylandInterface(this);
     } else {
         m_wm = new WindowSystem::XWindowInterface(this);
     }
 
     setupWaylandIntegration();
 
     KPackage::Package package(new Latte::Package(this));
 
     m_screenPool->load();
 
     if (!package.isValid()) {
         qWarning() << staticMetaObject.className()
                    << "the package" << package.metadata().rawData() << "is invalid!";
         return;
     } else {
         qDebug() << staticMetaObject.className()
                  << "the package" << package.metadata().rawData() << "is valid!";
     }
 
     setKPackage(package);
     //! universal settings / extendedtheme must be loaded after the package has been set
     m_universalSettings->load();
     m_themeExtended->load();
 
     qmlRegisterTypes();
 
     if (m_activitiesConsumer && (m_activitiesConsumer->serviceStatus() == KActivities::Consumer::Running)) {
         load();
     }
 
     connect(m_activitiesConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
 
     m_viewsScreenSyncTimer.setSingleShot(true);
     m_viewsScreenSyncTimer.setInterval(m_universalSettings->screenTrackerInterval());
     connect(&m_viewsScreenSyncTimer, &QTimer::timeout, this, &Corona::syncLatteViewsToScreens);
     connect(m_universalSettings, &UniversalSettings::screenTrackerIntervalChanged, this, [this]() {
         m_viewsScreenSyncTimer.setInterval(m_universalSettings->screenTrackerInterval());
     });
 
     //! Dbus adaptor initialization
     new LatteDockAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Latte"), this);
 }
 
 Corona::~Corona()
 {
     //! BEGIN: Give the time to slide-out views when closing
     m_layoutsManager->synchronizer()->hideAllViews();
 
     //! Don't delay the destruction under wayland in any case
     //! because it creates a crash with kwin effects
     //! https://bugs.kde.org/show_bug.cgi?id=392890
     if (!KWindowSystem::isPlatformWayland()) {
         QTimer::singleShot(400, [this]() {
             m_quitTimedEnded = true;
         });
 
         while (!m_quitTimedEnded) {
             QGuiApplication::processEvents(QEventLoop::AllEvents, 50);
         }
     }
 
     //! END: slide-out views when closing
 
     m_viewsScreenSyncTimer.stop();
 
     if (m_layoutsManager->memoryUsage() == MemoryUsage::SingleLayout) {
         cleanConfig();
     }
 
     qDebug() << "Latte Corona - unload: containments ...";
 
     m_layoutsManager->unload();
 
     m_plasmaGeometries->deleteLater();
     m_wm->deleteLater();
     m_dialogShadows->deleteLater();
     m_globalShortcuts->deleteLater();
     m_layoutsManager->deleteLater();
     m_screenPool->deleteLater();
     m_universalSettings->deleteLater();
     m_plasmaScreenPool->deleteLater();
     m_themeExtended->deleteLater();
     m_indicatorFactory->deleteLater();
 
     disconnect(m_activitiesConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
     delete m_activitiesConsumer;
 
     qDebug() << "Latte Corona - deleted...";
 
     if (!m_importFullConfigurationFile.isEmpty()) {
         //!NOTE: Restart latte to import the new configuration
         QString importCommand = "latte-dock --import-full \"" + m_importFullConfigurationFile + "\"";
         qDebug() << "Executing Import Full Configuration command : " << importCommand;
 
         QProcess::startDetached(importCommand);
     }
 }
 
 void Corona::load()
 {
     if (m_activitiesConsumer && (m_activitiesConsumer->serviceStatus() == KActivities::Consumer::Running) && m_activitiesStarting) {
         m_activitiesStarting = false;
 
         disconnect(m_activitiesConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
 
         m_layoutsManager->load();
 
         connect(this, &Corona::availableScreenRectChangedFrom, this, &Plasma::Corona::availableScreenRectChanged);
         connect(this, &Corona::availableScreenRegionChangedFrom, this, &Plasma::Corona::availableScreenRegionChanged);
 
         connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &Corona::primaryOutputChanged, Qt::UniqueConnection);
 
         connect(m_screenPool, &ScreenPool::primaryPoolChanged, this, &Corona::screenCountChanged);
 
         QString assignedLayout = m_layoutsManager->synchronizer()->shouldSwitchToLayout(m_activitiesConsumer->currentActivity());
 
         QString loadLayoutName = "";
 
         if (!m_defaultLayoutOnStartup && m_layoutNameOnStartUp.isEmpty()) {
             if (!assignedLayout.isEmpty() && assignedLayout != m_universalSettings->currentLayoutName()) {
                 loadLayoutName = assignedLayout;
             } else {
                 loadLayoutName = m_universalSettings->currentLayoutName();
             }
 
             if (!m_layoutsManager->synchronizer()->layoutExists(loadLayoutName)) {
                 loadLayoutName = m_layoutsManager->defaultLayoutName();
                 m_layoutsManager->importDefaultLayout(false);
             }
         } else if (m_defaultLayoutOnStartup) {
             loadLayoutName = m_layoutsManager->importer()->uniqueLayoutName(m_layoutsManager->defaultLayoutName());
             m_layoutsManager->importDefaultLayout(true);
         } else {
             loadLayoutName = m_layoutNameOnStartUp;
         }
 
         if (m_userSetMemoryUsage != -1 && !KWindowSystem::isPlatformWayland()) {
             MemoryUsage::LayoutsMemory usage = static_cast<MemoryUsage::LayoutsMemory>(m_userSetMemoryUsage);
 
             m_universalSettings->setLayoutsMemoryUsage(usage);
         }
 
         if (KWindowSystem::isPlatformWayland()) {
             m_universalSettings->setLayoutsMemoryUsage(MemoryUsage::SingleLayout);
         }
 
         m_layoutsManager->loadLayoutOnStartup(loadLayoutName);
 
 
         //! load screens signals such screenGeometryChanged in order to support
         //! plasmoid.screenGeometry properly
         for (QScreen *screen : qGuiApp->screens()) {
             addOutput(screen);
         }
 
         connect(qGuiApp, &QGuiApplication::screenAdded, this, &Corona::addOutput, Qt::UniqueConnection);
         connect(qGuiApp, &QGuiApplication::screenRemoved, this, &Corona::screenRemoved, Qt::UniqueConnection);
     }
 }
 
 void Corona::unload()
 {
     qDebug() << "unload: removing containments...";
 
     while (!containments().isEmpty()) {
         //deleting a containment will remove it from the list due to QObject::destroyed connect in Corona
         //this form doesn't crash, while qDeleteAll(containments()) does
         delete containments().first();
     }
 }
 
 void Corona::setupWaylandIntegration()
 {
     if (!KWindowSystem::isPlatformWayland()) {
         return;
     }
 
     using namespace KWayland::Client;
 
     auto connection = ConnectionThread::fromApplication(this);
 
     if (!connection) {
         return;
     }
 
     Registry *registry{new Registry(this)};
     registry->create(connection);
 
     connect(registry, &Registry::plasmaShellAnnounced, this
             , [this, registry](quint32 name, quint32 version) {
         m_waylandCorona = registry->createPlasmaShell(name, version, this);
     });
 
     QObject::connect(registry, &KWayland::Client::Registry::plasmaWindowManagementAnnounced,
                      [this, registry](quint32 name, quint32 version) {
         KWayland::Client::PlasmaWindowManagement *pwm = registry->createPlasmaWindowManagement(name, version, this);
 
         WindowSystem::WaylandInterface *wI = qobject_cast<WindowSystem::WaylandInterface *>(m_wm);
 
         if (wI) {
             wI->initWindowManagement(pwm);
         }
     });
 
 #if KF5_VERSION_MINOR >= 52
     QObject::connect(registry, &KWayland::Client::Registry::plasmaVirtualDesktopManagementAnnounced,
                      [this, registry] (quint32 name, quint32 version) {
         KWayland::Client::PlasmaVirtualDesktopManagement *vdm = registry->createPlasmaVirtualDesktopManagement(name, version, this);
 
         WindowSystem::WaylandInterface *wI = qobject_cast<WindowSystem::WaylandInterface *>(m_wm);
 
         if (wI) {
             wI->initVirtualDesktopManagement(vdm);
         }
     });
 #endif
 
     registry->setup();
     connection->roundtrip();
 }
 
 KWayland::Client::PlasmaShell *Corona::waylandCoronaInterface() const
 {
     return m_waylandCorona;
 }
 
 void Corona::cleanConfig()
 {
     auto containmentsEntries = config()->group("Containments");
     bool changed = false;
 
     for(const auto &cId : containmentsEntries.groupList()) {
         if (!containmentExists(cId.toUInt())) {
             //cleanup obsolete containments
             containmentsEntries.group(cId).deleteGroup();
             changed = true;
             qDebug() << "obsolete containment configuration deleted:" << cId;
         } else {
             //cleanup obsolete applets of running containments
             auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
             for(const auto &appletId : appletsEntries.groupList()) {
                 if (!appletExists(cId.toUInt(), appletId.toUInt())) {
                     appletsEntries.group(appletId).deleteGroup();
                     changed = true;
                     qDebug() << "obsolete applet configuration deleted:" << appletId;
                 }
             }
         }
     }
 
     if (changed) {
         config()->sync();
         qDebug() << "configuration file cleaned...";
     }
 }
 
 bool Corona::containmentExists(uint id) const
 {
     for(const auto containment : containments()) {
         if (id == containment->id()) {
             return true;
         }
     }
 
     return false;
 }
 
 bool Corona::appletExists(uint containmentId, uint appletId) const
 {
     Plasma::Containment *containment = nullptr;
 
     for(const auto cont : containments()) {
         if (containmentId == cont->id()) {
             containment = cont;
             break;
         }
     }
 
     if (!containment) {
         return false;
     }
 
     for(const auto applet : containment->applets()) {
         if (applet->id() == appletId) {
             return true;
         }
     }
 
     return false;
 }
 
 KActivities::Consumer *Corona::activitiesConsumer() const
 {
     return m_activitiesConsumer;
 }
 
 PanelShadows *Corona::dialogShadows() const
 {
     return m_dialogShadows;
 }
 
 GlobalShortcuts *Corona::globalShortcuts() const
 {
     return m_globalShortcuts;
 }
 
 ScreenPool *Corona::screenPool() const
 {
     return m_screenPool;
 }
 
 UniversalSettings *Corona::universalSettings() const
 {
     return m_universalSettings;
 }
 
 WindowSystem::AbstractWindowInterface *Corona::wm() const
 {
     return m_wm;
 }
 
 Indicator::Factory *Corona::indicatorFactory() const
 {
     return m_indicatorFactory;
 }
 
 Layouts::Manager *Corona::layoutsManager() const
 {
     return m_layoutsManager;
 }
 
 PlasmaExtended::ScreenPool *Corona::plasmaScreenPool() const
 {
     return m_plasmaScreenPool;
 }
 
 PlasmaExtended::Theme *Corona::themeExtended() const
 {
     return m_themeExtended;
 }
 
 int Corona::numScreens() const
 {
     return qGuiApp->screens().count();
 }
 
 QRect Corona::screenGeometry(int id) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     QString screenName;
 
     if (m_screenPool->hasId(id)) {
         screenName = m_screenPool->connector(id);
     }
 
     for(const auto scr : screens) {
         if (scr->name() == screenName) {
             screen = scr;
             break;
         }
     }
 
     return screen->geometry();
 }
 
 CentralLayout *Corona::centralLayout(QString name) const
 {
     CentralLayout *result{nullptr};
 
     if (name.isEmpty()) {
         result = m_layoutsManager->currentLayout();
     } else {
         CentralLayout *tempCentral = m_layoutsManager->synchronizer()->centralLayout(name);
 
         if (!tempCentral) {
             //! Identify best active layout to be used for metrics calculations.
             //! Active layouts are always take into account their shared layouts for their metrics
             SharedLayout *sharedLayout = m_layoutsManager->synchronizer()->sharedLayout(name);
 
             if (sharedLayout) {
                 tempCentral = sharedLayout->currentCentralLayout();
             }
         }
 
         if (tempCentral) {
             result = tempCentral;
         }
     }
 
     return result;
 }
 
 Layout::GenericLayout *Corona::layout(QString name) const
 {
     Layout::GenericLayout *result{nullptr};
 
     if (name.isEmpty()) {
         result = m_layoutsManager->currentLayout();
     } else {
         result = m_layoutsManager->synchronizer()->layout(name);
 
         if (!result) {
             result = m_layoutsManager->currentLayout();
         }
     }
 
     return result;
 }
 
 QRegion Corona::availableScreenRegion(int id) const
 {
     return availableScreenRegionWithCriteria(id);
 }
 
 QRegion Corona::availableScreenRegionWithCriteria(int id,
                                                   QString forLayout,
                                                   QList<Types::Visibility> ignoreModes,
                                                   QList<Plasma::Types::Location> ignoreEdges,
                                                   bool ignoreExternalPanels,
                                                   bool desktopUse) const
 {
     const QScreen *screen = m_screenPool->screenForId(id);
     CentralLayout *layout = centralLayout(forLayout);
 
     if (!screen) {
         return {};
     }
 
     QRegion available = ignoreExternalPanels ? screen->geometry() : screen->availableGeometry();
 
     if (!layout) {
         return available;
     }
 
     //! blacklist irrelevant visibility modes
     if (!ignoreModes.contains(Latte::Types::None)) {
         ignoreModes << Latte::Types::None;
     }
 
     if (!ignoreModes.contains(Latte::Types::NormalWindow)) {
         ignoreModes << Latte::Types::NormalWindow;
     }
 
     bool allEdges = ignoreEdges.isEmpty();
     QList<Latte::View *> views = layout->latteViews();
 
     for (const auto *view : views) {
         if (view && view->containment() && view->screen() == screen
                 && ((allEdges || !ignoreEdges.contains(view->location()))
                     && (view->visibility() && !ignoreModes.contains(view->visibility()->mode())))) {
             int realThickness = view->normalThickness();
 
             int x = 0; int y = 0; int w = 0; int h = 0;
 
             switch (view->formFactor()) {
             case Plasma::Types::Horizontal:
                 if (view->behaveAsPlasmaPanel()) {
                     w = view->width();
                     x = view->x();
                 } else {
                     w = view->maxLength() * view->width();
                     int offsetW = view->offset() * view->width();
 
                     switch (view->alignment()) {
                     case Latte::Types::Left:
                         x = view->x() + offsetW;
                         break;
 
                     case Latte::Types::Center:
                     case Latte::Types::Justify:
                         x = (view->geometry().center().x() - w/2) + offsetW;
                         break;
 
                     case Latte::Types::Right:
                         x = view->geometry().right() - w - offsetW;
                         break;
                     }
                 }
                 break;
             case Plasma::Types::Vertical:
                 if (view->behaveAsPlasmaPanel()) {
                     h = view->height();
                     y = view->y();
                 } else {
                     h = view->maxLength() * view->height();
                     int offsetH = view->offset() * view->height();
 
                     switch (view->alignment()) {
                     case Latte::Types::Top:
                         y = view->y() + offsetH;
                         break;
 
                     case Latte::Types::Center:
                     case Latte::Types::Justify:
                         y = (view->geometry().center().y() - h/2) + offsetH;
                         break;
 
                     case Latte::Types::Bottom:
                         y = view->geometry().bottom() - h - offsetH;
                         break;
                     }
                 }
                 break;
             }
 
             // Usually availableScreenRect is used by the desktop,
             // but Latte don't have desktop, then here just
             // need calculate available space for top and bottom location,
             // because the left and right are those who dodge others views
             switch (view->location()) {
             case Plasma::Types::TopEdge:
                 if (view->behaveAsPlasmaPanel()) {
                     QRect viewGeometry = view->geometry();
 
                     if (desktopUse) {
                         //! ignore any real window slide outs in all cases
                         viewGeometry.moveTop(view->screen()->geometry().top() + view->screenEdgeMargin());
                     }
 
                     available -= viewGeometry;
                 } else {                  
                     y = view->y();
                     available -= QRect(x, y, w, realThickness);
                 }
 
                 break;
 
             case Plasma::Types::BottomEdge:
                 if (view->behaveAsPlasmaPanel()) {
                     QRect viewGeometry = view->geometry();
 
                     if (desktopUse) {
                         //! ignore any real window slide outs in all cases
                         viewGeometry.moveTop(view->screen()->geometry().bottom() - view->screenEdgeMargin() - viewGeometry.height());
                     }
 
                     available -= viewGeometry;
                 } else {
                     y = view->geometry().bottom() - realThickness + 1;
                     available -= QRect(x, y, w, realThickness);
                 }
 
                 break;
 
             case Plasma::Types::LeftEdge:
                 if (view->behaveAsPlasmaPanel()) {
                     QRect viewGeometry = view->geometry();
 
                     if (desktopUse) {
                         //! ignore any real window slide outs in all cases
                         viewGeometry.moveLeft(view->screen()->geometry().left() + view->screenEdgeMargin());
                     }
 
                     available -= viewGeometry;
                 } else {
                     x = view->x();
                     available -= QRect(x, y, realThickness, h);
                 }
 
                 break;
 
             case Plasma::Types::RightEdge:
                 if (view->behaveAsPlasmaPanel()) {
                     QRect viewGeometry = view->geometry();
 
                     if (desktopUse) {
                         //! ignore any real window slide outs in all cases
                         viewGeometry.moveLeft(view->screen()->geometry().right() - view->screenEdgeMargin() - viewGeometry.width());
                     }
 
                     available -= viewGeometry;
                 } else {                    
                     x = view->geometry().right() - realThickness + 1;
                     available -= QRect(x, y, realThickness, h);
                 }
 
                 break;
 
             default:
                 //! bypass clang warnings
                 break;
             }
         }
     }
 
     /*qDebug() << "::::: FREE AREAS :::::";
 
     for (int i = 0; i < available.rectCount(); ++i) {
         qDebug() << available.rects().at(i);
     }
 
     qDebug() << "::::: END OF FREE AREAS :::::";*/
 
     return available;
 }
 
 QRect Corona::availableScreenRect(int id) const
 {
     return availableScreenRectWithCriteria(id);
 }
 
 QRect Corona::availableScreenRectWithCriteria(int id,
                                               QString forLayout,
                                               QList<Types::Visibility> ignoreModes,
                                               QList<Plasma::Types::Location> ignoreEdges,
                                               bool ignoreExternalPanels,
                                               bool desktopUse) const
 {
     const QScreen *screen = m_screenPool->screenForId(id);
     CentralLayout *layout = centralLayout(forLayout);
 
     if (!screen) {
         return {};
     }
 
     QRect available = ignoreExternalPanels ? screen->geometry() : screen->availableGeometry();
 
     if (!layout) {
         return available;
     }
 
     //! blacklist irrelevant visibility modes
     if (!ignoreModes.contains(Latte::Types::None)) {
         ignoreModes << Latte::Types::None;
     }
 
     if (!ignoreModes.contains(Latte::Types::NormalWindow)) {
         ignoreModes << Latte::Types::NormalWindow;
     }
 
     bool allEdges = ignoreEdges.isEmpty();
     QList<Latte::View *> views = layout->latteViews();
 
     for (const auto *view : views) {
         if (view && view->containment() && view->screen() == screen
                 && ((allEdges || !ignoreEdges.contains(view->location()))
                     && (view->visibility() && !ignoreModes.contains(view->visibility()->mode())))) {
 
             int appliedThickness = view->behaveAsPlasmaPanel() ? view->screenEdgeMargin() + view->normalThickness() : view->normalThickness();
 
             // Usually availableScreenRect is used by the desktop,
             // but Latte don't have desktop, then here just
             // need calculate available space for top and bottom location,
             // because the left and right are those who dodge others docks
             switch (view->location()) {
             case Plasma::Types::TopEdge:
                 if (view->behaveAsPlasmaPanel() && desktopUse) {
                     //! ignore any real window slide outs in all cases
                     available.setTop(qMax(available.top(), view->screen()->geometry().top() + appliedThickness));
                 } else {
                     available.setTop(qMax(available.top(), view->y() + appliedThickness));
                 }
                 break;
 
             case Plasma::Types::BottomEdge:
                 if (view->behaveAsPlasmaPanel() && desktopUse) {
                     //! ignore any real window slide outs in all cases
                     available.setBottom(qMin(available.bottom(), view->screen()->geometry().bottom() - appliedThickness));
                 } else {
                     available.setBottom(qMin(available.bottom(), view->y() + view->height() - appliedThickness));
                 }
                 break;
 
             case Plasma::Types::LeftEdge:
                 if (view->behaveAsPlasmaPanel() && desktopUse) {
                     //! ignore any real window slide outs in all cases
                     available.setLeft(qMax(available.left(), view->screen()->geometry().left() + appliedThickness));
                 } else {
                     available.setLeft(qMax(available.left(), view->x() + appliedThickness));
                 }
                 break;
 
             case Plasma::Types::RightEdge:
                 if (view->behaveAsPlasmaPanel() && desktopUse) {
                     //! ignore any real window slide outs in all cases
                     available.setRight(qMin(available.right(), view->screen()->geometry().right() - appliedThickness));
                 } else {
                     available.setRight(qMin(available.right(), view->x() + view->width() - appliedThickness));
                 }
                 break;
 
             default:
                 //! bypass clang warnings
                 break;
             }
         }
     }
 
     return available;
 }
 
 void Corona::addOutput(QScreen *screen)
 {
     Q_ASSERT(screen);
 
     int id = m_screenPool->id(screen->name());
 
     if (id == -1) {
         int newId = m_screenPool->firstAvailableId();
         m_screenPool->insertScreenMapping(newId, screen->name());
     }
 
     connect(screen, &QScreen::geometryChanged, this, [ = ]() {
         const int id = m_screenPool->id(screen->name());
 
         if (id >= 0) {
             emit screenGeometryChanged(id);
             emit availableScreenRegionChanged();
             emit availableScreenRectChanged();
         }
     });
 
     emit availableScreenRectChanged();
     emit screenAdded(m_screenPool->id(screen->name()));
 
     screenCountChanged();
 }
 
 void Corona::primaryOutputChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 void Corona::screenRemoved(QScreen *screen)
 {
     screenCountChanged();
 }
 
 void Corona::screenCountChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 //! the central functions that updates loading/unloading latteviews
 //! concerning screen changed (for multi-screen setups mainly)
 void Corona::syncLatteViewsToScreens()
 {
     m_layoutsManager->synchronizer()->syncLatteViewsToScreens();
 }
 
 int Corona::primaryScreenId() const
 {
     return m_screenPool->id(qGuiApp->primaryScreen()->name());
 }
 
 void Corona::quitApplication()
 {
     //! this code must be called asynchronously because it is called
     //! also from qml (Settings window).
     QTimer::singleShot(300, [this]() {
         m_layoutsManager->hideLatteSettingsDialog();
         m_layoutsManager->synchronizer()->hideAllViews();
     });
 
     //! give the time for the views to hide themselves
     QTimer::singleShot(800, [this]() {
         qGuiApp->quit();
     });
 }
 
 void Corona::aboutApplication()
 {
     if (aboutDialog) {
         aboutDialog->hide();
         aboutDialog->deleteLater();
     }
 
     aboutDialog = new KAboutApplicationDialog(KAboutData::applicationData());
     connect(aboutDialog.data(), &QDialog::finished, aboutDialog.data(), &QObject::deleteLater);
     m_wm->skipTaskBar(*aboutDialog);
     m_wm->setKeepAbove(aboutDialog->winId(), true);
 
     aboutDialog->show();
 }
 
 int Corona::screenForContainment(const Plasma::Containment *containment) const
 {
     //FIXME: indexOf is not a proper way to support multi-screen
     // as for environment to environment the indexes change
     // also there is the following issue triggered
     // from latteView adaptToScreen()
     //
     // in a multi-screen environment that
     // primary screen is not set to 0 it was
     // created an endless showing loop at
     // startup (catch-up race) between
     // screen:0 and primaryScreen
 
     //case in which this containment is child of an applet, hello systray :)
 
     if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
         if (Plasma::Containment *cont = parentApplet->containment()) {
             return screenForContainment(cont);
         } else {
             return -1;
         }
     }
 
     Plasma::Containment *c = const_cast<Plasma::Containment *>(containment);
     Latte::View *view =  m_layoutsManager->synchronizer()->viewForContainment(c);
 
     if (view && view->screen()) {
         return m_screenPool->id(view->screen()->name());
     }
 
     //Failed? fallback on lastScreen()
     //lastScreen() is the correct screen for panels
     //It is also correct for desktops *that have the correct activity()*
     //a containment with lastScreen() == 0 but another activity,
     //won't be associated to a screen
     //     qDebug() << "ShellCorona screenForContainment: " << containment << " Last screen is " << containment->lastScreen();
 
     for (auto screen : qGuiApp->screens()) {
         // containment->lastScreen() == m_screenPool->id(screen->name()) to check if the lastScreen refers to a screen that exists/it's known
         if (containment->lastScreen() == m_screenPool->id(screen->name()) &&
                 (containment->activity() == m_activitiesConsumer->currentActivity() ||
                  containment->containmentType() == Plasma::Types::PanelContainment || containment->containmentType() == Plasma::Types::CustomPanelContainment)) {
             return containment->lastScreen();
         }
     }
 
     return -1;
 }
 
 void Corona::showAlternativesForApplet(Plasma::Applet *applet)
 {
     const QString alternativesQML = kPackage().filePath("appletalternativesui");
 
     if (alternativesQML.isEmpty()) {
         return;
     }
 
     Latte::View *latteView =  m_layoutsManager->synchronizer()->viewForContainment(applet->containment());
 
     KDeclarative::QmlObjectSharedEngine *qmlObj{nullptr};
 
     if (latteView) {
         latteView->setAlternativesIsShown(true);
         qmlObj = new KDeclarative::QmlObjectSharedEngine(latteView);
     } else {
         qmlObj = new KDeclarative::QmlObjectSharedEngine(this);
     }
 
     qmlObj->setInitializationDelayed(true);
     qmlObj->setSource(QUrl::fromLocalFile(alternativesQML));
 
     AlternativesHelper *helper = new AlternativesHelper(applet, qmlObj);
     qmlObj->rootContext()->setContextProperty(QStringLiteral("alternativesHelper"), helper);
 
     m_alternativesObjects << qmlObj;
     qmlObj->completeInitialization();
 
     //! Alternative dialog signals
     connect(helper, &QObject::destroyed, this, [latteView]() {
         latteView->setAlternativesIsShown(false);
     });
 
     connect(qmlObj->rootObject(), SIGNAL(visibleChanged(bool)),
             this, SLOT(alternativesVisibilityChanged(bool)));
 
     connect(applet, &Plasma::Applet::destroyedChanged, this, [this, qmlObj](bool destroyed) {
         if (!destroyed) {
             return;
         }
 
         QMutableListIterator<KDeclarative::QmlObjectSharedEngine *> it(m_alternativesObjects);
 
         while (it.hasNext()) {
             KDeclarative::QmlObjectSharedEngine *obj = it.next();
 
             if (obj == qmlObj) {
                 it.remove();
                 obj->deleteLater();
             }
         }
     });
 }
 
 void Corona::alternativesVisibilityChanged(bool visible)
 {
     if (visible) {
         return;
     }
 
     QObject *root = sender();
 
     QMutableListIterator<KDeclarative::QmlObjectSharedEngine *> it(m_alternativesObjects);
 
     while (it.hasNext()) {
         KDeclarative::QmlObjectSharedEngine *obj = it.next();
 
         if (obj->rootObject() == root) {
             it.remove();
             obj->deleteLater();
         }
     }
 }
 
 void Corona::addViewForLayout(QString layoutName)
 {
     qDebug() << "loading default layout";
     //! Setting mutable for create a containment
     setImmutability(Plasma::Types::Mutable);
     QVariantList args;
     auto defaultContainment = createContainmentDelayed("org.kde.latte.containment", args);
     defaultContainment->setContainmentType(Plasma::Types::PanelContainment);
     defaultContainment->init();
 
     if (!defaultContainment || !defaultContainment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto config = defaultContainment->config();
     defaultContainment->restore(config);
 
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                 Types::TopEdge, Types::RightEdge};
 
     Layout::GenericLayout *currentLayout = m_layoutsManager->synchronizer()->layout(layoutName);
 
     if (currentLayout) {
         edges = currentLayout->freeEdges(defaultContainment->screen());
     }
 
     if ((edges.count() > 0)) {
         defaultContainment->setLocation(edges.at(0));
     } else {
         defaultContainment->setLocation(Plasma::Types::BottomEdge);
     }
 
     if (m_layoutsManager->memoryUsage() == MemoryUsage::MultipleLayouts) {
         config.writeEntry("layoutId", layoutName);
     }
 
     defaultContainment->updateConstraints(Plasma::Types::StartupCompletedConstraint);
 
     defaultContainment->save(config);
     requestConfigSync();
 
     defaultContainment->flushPendingConstraintsEvents();
     emit containmentAdded(defaultContainment);
     emit containmentCreated(defaultContainment);
 
     defaultContainment->createApplet(QStringLiteral("org.kde.latte.plasmoid"));
-    defaultContainment->createApplet(QStringLiteral("org.kde.plasma.analogclock"));
 }
 
 void Corona::loadDefaultLayout()
 {
     addViewForLayout(m_layoutsManager->currentLayoutName());
 }
 
 QStringList Corona::containmentsIds()
 {
     QStringList ids;
 
     for(const auto containment : containments()) {
         ids << QString::number(containment->id());
     }
 
     return ids;
 }
 
 QStringList Corona::appletsIds()
 {
     QStringList ids;
 
     for(const auto containment : containments()) {
         auto applets = containment->config().group("Applets");
         ids << applets.groupList();
     }
 
     return ids;
 }
 
 //! Activate launcher menu through dbus interface
 void Corona::activateLauncherMenu()
 {
     m_globalShortcuts->activateLauncherMenu();
 }
 
 void Corona::windowColorScheme(QString windowIdAndScheme)
 {
     int firstSlash = windowIdAndScheme.indexOf("-");
     QString windowIdStr = windowIdAndScheme.mid(0, firstSlash);
     QString schemeStr = windowIdAndScheme.mid(firstSlash + 1);
 
     if (KWindowSystem::isPlatformWayland()) {
         QTimer::singleShot(200, [this, schemeStr]() {
             //! [Wayland Case] - give the time to be informed correctly for the active window id
             //! otherwise the active window id may not be the same with the one trigerred
             //! the color scheme dbus signal
             QString windowIdStr = m_wm->activeWindow().toString();
             m_wm->schemesTracker()->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr);
         });
     } else {
         m_wm->schemesTracker()->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr);
     }
 }
 
 //! update badge for specific view item
 void Corona::updateDockItemBadge(QString identifier, QString value)
 {
     m_globalShortcuts->updateViewItemBadge(identifier, value);
 }
 
 
 void Corona::switchToLayout(QString layout)
 {
     if ((layout.startsWith("file:/") || layout.startsWith("/")) && layout.endsWith(".layout.latte")) {
         //! Import and load runtime a layout through dbus interface
         //! It can be used from external programs that want to update runtime
         //! the Latte shown layout
         QString layoutPath = layout;
 
         //! cleanup layout path
         if (layoutPath.startsWith("file:///")) {
             layoutPath = layout.remove("file://");
         } else if (layoutPath.startsWith("file://")) {
             layoutPath = layout.remove("file:/");
         }
 
         //! check out layoutpath existence
         if (QFileInfo(layoutPath).exists()) {
             qDebug() << " Layout is going to be imported and loaded from file :: " << layoutPath;
 
             QString importedLayout = m_layoutsManager->importer()->importLayoutHelper(layoutPath);
 
             if (importedLayout.isEmpty()) {
                 qDebug() << i18n("The layout cannot be imported from file :: ") << layoutPath;
             } else {
                 m_layoutsManager->synchronizer()->loadLayouts();
                 m_layoutsManager->switchToLayout(importedLayout);
             }
         } else {
             qDebug() << " Layout from missing file can not be imported and loaded :: " << layoutPath;
         }
     } else {
         m_layoutsManager->switchToLayout(layout);
     }
 }
 
 void Corona::showSettingsWindow(int page)
 {
     Settings::Dialog::ConfigurationPage p = Settings::Dialog::LayoutPage;
 
     if (page >= Settings::Dialog::LayoutPage && page <= Settings::Dialog::PreferencesPage) {
         p = static_cast<Settings::Dialog::ConfigurationPage>(page);
     }
 
     m_layoutsManager->showLatteSettingsDialog(p);
 }
 
 void Corona::setContextMenuView(int id)
 {
     //! set context menu view id
     m_contextMenuViewId = id;
 }
 
 QStringList Corona::contextMenuData()
 {
     QStringList data;
     Types::ViewType viewType{Types::DockView};
 
     Latte::CentralLayout *currentLayout = m_layoutsManager->currentLayout();
 
     if (currentLayout) {
         viewType = currentLayout->latteViewType(m_contextMenuViewId);
     }
 
     data << QString::number((int)m_layoutsManager->memoryUsage());
     data << m_layoutsManager->currentLayoutName();
     data << QString::number((int)viewType);
 
     for(const auto &layoutName : m_layoutsManager->menuLayouts()) {
         if (m_layoutsManager->synchronizer()->centralLayout(layoutName)) {
             data << QString("1," + layoutName);
         } else {
             data << QString("0," + layoutName);
         }
     }
 
     //! reset context menu view id
     m_contextMenuViewId = -1;
     return data;
 }
 
 void Corona::setBackgroundFromBroadcast(QString activity, QString screenName, QString filename)
 {
     if (filename.startsWith("file://")) {
         filename = filename.remove(0,7);
     }
 
     PlasmaExtended::BackgroundCache::self()->setBackgroundFromBroadcast(activity, screenName, filename);
 }
 
 void Corona::setBroadcastedBackgroundsEnabled(QString activity, QString screenName, bool enabled)
 {
     PlasmaExtended::BackgroundCache::self()->setBroadcastedBackgroundsEnabled(activity, screenName, enabled);
 }
 
 void Corona::toggleHiddenState(QString layoutName, QString screenName, int screenEdge)
 {
     Layout::GenericLayout *gLayout = layout(layoutName);
 
     if (gLayout) {
         gLayout->toggleHiddenState(screenName, (Plasma::Types::Location)screenEdge);
     }
 }
 
 void Corona::importFullConfiguration(const QString &file)
 {
     m_importFullConfigurationFile = file;
     quitApplication();
 }
 
 inline void Corona::qmlRegisterTypes() const
 {   
     qmlRegisterUncreatableMetaObject(Latte::Settings::staticMetaObject,
                                      "org.kde.latte.private.app",          // import statement
                                      0, 1,                                 // major and minor version of the import
                                      "Settings",                           // name in QML
                                      "Error: only enums of latte app settings");
 
     qmlRegisterType<Latte::BackgroundTracker>("org.kde.latte.private.app", 0, 1, "BackgroundTracker");
     qmlRegisterType<Latte::Interfaces>("org.kde.latte.private.app", 0, 1, "Interfaces");
 
 
 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
     qmlRegisterType<QScreen>();
     qmlRegisterType<Latte::View>();
     qmlRegisterType<Latte::ViewPart::WindowsTracker>();
     qmlRegisterType<Latte::ViewPart::TrackerPart::CurrentScreenTracker>();
     qmlRegisterType<Latte::ViewPart::TrackerPart::AllScreensTracker>();
     qmlRegisterType<Latte::WindowSystem::SchemeColors>();
     qmlRegisterType<Latte::WindowSystem::Tracker::LastActiveWindow>();
     qmlRegisterType<Latte::Types>();
 #else
     qmlRegisterAnonymousType<QScreen>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::View>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::ViewPart::WindowsTracker>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::ViewPart::TrackerPart::CurrentScreenTracker>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::ViewPart::TrackerPart::AllScreensTracker>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::WindowSystem::SchemeColors>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::WindowSystem::Tracker::LastActiveWindow>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::Types>("latte-dock", 1);
 #endif
 }
 
 }
diff --git a/app/view/settings/primaryconfigview.cpp b/app/view/settings/primaryconfigview.cpp
index 861a7fee..56ebd0ba 100644
--- a/app/view/settings/primaryconfigview.cpp
+++ b/app/view/settings/primaryconfigview.cpp
@@ -1,864 +1,863 @@
 /*
 *  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 "primaryconfigview.h"
 
 // local
 #include <config-latte.h>
 #include "secondaryconfigview.h"
 #include "../effects.h"
 #include "../panelshadows_p.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../layouts/manager.h"
 #include "../../layout/genericlayout.h"
 #include "../../settings/universalsettings.h"
 #include "../../shortcuts/globalshortcuts.h"
 #include "../../shortcuts/shortcutstracker.h"
 #include "../../wm/abstractwindowinterface.h"
 
 // Qt
 #include <QQuickItem>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedContext>
 #include <KDeclarative/KDeclarative>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowEffects>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Package>
 
 namespace Latte {
 namespace ViewPart {
 
 PrimaryConfigView::PrimaryConfigView(Plasma::Containment *containment, Latte::View *view, QWindow *parent)
     : PlasmaQuick::ConfigView(containment, parent),
       m_latteView(view)
 {
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona());
 
     setupWaylandIntegration();
 
     setTitle(validTitle());
 
     if (KWindowSystem::isPlatformX11()) {
         m_corona->wm()->registerIgnoredWindow(winId());
     } else {
         connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, &PrimaryConfigView::updateWaylandId);
     }
 
     setScreen(m_latteView->screen());
 
     if (containment) {
         setIcon(qGuiApp->windowIcon());
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(100);
 
     connect(this, &QQuickView::widthChanged, this, &PrimaryConfigView::updateEffects);
     connect(this, &QQuickView::heightChanged, this, &PrimaryConfigView::updateEffects);
 
     connect(this, &PrimaryConfigView::availableScreenGeometryChanged, this, &PrimaryConfigView::syncGeometry);
     connect(this, &PrimaryConfigView::inAdvancedModeChanged, this, &PrimaryConfigView::saveConfig);
     connect(this, &PrimaryConfigView::inAdvancedModeChanged, this, &PrimaryConfigView::updateShowInlineProperties);
     connect(this, &PrimaryConfigView::inAdvancedModeChanged, this, &PrimaryConfigView::syncGeometry);
 
     connect(this, &PrimaryConfigView::inAdvancedModeChanged, m_latteView, &Latte::View::inSettingsAdvancedModeChanged);
 
     connect(this, &QQuickView::statusChanged, [&](QQuickView::Status status) {
         if (status == QQuickView::Ready) {
             updateEffects();
         }
     });
 
     connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() {
         setScreen(m_latteView->screen());
         setFlags(wFlags());
 
         if (KWindowSystem::isPlatformX11()) {
             m_corona->wm()->setViewExtraFlags(this, false, Latte::Types::NormalWindow);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
 
     connections << connect(m_latteView, &View::hiddenConfigurationWindowsAreDeletedChanged, this, &PrimaryConfigView::onHiddenConfigurationWindowsAreDeletedChanged);
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &PrimaryConfigView::syncGeometry);
     connections << connect(containment, &Plasma::Containment::immutabilityChanged, this, &PrimaryConfigView::immutabilityChanged);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 
     if (m_corona) {
         connections << connect(m_corona, &Latte::Corona::raiseViewsTemporaryChanged, this, &PrimaryConfigView::raiseDocksTemporaryChanged);
         connections << connect(m_corona, &Latte::Corona::availableScreenRectChangedFrom, this, &PrimaryConfigView::updateAvailableScreenGeometry);
     }
 }
 
 PrimaryConfigView::~PrimaryConfigView()
 {
     qDebug() << "ConfigView deleting ...";
 
     if (m_latteView->indicator()) {
         //! destroy indicator config ui when the configuration window is closed
         m_latteView->indicator()->releaseConfigUi();
     }
 
     m_corona->dialogShadows()->removeWindow(this);
 
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     if (m_secConfigView) {
         m_secConfigView->deleteLater();
     }
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 }
 
 void PrimaryConfigView::init()
 {
     qDebug() << "dock config view : initialization started...";
     m_originalByPassWM = m_latteView->byPassWM();
     m_originalMode = m_latteView->visibility()->mode();
 
     loadConfig();
     //! inform view about the current settings level
     emit m_latteView->inSettingsAdvancedModeChanged();
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
     m_corona->dialogShadows()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), m_corona->globalShortcuts()->shortcutsTracker());
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
 
     if (m_corona) {
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), m_corona->universalSettings());
         rootContext()->setContextProperty(QStringLiteral("layoutsManager"), m_corona->layoutsManager());
     }
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedockconfigurationui";
 
     updateEnabledBorders();
     updateAvailableScreenGeometry();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     qDebug() << "dock config view : initialization ended...";
 }
 
 inline Qt::WindowFlags PrimaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QString PrimaryConfigView::validTitle() const
 {
     return QString("#primaryconfig#" + QString::number(m_latteView->containment()->id()));
 }
 
 QQuickView *PrimaryConfigView::secondaryWindow()
 {
     return m_secConfigView;
 }
 
 void PrimaryConfigView::showSecondaryWindow()
 {       
     if (!m_secConfigView) {
         m_secConfigView = new SecondaryConfigView(m_latteView, this);
         m_secConfigView->init();
     } else if (m_secConfigView && !m_latteView->hiddenConfigurationWindowsAreDeleted() && !m_secConfigView->isVisible()){
         m_secConfigView->show();
     }
 }
 
 void PrimaryConfigView::hideSecondaryWindow()
 {
     if (m_secConfigView) {
         if (m_latteView->hiddenConfigurationWindowsAreDeleted()) {
             auto secWindow = m_secConfigView;
             m_secConfigView = nullptr;
             secWindow->deleteLater();
         } else {
             m_secConfigView->hide();
         }
 
         if (KWindowSystem::isPlatformX11() && m_latteView->effects()) {
             //! this is needed in order for subtracked mask of secondary window to
             //! be released properly when changing for Advanced to Basic mode.
             //! Under wayland this is not needed because masks do not break any visuals.
             m_latteView->effects()->updateMask();
         }
     }
 }
 
 void PrimaryConfigView::onHiddenConfigurationWindowsAreDeletedChanged()
 {
     if (m_latteView && m_latteView->hiddenConfigurationWindowsAreDeleted() && !isVisible()) {
         deleteLater();
     }
 }
 
 void PrimaryConfigView::updateAvailableScreenGeometry(View *origin)
 {    
     int currentScrId = m_latteView->positioner()->currentScreenId();
 
     QList<Latte::Types::Visibility> ignoreModes{Latte::Types::SideBar};
 
     if (m_latteView->visibility() && m_latteView->visibility()->mode() == Latte::Types::SideBar) {
         ignoreModes.removeAll(Latte::Types::SideBar);
     }
 
     m_availableScreenGeometry = m_corona->availableScreenRectWithCriteria(currentScrId, QString(), ignoreModes, {}, false);
 
     emit availableScreenGeometryChanged();
 }
 
 QRect PrimaryConfigView::availableScreenGeometry() const
 {
     return m_availableScreenGeometry;
 }
 
 QRect PrimaryConfigView::geometryWhenVisible() const
 {
     return m_geometryWhenVisible;
 }
 
 void PrimaryConfigView::requestActivate()
 {
     if (KWindowSystem::isPlatformWayland() && m_shellSurface) {
         updateWaylandId();
         m_corona->wm()->requestActivate(m_waylandWindowId);
     } else {
         QQuickView::requestActivate();
     }
 }
 
 void PrimaryConfigView::syncGeometry()
 {
     if (!m_latteView || !m_latteView->layout() || !m_latteView->containment() || !rootObject()) {
         return;
     }
 
     const QSize size(rootObject()->width(), rootObject()->height());
     const auto location = m_latteView->containment()->location();
     const auto scrGeometry = m_latteView->screenGeometry();
     const auto availGeometry = m_availableScreenGeometry;
 
     int clearThickness = m_latteView->editThickness();
 
     QPoint position{0, 0};
 
     int xPos{0};
     int yPos{0};
 
     switch (m_latteView->formFactor()) {
     case Plasma::Types::Horizontal: {
         if (m_inAdvancedMode) {
             if (qApp->isLeftToRight()) {
                 xPos = availGeometry.x() + availGeometry.width() - size.width();
             } else {
                 xPos = availGeometry.x();
             }
         } else {
             xPos = scrGeometry.center().x() - size.width() / 2;
         }
 
         if (location == Plasma::Types::TopEdge) {
             yPos = scrGeometry.y() + clearThickness;
         } else if (location == Plasma::Types::BottomEdge) {
             yPos = scrGeometry.y() + scrGeometry.height() - clearThickness - size.height();
         }
     }
         break;
 
     case Plasma::Types::Vertical: {
         if (location == Plasma::Types::LeftEdge) {
             xPos = scrGeometry.x() + clearThickness;
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         } else if (location == Plasma::Types::RightEdge) {
             xPos = scrGeometry.x() + scrGeometry.width() - clearThickness - size.width();
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         }
     }
         break;
 
     default:
         qWarning() << "no sync geometry, wrong formFactor";
         break;
     }
 
     position = {xPos, yPos};
 
     updateEnabledBorders();
 
     auto geometry = QRect(position.x(), position.y(), size.width(), size.height());
 
     if (m_geometryWhenVisible == geometry) {
         return;
     }
 
     m_geometryWhenVisible = geometry;
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 
     setMaximumSize(size);
     setMinimumSize(size);
     resize(size);
 
     updateViewMask();
     emit m_latteView->configWindowGeometryChanged();
 }
 
 void PrimaryConfigView::updateViewMask()
 {
     bool environmentState = (KWindowSystem::isPlatformX11() && KWindowSystem::compositingActive());
 
     if (!environmentState) {
         return;
     }
 
     int x, y, thickness, length;
     QRegion area;
 
     thickness = m_latteView->effects()->editShadow();
 
     if (m_latteView->formFactor() == Plasma::Types::Vertical) {
         length = m_geometryWhenVisible.height();
     } else {
         length = m_geometryWhenVisible.width();
     }
 
     if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
         x = m_geometryWhenVisible.x() - m_latteView->x();
     } else {
         y = m_geometryWhenVisible.y() - m_latteView->y();
     }
 
     if (m_latteView->location() == Plasma::Types::BottomEdge) {
         y = m_latteView->height() - m_latteView->editThickness() - m_latteView->effects()->editShadow();
     } else if (m_latteView->location() == Plasma::Types::TopEdge) {
         y = m_latteView->editThickness();
     } else if (m_latteView->location() == Plasma::Types::LeftEdge) {
         x = m_latteView->editThickness();
     } else if (m_latteView->location() == Plasma::Types::RightEdge) {
         x = m_latteView->width() - m_latteView->editThickness() - m_latteView->effects()->editShadow();
     }
 
     if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
         area = QRect(x, y, length, thickness);
     } else {
         area = QRect(x, y, thickness, length);
     }
 
     m_latteView->effects()->setSubtractedMaskRegion(validTitle(), area);
 }
 
 void PrimaryConfigView::syncSlideEffect()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto slideLocation = WindowSystem::AbstractWindowInterface::Slide::None;
 
     switch (m_latteView->containment()->location()) {
     case Plasma::Types::TopEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Top;
         break;
 
     case Plasma::Types::RightEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Right;
         break;
 
     case Plasma::Types::BottomEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Bottom;
         break;
 
     case Plasma::Types::LeftEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Left;
         break;
 
     default:
         qDebug() << staticMetaObject.className() << "wrong location";
         break;
     }
 
     m_corona->wm()->slideWindow(*this, slideLocation);
 }
 
 void PrimaryConfigView::showEvent(QShowEvent *ev)
 {
     QQuickWindow::showEvent(ev);
 
     if (!m_latteView) {
         return;
     }
 
     setFlags(wFlags());
     m_corona->wm()->setViewExtraFlags(this, false, Latte::Types::NormalWindow);
 
     syncGeometry();
     syncSlideEffect();
 
     if (m_latteView && m_latteView->containment()) {
         m_latteView->containment()->setUserConfiguring(true);
     }
 
     m_screenSyncTimer.start();
     QTimer::singleShot(400, this, &PrimaryConfigView::syncGeometry);
 
     updateShowInlineProperties();
     updateViewMask();
 
     emit showSignal();
 
     if (m_latteView && m_latteView->layout()) {
         m_latteView->layout()->setLastConfigViewFor(m_latteView);
     }
 
     if (m_shellSurface) {
         //! readd shadows after hiding because the window shadows are not shown again after first showing
         m_corona->dialogShadows()->addWindow(this, m_enabledBorders);
     }
 }
 
 void PrimaryConfigView::hideEvent(QHideEvent *ev)
 {
     if (!m_latteView) {
         deleteLater();
         return;
     }
 
     if (m_latteView->containment()) {
         m_latteView->containment()->setUserConfiguring(false);
     }
 
     m_latteView->effects()->removeSubtractedMaskRegion(validTitle());
 
     const auto mode = m_latteView->visibility()->mode();
 
     if ((mode == Types::AlwaysVisible || mode == Types::WindowsGoBelow)
             && !(m_originalMode == Types::AlwaysVisible || m_originalMode == Types::WindowsGoBelow)) {
         //! mode changed to AlwaysVisible OR WindowsGoBelow FROM Dodge mode
         if (m_originalByPassWM) {
             //! if original by pass is active
             m_latteView->layout()->recreateView(m_latteView->containment());
         }
     } else if (m_latteView->byPassWM() != m_originalByPassWM) {
         m_latteView->layout()->recreateView(m_latteView->containment());
     }
 
     if (m_latteView->hiddenConfigurationWindowsAreDeleted()) {
         deleteLater();
     } else {
         setVisible(false);
     }
 }
 
 void PrimaryConfigView::focusOutEvent(QFocusEvent *ev)
 {
     Q_UNUSED(ev);
 
     const auto *focusWindow = qGuiApp->focusWindow();
 
     if (!m_latteView
             || (focusWindow && (focusWindow->flags().testFlag(Qt::Popup)
                                 || focusWindow->flags().testFlag(Qt::ToolTip)))
             || m_latteView->alternativesIsShown()) {
         return;
     }
 
     if (!m_blockFocusLost && !m_latteView->containsMouse()
             && (!m_secConfigView || (m_secConfigView && !m_secConfigView->isActive()))) {
         hideConfigWindow();
     }
 }
 
 void PrimaryConfigView::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland primary settings surface was created...";
 
         m_shellSurface = interface->createSurface(s, this);
         m_corona->wm()->setViewExtraFlags(m_shellSurface, false);
 
         syncGeometry();
     }
 }
 
 bool PrimaryConfigView::event(QEvent *e)
 {
     if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
 
                 if (m_shellSurface) {
                     break;
                 }
 
                 setupWaylandIntegration();
                 break;
 
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 if (m_shellSurface) {
                     delete m_shellSurface;
                     m_shellSurface = nullptr;
                     qDebug() << "WAYLAND config window surface was deleted...";
                 }
 
                 break;
             }
         }
     }
 
     return PlasmaQuick::ConfigView::event(e);
 }
 
 
 void PrimaryConfigView::immutabilityChanged(Plasma::Types::ImmutabilityType type)
 {
     if (type != Plasma::Types::Mutable && isVisible())
         hideConfigWindow();
 }
 
 bool PrimaryConfigView::sticker() const
 {
     return m_blockFocusLost;
 }
 
 void PrimaryConfigView::setSticker(bool blockFocusLost)
 {
     if (m_blockFocusLost == blockFocusLost)
         return;
 
     m_blockFocusLost = blockFocusLost;
 }
 
 bool PrimaryConfigView::showInlineProperties() const
 {
     return m_showInlineProperties;
 }
 void PrimaryConfigView::setShowInlineProperties(bool show)
 {
     if (m_showInlineProperties == show) {
         return;
     }
 
     m_showInlineProperties = show;
     emit showInlinePropertiesChanged();
 }
 
 void PrimaryConfigView::updateShowInlineProperties()
 {
     if (!m_latteView) {
         return;
     }
 
     bool showSecWindow{false};
     bool advancedApprovedSecWindow{false};
 
     if (m_inAdvancedMode && m_latteView->formFactor() != Plasma::Types::Vertical) {
         showSecWindow = true;
         advancedApprovedSecWindow = true;
     }
 
     //! consider screen geometry for showing or not the secondary window
     if (showSecWindow && !geometryWhenVisible().isNull()) {
         if (m_secConfigView && m_secConfigView->geometryWhenVisible().intersects(geometryWhenVisible())) {
             showSecWindow = false;
         } else if (advancedApprovedSecWindow) {
             showSecWindow = true;
         }
     }
 
     if (showSecWindow) {
         showSecondaryWindow();
 
        // QTimer::singleShot(150, m_secConfigView, SLOT(show()));
         setShowInlineProperties(false);
     } else {
         hideSecondaryWindow();
         setShowInlineProperties(true);
     }
 
     // qDebug() << " showSecWindow:" << showSecWindow << " _ " << " inline:"<< !showSecWindow;
 }
 
 void PrimaryConfigView::updateWaylandId()
 {
     Latte::WindowSystem::WindowId newId = m_corona->wm()->winIdFor("latte-dock", validTitle());
 
     if (m_waylandWindowId != newId) {
         if (!m_waylandWindowId.isNull()) {
             m_corona->wm()->unregisterIgnoredWindow(m_waylandWindowId);
         }
 
         m_waylandWindowId = newId;
         m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
     }
 }
 
 bool PrimaryConfigView::inAdvancedMode() const
 {
     return m_inAdvancedMode;
 }
 
 void PrimaryConfigView::setInAdvancedMode(bool advanced)
 {
     if (m_inAdvancedMode == advanced) {
         return;
     }
 
     m_inAdvancedMode = advanced;
     emit inAdvancedModeChanged();
 }
 
 void PrimaryConfigView::hideConfigWindow()
 {
     if (m_shellSurface) {
         //!NOTE: Avoid crash in wayland environment with qt5.9
         close();
     } else {
         hide();
     }
 
     hideSecondaryWindow();
 }
 
 void PrimaryConfigView::updateLaunchersForGroup(int groupInt)
 {
     Types::LaunchersGroup group = (Types::LaunchersGroup)groupInt;
 
     //! when the layout/global launchers list is empty then the current dock launchers are used for them
     //! as a start point
     if (m_corona &&  m_latteView->layout()) {
         if ((group == Types::LayoutLaunchers && m_latteView->layout()->launchers().isEmpty())
                 || (group == Types::GlobalLaunchers && m_corona->universalSettings()->launchers().isEmpty())) {
 
             Plasma::Containment *c = m_latteView->containment();
 
             const auto &applets = c->applets();
 
             for (auto *applet : applets) {
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 if (meta.pluginId() == "org.kde.latte.plasmoid") {
                     if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                         const auto &childItems = appletInterface->childItems();
 
                         if (childItems.isEmpty()) {
                             continue;
                         }
 
                         for (QQuickItem *item : childItems) {
                             if (auto *metaObject = item->metaObject()) {
                                 // not using QMetaObject::invokeMethod to avoid warnings when calling
                                 // this on applets that don't have it or other child items since this
                                 // is pretty much trial and error.
                                 // Also, "var" arguments are treated as QVariant in QMetaObject
 
                                 int methodIndex = metaObject->indexOfMethod("getLauncherList()");
 
                                 if (methodIndex == -1) {
                                     continue;
                                 }
 
                                 QMetaMethod method = metaObject->method(methodIndex);
 
                                 QVariant launchers;
 
                                 if (method.invoke(item, Q_RETURN_ARG(QVariant, launchers))) {
                                     if (group == Types::LayoutLaunchers) {
                                         m_latteView->layout()->setLaunchers(launchers.toStringList());
                                     } else if (group == Types::GlobalLaunchers) {
                                         m_corona->universalSettings()->setLaunchers(launchers.toStringList());
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
-
 }
 
 //!BEGIN borders
 Plasma::FrameSvg::EnabledBorders PrimaryConfigView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void PrimaryConfigView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::BottomBorder : ~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 &= m_inReverse ? ~Plasma::FrameSvg::TopBorder : ~Plasma::FrameSvg::BottomBorder;
         break;
 
     default:
         break;
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
 
         m_corona->dialogShadows()->addWindow(this, m_enabledBorders);
 
         emit enabledBordersChanged();
     }
 }
 //!END borders
 
 void PrimaryConfigView::updateEffects()
 {
     //! Don't apply any effect before the wayland surface is created under wayland
     //! https://bugs.kde.org/show_bug.cgi?id=392890
     if (KWindowSystem::isPlatformWayland() && !m_shellSurface) {
         return;
     }
 
     if (!m_background) {
         m_background = new Plasma::FrameSvg(this);
     }
 
     if (m_background->imagePath() != "dialogs/background") {
         m_background->setImagePath(QStringLiteral("dialogs/background"));
     }
 
     m_background->setEnabledBorders(m_enabledBorders);
     m_background->resizeFrame(size());
 
     QRegion mask = m_background->mask();
 
     QRegion fixedMask = mask.isNull() ? QRegion(QRect(0,0,width(),height())) : mask;
 
     if (!fixedMask.isEmpty()) {
         setMask(fixedMask);
     } else {
         setMask(QRegion());
     }
 
     if (KWindowSystem::compositingActive()) {
         KWindowEffects::enableBlurBehind(winId(), true, fixedMask);
     } else {
         KWindowEffects::enableBlurBehind(winId(), false);
     }
 }
 
 //!BEGIN configuration
 void PrimaryConfigView::loadConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
     auto config = m_latteView->containment()->config();
     int complexity = config.readEntry("settingsComplexity", 0);
     setInAdvancedMode(complexity>0);
 }
 
 void PrimaryConfigView::saveConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto config = m_latteView->containment()->config();
     int complexity = m_inAdvancedMode ? 1 : 0;
     config.writeEntry("settingsComplexity", complexity);
 }
 //!END configuration
 
 }
 }
 
diff --git a/plasmoid/package/contents/ui/main.qml b/plasmoid/package/contents/ui/main.qml
index 2e90032b..999e384d 100644
--- a/plasmoid/package/contents/ui/main.qml
+++ b/plasmoid/package/contents/ui/main.qml
@@ -1,2030 +1,2031 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.8
 import QtQuick.Layouts 1.1
 import 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.taskmanager 0.1 as TaskManager
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.activities 0.1 as Activities
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import org.kde.latte.abilities.applets 0.1 as AppletAbility
 
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "abilities" as Ability
 import "previews" as Previews
 import "task" as Task
 import "taskslayout" as TasksLayout
 import "../code/tools.js" as TaskTools
 import "../code/activitiesTools.js" as ActivitiesTools
 import "../code/ColorizerTools.js" as ColorizerTools
 
 Item {
     id:root
 
     Layout.fillWidth: scrollingEnabled && !root.vertical
     Layout.fillHeight: scrollingEnabled && root.vertical
 
     Layout.minimumWidth: -1
     Layout.minimumHeight: -1
     Layout.preferredWidth: tasksWidth
     Layout.preferredHeight: tasksHeight
     Layout.maximumWidth: -1
     Layout.maximumHeight: -1
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.vertical
     LayoutMirroring.childrenInherit: true
 
     property bool plasma515: latteView ? latteView.plasma515 : LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,15,0)
     property bool plasma518: latteView ? latteView.plasma518 : LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,18,0)
 
     property bool editMode: latteView ? latteView.editMode : plasmoid.userConfiguring
     property bool inConfigureAppletsMode: latteView ? latteView.inConfigureAppletsMode : true
     property bool disableRestoreZoom: false //blocks restore animation in rightClick
     property bool disableAllWindowsFunctionality: plasmoid.configuration.hideAllTasks
     property bool dropNewLauncher: false
     property bool inActivityChange: false
     property bool inDraggingPhase: false
     property bool initializationStep: false //true
     property bool isHovered: false
     property bool showBarLine: plasmoid.configuration.showBarLine
     property bool useThemePanel: plasmoid.configuration.useThemePanel
     property bool taskInAnimation: noTasksInAnimation > 0 ? true : false
     property bool transparentPanel: plasmoid.configuration.transparentPanel
     property bool vertical: plasmoid.formFactor === PlasmaCore.Types.Vertical ? true : false
 
     property int clearWidth
     property int clearHeight
 
     property int newDroppedPosition: -1
     property int noInitCreatedBuffers: 0
     property int noTasksInAnimation: 0
     property int themePanelSize: plasmoid.configuration.panelSize
 
     property int location : {
         if (plasmoid.location === PlasmaCore.Types.LeftEdge
                 || plasmoid.location === PlasmaCore.Types.RightEdge
                 || plasmoid.location === PlasmaCore.Types.TopEdge) {
             return plasmoid.location;
         }
 
         return PlasmaCore.Types.BottomEdge;
     }
 
     property int tasksStarting: 0
 
     ///Don't use Math.floor it adds one pixel in animations and creates glitches
     property int widthMargins: root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
     property int heightMargins: !root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthEdges
 
     property int internalWidthMargins: root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthPaddings
     property int internalHeightMargins: !root.vertical ? metrics.totals.thicknessEdges : metrics.totals.lengthPaddings
 
     property real textColorBrightness: ColorizerTools.colorBrightness(themeTextColor)
     property color minimizedDotColor: {
         if (latteView) {
             return latteView.minimizedDotColor;
         }
 
         return textColorBrightness > 127.5 ? Qt.darker(themeTextColor, 1.7) : Qt.lighter(themeBackgroundColor, 7)
     }
 
     property color themeTextColor: theme.textColor
     property color themeBackgroundColor: theme.backgroundColor
 
     property color lightTextColor: textColorBrightness > 127.5 ? themeTextColor : themeBackgroundColor
 
     //a small badgers record (id,value)
     //in order to track badgers when there are changes
     //in launcher reference from libtaskmanager
     property variant badgers:[]
     property variant launchersOnActivities: []
 
     //global plasmoid reference to the context menu
     property QtObject contextMenu: null
     property QtObject contextMenuComponent: Qt.createComponent("ContextMenu.qml");
     property Item dragSource: null
 
     property Item tasksExtendedManager: _tasksExtendedManager
     readonly property alias animations: _animations
     readonly property alias indexer: _indexer
     readonly property alias launchers: _launchers
     readonly property alias metrics: _metrics
     readonly property alias parabolic: _parabolic
     readonly property alias shortcuts: _shortcuts
 
     readonly property alias containsDrag: mouseHandler.containsDrag
     readonly property bool dragAreaEnabled: latteView ? (root.dragSource !== null
                                                          || latteView.dragInfo.isSeparator
                                                          || latteView.dragInfo.isTask
                                                          || !latteView.dragInfo.isPlasmoid)
                                                       : true
 
     //! it is used to play the animation correct when the user removes a launcher
     property string launcherForRemoval: ""
 
     //BEGIN Latte Dock properties
     property bool badges3DStyle: latteView ? latteView.badges3DStyle : true
     property bool dockIsShownCompletely: latteView ? latteView.dockIsShownCompletely : true
     property bool enableShadows: latteView ? latteView.enableShadows > 0 : plasmoid.configuration.showShadows
     property bool forceHidePanel: false
 
     property bool disableLeftSpacer: false
     property bool disableRightSpacer: false
     property bool dockIsHidden: latteView ? latteView.dockIsHidden : false
     property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
     property bool highlightWindows: hoverAction === LatteTasks.Types.HighlightWindows || hoverAction === LatteTasks.Types.PreviewAndHighlightWindows
     property bool parabolicEffectEnabled: latteView ? latteView.parabolicEffectEnabled : parabolic.factor.zoom && !root.editMode
 
     property bool scrollingEnabled: plasmoid.configuration.scrollTasksEnabled
     property bool autoScrollTasksEnabled: scrollingEnabled && plasmoid.configuration.autoScrollTasksEnabled
     property bool manualScrollTasksEnabled: scrollingEnabled &&  manualScrollTasksType !== LatteTasks.Types.ManualScrollDisabled
     property int manualScrollTasksType: plasmoid.configuration.manualScrollTasksType
 
     property bool showInfoBadge: plasmoid.configuration.showInfoBadge
     property bool showProgressBadge: plasmoid.configuration.showInfoBadge
     property bool showAudioBadge: plasmoid.configuration.showAudioBadge
     property bool infoBadgeProminentColorEnabled: plasmoid.configuration.infoBadgeProminentColorEnabled
     property bool audioBadgeActionsEnabled: plasmoid.configuration.audioBadgeActionsEnabled
     property bool showOnlyCurrentScreen: plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: plasmoid.configuration.showOnlyCurrentActivity
     property bool showPreviews:  hoverAction === LatteTasks.Types.PreviewWindows || hoverAction === LatteTasks.Types.PreviewAndHighlightWindows
     property bool showWindowActions: plasmoid.configuration.showWindowActions && !disableAllWindowsFunctionality
-    property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers || disableAllWindowsFunctionality
+    property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers && !disableAllWindowsFunctionality
 
     property bool titleTooltips: latteView ? latteView.titleTooltips : false
     property alias windowPreviewIsShown: windowsPreviewDlg.visible
 
     property int launchersGroup: plasmoid.configuration.launchersGroup
 
     property int leftClickAction: plasmoid.configuration.leftClickAction
     property int middleClickAction: plasmoid.configuration.middleClickAction
     property int hoverAction: plasmoid.configuration.hoverAction
     property int modifier: plasmoid.configuration.modifier
     property int modifierClickAction: plasmoid.configuration.modifierClickAction
     property int modifierClick: plasmoid.configuration.modifierClick
     property int modifierQt:{
         if (modifier === LatteTasks.Types.Shift)
             return Qt.ShiftModifier;
         else if (modifier === LatteTasks.Types.Ctrl)
             return Qt.ControlModifier;
         else if (modifier === LatteTasks.Types.Alt)
             return Qt.AltModifier;
         else if (modifier === LatteTasks.Types.Meta)
             return Qt.MetaModifier;
         else return -1;
     }
     property int taskScrollAction: plasmoid.configuration.taskScrollAction
 
     onTaskScrollActionChanged: {
         if (taskScrollAction > LatteTasks.Types.ScrollToggleMinimized) {
             //! migrating scroll action to LatteTasks.Types.ScrollAction
             plasmoid.configuration.taskScrollAction = plasmoid.configuration.taskScrollAction-LatteTasks.Types.ScrollToggleMinimized;
         }
     }
 
     //! Real properties are need in order for parabolic effect to be 1px precise perfect.
     //! This way moving from Tasks to Applets and vice versa is pretty stable when hovering with parabolic effect.
     property real tasksHeight:  mouseHandler.height
     property real tasksWidth: mouseHandler.width
 
     //updated from Binding
     property int alignment
 
     readonly property real currentPanelOpacity: latteView ? latteView.currentPanelTransparency / 100 : 1
 
     property int appShadowSize: latteView ? latteView.appShadowSize : Math.ceil(0.12*metrics.iconSize)
     property string appShadowColor: latteView ? latteView.appShadowColor : "#ff080808"
     property string appShadowColorSolid: latteView ? latteView.appShadowColorSolid : "#ff080808"
 
     property alias tasksCount: tasksModel.count
 
     readonly property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property bool viewLayoutIsCurrent: latteView && viewLayout && latteView.layoutsManager
                                                 && viewLayout.name === latteView.layoutsManager.currentLayoutName
     readonly property string viewLayoutName: viewLayout ? viewLayout.name : ""
     readonly property QtObject viewLayout : latteView && latteView.viewLayout ? latteView.viewLayout : null
 
     property Item latteView: null
     readonly property Item indicators: latteView ? latteView.indicatorsManager : indicatorsStandaloneLoader.item
     //END Latte Dock Panel properties
 
     //BEGIN Latte Dock Communicator
     property QtObject latteBridge: null
 
     readonly property bool enforceLattePalette: latteBridge && latteBridge.applyPalette && latteBridge.palette
     readonly property bool latteInEditMode: latteBridge && latteBridge.inEditMode
     //END  Latte Dock Communicator
 
     Plasmoid.preferredRepresentation: Plasmoid.fullRepresentation
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     signal draggingFinished();
     signal hiddenTasksUpdated();
     signal launchersUpdatedFor(string launcher);
     signal presentWindows(variant winIds);
     signal requestLayout;
     signal signalPreviewsShown();
     //signal signalDraggingState(bool value);
     signal showPreviewForTasks(QtObject group);
     //trigger updating scaling of neighbour delegates of zoomed delegate
     signal updateScale(int delegateIndex, real newScale, real step)
     signal mimicEnterForParabolic();
     signal publishTasksGeometries();
     signal windowsHovered(variant winIds, bool hovered)
 
     //onAnimationsChanged: console.log(animations);
     /* Rectangle{
                 anchors.fill: parent
                 border.width: 1
                 border.color: "red"
                 color: "white"
             } */
     onLatteViewChanged: {
         if (latteView) {
             plasmoid.action("configure").visible = false;
             plasmoid.configuration.isInLatteDock = true;
 
             if (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                     || root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                 tasksModel.updateLaunchersList();
             }
         } else {
             plasmoid.configuration.isInLatteDock = false;
         }
     }
 
     onLaunchersGroupChanged:{
         if(latteView) {
             tasksModel.updateLaunchersList();
         }
     }
 
     Connections {
         target: plasmoid
         onLocationChanged: {
             iconGeometryTimer.start();
         }
     }
 
     Connections {
         target: plasmoid.configuration
 
         // onLaunchersChanged: tasksModel.launcherList = plasmoid.configuration.launchers
         onGroupingAppIdBlacklistChanged: tasksModel.groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
         onGroupingLauncherUrlBlacklistChanged: tasksModel.groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
     }
 
 
     Connections{
         target: latteView
         onDockIsHiddenChanged:{
             if (latteView.dockIsHidden) {
                 windowsPreviewDlg.hide("3.3");
             }
         }
     }
 
 
     Connections{
         target: latteView && latteView.layoutsManager ? latteView.layoutsManager : null
 
         onCurrentLayoutNameChanged: root.publishTasksGeometries();
     }
 
     Binding {
         target: plasmoid
         property: "status"
         value: (tasksModel.anyTaskDemandsAttentionInValidTime || root.dragSource ?
                     PlasmaCore.Types.NeedsAttentionStatus : PlasmaCore.Types.PassiveStatus);
     }
 
     /////
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
     //!
     Item {
         id: graphicsSystem
         readonly property bool isAccelerated: (GraphicsInfo.api !== GraphicsInfo.Software)
                                               && (GraphicsInfo.api !== GraphicsInfo.Unknown)
     }
 
     Loader {
         id: indicatorsStandaloneLoader
         active: !latteView && !plasmoid.configuration.isInLatteDock
         source: "indicators/Manager.qml"
     }
 
     Binding {
         target: root
         property: "alignment"
         value: {
             if (latteView) {
                 if (latteView.panelAlignment === -1) {
                     return;
                 }
 
                 if (latteView.panelAlignment === LatteCore.Types.Justify) {
                     if (latteView.latteAppletPos>=0 && latteView.latteAppletPos<100) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? LatteCore.Types.Left : LatteCore.Types.Top;
                     } else if (latteView.latteAppletPos>=100 && latteView.latteAppletPos<200) {
                         return LatteCore.Types.Center;
                     } else if (latteView.latteAppletPos>=200) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? LatteCore.Types.Right : LatteCore.Types.Bottom;
                     }
 
                     return LatteCore.Types.Center;
                 }
 
                 return latteView.panelAlignment;
             }
 
             return LatteCore.Types.Center;
         }
     }
 
     /////
 
     function launchersDropped(urls){
         mouseHandler.urlsDropped(urls);
     }
 
     ///UPDATE
     function launcherExists(url) {
         return (ActivitiesTools.getIndex(url, tasksModel.launcherList)>=0);
     }
 
     function taskExists(url) {
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.launcherUrl===url && task.isWindow) {
                 return true;
             }
         }
         return false;
     }
 
     function launchersDrop(event) {
         var createLaunchers = false;
 
         if (event.mimeData.hasUrls) {
             createLaunchers = event.mimeData.urls.every(function (item) {
                 return backend.isApplication(item)
             });
         }
 
         return createLaunchers;
     }
 
     function currentLauncherList() {
         var launch = [];
         var launchersList = [];
 
         if (viewLayout) {
             if (latteView && latteView.layoutsManager
                     && latteView.viewLayout && latteView.universalSettings
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     launchersList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     launchersList = latteView.universalSettings.launchers;
                 }
             }
         } else {
             launchersList = plasmoid.configuration.launchers59;
         }
 
 
         for(var i=0; i<launchersList.length; ++i){
             var launcherRecord = launchersList[i];
 
             if (launcherRecord.indexOf("[") === -1) {
                 //global launcher
                 launch.push(launcherRecord);
             } else {
                 //launcher assigned to activities
                 var end = launcherRecord.indexOf("\n");
                 var explicitLauncher = launcherRecord.substring(end+1,launcherRecord.length);
                 if (explicitLauncher !== "" && launcherRecord.indexOf(activityInfo.currentActivity) > -1) {
                     launch.push(explicitLauncher);
                 }
             }
         }
 
         return launch;
     }
 
     function currentListViewLauncherList() {
         var launch = [];
 
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = icList.childAtIndex(i);
 
             if (task!==undefined && task.launcherUrl!=="" && tasksModel.launcherInCurrentActivity(task.launcherUrl)) {
                 launch.push(task.launcherUrl);
             }
         }
 
         return launch;
     }
 
     function forcePreviewsHiding(debug) {
         //console.log("   Tasks: Force hide previews event called: "+debug);
         windowsPreviewDlg.visible = false;
         windowsPreviewDlg.mainItem.visible = false;
         windowsPreviewDlg.activeItem = null;
     }
 
     function hidePreview(){
         windowsPreviewDlg.hide(11);
     }
 
     onDragSourceChanged: {
         if (dragSource == null) {
             root.draggingFinished();
             tasksModel.syncLaunchers();
 
             restoreDraggingPhaseTimer.start();
         } else {
             inDraggingPhase = true;
         }
     }
 
     /////Window previews///////////
 
     Previews.ToolTipDelegate2 {
         id: toolTipDelegate
         visible: false
     }
 
     ////BEGIN interfaces
 
     LatteTasks.Dialog{
         id: windowsPreviewDlg
         // hideOnWindowDeactivate: false
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: root.location
         mainItem: toolTipDelegate
         visible: false
 
         property bool signalSent: false
         property Item activeItem: null
 
         Component.onCompleted: mainItem.visible = true;
 
         onContainsMouseChanged: {
             //! Orchestrate restore zoom and previews window hiding. Both should be
             //! triggered together.
             if (containsMouse) {
                 hidePreviewWinTimer.stop();
                 parabolic.stopRestoreZoomTimer();
                 parabolic.setDirectRenderingEnabled(false);
             } else {
                 hide(7.3);
                 parabolic.startRestoreZoomTimer();
             }
         }
 
         function hide(debug){
             //console.log("   Tasks: hide previews event called: "+debug);
             if (containsMouse || !visible) {
                 return;
             }
 
             if (latteView && signalSent) {
                 //it is used to unblock dock hiding
                 signalSent = false;
             }
 
             if (!root.contextMenu) {
                 root.disableRestoreZoom = false;
             }
 
             hidePreviewWinTimer.start();
         }
 
         function show(taskItem){
             if (root.disableAllWindowsFunctionality) {
                 return;
             }
 
             hidePreviewWinTimer.stop();
 
             // console.log("preview show called...");
             if ((!activeItem || (activeItem !== taskItem)) && !root.contextMenu) {
                 //console.log("preview show called: accepted...");
 
                 //this can be used from others to hide their appearance
                 //e.g but applets from the dock to hide themselves
                 if (!visible) {
                     root.signalPreviewsShown();
                 }
 
                 activeItem = taskItem;
                 toolTipDelegate.parentTask = taskItem;
 
                 if (latteView && !signalSent) {
                     //it is used to block dock hiding
                     signalSent = true;
                 }
 
                 //! Workaround in order to update properly the previews thumbnails
                 //! when switching between single thumbnail to another single thumbnail
                 mainItem.visible = false;
                 visible = true;
                 mainItem.visible = true;
             }
         }
     }
 
     //! Delay windows previews hiding
     Timer {
         id: hidePreviewWinTimer
         interval: 300
         onTriggered: {
             //! Orchestrate restore zoom and previews window hiding. Both should be
             //! triggered together.
             var contains = (windowsPreviewDlg.containsMouse
                             || (windowsPreviewDlg.activeItem && windowsPreviewDlg.activeItem.containsMouse) /*main task*/
                             || (windowsPreviewDlg.activeItem /*dragging file(s) from outside*/
                                 && mouseHandler.hoveredItem
                                 && !root.dragSource
                                 && mouseHandler.hoveredItem === windowsPreviewDlg.activeItem));
 
             if (!contains) {
                 root.forcePreviewsHiding();
             }
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown. It is mostly used under wayland in order to avoid crashes. When the context
     //! menu will be shown there is a chance that previews window has already appeared in that
     //! case the previews window must become hidden
     Timer {
         id: windowsPreviewCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (windowsPreviewDlg.visible && root.contextMenu) {
                 windowsPreviewDlg.hide("8.2");
             }
         }
     }
 
     //! Timer to delay the removal of the window through the context menu in case the
     //! the window is zoomed
     Timer{
         id: delayWindowRemovalTimer
         //this is the animation time needed in order for tasks to restore their zoom first
         interval: 7 * (animations.speedFactor.current * animations.duration.small)
 
         property var modelIndex
 
         onTriggered: {
             tasksModel.requestClose(delayWindowRemovalTimer.modelIndex)
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: delayWindowRemovalTimer called...");
             }
         }
     }
 
     Timer {
         id: activityChangeDelayer
         interval: 150
         onTriggered: {
             root.inActivityChange = false;
             activityInfo.previousActivity = activityInfo.currentActivity;
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: activityChangeDelayer called...");
             }
         }
     }
 
     /////Window Previews/////////
 
 
     property bool loadLaunchersFirstTime: false;
 
     onViewLayoutChanged: {
         if (viewLayout && !loadLaunchersFirstTime) {
             tasksModel.updateLaunchersList();
             loadLaunchersFirstTime = true;
         }
     }
 
     TaskManager.TasksModel {
         id: tasksModel
 
         virtualDesktop: virtualDesktopInfo.currentDesktop
         screenGeometry: root.screenGeometry
         // comment in order to support LTS Plasma 5.8
         // screen: plasmoid.screen
         activity: viewLayout ? viewLayout.lastUsedActivity : activityInfo.currentActivity
 
         filterByVirtualDesktop: root.showOnlyCurrentDesktop
         filterByScreen: root.showOnlyCurrentScreen
         filterByActivity: root.showOnlyCurrentActivity
 
         launchInPlace: true
         separateLaunchers: false
         groupInline: false
 
         groupMode: groupTasksByDefault ? TaskManager.TasksModel.GroupApplications : TaskManager.TasksModel.GroupDisabled
         sortMode: TaskManager.TasksModel.SortManual
 
         property bool anyTaskDemandsAttentionInValidTime: false
 
         function updateLaunchersList(){
             if (latteView
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     console.log("Tasks: Applying LAYOUT Launchers List...");
                     tasksModel.launcherList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     console.log("Tasks: Applying GLOBAL Launchers List...");
                     tasksModel.launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 console.log("Tasks: Applying UNIQUE Launchers List...");
                 tasksModel.launcherList = plasmoid.configuration.launchers59;
             }
         }
 
         function launcherInCurrentActivity(url) {
             var activities = tasksModel.launcherActivities(url);
 
             var NULL_UUID = "00000000-0000-0000-0000-000000000000";
 
-            if (activities.indexOf(NULL_UUID) !== -1 || activities.indexOf(activityInfo.currentActivity) !== -1)
+            if (activities.length === 0 || activities.indexOf(NULL_UUID) !== -1 || activities.indexOf(activityInfo.currentActivity) !== -1) {
                 return true;
+            }
 
             return false;
         }
 
         onActivityChanged: {
             ActivitiesTools.currentActivity = String(activity);
         }
 
         onLauncherListChanged: {
             if (viewLayout) {
                 if (latteView && latteView.layoutsManager
                         && latteView.viewLayout && latteView.universalSettings
                         && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                             || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                     if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                         latteView.viewLayout.launchers = launcherList;
                     } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                         latteView.universalSettings.launchers = launcherList;
                     }
 
                     if (inDraggingPhase) {
                         if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                             latteView.layoutsManager.launchersSignals.validateLaunchersOrder(root.viewLayoutName,
                                                                                              plasmoid.id,
                                                                                              root.launchersGroup,
                                                                                              currentLauncherList());
                         }
                     }
                 } else {
                     plasmoid.configuration.launchers59 = launcherList;
                 }
             } else {
                 plasmoid.configuration.launchers59 = launcherList;
             }
         }
 
         onGroupingAppIdBlacklistChanged: {
             plasmoid.configuration.groupingAppIdBlacklist = groupingAppIdBlacklist;
         }
 
         onGroupingLauncherUrlBlacklistChanged: {
             plasmoid.configuration.groupingLauncherUrlBlacklist = groupingLauncherUrlBlacklist;
         }
 
         onAnyTaskDemandsAttentionChanged: {
             if (anyTaskDemandsAttention){
                 anyTaskDemandsAttentionInValidTime = true;
                 attentionTimerComponent.createObject(root);
             }
         }
 
 
         Component.onCompleted: {
             ActivitiesTools.launchersOnActivities = root.launchersOnActivities
             ActivitiesTools.currentActivity = String(activityInfo.currentActivity);
             ActivitiesTools.plasmoid = plasmoid;
 
             //var loadedLaunchers = ActivitiesTools.restoreLaunchers();
             ActivitiesTools.importLaunchersToNewArchitecture();
 
             if (viewLayout && latteView.universalSettings
                     && (root.launchersGroup === LatteCore.Types.LayoutLaunchers
                         || root.launchersGroup === LatteCore.Types.GlobalLaunchers)) {
 
                 if (root.launchersGroup === LatteCore.Types.LayoutLaunchers) {
                     launcherList = latteView.viewLayout.launchers;
                 } else if (root.launchersGroup === LatteCore.Types.GlobalLaunchers) {
                     launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 launcherList = plasmoid.configuration.launchers59;
             }
 
             groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
             groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
 
             icList.model = tasksModel;
             tasksStarting = count;
 
             ///Plasma 5.9 enforce grouping at all cases
             if (LatteCore.Environment.plasmaDesktopVersion >= LatteCore.Environment.makeVersion(5,9,0)) {
                 groupingWindowTasksThreshold = -1;
             }
         }
     }
 
     //! TaskManagerBackend required a groupDialog setting otherwise it crashes. This patch
     //! sets one just in order not to crash TaskManagerBackend
     PlasmaCore.Dialog {
         //ghost group Dialog to not crash TaskManagerBackend
         id: groupDialogGhost
         visible: false
 
         type: PlasmaCore.Dialog.PopupMenu
         flags: Qt.WindowStaysOnTopHint
         hideOnWindowDeactivate: true
         location: root.location
     }
 
 
     TaskManagerApplet.Backend {
         id: backend
 
         taskManagerItem: root
         toolTipItem: toolTipDelegate
         highlightWindows: root.highlightWindows
 
         onAddLauncher: {
             tasksModel.requestAddLauncher(url);
         }
 
         Component.onCompleted: {
             //! In Plasma 5.9 TaskManagerBackend required a groupDialog setting
             //! otherwise it crashes.
             //! frameworks 5.29.0 provide id 335104
             //! work only after Plasma 5.9 and frameworks 5.29
             //! + added a check for groupDialog also when it is present
             //!   in plasma 5.8 (that was introduced after 5.8.5)
             if (LatteCore.Environment.frameworksVersion >= 335104 || (groupDialog !== undefined)) {
                 groupDialog = groupDialogGhost;
             }
         }
     }
 
     TaskManagerApplet.DragHelper {
         id: dragHelper
 
         dragIconSize: units.iconSizes.medium
     }
 
     TaskManager.VirtualDesktopInfo {
         id: virtualDesktopInfo
     }
 
     TaskManager.ActivityInfo {
         id: activityInfo
 
         property string previousActivity: ""
         onCurrentActivityChanged: {
             root.inActivityChange = true;
             activityChangeDelayer.start();
         }
 
         Component.onCompleted: previousActivity = currentActivity;
     }
 
     PlasmaCore.DataSource {
         id: mpris2Source
         engine: "mpris2"
         connectedSources: sources
         function sourceNameForLauncherUrl(launcherUrl, pid) {
             if (!launcherUrl || launcherUrl === "") {
                 return "";
             }
 
             // MPRIS spec explicitly mentions that "DesktopEntry" is with .desktop extension trimmed
             // Moreover, remove URL parameters, like wmClass (part after the question mark)
             var desktopFileName = launcherUrl.toString().split('/').pop().split('?')[0].replace(".desktop", "")
             if (desktopFileName.indexOf("applications:") === 0) {
                 desktopFileName = desktopFileName.substr(13)
             }
 
             for (var i = 0, length = connectedSources.length; i < length; ++i) {
                 var source = connectedSources[i];
                 // we intend to connect directly, otherwise the multiplexer steals the connection away
                 if (source === "@multiplex") {
                     continue;
                 }
 
                 var sourceData = data[source];
                 if (!sourceData) {
                     continue;
                 }
 
                 if (sourceData.DesktopEntry === desktopFileName || (pid && sourceData.InstancePid === pid)) {
                     return source;
                 }
 
                 var metadata = sourceData.Metadata;
                 if (metadata) {
                     var kdePid = metadata["kde:pid"];
                     if (kdePid && pid === kdePid) {
                         return source;
                     }
                 }
             }
 
             return ""
         }
 
         function startOperation(source, op) {
             var service = serviceForSource(source)
             var operation = service.operationDescription(op)
             return service.startOperationCall(operation)
         }
 
         function goPrevious(source) {
             startOperation(source, "Previous");
         }
         function goNext(source) {
             startOperation(source, "Next");
         }
         function play(source) {
             startOperation(source, "Play");
         }
         function pause(source) {
             startOperation(source, "Pause");
         }
         function playPause(source) {
             startOperation(source, "PlayPause");
         }
         function stop(source) {
             startOperation(source, "Stop");
         }
         function raise(source) {
             startOperation(source, "Raise");
         }
         function quit(source) {
             startOperation(source, "Quit");
         }
     }
 
     Loader {
         id: pulseAudio
         source: "PulseAudio.qml"
         active: root.showAudioBadge
     }
 
     TasksExtendedManager {
         id: _tasksExtendedManager
     }
 
     Ability.Animations {
         id: _animations
         bridge: latteBridge
     }
 
     Ability.Indexer {
         id: _indexer
         bridge: latteBridge
         layout: icList.contentItem
 
         allItemsCount: tasksModel.count
     }
 
     Ability.Launchers {
         id: _launchers
     }
 
     Ability.Metrics {
         id: _metrics
         bridge: latteBridge
     }
 
     Ability.ParabolicEffect {
         id: _parabolic
         bridge: latteBridge
         local.restoreZoomIsBlocked: root.contextMenu || windowsPreviewDlg.containsMouse
     }
 
     Ability.PositionShortcuts {
         id: _shortcuts
         bridge: latteBridge
         isStealingGlobalPositionShortcuts: plasmoid.configuration.isPreferredForPositionShortcuts
 
         onDisabledIsStealingGlobalPositionShortcuts: {
             plasmoid.configuration.isPreferredForPositionShortcuts = false;
         }
     }
 
     AppletAbility.Requirements{
         id: _requires
         bridge: latteBridge
 
         activeIndicatorEnabled: false
         latteIconOverlayEnabled: false
         lengthMarginsEnabled: false
         latteSideColoringEnabled: false
         screenEdgeMarginSupported: true        
         innerZoomFactor: {
             if (!_animations.active || !LatteCore.WindowSystem.compositingActive) {
                 return 1;
             }
 
             var hasHighThicknessAnimation = _animations.launcherBouncingEnabled || _animations.windowInAttentionEnabled || _animations.windowAddedInGroupEnabled;
 
             return hasHighThicknessAnimation ? 1.65 : 1.0;
         }
     }
 
     Component{
         id: attentionTimerComponent
         Timer{
             id: attentionTimer
             interval:8500
             onTriggered: {
                 tasksModel.anyTaskDemandsAttentionInValidTime = false;
                 destroy();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: attentionTimer called...");
                 }
             }
             Component.onCompleted: {
                 start();
             }
         }
     }
 
     //this timer restores the draggingPhase flag to false
     //after a dragging has finished... This delay is needed
     //in order to not animate any tasks are added after a
     //dragging
     Timer {
         id: restoreDraggingPhaseTimer
         interval: 150
         onTriggered: inDraggingPhase = false;
     }
 
     ///Red Liner!!! show the upper needed limit for animations
     Rectangle{
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: root.vertical ? 1 : 2 * metrics.iconSize
         height: root.vertical ? 2 * metrics.iconSize : 1
         color: "red"
         x: (root.location === PlasmaCore.Types.LeftEdge) ? neededSpace : parent.width - neededSpace
         y: (root.location === PlasmaCore.Types.TopEdge) ? neededSpace : parent.height - neededSpace
 
         visible: plasmoid.configuration.zoomHelper
 
         property int neededSpace: parabolic.factor.zoom*metrics.totals.length
     }
 
     Item{
         id:barLine
         anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
         anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
         anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
         anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: ( icList.orientation === Qt.Horizontal ) ? icList.width + spacing : smallSize
         height: ( icList.orientation === Qt.Vertical ) ? icList.height + spacing : smallSize
 
         property int spacing: latteBridge ? 0 : metrics.iconSize / 2
         property int smallSize: Math.max(0.10 * metrics.iconSize, 16)
 
         Behavior on opacity{
             NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
         }
 
         /// plasmoid's default panel
         BorderImage{
             anchors.fill:parent
             source: "../images/panel-west.png"
             border { left:8; right:8; top:8; bottom:8 }
 
             opacity: (plasmoid.configuration.showBarLine && !plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
 
             visible: (opacity == 0) ? false : true
 
             horizontalTileMode: BorderImage.Stretch
             verticalTileMode: BorderImage.Stretch
 
             Behavior on opacity{
                 NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
             }
         }
 
 
         /// item which is used as anchors for the plasma's theme
         Item{
             id:belower
 
             width: (root.location === PlasmaCore.Types.LeftEdge) ? shadowsSvgItem.margins.left : shadowsSvgItem.margins.right
             height: (root.location === PlasmaCore.Types.BottomEdge)? shadowsSvgItem.margins.bottom : shadowsSvgItem.margins.top
 
             anchors.top: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
             anchors.bottom: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
             anchors.right: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
             anchors.left: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
         }
 
 
         /// the current theme's panel
         PlasmaCore.FrameSvgItem{
             id: shadowsSvgItem
 
             anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? belower.bottom : undefined
             anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? belower.top : undefined
             anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? belower.left : undefined
             anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? belower.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
             width: root.vertical ? panelSize + margins.left + margins.right: parent.width
             height: root.vertical ? parent.height : panelSize + margins.top + margins.bottom
 
             imagePath: "translucent/widgets/panel-background"
             prefix:"shadow"
 
             opacity: (plasmoid.configuration.showBarLine && plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
             visible: (opacity == 0) ? false : true
 
             property int panelSize: ((root.location === PlasmaCore.Types.BottomEdge) ||
                                      (root.location === PlasmaCore.Types.TopEdge)) ?
                                         plasmoid.configuration.panelSize + belower.height:
                                         plasmoid.configuration.panelSize + belower.width
 
             Behavior on opacity{
                 NumberAnimation { duration: animations.speedFactor.current*animations.duration.large }
             }
 
 
             PlasmaCore.FrameSvgItem{
                 anchors.margins: belower.width-1
                 anchors.fill:parent
                 imagePath: plasmoid.configuration.transparentPanel ? "translucent/widgets/panel-background" :
                                                                      "widgets/panel-background"
             }
         }
 
 
         TasksLayout.MouseHandler {
             id: mouseHandler
             anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? scrollableList.bottom : undefined
             anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? scrollableList.top : undefined
             anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? scrollableList.left : undefined
             anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? scrollableList.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? scrollableList.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? scrollableList.verticalCenter : undefined
 
             width: root.vertical ? maxSize : icList.width
             height: root.vertical ? icList.height : maxSize
 
             target: icList
 
             visible: root.dragAreaEnabled
 
             property int maxSize: (parabolic.local.lastIndex>=0 || windowPreviewIsShown || animations.hasThicknessAnimation) ?
                                       (parabolic.factor.maxZoom * metrics.totals.thickness) + metrics.margin.screenEdge :
                                       metrics.totals.thickness + metrics.margin.screenEdge
 
             function onlyLaunchersInList(list){
                 return list.every(function (item) {
                     return backend.isApplication(item)
                 });
             }
 
             function urlsDroppedOnArea(urls){
                 // If all dropped URLs point to application desktop files, we'll add a launcher for each of them.
                 if (onlyLaunchersInList(urls)) {
                     urls.forEach(function (item) {
                         addLauncher(item);
                     });
                     return;
                 }
 
                 if (!hoveredItem) {
                     return;
                 }
 
                 // DeclarativeMimeData urls is a QJsonArray but requestOpenUrls expects a proper QList<QUrl>.
                 var urlsList = backend.jsonArrayToUrlList(urls);
 
                 // Otherwise we'll just start a new instance of the application with the URLs as argument,
                 // as you probably don't expect some of your files to open in the app and others to spawn launchers.
                 tasksModel.requestOpenUrls(hoveredItem.modelIndex(), urlsList);
             }
 
             onUrlsDropped: {               
                 //! inform synced docks for new dropped launchers
                 if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers && onlyLaunchersInList(urls)) {
                     latteView.layoutsManager.launchersSignals.urlsDropped(root.viewLayoutName,
                                                                           root.launchersGroup, urls);
                     return;
                 }
 
                 //! if the list does not contain only launchers then just open the corresponding
                 //! urls with the relevant app
                 urlsDroppedOnArea(urls);
             }
         }
 
         /* Rectangle {
             anchors.fill: scrollableList
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
         TasksLayout.ScrollableList {
             id: scrollableList
             width: !root.vertical ? length : thickness
             height: root.vertical ? length : thickness
             contentWidth: icList.width
             contentHeight: icList.height
 
             property int thickness:0 // through Binding to avoid binding loops
             property int length:0 // through Binding to avoid binding loops
 
             //onCurrentPosChanged: console.log("CP :: "+ currentPos + " icW:"+icList.width + " rw: "+root.width + " w:" +width);
 
             layer.enabled: contentsExceed && root.scrollingEnabled
             layer.effect: OpacityMask {
                 maskSource: TasksLayout.ScrollOpacityMask{
                     width: scrollableList.width
                     height: scrollableList.height
                 }
             }
 
             Binding {
                 target: scrollableList
                 property: "thickness"
                 when: latteView && !latteView.maskManager.inTempHiding
                 value: {
                     if (latteView) {
                         return animations.hasThicknessAnimation ? latteView.maskManager.thicknessZoom : latteView.maskManager.thicknessNormal;
                     }
 
                     return metrics.totals.thickness * parabolic.factor.zoom;
                 }
             }
 
             Binding {
                 target: scrollableList
                 property: "length"
                 when: latteView && !latteView.maskManager.inTempHiding
                 value: {
                     if (root.vertical) {
                         return Math.min(root.height, icList.height)
                     }
 
                     return Math.min(root.width, icList.width);
                 }
             }
 
             TasksLayout.ScrollPositioner {
                 id: listViewBase
 
                 ListView {
                     id:icList
                     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
                     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
                     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
                     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
                     anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
                     anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
                     width: !root.vertical ? contentWidth : mouseHandler.maxSize
                     height: root.vertical ? contentHeight : mouseHandler.maxSize
                     boundsBehavior: Flickable.StopAtBounds
                     orientation: plasmoid.formFactor === PlasmaCore.Types.Vertical ? Qt.Vertical : Qt.Horizontal
                     delegate: Task.TaskItem{
                         animations: _animations
                         indexer: _indexer
                         launchers: _launchers
                         metrics: _metrics
                         parabolic: _parabolic
                         requires: _requires
                         shortcuts: _shortcuts
                     }
 
                     property int currentSpot : -1000
                     property int previousCount : 0
 
                     property int tasksCount: tasksModel.count
 
                     //the duration of this animation should be as small as possible
                     //it fixes a small issue with the dragging an item to change it's
                     //position, if the duration is too big there is a point in the
                     //list that an item is going back and forth too fast
 
                     //more of a trouble
                     moveDisplaced: Transition {
                         NumberAnimation { properties: "x,y"; duration: animations.speedFactor.current*animations.duration.large; easing.type: Easing.Linear }
                     }
 
                     ///this transition can not be used with dragging !!!! I breaks
                     ///the lists indexes !!!!!
                     ///move: Transition {
                     ///    NumberAnimation { properties: "x,y"; duration: 400; easing.type: Easing.Linear }
                     ///}
 
                     function childAtPos(x, y){
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             var choords = mapFromItem(task,0, 0);
 
                             if( (task.objectName==="TaskItem") && (x>=choords.x) && (x<=choords.x+task.width)
                                     && (y>=choords.y) && (y<=choords.y+task.height)){
                                 return task;
                             }
                         }
 
                         return null;
                     }
 
                     function childAtIndex(position) {
                         var tasks = icList.contentItem.children;
 
                         if (position < 0)
                             return;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task.lastValidIndex === position
                                     || (task.lastValidIndex === -1 && task.itemIndex === position )) {
                                 return task;
                             }
                         }
 
                         return undefined;
                     }
 
                     function launcherModelIndex(url) {
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task && (task.launcherUrl===url)) {
                                 return task.itemIndex;
                             }
                         }
 
                         return -1;
                     }
                 }
             } // ScrollPositioner
         } // ScrollableList
 
         TasksLayout.ScrollEdgeShadows {
             id: scrollShadows
             width: !root.vertical ? scrollableList.width : thickness
             height: !root.vertical ? thickness : scrollableList.height
             visible: scrollableList.contentsExceed
 
             flickable: scrollableList
         } // ScrollEdgeShadows
 
         LatteComponents.AddingArea {
             id: newDroppedLauncherVisual
             width: root.vertical ? metrics.totals.thickness : scrollableList.width
             height: root.vertical ? scrollableList.height : metrics.totals.thickness
 
             visible: backgroundOpacity > 0
             radius: metrics.iconSize/10
             backgroundOpacity: root.dropNewLauncher && mouseHandler.onlyLaunchers && (root.dragSource == null)? 0.75 : 0
             duration: animations.speedFactor.current
 
             title: i18n("Tasks Area")
 
             states: [
                 ///Bottom Edge
                 State {
                     name: "left"
                     when: root.location===PlasmaCore.Types.LeftEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:undefined; bottom:undefined; left:scrollableList.left; right:undefined;
                             horizontalCenter:undefined; verticalCenter:scrollableList.verticalCenter}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:0; bottomMargin:0; leftMargin:metrics.margin.screenEdge; rightMargin:0;}
                     }
                 },
                 State {
                     name: "right"
                     when: root.location===PlasmaCore.Types.RightEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:undefined; bottom:undefined; left:undefined; right:scrollableList.right;
                             horizontalCenter:undefined; verticalCenter:scrollableList.verticalCenter}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:0; bottomMargin:0; leftMargin:0; rightMargin:metrics.margin.screenEdge;}
                     }
                 },
                 State {
                     name: "top"
                     when: root.location===PlasmaCore.Types.TopEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:scrollableList.top; bottom:undefined; left:undefined; right:undefined;
                             horizontalCenter:scrollableList.horizontalCenter; verticalCenter:undefined}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:metrics.margin.screenEdge; bottomMargin:0; leftMargin:0; rightMargin:0;}
                     }
                 },
                 State {
                     name: "bottom"
                     when: root.location!==PlasmaCore.Types.TopEdge
                           && root.location !== PlasmaCore.Types.LeftEdge
                           && root.location !== PlasmaCore.Types.RightEdge
 
                     AnchorChanges {
                         target: newDroppedLauncherVisual
                         anchors{ top:undefined; bottom:scrollableList.bottom; left:undefined; right:undefined;
                             horizontalCenter:scrollableList.horizontalCenter; verticalCenter:undefined}
                     }
 
                     PropertyChanges {
                         target: newDroppedLauncherVisual
                         anchors{ topMargin:0; bottomMargin:metrics.margin.screenEdge; leftMargin:0; rightMargin:0;}
                     }
                 }
             ]
         }
     }
 
     //// helpers
 
     Timer {
         id: iconGeometryTimer
         // INVESTIGATE: such big interval but unfortunately it does not work otherwise
         interval: 500
         repeat: false
 
         onTriggered: {
             root.publishTasksGeometries();
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: iconGeometryTimer called...");
             }
         }
     }
 
 
     ///REMOVE
     ////Activities List
     ////it can be used to cleanup the launchers from garbage-deleted activities....
     Item{
         id: activityModelInstance
         property int count: activityModelRepeater.count
 
         Repeater {
             id:activityModelRepeater
             model: Activities.ActivityModel {
                 id: activityModel
                 //  shownStates: "Running"
             }
             delegate: Item {
                 visible: false
                 property string activityId: model.id
                 property string activityName: model.name
             }
         }
 
         function activities(){
             var activitiesResult = [];
 
             for(var i=0; i<activityModelInstance.count; ++i){
                 console.log(children[i].activityId);
                 activitiesResult.push(children[i].activityId);
             }
 
             return activitiesResult;
         }
 
         ///REMOVE
         onCountChanged: {
             /*  if(activityInfo.currentActivity != "00000000-0000-0000-0000-000000000000"){
                 console.log("----------- Latte Plasmoid Signal: Activities number was changed ---------");
                 var allActivities = activities();
                 ActivitiesTools.cleanupRecords(allActivities);
                 console.log("----------- Latte Plasmoid Signal End ---------");
             }*/
         }
     }
 
     Timer{
         id:launchersOrderValidatorTimer
         interval: 400
 
         property var launchers: []
 
         function launchersAreInSync() {
             return arraysAreEqual(currentListViewLauncherList(), launchers);
         }
 
         function launcherValidPos(url) {
             for (var i=0; i<launchers.length; ++i) {
                 if (launchers[i] === url) {
                     return i;
                 }
             }
 
             return -1;
         }
 
         function arraysAreEqual(list1, list2) {
             if (list1.length !== list2.length) {
                 console.log("  arrays have different size...")
                 return false;
             }
 
             for (var i=0; i<list1.length; ++i) {
                 if (list1[i] !== list2[i]) {
                     return false;
                 }
             }
 
             return true;
         }
 
         //! true if upward is the best way to iterate through current
         //! in order to make it equal with goal
         function upwardIsBetter(current, goal)
         {
             var tCurrent = current.slice();
 
             if (!arraysAreEqual(tCurrent, goal)) {
                 for (var i=0; i<tCurrent.length; ++i) {
                     if (tCurrent[i] !== goal[i]) {
                         var val = tCurrent[i];
                         tCurrent.splice(i, 1);
                         tCurrent.splice(goal.indexOf(val), 0, val);
 
                         if (arraysAreEqual(tCurrent, goal)){
                             return true;
                         } else {
                             return false;
                         }
                     }
                 }
             }
 
             return false;
         }
 
 
         onTriggered: {
             if (launchersAreInSync()) {
                 stop();
                 console.log("launchers synced at:" + launchers);
                 launchers.length = 0;
                 tasksModel.syncLaunchers();
             } else {
                 var currentLaunchers = currentListViewLauncherList();
 
                 if (upwardIsBetter(currentLaunchers, launchers)) {
                     console.log("UPWARD....");
                     for (var i=0; i<currentLaunchers.length; ++i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 } else {
                     console.log("DOWNWARD....");
                     for (var i=currentLaunchers.length-1; i>=0; --i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 }
 
                 console.log("why we reached ??? ");
                 console.log("CURRENT ::: " + currentLaunchers);
                 console.log("VALID   ::: " + launchers);
             }
         }
     }
 
     /////////
 
     //// functions
     function addInternalSeparatorAtPos(pos) {
         var separatorName = launchers.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.viewLayoutName,
                                                                       root.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     function activateTaskAtIndex(index) {
         // This is called with Meta+number shortcuts by plasmashell when Tasks are in a plasma panel.
         shortcuts.sglActivateEntryAtIndex(index);
     }
 
     function newInstanceForTaskAtIndex(index) {
         // This is called with Meta+Alt+number shortcuts by plasmashell when Tasks are in a plasma panel.
         shortcuts.sglNewInstanceForEntryAtIndex(index);
     }
 
     function getBadger(identifier) {
         var ident1 = identifier;
         var n = ident1.lastIndexOf('/');
 
         var result = n>=0 ? ident1.substring(n + 1) : identifier;
 
         for(var i=0; i<badgers.length; ++i) {
             if (result.indexOf(badgers[i].id) >= 0) {
                 return badgers[i];
             }
         }
     }
 
     function updateBadge(identifier, value) {
         var tasks = icList.contentItem.children;
         var identifierF = identifier.concat(".desktop");
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task && task.launcherUrl && task.launcherUrl.indexOf(identifierF) >= 0) {
                 task.badgeIndicator = value === "" ? 0 : Number(value);
                 var badge = getBadger(identifierF);
                 if (badge) {
                     badge.value = value;
                 } else {
                     badgers.push({id: identifierF, value: value});
                 }
             }
         }
     }
 
     function getLauncherList() {
         return plasmoid.configuration.launchers59;
     }
 
     //! BEGIN ::: external launchers signals in order to update the tasks model
     function extSignalAddLauncher(group, launcher) {
         if (group === root.launchersGroup) {
             tasksModel.requestAddLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncher(group, launcher) {
         if (group === root.launchersGroup) {
             root.launcherForRemoval = launcher;
             tasksModel.requestRemoveLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalAddLauncherToActivity(group, launcher, activity) {
         if (group === root.launchersGroup) {
             var launcherActivities = tasksModel.launcherActivities(launcher);
 
             if (activity !== tasksModel.activity && (launcherActivities[0] === "00000000-0000-0000-0000-000000000000")) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestAddLauncherToActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncherFromActivity(group, launcher, activity) {
         if (group === root.launchersGroup) {
             if (activity === tasksModel.activity) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestRemoveLauncherFromActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalUrlsDropped(group, urls) {
         if (group === root.launchersGroup) {
             mouseHandler.urlsDroppedOnArea(urls);
         }
     }
 
     function extSignalMoveTask(group, from, to) {
         if (group === root.launchersGroup && !root.dragSource) {
             tasksModel.move(from, to);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalValidateLaunchersOrder(group, launchers) {
         if (group === root.launchersGroup && !root.dragSource) {
             launchersOrderValidatorTimer.stop();
             launchersOrderValidatorTimer.launchers = launchers;
             launchersOrderValidatorTimer.start();
         }
     }
 
     //! END ::: external launchers signals in order to update the tasks model
 
 
     //! it is used to add the fake desktop file which represents
     //! the separator (fake launcher)
     function addSeparator(pos){
         var separatorName = launchers.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && root.launchersGroup >= LatteCore.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     function previewContainsMouse() {
         return windowsPreviewDlg.containsMouse;
     }
 
     function containsMouse(){
         //console.log("s1...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         //if (previewContainsMouse())
         //  windowsPreviewDlg.hide(4);
 
         if (previewContainsMouse())
             return true;
 
         //console.log("s3...");
         var tasks = icList.contentItem.children;
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if(task && task.containsMouse){
                 // console.log("Checking "+i+" - "+task.index+" - "+task.containsMouse);
                 return true;
             }
         }
 
         return false;
     }
 
     function hasLauncher(url) {
         return tasksModel.launcherPosition(url) != -1;
     }
 
     function addLauncher(url) {
         //workaround to protect in case the launcher contains the iconData
         var pos = url.indexOf("?iconData=");
 
         if (pos>0) {
             url = url.substring( 0, url.indexOf("?iconData=" ) );
         }
 
         var path = url;
         var filename = path.split("/").pop();
         tasksExtendedManager.addToBeAddedLauncher(filename);
 
         tasksModel.requestAddLauncher(url);
         launchersUpdatedFor(url);
         tasksModel.syncLaunchers();
     }
 
     function resetDragSource() {
         dragSource.z = 0;
         dragSource = null;
     }
 
     ///REMOVE
     /*function createContextMenu(task) {
         var menu = root.contextMenuComponent.createObject(task);
         menu.visualParent = task;
         menu.mpris2Source = mpris2Source;
         menu.activitiesCount = activityModelInstance.count;
         return menu;
     }*/
 
     function createContextMenu(rootTask, modelIndex, args) {
         var initialArgs = args || {}
         initialArgs.visualParent = rootTask;
         initialArgs.modelIndex = modelIndex;
         initialArgs.mpris2Source = mpris2Source;
         initialArgs.backend = backend;
 
         root.contextMenu = root.contextMenuComponent.createObject(rootTask, initialArgs);
 
         return root.contextMenu;
     }
 
     Component.onCompleted:  {
         root.presentWindows.connect(backend.presentWindows);
         root.windowsHovered.connect(backend.windowsHovered);
         dragHelper.dropped.connect(resetDragSource);
     }
 
     Component.onDestruction: {
         root.presentWindows.disconnect(backend.presentWindows);
         root.windowsHovered.disconnect(backend.windowsHovered);
         dragHelper.dropped.disconnect(resetDragSource);
     }
 
     //BEGIN states
     // Alignments
     // 0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Bottom Edge
         State {
             name: "bottomCenter"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomLeft"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomRight"
             when: (root.location===PlasmaCore.Types.BottomEdge && root.alignment===LatteCore.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Top Edge
         State {
             name: "topCenter"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "topLeft"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "topRight"
             when: (root.location===PlasmaCore.Types.TopEdge && root.alignment===LatteCore.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ////Left Edge
         State {
             name: "leftCenter"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "leftTop"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "leftBottom"
             when: (root.location===PlasmaCore.Types.LeftEdge && root.alignment===LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Right Edge
         State {
             name: "rightCenter"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "rightTop"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "rightBottom"
             when: (root.location===PlasmaCore.Types.RightEdge && root.alignment===LatteCore.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         }
 
     ]
     //END states
 
 }
diff --git a/plasmoid/package/contents/ui/task/TaskItem.qml b/plasmoid/package/contents/ui/task/TaskItem.qml
index 11dc87bd..4aa118d4 100644
--- a/plasmoid/package/contents/ui/task/TaskItem.qml
+++ b/plasmoid/package/contents/ui/task/TaskItem.qml
@@ -1,1682 +1,1690 @@
 /*
 *  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.Layouts 1.1
 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.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.latte.core 0.2 as LatteCore
 
 import org.kde.latte.private.tasks 0.1 as LatteTasks
 
 import "animations" as TaskAnimations
 import "indicator" as Indicator
 
 MouseArea{
     id: taskItem
 
     visible: false //true//(isStartup && animations.speedFactor.current !== 0) ? false : true
 
     anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
     anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
     anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
     anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
     objectName: "TaskItem"
 
     width: {
         if (!visible)
             return 0;
 
         if (isSeparator) {
             if (root.vertical) {
                 return taskItem.metrics.totals.thickness + taskItem.metrics.margin.screenEdge;
             } else {
                 if (root.dragSource || !root.parabolicEffectEnabled) {
                     return LatteCore.Environment.separatorLength+2*taskItem.metrics.margin.length;
                 }
             }
 
             return 0;
         }
 
         if (root.vertical) {
             return wrapper.width;
         } else {
             return hiddenSpacerLeft.width+wrapper.width+hiddenSpacerRight.width;
         }
     }
 
     /*onWidthChanged: {
         console.log("T: " + itemIndex + " - " + launcherUrl + " - " + width + " _ "+ hiddenSpacerLeft.width + " _ " + wrapper.width + " _ " + hiddenSpacerRight.width);
     }*/
 
     height: {
         if (!visible)
             return 0;
 
         if (isSeparator) {
             if (!root.vertical) {
                 return taskItem.metrics.totals.thickness + taskItem.metrics.margin.screenEdge;
             } else {
                 if (root.dragSource || !root.parabolicEffectEnabled) {
                     return LatteCore.Environment.separatorLength+2*taskItem.metrics.margin.length;
                 }
             }
 
             return 0;
         }
 
         if (root.vertical) {
             return hiddenSpacerLeft.height + wrapper.height + hiddenSpacerRight.height;
         } else {
             return wrapper.height;
         }
     }
 
     acceptedButtons: Qt.LeftButton | Qt.MidButton | Qt.RightButton
     hoverEnabled: visible && (!inAnimation) && (!IsStartup) && (!root.taskInAnimation)
                   &&(!inBouncingAnimation) && !isSeparator
     // hoverEnabled: false
     //opacity : isSeparator && (hiddenSpacerLeft.neighbourSeparator || hiddenSpacerRight.neighbourSeparator) ? 0 : 1
 
     property bool buffersAreReady: false
     property bool delayingRemove: ListView.delayRemove
     property bool scalesUpdatedOnce: false
     //states that exist in windows in a Group of windows
     property bool hasActive: isActive
     property bool hasMinimized: (IsGroupParent === true) ? subWindows.hasMinimized : isMinimized
     property bool hasShown: (IsGroupParent === true) ? subWindows.hasShown : !isMinimized && isWindow
     property bool inAttention: isDemandingAttention && plasmoid.status === PlasmaCore.Types.RequiresAttentionStatus ? true : false
     /*animations flags*/
     property bool inAnimation: true
     property bool inAddRemoveAnimation: true
     property bool inAttentionAnimation: false
     property bool inBlockingAnimation: false
     property bool inBouncingAnimation: false
     property bool inFastRestoreAnimation: false
     property bool inMimicParabolicAnimation: false
     property bool inNewWindowAnimation: false
     property real mimicParabolicScale: -1
     property bool inPopup: false
     property bool inRemoveStage: false
 
     property bool isAbleToShowPreview: true
     property bool isActive: (IsActive === true) ? true : false
     property bool isDemandingAttention: (IsDemandingAttention === true) ? true : false
     property bool isDragged: false
     property bool isGroupable: (IsGroupable === true) ? true : false
     property bool isGroupParent: (IsGroupParent === true) ? true : false
     readonly property bool isHidden: !visible || isForcedHidden
     property bool isForcedHidden: false
     property bool isLauncher: (IsLauncher === true) ? true : false
     property bool isMinimized: (IsMinimized === true) ? true : false
     property bool isSeparator: false
     property bool isStartup: (IsStartup === true) ? true : false
     property bool isWindow: (IsWindow === true) ? true : false
     property bool isZoomed: false
 
     property bool canPublishGeometries: (isWindow || isStartup || isGroupParent) && visible && width>=taskItem.metrics.iconSize && height>=taskItem.metrics.iconSize
                                         && !taskItem.delayingRemove
                                         && (wrapper.mScale===1 || wrapper.mScale===taskItem.parabolic.factor.zoom) //don't publish during zoom animation
 
     property bool hoveredFromDragging: (mouseHandler.hoveredItem === taskItem) || (mouseHandler.ignoredItem === taskItem)
 
     property bool pressed: false
     property bool wheelIsBlocked: false
 
     property int animationTime: (taskItem.animations.active ? taskItem.animations.speedFactor.current : 2) * (1.2 *taskItem.animations.duration.small)
     property int badgeIndicator: 0 //it is used from external apps
     property int itemIndex: index
     property int lastValidIndex: -1 //used for the removal animation
     property int lastButtonClicked: -1;
     property int pressX: -1
     property int pressY: -1
     property int resistanceDelay: 450
     property int spacersMaxSize: Math.max(0,Math.ceil(0.55*taskItem.metrics.iconSize) - taskItem.metrics.totals.lengthEdges)
     property int windowsCount: subWindows.windowsCount
     property int windowsMinimizedCount: subWindows.windowsMinimized
 
     //! are set by the indicator
     property int iconOffsetX: 0
     property int iconOffsetY: 0
 
     property string activity: tasksModel.activity
 
     readonly property var m: model
     readonly property int pid: model && model.AppPid ? model.AppPid : -1
     readonly property string appName: model && model.AppName ? model.AppName : ""
 
     property string modelLauncherUrl: (LauncherUrlWithoutIcon && LauncherUrlWithoutIcon !== null) ? LauncherUrlWithoutIcon : ""
     property string modelLauncherUrlWithIcon: (LauncherUrl && LauncherUrl !== null) ? LauncherUrl : ""
     property string launcherUrl: ""
     property string launcherUrlWithIcon: ""
     property string launcherName: ""
 
     property Item tooltipVisualParent: wrapper.titleTooltipVisualParent
     property Item previewsVisualParent: wrapper.previewsTooltipVisualParent
     property Item wrapperAlias: wrapper
 
     //abilities
     property Item animations: null
     property Item indexer: null
     property Item launchers: null
     property Item metrics: null
     property Item parabolic: null
     property Item requires: null
     property Item shortcuts: null
 
     onModelLauncherUrlChanged: {
         if (modelLauncherUrl !== ""){
             launcherUrl = modelLauncherUrl;
 
             //!extract the launcherName if possible
             var nameStarts = launcherUrl.lastIndexOf("/");
             if (nameStarts === -1){
                 nameStarts = launcherUrl.lastIndexOf(":");
             }
 
             var nameEnds = launcherUrl.lastIndexOf(".desktop");
 
             if (nameStarts!==-1 && nameEnds!==-1 && nameStarts<nameEnds) {
                 launcherName = launcherUrl.substring(nameStarts+1,nameEnds);
             }
         }
 
         if (launchers.isSeparator(modelLauncherUrl)){
             isSeparator = true;
         } else {
             isSeparator = false;
         }
     }
 
     onModelLauncherUrlWithIconChanged: {
         if (modelLauncherUrlWithIcon !== ""){
             launcherUrlWithIcon = modelLauncherUrlWithIcon;
         }
     }
 
     onHoveredFromDraggingChanged: {
         if (hoveredFromDragging) {
             scrollableList.autoScrollFor(taskItem, true);
         }
     }
 
     //! separators flags
     readonly property bool tailItemIsSeparator: {
         if (isSeparator || itemIndex < 0 ) {
             return false;
         }
 
         var tail = index - 1;
 
         while(tail>=0 && taskItem.indexer.hidden.indexOf(tail)>=0) {
             tail = tail - 1;
         }
 
         var hasTailItemSeparator = taskItem.indexer.separators.indexOf(tail)>=0;
 
         if (!hasTailItemSeparator && itemIndex === taskItem.indexer.firstVisibleItemIndex){
             return taskItem.indexer.tailAppletIsSeparator;
         }
 
         return hasTailItemSeparator;
     }
 
     readonly property bool headItemIsSeparator: {
         if (isSeparator || itemIndex < 0 ) {
             return false;
         }
 
         var head = index + 1;
 
         while(head>=0 && taskItem.indexer.hidden.indexOf(head)>=0) {
             head = head + 1;
         }
 
         var hasHeadItemSeparator = taskItem.indexer.separators.indexOf(head)>=0;
 
         if (!hasHeadItemSeparator && itemIndex === taskItem.indexer.lastVisibleItemIndex){
             return taskItem.indexer.headAppletIsSeparator;
         }
 
         return hasHeadItemSeparator;
     }
 
     ////// Audio streams //////
     property Item audioStreamOverlay
     property var audioStreams: []
     readonly property bool hasAudioStream: root.showAudioBadge && audioStreams.length > 0 && !isLauncher
     readonly property bool playingAudio: hasAudioStream && audioStreams.some(function (item) {
         return !item.corked
     })
 
     readonly property bool muted: hasAudioStream && audioStreams.every(function (item) {
         return item.muted
     })
 
     readonly property int volume: {
         if (!hasAudioStream){
             return 0;
         }
 
         var maxVolume = 0;
         for (var i=0; i<audioStreams.length; ++i){
             if (audioStreams[i].volume > maxVolume)
                 maxVolume = audioStreams[i].volume;
         }
 
         return maxVolume;
     }
 
     //////
 
     property QtObject contextMenu: null
     property QtObject draggingResistaner: null
     property QtObject hoveredTimerObj: null
 
     signal groupWindowAdded();
     signal groupWindowRemoved();
     signal checkWindowsStates();
 
     Behavior on opacity {
         // NumberAnimation { duration: (IsStartup || (IsLauncher) ) ? 0 : 400 }
         NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
     }
 
     Loader{
         anchors.fill: parent
         active: latteView && latteView.debugMode
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.color:  "blue"
             border.width: 1
         }
     }
 
 
     SubWindows{
         id: subWindows
 
         property int previousCount: 0
 
         onWindowsCountChanged: {
-            if (root.showWindowsOnlyFromLaunchers && !root.indicatorsEnabled) {
+            if (root.disableAllWindowsFunctionality) {
                 return;
             }
 
             if ((windowsCount >= 2)
                     && (windowsCount > previousCount)
                     && !(taskItem.containsMouse)
                     && !root.dragSource ){
                 taskItem.groupWindowAdded();
             } else if ((windowsCount >= 1)
                      && (windowsCount < previousCount)
                      && !root.dragSource
                      && !taskItem.delayingRemove){
                 //sometimes this is triggered in dragging with no reason
                 taskItem.groupWindowRemoved();
             }
 
             if (windowsCount>=1) {
                 taskItem.slotPublishGeometries();
             }
 
             //! workaround in order to update correctly the previousCount
             //! windowsCount can not return to zero because is such case
             //! the window task is removed and the launcher is added from
             //! libtaskmanager
             if (windowsCount>=1) {
                 previousCount = windowsCount;
             }
         }
     }
 
     Loader {
         id: isSeparatorRectangle
         active: (opacityN>0)
 
         width: taskItem.width
         height: taskItem.height
         anchors.centerIn: separatorItem
 
         property real opacityN: isSeparator && root.contextMenu && root.contextMenu.visualParent === taskItem ? 1 : 0
 
         Behavior on opacityN {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         sourceComponent: Rectangle{
             anchors.fill: parent
             opacity: isSeparatorRectangle.opacityN
             radius: 3
 
             property color tempColor: theme.highlightColor
             color: tempColor
             border.width: 1
             border.color: theme.highlightColor
 
             onTempColorChanged: tempColor.a = 0.35;
 
         }
     }
 
     Item{
         id:separatorItem
 
         anchors.bottom: (root.location === PlasmaCore.Types.BottomEdge) ? parent.bottom : undefined
         anchors.top: (root.location === PlasmaCore.Types.TopEdge) ? parent.top : undefined
         anchors.left: (root.location === PlasmaCore.Types.LeftEdge) ? parent.left : undefined
         anchors.right: (root.location === PlasmaCore.Types.RightEdge) ? parent.right : undefined
 
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         anchors.bottomMargin: (root.location === PlasmaCore.Types.BottomEdge) ? margin : 0
         anchors.topMargin: (root.location === PlasmaCore.Types.TopEdge) ? margin : 0
         anchors.leftMargin: (root.location === PlasmaCore.Types.LeftEdge) ? margin : 0
         anchors.rightMargin: (root.location === PlasmaCore.Types.RightEdge) ? margin : 0
 
         opacity: (separatorShadow.active) || forceHiddenState ? 0 : 0.4
         visible: taskItem.isSeparator
 
         width: root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+taskItem.metrics.totals.lengthEdges: 1)
         height: !root.vertical ? taskItem.metrics.iconSize : ((root.dragSource || root.editMode) ? LatteCore.Environment.separatorLength+taskItem.metrics.totals.lengthEdges: 1)
 
         property bool forceHiddenState: false
 
         readonly property int margin: taskItem.metrics.margin.screenEdge + metrics.margin.thickness
 
         Behavior on opacity {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         Connections{
             target: root
 
             //! During dock sliding-in because the parabolic effect isnt trigerred
             //! immediately but we wait first the dock to go to its final normal
             //! place we might miss the activation of the parabolic effect.
             //! By catching that signal we are trying to solve this.
             onDockIsShownCompletelyChanged: {
                 if (dockIsShownCompletely && taskItem.containsMouse) {
                     if (root.vertical) {
                         taskItem.mousePosChanged(taskItem.mouseY);
                     } else {
                         taskItem.mousePosChanged(taskItem.mouseX);
                     }
                 }
             }
 
+            onDisableAllWindowsFunctionalityChanged: {
+                if (!root.editMode) {
+                    return;
+                }
+
+                taskItem.updateVisibilityBasedOnLaunchers();
+            }
+
             onShowWindowsOnlyFromLaunchersChanged: {
                 if (!root.editMode) {
                     return;
                 }
 
                 taskItem.updateVisibilityBasedOnLaunchers();
             }
 
             onInActivityChangeChanged: {
-                if (root.showWindowsOnlyFromLaunchers && !root.inActivityChange) {
+                if ((root.showWindowsOnlyFromLaunchers || root.disableAllWindowsFunctionality) && !root.inActivityChange) {
                     taskItem.updateVisibilityBasedOnLaunchers();
                 }
             }
         }
 
         Rectangle {
             anchors.centerIn: parent
 
             width: root.vertical ? taskItem.metrics.iconSize - 4  : 1
             height: !root.vertical ? taskItem.metrics.iconSize - 4 : 1
             color: enforceLattePalette ? latteBridge.palette.textColor : theme.textColor
         }
 
 
     }
 
     ///Shadow in tasks
     Loader{
         id: separatorShadow
         anchors.fill: separatorItem
         active: root.enableShadows && isSeparator && graphicsSystem.isAccelerated
         opacity: separatorItem.forceHiddenState ? 0 : 0.4
 
         Behavior on opacity {
             NumberAnimation { duration: taskItem.animations.speedFactor.current * taskItem.animations.duration.large }
         }
 
         sourceComponent: DropShadow{
             anchors.fill: parent
             color: root.appShadowColor
             fast: true
             samples: 2 * radius
             source: separatorItem
             radius: root.appShadowSize
             verticalOffset: 2
         }
     }
 
     /* Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
     Flow{
         id: taskFlow
         width: parent.width
         height: parent.height
 
         // a hidden spacer for the first element to add stability
         // IMPORTANT: hidden spacers must be tested on vertical !!!
         HiddenSpacer{ id:hiddenSpacerLeft;}
 
         Item{
             width: wrapper.width
             height: wrapper.height
 
             Indicator.Bridge{
                 id: indicatorBridge
             }
 
             Indicator.Loader{
                 id: indicatorBackLayer
                 level: Indicator.LevelOptions {
                     id: backLevelOptions
                     isBackground: true
                     bridge: indicatorBridge
 
                     Binding {
                         target: taskItem
                         property: "iconOffsetX"
                         value: backLevelOptions.requested.iconOffsetX
                     }
 
                     Binding {
                         target: taskItem
                         property: "iconOffsetY"
                         value: backLevelOptions.requested.iconOffsetY
                     }
                 }
             }
 
             Wrapper{id: wrapper}
 
             Indicator.Loader{
                 id: indicatorFrontLayer
                 level: Indicator.LevelOptions {
                     isForeground: true
                     bridge: indicatorBridge
                 }
             }
         }
 
         // a hidden spacer on the right for the last item to add stability
         HiddenSpacer{ id:hiddenSpacerRight; rightSpacer: true }
     }// Flow with hidden spacers inside
 
     Component {
         id: taskInitComponent
         Timer {
             id: timer
 
             interval: 800
             repeat: false
 
             onTriggered: {
                 //      taskItem.hoverEnabled = true;
                 slotPublishGeometries();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: taskInitComponentTimer called...");
                 }
 
                 timer.destroy();
             }
 
             Component.onCompleted: timer.start()
         }
     }
 
     ////// Values Changes /////
     //restore scales when there is no zoom factor for that item or
     //the mouse is out of the ListView
     // onItemIndexChanged: {
     //  }
 
     onAppNameChanged: updateAudioStreams()
     onPidChanged: updateAudioStreams()
     onHasAudioStreamChanged: updateAudioStreams()
 
     onCanPublishGeometriesChanged: {
         if (canPublishGeometries) {
             slotPublishGeometries();
             taskInitComponent.createObject(taskItem);
         }
     }
 
     onItemIndexChanged: {
         if (itemIndex>=0) {
             lastValidTimer.start();
         }
     }
 
     onIsDraggedChanged: {
         if(isDragged && (!root.inConfigureAppletsMode)){
             root.dragSource = taskItem;
             dragHelper.startDrag(taskItem, model.MimeType, model.MimeData,
                                  model.LauncherUrlWithoutIcon, model.decoration);
             pressX = -1;
             pressY = -1;
         }
     }
 
     onIsMinimizedChanged: {
         checkWindowsStates();
     }
 
     onIsActiveChanged: {
         checkWindowsStates();
         if (isActive) {
             scrollableList.focusOn(taskItem);
         }
     }
 
     onIsSeparatorChanged: {
         if (isSeparator) {
             if (tasksExtendedManager.isLauncherToBeMoved(launcherUrl) && itemIndex>=0) {
                 tasksExtendedManager.moveLauncherToCorrectPos(launcherUrl, itemIndex);
             }
         }
     }
 
     onLauncherUrlChanged: updateBadge();
 
     ////// End of Values Changes /////
 
 
     ///////////////// Mouse Area Events ///////////////////
     onEntered: {
         taskItem.parabolic.stopRestoreZoomTimer();
 
         restoreAnimation.stop();
 
         if ((taskItem.parabolic.local.lastIndex !== itemIndex) && isLauncher && windowsPreviewDlg.visible) {
             windowsPreviewDlg.hide(1);
         }
 
         if (root.latteView && !root.showPreviews && root.titleTooltips){
             showTitleTooltip();
         }
 
         //! show previews if enabled
         if(isAbleToShowPreview && ((root.showPreviews && windowsPreviewDlg.activeItem !== taskItem) || root.highlightWindows)){
             if (hoveredTimerObj) {
                 //! don't delay showing preview in normal states,
                 //! that is when the dock wasn't hidden
                 if (!hoveredTimerObj.running) {
                     hoveredTimerObj.start();
                 }
             } else {
                 if (!root.disableAllWindowsFunctionality) {
                     hoveredTimerObj = hoveredTimerComponent.createObject(taskItem);
                 }
             }
         }
 
         if (root.autoScrollTasksEnabled) {
             scrollableList.autoScrollFor(taskItem, false);
         }
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
     }
 
     // IMPORTANT: This must be improved ! even for small milliseconds  it reduces performance
     onExited: {
         scalesUpdatedOnce = false;
         isAbleToShowPreview = true;
 
         if (root.latteView && (!root.showPreviews || (root.showPreviews && isLauncher))){
             root.latteView.hideTooltipLabel();
         }
 
         if (root.showPreviews) {
             root.hidePreview(17.5);
         }
 
         if (taskItem.parabolic.factor.zoom>1){
             taskItem.parabolic.startRestoreZoomTimer();
         }
     }
 
     //! mouseX-Y values are delayed to be updated onEntered events and at the same time
     //! onPositionChanged signal may be delayed. we can fix this by don't delay at all
     //! when mouseX-Y is updated based on the plasmoid formFactor
     function mousePosChanged(mousePos) {
         if (mousePos<0 ||
                 (inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             var rapidMovement = taskItem.parabolic.local.lastIndex>=0 && Math.abs(taskItem.parabolic.local.lastIndex-itemIndex)>1;
 
             if (rapidMovement) {
                 taskItem.parabolic.setDirectRenderingEnabled(true);
             }
 
             if( ((wrapper.mScale == 1 || wrapper.mScale === taskItem.parabolic.factor.zoom) && !taskItem.parabolic.directRenderingEnabled)
                     || taskItem.parabolic.directRenderingEnabled || !scalesUpdatedOnce) {
                 if(root.dragSource == null){
                     var step = Math.abs(icList.currentSpot-mousePos);
                     if (step >= taskItem.animations.hoverPixelSensitivity){
                         icList.currentSpot = mousePos;
 
                         wrapper.calculateParabolicScales(mousePos);
                     }
                 }
             }
         }
     }
 
     onMouseXChanged: {
         if (!root.vertical) {
             mousePosChanged(mouseX);
         }
     }
 
     onMouseYChanged: {
         if (root.vertical) {
             mousePosChanged(mouseY);
         }
     }
 
 
 
     onPositionChanged: {
         if ((inBlockingAnimation && !(inAttentionAnimation||inFastRestoreAnimation||inMimicParabolicAnimation)))
             return;
 
         if (root.latteView && root.latteView.isHalfShown) {
             return;
         }
 
         if((inAnimation == false)&&(!root.taskInAnimation)&&(!root.disableRestoreZoom) && hoverEnabled){
             // mouse.button is always 0 here, hence checking with mouse.buttons
             if (pressX != -1 && mouse.buttons == Qt.LeftButton
                     && isDragged
                     && dragHelper.isDrag(pressX, pressY, mouse.x, mouse.y) ) {
                 root.dragSource = taskItem;
                 dragHelper.startDrag(taskItem, model.MimeType, model.MimeData,
                                      model.LauncherUrlWithoutIcon, model.decoration);
                 pressX = -1;
                 pressY = -1;
             }
         }
     }
 
     onContainsMouseChanged:{
         if(!containsMouse && !inAnimation) {
             pressed=false;
         }
 
         ////disable hover effect///
         if (isWindow && root.highlightWindows && !containsMouse) {
             root.windowsHovered( root.plasma515 ? model.WinIdList : model.LegacyWinIdList , false);
         }
     }
 
     onPressed: {
         //console.log("Pressed Task Delegate..");
         if (LatteCore.WindowSystem.compositingActive && !LatteCore.WindowSystem.isPlatformWayland) {
             if(root.leftClickAction !== LatteTasks.Types.PreviewWindows) {
                 isAbleToShowPreview = false;
                 windowsPreviewDlg.hide(2);
             }
         }
 
         slotPublishGeometries();
 
         var modAccepted = modifierAccepted(mouse);
 
         if ((mouse.button == Qt.LeftButton)||(mouse.button == Qt.MidButton) || modAccepted) {
             lastButtonClicked = mouse.button;
             pressed = true;
             pressX = mouse.x;
             pressY = mouse.y;
 
             if(draggingResistaner == null && !modAccepted)
                 draggingResistaner = resistanerTimerComponent.createObject(taskItem);
         }
         else if (mouse.button == Qt.RightButton && !modAccepted){
             // When we're a launcher, there's no window controls, so we can show all
             // places without the menu getting super huge.
             if (model.IsLauncher === true && !isSeparator) {
                 showContextMenu({showAllPlaces: true})
             } else {
                 showContextMenu();
             }
         }
     }
 
     onReleased: {
         //console.log("Released Task Delegate...");
         if (draggingResistaner != null){
             draggingResistaner.destroy();
             draggingResistaner = null;
         }
 
         if(pressed && (!inBlockingAnimation || inAttentionAnimation) && !isSeparator){
 
             if (modifierAccepted(mouse) && !root.disableAllWindowsFunctionality){
                 if( !taskItem.isLauncher ){
                     if (root.modifierClickAction == LatteTasks.Types.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.modifierClickAction == LatteTasks.Types.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.modifierClickAction == LatteTasks.Types.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.modifierClickAction == LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.modifierClickAction == LatteTasks.Types.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.MidButton && !root.disableAllWindowsFunctionality){
                 if( !taskItem.isLauncher ){
                     if (root.middleClickAction == LatteTasks.Types.NewInstance) {
                         tasksModel.requestNewInstance(modelIndex());
                     } else if (root.middleClickAction == LatteTasks.Types.Close) {
                         tasksModel.requestClose(modelIndex());
                     } else if (root.middleClickAction == LatteTasks.Types.ToggleMinimized) {
                         tasksModel.requestToggleMinimized(modelIndex());
                     } else if ( root.middleClickAction == LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     } else if (root.middleClickAction == LatteTasks.Types.ToggleGrouping) {
                         tasksModel.requestToggleGrouping(modelIndex());
                     }
                 } else {
                     activateTask();
                 }
             } else if (mouse.button == Qt.LeftButton){
                 if( !taskItem.isLauncher && !root.disableAllWindowsFunctionality ){
                     if ( (root.leftClickAction === LatteTasks.Types.PreviewWindows && isGroupParent)
                             || ( (LatteCore.WindowSystem.isPlatformWayland || !LatteCore.WindowSystem.compositingActive)
                                 && root.leftClickAction === LatteTasks.Types.PresentWindows
                                 && isGroupParent) ) {
                         if(windowsPreviewDlg.activeItem !== taskItem || !windowsPreviewDlg.visible){
                             showPreviewWindow();
                         } else {
                             root.forcePreviewsHiding(21.1);
                         }
                     } else if ( (root.leftClickAction === LatteTasks.Types.PresentWindows && !(isGroupParent && !LatteCore.WindowSystem.compositingActive))
                                || ((root.leftClickAction === LatteTasks.Types.PreviewWindows && !isGroupParent)) ) {
                         activateTask();
                     } else if (root.leftClickAction === LatteTasks.Types.CycleThroughTasks) {
                         if (isGroupParent)
                             subWindows.activateNextTask();
                         else
                             activateTask();
                     }
                 } else {
                     activateTask();
                 }
             }
 
             backend.cancelHighlightWindows();
         }
 
         pressed = false;
     }
 
     onWheel: {
         var wheelActionsEnabled = (root.taskScrollAction !== LatteTasks.Types.ScrollNone || manualScrollTasksEnabled);
 
         if (isSeparator
                 || wheelIsBlocked
                 || !wheelActionsEnabled
                 || inBouncingAnimation
                 || (latteView && (latteView.dockIsHidden || latteView.inSlidingIn || latteView.inSlidingOut))){
 
             return;
         }
 
         var angleVertical = wheel.angleDelta.y / 8;
         var angleHorizontal = wheel.angleDelta.x / 8;
 
         wheelIsBlocked = true;
         scrollDelayer.start();
 
         var verticalDirection = (Math.abs(angleVertical) > Math.abs(angleHorizontal));
         var mainAngle = verticalDirection ? angleVertical : angleHorizontal;
 
         var positiveDirection = (mainAngle > 12);
         var negativeDirection = (mainAngle < -12);
 
         var parallelScrolling = (verticalDirection && plasmoid.formFactor === PlasmaCore.Types.Vertical)
                 || (!verticalDirection && plasmoid.formFactor === PlasmaCore.Types.Horizontal);
 
         if (positiveDirection) {
             slotPublishGeometries();
 
             var overflowScrollingAccepted = (root.manualScrollTasksEnabled
                                              && scrollableList.contentsExceed
                                              && (root.manualScrollTasksType === LatteTasks.Types.ManualScrollVerticalHorizontal
                                                  || (root.manualScrollTasksType === LatteTasks.Types.ManualScrollOnlyParallel && parallelScrolling)) );
 
 
             if (overflowScrollingAccepted) {
                 scrollableList.decreasePos();
             } else {
                 if (isLauncher || root.disableAllWindowsFunctionality) {
                     wrapper.runLauncherAnimation();
                 } else if (isGroupParent) {
                     subWindows.activateNextTask();
                 } else {
                     var taskIndex = modelIndex();
 
                     if (isMinimized) {
                         tasksModel.requestToggleMinimized(taskIndex);
                     }
 
                     tasksModel.requestActivate(taskIndex);
                 }
 
                 // hidePreviewWindow();
             }
         } else if (negativeDirection) {
             slotPublishGeometries();
 
             var overflowScrollingAccepted = (root.manualScrollTasksEnabled
                                              && scrollableList.contentsExceed
                                              && (root.manualScrollTasksType === LatteTasks.Types.ManualScrollVerticalHorizontal
                                                  || (root.manualScrollTasksType === LatteTasks.Types.ManualScrollOnlyParallel && parallelScrolling)) );
 
 
             if (overflowScrollingAccepted) {
                 scrollableList.increasePos();
             } else {
                 if (isLauncher || root.disableAllWindowsFunctionality) {
                     // do nothing
                 } else if (isGroupParent) {
                     if (root.taskScrollAction === LatteTasks.Types.ScrollToggleMinimized) {
                         subWindows.minimizeTask();
                     } else {
                         subWindows.activatePreviousTask();
                     }
                 } else {
                     var taskIndex = modelIndex();
 
                     var hidingTask = (!isMinimized && root.taskScrollAction === LatteTasks.Types.ScrollToggleMinimized);
 
                     if (isMinimized || hidingTask) {
                         tasksModel.requestToggleMinimized(taskIndex);
                     }
 
                     if (!hidingTask) {
                         tasksModel.requestActivate(taskIndex);
                     }
                 }
 
                 // hidePreviewWindow();
             }
         }
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
 
         interval: 400
 
         onTriggered: taskItem.wheelIsBlocked = false;
     }
 
     ///////////////// End Of Mouse Area Events ///////////////////
 
     ///// Handlers for Signals /////
     function animationStarted(){
         //    console.log("Animation started: " + index);
         inAnimation = true;
     }
 
     function animationEnded(){
         //   console.log("Animation ended: " + index);
         inAnimation = false;
     }
 
     function sltClearZoom(){
         restoreAnimation.start();
     }
 
     function handlerDraggingFinished(){
         isDragged = false;
     }
     ///// End of Handlers //////
 
 
 
     ///// Helper functions /////
     function activateNextTask() {
         subWindows.activateNextTask();
     }
 
     function activateTask() {
         if( taskItem.isLauncher || root.disableAllWindowsFunctionality){
             if (LatteCore.WindowSystem.compositingActive) {
                 wrapper.runLauncherAnimation();
             } else {
                 launcherAction();
             }
         }
         else{
             if (model.IsGroupParent) {
                 if (LatteCore.WindowSystem.compositingActive && backend.canPresentWindows()) {
                     root.presentWindows(root.plasma515 ? model.WinIdList: model.LegacyWinIdList );
                 }
             } else {
                 if (isMinimized) {
                     var i = modelIndex();
                     tasksModel.requestToggleMinimized(i);
                     tasksModel.requestActivate(i);
                 } else if (isActive) {
                     tasksModel.requestToggleMinimized(modelIndex());
                 } else {
                     tasksModel.requestActivate(modelIndex());
                 }
             }
         }
     }
 
     function showPreviewWindow() {
         if (root.disableAllWindowsFunctionality || !isAbleToShowPreview) {
             return;
         }
 
         if(windowsPreviewDlg.activeItem !== taskItem){
             if (!root.latteView
                     || (root.latteView && !root.latteView.isHalfShown && !root.latteView.inSlidingIn && !root.latteView.inSlidingOut)) {
                 if (root.latteView && root.titleTooltips) {
                     root.latteView.hideTooltipLabel();
                 }
 
                 taskItem.preparePreviewWindow(false);
                 windowsPreviewDlg.show(taskItem);
             }
         }
     }
 
     function showTitleTooltip() {
         if (root.latteView && root.titleTooltips){
             var displayText = isWindow ? model.display : model.AppName;
             var maxCharacters = 80;
 
             var fixedDisplayText = displayText.length>maxCharacters ? displayText.substring(0,maxCharacters-1) + "..." : displayText;
 
             root.latteView.showTooltipLabel(taskItem, fixedDisplayText);
         }
     }
 
     function hidePreviewWindow() {
         if(windowsPreviewDlg.activeItem === taskItem){
             windowsPreviewDlg.hide("14.1");
 
             if (root.latteView && root.titleTooltips && containsMouse) {
                 showTitleTooltip();
             }
         }
     }
 
     function preparePreviewWindow(hideClose){
         windowsPreviewDlg.visualParent = previewsVisualParent;
 
         toolTipDelegate.parentTask = taskItem;
 
         //! WORKAROUND, in order for toolTipDelegate to re-instantiate the previews model when
         //! previews are changing from single instance preview to another single instance
         toolTipDelegate.rootIndex = undefined;
         toolTipDelegate.rootIndex = tasksModel.makeModelIndex(itemIndex, -1);
 
         toolTipDelegate.hideCloseButtons = hideClose;
 
         toolTipDelegate.appName = Qt.binding(function() {
             return model.AppName;
         });
 
         if (!isLauncher) {
             toolTipDelegate.pidParent = Qt.binding(function() {
                 return model.AppPid;
             });
         } else {
             toolTipDelegate.pidParent = -1;
         }
 
         toolTipDelegate.windows = Qt.binding(function() {
             return root.plasma515 ? model.WinIdList : model.LegacyWinIdList ;
         });
         toolTipDelegate.isGroup = Qt.binding(function() {
             return model.IsGroupParent == true;
         });
         toolTipDelegate.icon = Qt.binding(function() {
             return model.decoration;
         });
         toolTipDelegate.launcherUrl = Qt.binding(function() {
             return model.LauncherUrlWithoutIcon;
         });
         toolTipDelegate.isLauncher = Qt.binding(function() {
             return model.IsLauncher == true;
         });
         toolTipDelegate.isMinimizedParent = Qt.binding(function() {
             return model.IsMinimized == true;
         });
         toolTipDelegate.displayParent = Qt.binding(function() {
             return model.display;
         });
         toolTipDelegate.genericName = Qt.binding(function() {
             return model.GenericName;
         });
         toolTipDelegate.virtualDesktopParent = Qt.binding(function() {
             return (model.VirtualDesktops !== undefined && model.VirtualDesktops.length > 0) ? model.VirtualDesktops : [0];
         });
         toolTipDelegate.isOnAllVirtualDesktopsParent = Qt.binding(function() {
             return model.IsOnAllVirtualDesktops == true;
         });
         toolTipDelegate.activitiesParent = Qt.binding(function() {
             return model.Activities;
         });
     }
 
 
     function launcherAction(){
         // if ((lastButtonClicked == Qt.LeftButton)||(lastButtonClicked == Qt.MidButton)){
         if (LatteCore.WindowSystem.compositingActive) {
             inBouncingAnimation = true;
             tasksExtendedManager.addWaitingLauncher(taskItem.launcherUrl);
         }
 
         if (root.disableAllWindowsFunctionality) {
             tasksModel.requestNewInstance(modelIndex());
         } else {
             tasksModel.requestActivate(modelIndex());
         }
     }
 
     ///window previews///
     function generateSubText(task) {
         var subTextEntries = new Array();
 
         if (!plasmoid.configuration.showOnlyCurrentDesktop
                 && virtualDesktopInfo.numberOfDesktops > 1
                 && model.IsOnAllVirtualDesktops !== true
                 && model.VirtualDesktop != -1
                 && model.VirtualDesktop != undefined) {
             subTextEntries.push(i18n("On %1", virtualDesktopInfo.desktopNames[model.VirtualDesktop - 1]));
         }
 
         if (model.Activities == undefined) {
             return subTextEntries.join("\n");
         }
 
         if (model.Activities.length == 0 && activityInfo.numberOfRunningActivities > 1) {
             subTextEntries.push(i18nc("Which virtual desktop a window is currently on",
                                       "Available on all activities"));
         } else if (model.Activities.length > 0) {
             var activityNames = new Array();
 
             for (var i = 0; i < model.Activities.length; i++) {
                 var activity = model.Activities[i];
 
                 if (plasmoid.configuration.showOnlyCurrentActivity) {
                     if (activity != activityInfo.currentActivity) {
                         activityNames.push(activityInfo.activityName(model.Activities[i]));
                     }
                 } else if (activity != activityInfo.currentActivity) {
                     activityNames.push(activityInfo.activityName(model.Activities[i]));
                 }
             }
 
             if (plasmoid.configuration.showOnlyCurrentActivity) {
                 if (activityNames.length > 0) {
                     subTextEntries.push(i18nc("Activities a window is currently on (apart from the current one)",
                                               "Also available on %1", activityNames.join(", ")));
                 }
             } else if (activityNames.length > 0) {
                 subTextEntries.push(i18nc("Which activities a window is currently on",
                                           "Available on %1", activityNames.join(", ")));
             }
         }
 
         return subTextEntries.join("\n");
     }
     ///window previews////
 
     function modelIndex(){
         return tasksModel.makeModelIndex(index);
     }
 
     function showContextMenu(args) {
         if (isSeparator && !root.editMode)
             return;
 
         if (!root.contextMenu) {
             contextMenu = root.createContextMenu(taskItem, modelIndex(), args);
             contextMenu.show();
         } else {
             //! make sure that context menu isnt deleted multiple times and creates a crash
             //! bug case: 397635
             var cMenu = root.contextMenu;
             root.contextMenu = null;
             cMenu.destroy();
         }
     }
 
     function modifierAccepted(mouse){
         if (mouse.modifiers & root.modifierQt){
             if ((mouse.button === Qt.LeftButton && root.modifierClick === LatteTasks.Types.LeftClick)
                     || (mouse.button === Qt.MiddleButton && root.modifierClick === LatteTasks.Types.MiddleClick)
                     || (mouse.button === Qt.RightButton && root.modifierClick === LatteTasks.Types.RightClick))
                 return true;
         }
 
         return false;
     }
 
     function setBlockingAnimation(value){
         inBlockingAnimation = value;
     }
 
     function slotMimicEnterForParabolic(){
         if (containsMouse) {
             if (inMimicParabolicAnimation) {
                 mimicParabolicScale = taskItem.parabolic.factor.zoom;
             }
 
             wrapper.calculateParabolicScales(icList.currentSpot);
         }
     }
 
     function slotShowPreviewForTasks(group) {
         if (group === taskItem && !windowsPreviewDlg.visible) {
             preparePreviewWindow(true);
             windowsPreviewDlg.show(taskItem);
         }
     }
 
     function slotPublishGeometries() {
         //! this way we make sure that layouts that are in different activities that the current layout
         //! don't publish their geometries
         if ( canPublishGeometries && (!latteView || root.viewLayoutIsCurrent)) {
             var globalChoords = backend.globalRect(wrapper.visualIconItem);
             var limits = backend.globalRect(scrollableList);
 
             //! Limit the published geometries boundaries at scrolling area boundaries
             var adjX = Math.min(limits.x+limits.width, Math.max(limits.x, globalChoords.x));
             var adjY = Math.min(limits.y+limits.height, Math.max(limits.y, globalChoords.y));
 
             var length = taskItem.metrics.iconSize * wrapper.mScale;
             var thickness = length;
 
             //! Magic Lamp effect doesn't like coordinates outside the screen and
             //! width,heights of zero value... So we now normalize the geometries
             //! sent in order to avoid such circumstances
             if (root.vertical) {
                 if (adjY !== globalChoords.y) {
                     if (((globalChoords.y+globalChoords.height) < limits.y) || (globalChoords.y)>(limits.y+limits.height)) {
                         //! totally out of boundaries
                         length = 4;
                     } else {
                         //! semi-part out of boundaries
                         length = Math.max(4, Math.abs(adjY - globalChoords.y));
                     }
 
                     globalChoords.height = length;
                 }
             } else {
                 if (adjX !== globalChoords.x) {
                     if (((globalChoords.x+globalChoords.width) < limits.x) || (globalChoords.x)>(limits.x+limits.width)) {
                         //! totally out of boundaries
                         length = 4;
                     } else {
                         //! semi-part out of boundaries
                         length = Math.max(4, Math.abs(adjX - globalChoords.x));
                     }
 
                     globalChoords.width = length;
                 }
             }
 
             globalChoords.x = adjX;
             globalChoords.y = adjY;
 
             if (latteView && latteView.dockIsHidden) {
                 if (root.location === PlasmaCore.Types.BottomEdge) {
                     globalChoords.y = root.screenGeometry.y+root.screenGeometry.height-1;
                     globalChoords.height = 1;
                 } else if (root.location === PlasmaCore.Types.TopEdge) {
                     globalChoords.y = root.screenGeometry.y+1;
                     globalChoords.height = 1;
                 } else if (root.location === PlasmaCore.Types.LeftEdge) {
                     globalChoords.x = root.screenGeometry.x+1;
                     globalChoords.width = 1;
                 } else if (root.location === PlasmaCore.Types.RightEdge) {
                     globalChoords.x = root.screenGeometry.x+root.screenGeometry.width - 1;
                     globalChoords.width = 1;
                 }
             }
 
             tasksModel.requestPublishDelegateGeometry(taskItem.modelIndex(), globalChoords, taskItem);
         }
     }
 
     function slotWaitingLauncherRemoved(launch) {
         if ((isWindow || isStartup || isLauncher) && !visible && launch === launcherUrl) {
             wrapper.mScale = 1;
             visible = true;
         }
     }
 
 
     function updateAudioStreams() {
         if (root.dragSource !== null) {
             audioStreams = [];
             return;
         }
 
         var pa = pulseAudio.item;
         if (!pa) {
             audioStreams = [];
             return;
         }
 
         var streams = pa.streamsForPid(taskItem.pid);
         if (streams.length) {
             pa.registerPidMatch(taskItem.appName);
         } else {
             // We only want to fall back to appName matching if we never managed to map
             // a PID to an audio stream window. Otherwise if you have two instances of
             // an application, one playing and the other not, it will look up appName
             // for the non-playing instance and erroneously show an indicator on both.
             if (!pa.hasPidMatch(taskItem.appName)) {
                 var streams_result;
                 streams_result = pa.streamsForAppName(taskItem.appName);
                 if (streams_result.length===0 && launcherName !== "") {
                     streams_result = pa.streamsForAppName(launcherName);
                 }
                 streams = streams_result;
             }
         }
 
         // fix a binding loop concerning audiostreams, the audiostreams
         // should be updated only when they have changed
         var changed = false;
 
         if (streams.length !== audioStreams.length) {
             changed = true;
         } else {
             for(var i=0; i<streams.length; ++i) {
                 if (streams[i] !== audioStreams[i]) {
                     changed = true;
                     break;
                 }
             }
         }
 
         if (changed) {
             taskItem.audioStreams = streams;
         }
     }
 
     function slotLaunchersChangedFor(launcher) {
-        if (root.showWindowsOnlyFromLaunchers && launcher === launcherUrl) {
+        if ((root.showWindowsOnlyFromLaunchers || root.disableAllWindowsFunctionality) && launcher === launcherUrl) {
             updateVisibilityBasedOnLaunchers()
         }
     }
 
     function updateVisibilityBasedOnLaunchers(){
         var launcherExists = !(((tasksModel.launcherPosition(taskItem.launcherUrl) == -1)
                                 && (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) == -1) )
                                || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl));
 
-        if (root.showWindowsOnlyFromLaunchers) {
-            var hideWindow =  !launcherExists && taskItem.isWindow;
+        if (root.showWindowsOnlyFromLaunchers || root.disableAllWindowsFunctionality) {
+            var hideWindow =  !launcherExists && (taskItem.isWindow || root.disableAllWindowsFunctionality);
 
             if (hideWindow) {
                 isForcedHidden = true;
                 taskRealRemovalAnimation.start();
             } else if (launcherExists && taskItem.isWindow && !taskItem.isVisible) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         } else {
             var showWindow =  !launcherExists && taskItem.isWindow;
 
             if (showWindow) {
                 showWindowAnimation.showWindow();
                 isForcedHidden = false;
             }
         }
     }
 
     function toggleMuted() {
         if (muted) {
             taskItem.audioStreams.forEach(function (item) { item.unmute(); });
         } else {
             taskItem.audioStreams.forEach(function (item) { item.mute(); });
         }
     }
 
     function increaseVolume() {
         taskItem.audioStreams.forEach(function (item) { item.increaseVolume(); });
     }
 
     function decreaseVolume() {
         taskItem.audioStreams.forEach(function (item) { item.decreaseVolume(); });
     }
 
     function updateBadge() {
         var badger = root.getBadger(launcherUrl);
 
         if (badger) {
             badgeIndicator = parseInt(badger.value);
         } else {
             badgeIndicator = 0;
         }
     }
 
     Connections {
         target: pulseAudio.item
         ignoreUnknownSignals: true // Plasma-PA might not be available
         onStreamsChanged: taskItem.updateAudioStreams()
     }
 
     Connections {
         target: root
         //trying to fix #440, showing the audio icon indicator to irrelevant tasks
         //after dragging an existent task with audio
         onDragSourceChanged: taskItem.updateAudioStreams()
         onShowAudioBadgeChanged: taskItem.updateAudioStreams()
     }
 
     Connections {
         target: scrollableList
         onAnimationsFinishedChanged: {
             if (scrollableList.animationsFinished) {
                 taskItem.slotPublishGeometries();
             }
         }
     }
 
     Connections {
         target: shortcuts
         onSglActivateEntryAtIndex: {
             if (!taskItem.shortcuts.isEnabled) {
                 return;
             }
 
             var shortcutIndex = taskItem.shortcuts.shortcutIndex(taskItem.itemIndex);
 
             if (shortcutIndex === entryIndex) {
                 if (taskItem.isGroupParent) {
                     taskItem.activateNextTask();
                 } else {
                     taskItem.activateTask();
                 }
             }
         }
 
         onSglNewInstanceForEntryAtIndex: {
             if (!taskItem.shortcuts.isEnabled) {
                 return;
             }
 
             var shortcutIndex = taskItem.shortcuts.shortcutIndex(taskItem.itemIndex);
 
             if (shortcutIndex === entryIndex) {
                 tasksModel.requestNewInstance(taskItem.modelIndex());
             }
         }
     }
 
     Connections {
         target: latteView
         onDockIsHiddenChanged: {
             if (dockIsHidden) {
                 taskItem.slotPublishGeometries();
             }
         }
 
         onDockIsShownCompletelyChanged: {
             if (dockIsShownCompletely) {
                 taskItem.slotPublishGeometries();
             }
         }
     }
 
 
     ///// End of Helper functions ////
 
     Component.onCompleted: {
         root.draggingFinished.connect(handlerDraggingFinished);
         root.publishTasksGeometries.connect(slotPublishGeometries);
         root.showPreviewForTasks.connect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.connect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.connect(slotLaunchersChangedFor);
 
         parabolic.sglClearZoom.connect(sltClearZoom);
 
         var hasShownLauncher = ((tasksModel.launcherPosition(taskItem.launcherUrl) !== -1)
                                 || (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) !== -1) );
 
         //startup without launcher
         var hideStartup =  ((!hasShownLauncher || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl))
                             && taskItem.isStartup);
 
         if (!LatteCore.WindowSystem.compositingActive) {
             visible = true;
         } else if ( (isWindow || isStartup || isLauncher) && tasksExtendedManager.waitingLauncherExists(launcherUrl)) {
             tasksExtendedManager.waitingLauncherRemoved.connect(slotWaitingLauncherRemoved);
             visible = false;
         } else if (hideStartup){
             visible = false;
         } else {
             visible = true;
         }
 
         showWindowAnimation.showWindow();
         updateAudioStreams();
     }
 
     Component.onDestruction: {
         root.draggingFinished.disconnect(handlerDraggingFinished);
         root.publishTasksGeometries.disconnect(slotPublishGeometries);
         root.showPreviewForTasks.disconnect(slotShowPreviewForTasks);
         root.mimicEnterForParabolic.disconnect(slotMimicEnterForParabolic);
         root.launchersUpdatedFor.disconnect(slotLaunchersChangedFor);
 
         parabolic.sglClearZoom.disconnect(sltClearZoom);
 
         tasksExtendedManager.waitingLauncherRemoved.disconnect(slotWaitingLauncherRemoved);
 
         wrapper.sendEndOfNeedBothAxisAnimation();
     }
 
     /////Animations
 
     TaskAnimations.ShowWindowAnimation{ id: showWindowAnimation }
 
     TaskAnimations.RestoreAnimation{ id: restoreAnimation }
 
     //A Timer to check how much time the task is hovered in order to check if we must
     //show window previews
     Component {
         id: hoveredTimerComponent
         Timer {
             id: hoveredTimer
 
             interval: Math.max(150,plasmoid.configuration.previewsDelay)
 
             repeat: false
 
             onTriggered: {
                 if (root.disableAllWindowsFunctionality || !isAbleToShowPreview) {
                     return;
                 }
 
                 if (taskItem.containsMouse) {
                     if (root.showPreviews) {
                         showPreviewWindow();
                     }
 
                     if (taskItem.isWindow && root.highlightWindows) {
                         root.windowsHovered( root.plasma515 ? model.WinIdList : model.LegacyWinIdList , taskItem.containsMouse);
                     }
                 }
 
                 hoveredTimer.destroy();
             }
 
             Component.onCompleted: hoveredTimer.start()
         }
     }
 
 
     //A Timer to help in resist a bit to dragging, the user must try
     //to press a little first before dragging Started
     Component {
         id: resistanerTimerComponent
         Timer {
             id: resistanerTimer
             interval: taskItem.resistanceDelay
             repeat: false
 
             onTriggered: {
                 if (!taskItem.inBlockingAnimation){
                     taskItem.isDragged = true;
                 }
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: resistanerTimer called...");
                 }
 
                 resistanerTimer.destroy();
             }
 
             Component.onCompleted: resistanerTimer.start()
         }
     }
 
     ///trying to compete with the crazy situation in the tasksModel
     ///with launchers and startups... There are windows that stay
     ///startup mode e.g. chrome, libreoffice... not showing startups
     ///the user can lose windows...
     ///Based on the animations, windows are shown directly, startups
     ///are shown after 5secs of existence, and launchers after 200ms
     ///for launchers this is set in order to give to a window the time
     ///to disappear and then show the launcher...
 
 
     //   property int mainDelay: IsLauncher ? 800 : 400
     //   property int mainDelay: icList.delayingRemoval ? 2*showWindowAnimation.speed : 450
 
     //BE CAREFUL: this interval (e.g. 700ms) must be lower from the removal animation
     //duration e.g.(800ms) because there are situations that because of this some
     //launchers delay A LOT to reappear, e.g google-chrome
     //I will blacklist google-chrome as I have not found any other case for this bug
     //to appear, but even this way there are cases that still appears...
     property int mainDelay: (AppId == "google-chrome") ? 0 : 2 * taskItem.animations.speedFactor.current * showWindowAnimation.speed
     property int windowDelay: taskItem.isStartup ? 3 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large : mainDelay
 
     Component {
         id: delayShowWindow
         Timer {
             id: timerWindow
 
             interval: windowDelay
 
             repeat: false
 
             onTriggered: {
                 //console.log("I am in here: "+taskItem.windowDelay);
                 // showWindowAnimation.execute();
                 if(!taskItem.buffersAreReady)
                     showWindowAnimation.showWindow();
                 else
                     showWindowAnimation.execute();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: timerWindow called...");
                 }
 
                 timerWindow.destroy();
             }
 
             Component.onCompleted: timerWindow.start()
         }
     }
 
     // when changing activities and desktops the index of the tasks
     // is updated immediately to -1, this timer protects this indexing
     // change in order to provide a beautiful removal tasks animation
     Timer {
         id: lastValidTimer
         interval: 100 ///the interval does not follow the animations timing
         repeat: false
 
         onTriggered: {
             if (taskItem.itemIndex >= 0){
                 taskItem.lastValidIndex = taskItem.itemIndex;
             }
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: lastValidTimer called...");
             }
         }
     }
 
     ///Item's Removal Animation
     ListView.onRemove: TaskAnimations.RealRemovalAnimation{ id: taskRealRemovalAnimation }
 
 }// main Item
 
diff --git a/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml b/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml
index 7f4e4463..15e878aa 100644
--- a/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml
+++ b/plasmoid/package/contents/ui/task/animations/RealRemovalAnimation.qml
@@ -1,192 +1,192 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.0
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 
 SequentialAnimation {
     id: taskRealRemovalAnimation
     PropertyAction { target: taskItem; property: "ListView.delayRemove"; value: true }
     PropertyAction { target: taskItem; property: "inAnimation"; value: true }
     PropertyAction { target: taskItem; property: "inAddRemoveAnimation"; value: true }
     PropertyAction { target: taskItem; property: "inRemoveStage"; value: true }
 
     //Animation Add/Remove (1) - when is window with no launcher, animations enabled
     //Animation Add/Remove (4) - the user removes a launcher, animation enabled
     property bool animation1: ((((tasksModel.launcherPosition(taskItem.launcherUrl) === -1)
                                  && (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) === -1) )
                                 || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl))
                                && !taskItem.isStartup && LatteCore.WindowSystem.compositingActive)
 
     property bool animation4: ((taskItem.launcherUrl===root.launcherForRemoval
                                 || taskItem.launcherUrlWithIcon===root.launcherForRemoval )
                                && !taskItem.isStartup && LatteCore.WindowSystem.compositingActive)
 
     property bool enabledAnimation: (animation1 || animation4) && (taskItem.animations.newWindowSlidingEnabled)
                                     && !taskItem.inBouncingAnimation
                                     && !taskItem.isSeparator
                                     && taskItem.visible;
 
     readonly property string needLengthEvent: taskRealRemovalAnimation + "_realremoval"
 
     ScriptAction{
         script:{
             //! When a window is removed and afterwards its launcher must be shown immediately!
             if (!enabledAnimation && taskItem.isWindow && !taskItem.isSeparator
                     && tasksModel.launcherPosition(taskItem.launcherUrl) !== -1
                     && !tasksExtendedManager.immediateLauncherExists(taskItem.launcherUrl)){
                 tasksExtendedManager.addImmediateLauncher(taskItem.launcherUrl);
             }
 
             //trying to fix the ListView nasty behavior
             //during the removal the anchoring for ListView children changes a lot
             var previousTask = icList.childAtIndex(taskItem.lastValidIndex-1);
 
             if (previousTask !== undefined && !previousTask.isStartup && !previousTask.inBouncingAnimation){
                 //! When removing a task and there are surrounding separators then the hidden spacers
                 //! are updated immediately for the neighbour tasks. In such case in order to not break
                 //! the removal animation a small margin must applied
                 var spacer = taskItem.headItemIsSeparator ? -(2+taskItem.metrics.totals.lengthEdge) : ( taskItem.headItemIsSeparator ? (2+taskItem.metrics.totals.lengthEdge)/2 : 0);
 
                 if (root.vertical) {
                     taskItem.anchors.top = previousTask.bottom;
                     taskItem.anchors.topMargin = spacer;
                 } else {
                     taskItem.anchors.left = previousTask.right;
                     taskItem.anchors.leftMargin = spacer;
                 }
             }
 
             // console.log("1." + taskItem.launcherUrl + " - " + taskRealRemovalAnimation.enabledAnimation);
             // console.log("2." + root.launcherForRemoval + " - " + taskItem.isLauncher);
 
             taskItem.animations.needLength.addEvent(needLengthEvent);
 
             if (wrapper.mScale > 1 && !taskRealRemovalAnimation.enabledAnimation
                     && !taskItem.inBouncingAnimation && LatteCore.WindowSystem.compositingActive) {
                 tasksExtendedManager.setFrozenTask(taskItem.launcherUrl, wrapper.mScale);
             }
         }
     }
 
     //Ghost animation that acts as a delayer in case there is a bouncing animation
     //taking place
     PropertyAnimation {
         target: wrapper
         property: "opacity"
         to: 1
 
         //this duration must be a bit less than the bouncing animation. Otherwise the
         //smooth transition between removals is breaking
         duration:  taskItem.inBouncingAnimation  && !taskItem.isSeparator? 4*launcherSpeedStep + 50 : 0
         easing.type: Easing.InQuad
 
         property int launcherSpeedStep: 0.8 * taskItem.animations.speedFactor.current * taskItem.animations.duration.large
     }
     //end of ghost animation
 
     PropertyAnimation {
         target: wrapper
         property: "mScale"
         to: 1
         duration:  taskRealRemovalAnimation.enabledAnimation ? showWindowAnimation.speed : 0
         easing.type: Easing.InQuad
     }
 
     //PropertyAction { target: wrapper; property: "opacity"; value: isWindow ? 0 : 1 }
     //animation mainly for launchers removal and startups
     ParallelAnimation{
         id: removalAnimation
 
         // property int speed: (IsStartup && !taskItem.visible)? 0 : 400
         //property int speed: 400
         NumberAnimation {
             target: wrapper;
             property: "opacity";
             to: 0;
             duration: taskRealRemovalAnimation.enabledAnimation ? 1.35*showWindowAnimation.speed : 0
             easing.type: Easing.InQuad
         }
 
         PropertyAnimation {
             target: wrapper
             property: (icList.orientation === Qt.Vertical) ? "tempScaleWidth" : "tempScaleHeight"
             to: 0
             duration:  taskRealRemovalAnimation.enabledAnimation ? 1.35*showWindowAnimation.speed : 0
             easing.type: Easing.InQuad
         }
     }
 
     //smooth move into place the surrounding tasks
     PropertyAnimation {
         target: wrapper
         property: (icList.orientation === Qt.Vertical) ? "tempScaleHeight" : "tempScaleWidth"
         to: 0
         duration:  taskRealRemovalAnimation.enabledAnimation ? 1.35*showWindowAnimation.speed : 0
         easing.type: Easing.InQuad
     }
 
     ScriptAction{
         script:{
             if (showWindowAnimation.animationSent){
                 //console.log("SAFETY REMOVAL 1: animation removing ended");
                 showWindowAnimation.animationSent = false;
                 taskItem.animations.needLength.removeEvent(showWindowAnimation.needLengthEvent);
             }
 
             taskItem.animations.needLength.removeEvent(needLengthEvent);
 
             if(taskItem.launcherUrl===root.launcherForRemoval && taskItem.isLauncher)
                 root.launcherForRemoval="";
 
             if (windowsPreviewDlg.visible && windowsPreviewDlg.mainItem.parentTask === taskItem
                     && isWindow && !isGroupParent){
                 hidePreview();
             }
 
-            if (root.showWindowsOnlyFromLaunchers) {
+            if (root.showWindowsOnlyFromLaunchers || root.disableAllWindowsFunctionality) {
                 if (root.vertical) {
                     taskItem.anchors.top = undefined;
                     taskItem.anchors.topMargin = 0;
                 } else {
                     taskItem.anchors.left = undefined;
                     taskItem.anchors.leftMargin = 0;
                 }
             }
 
             taskItem.visible = false;
 
             //send signal that the launcher is really removing
             if (taskItem.inBouncingAnimation) {
                 tasksExtendedManager.removeWaitingLauncher(taskItem.launcherUrl);
                 taskItem.parabolic.setDirectRenderingEnabled(false);
             }
         }
     }
 
     PropertyAction { target: taskItem; property: "inAnimation"; value: false }
     PropertyAction { target: taskItem; property: "inAddRemoveAnimation"; value: false }
     PropertyAction { target: taskItem; property: "inRemoveStage"; value: false }
 
     PropertyAction { target: taskItem; property: "ListView.delayRemove"; value: false }
 }
diff --git a/plasmoid/package/contents/ui/task/animations/ShowWindowAnimation.qml b/plasmoid/package/contents/ui/task/animations/ShowWindowAnimation.qml
index fa472fa0..72d3bf95 100644
--- a/plasmoid/package/contents/ui/task/animations/ShowWindowAnimation.qml
+++ b/plasmoid/package/contents/ui/task/animations/ShowWindowAnimation.qml
@@ -1,206 +1,206 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.0
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte.core 0.2 as LatteCore
 
 ///item's added Animation
 SequentialAnimation{
     id:showWindowAnimation
     property int speed: taskItem.animations.newWindowSlidingEnabled ? (1.2 * taskItem.animations.speedFactor.normal * taskItem.animations.duration.large) : 0
     property bool animationSent: false
 
     readonly property string needLengthEvent: showWindowAnimation + "_showwindow"
 
     //Ghost animation that acts as a delayer, in order to fix #342
     PropertyAnimation {
         target: wrapper
         property: "opacity"
         to: 0
         //it is not depend to durationTime when animations are active
         duration: taskItem.animations.newWindowSlidingEnabled ? 750 : 0
         easing.type: Easing.InQuad
     }
     //end of ghost animation
 
     ScriptAction{
         script:{
             if (!showWindowAnimation.animationSent) {
                 showWindowAnimation.animationSent = true;
                 taskItem.animations.needLength.addEvent(needLengthEvent);
             }
         }
     }
 
     PropertyAnimation {
         target: wrapper
         property: (icList.orientation == Qt.Vertical) ? "tempScaleHeight" : "tempScaleWidth"
         to: 1
         duration: showWindowAnimation.speed
         easing.type: Easing.OutQuad
     }
 
     ParallelAnimation{
 
         PropertyAnimation {
             target: wrapper
             property: (icList.orientation == Qt.Vertical) ? "tempScaleWidth" : "tempScaleHeight"
             to: 1
             duration: showWindowAnimation.speed
             easing.type: Easing.OutQuad
         }
 
 
         PropertyAnimation {
             target: wrapper
             property: "opacity"
             from: 0
             to: 1
             duration: showWindowAnimation.speed
             easing.type: Easing.OutQuad
         }
     }
 
     onStopped: {
         taskItem.inAddRemoveAnimation = false;
 
         if (tasksExtendedManager.toBeAddedLauncherExists(taskItem.launcherUrl)) {
             tasksExtendedManager.removeToBeAddedLauncher(taskItem.launcherUrl);
         }
 
         if(taskItem.isWindow || taskItem.isStartup){
             taskInitComponent.createObject(wrapper);
             if (taskItem.isDemandingAttention){
                 taskItem.groupWindowAdded();
             }
         }
         taskItem.inAnimation = false;
 
         if (showWindowAnimation.animationSent) {
             taskItem.animations.needLength.removeEvent(needLengthEvent);
             showWindowAnimation.animationSent = false;
         }
     }
 
     function execute(){
         //trying to fix the ListView nasty behavior
         //during the removal the anchoring for ListView children changes a lot
         if (isWindow){
             var previousTask = icList.childAtIndex(index-1);
             var nextTask = icList.childAtIndex(index+1);
             if (previousTask !== undefined && nextTask !== undefined && nextTask.inBouncingAnimation){
                 if (root.vertical) {
                     taskItem.anchors.top = previousTask.bottom;
                 } else {
                     taskItem.anchors.left = previousTask.right;
                 }
             }
         }
 
         var hasShownLauncher = ((tasksModel.launcherPosition(taskItem.launcherUrl) !== -1)
                                     || (tasksModel.launcherPosition(taskItem.launcherUrlWithIcon) !== -1) );
 
         var launcherIsAlreadyShown = hasShownLauncher && isLauncher && !root.inActivityChange && !tasksExtendedManager.toBeAddedLauncherExists(taskItem.launcherUrl) ;
 
         //Animation Add/Remove (2) - when is window with no launcher, animations enabled
         //Animation Add/Remove (3) - when is launcher with no window, animations enabled
         var animation2 = ((!hasShownLauncher || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl))
                           && taskItem.isWindow
                           && LatteCore.WindowSystem.compositingActive);
 
         var animation3 = (!tasksExtendedManager.immediateLauncherExists(taskItem.launcherUrl)
                           && taskItem.isLauncher
                           && LatteCore.WindowSystem.compositingActive);
 
         var activities = tasksModel.launcherActivities(taskItem.launcherUrl);
         var animation6 = (root.inActivityChange && taskItem.isWindow
                           && activities.indexOf(activityInfo.currentActivity)>=0
                           && activities.indexOf(activityInfo.previousActivity) === -1
                           && LatteCore.WindowSystem.compositingActive);
 
 
         //startup without launcher, animation should be blocked
         var launcherExists = !(!hasShownLauncher || !tasksModel.launcherInCurrentActivity(taskItem.launcherUrl));
 
         //var hideStartup =  launcherExists && taskItem.isStartup; //! fix #976
-        var hideWindow =  root.showWindowsOnlyFromLaunchers && !launcherExists && taskItem.isWindow;
+        var hideWindow =  (root.showWindowsOnlyFromLaunchers || root.disableAllWindowsFunctionality) && !launcherExists && taskItem.isWindow;
 
         if (tasksExtendedManager.immediateLauncherExists(taskItem.launcherUrl) && taskItem.isLauncher) {
             tasksExtendedManager.removeImmediateLauncher(taskItem.launcherUrl);
         }
 
         //if (hideStartup || hideWindow) { //fix #976
         if (hideWindow) {
             isForcedHidden = true;
             taskItem.visible = false;
             wrapper.tempScaleWidth = 0;
             wrapper.tempScaleHeight = 0;
             wrapper.opacity = 0;
             taskItem.inAnimation = false;
         } else if (!LatteCore.WindowSystem.compositingActive || root.inDraggingPhase
                    || taskItem.isSeparator) {
             isForcedHidden = false;
             taskItem.visible = true;
             wrapper.tempScaleWidth = 1;
             wrapper.tempScaleHeight = 1;
             wrapper.mScale = 1;
             wrapper.opacity = 1;
             taskItem.inAnimation = false;
         } else if (( animation2 || animation3 || animation6 || isForcedHidden)
                    && (taskItem.animations.speedFactor.current !== 0) && !launcherIsAlreadyShown){
             isForcedHidden = false;
             taskItem.visible = true;
             wrapper.tempScaleWidth = 0;
             wrapper.tempScaleHeight = 0;
             start();
         } else {
             isForcedHidden = false;
             var frozenTask = tasksExtendedManager.getFrozenTask(taskItem.launcherUrl);
 
             if (frozenTask && frozenTask.mScale>1) {
                 wrapper.mScale = frozenTask.mScale;
                 tasksExtendedManager.removeFrozenTask(taskItem.launcherUrl);
             } else {
                 wrapper.tempScaleWidth = 1;
                 wrapper.tempScaleHeight = 1;
             }
 
             //! by enabling it we break the bouncing animation
             //taskItem.visible = true;
             wrapper.opacity = 1;
             taskItem.inAnimation = false;
         }
     }
 
     function showWindow(){
         execute();
     }
 
     Component.onDestruction: {
         if (animationSent){
             //console.log("SAFETY REMOVAL 2: animation removing ended");
             animationSent = false;
             taskItem.animations.needLength.removeEvent(needLengthEvent);
         }
     }
 }