diff --git a/app/view/containmentinterface.cpp b/app/view/containmentinterface.cpp
index 02d836ef..22a9457c 100644
--- a/app/view/containmentinterface.cpp
+++ b/app/view/containmentinterface.cpp
@@ -1,579 +1,579 @@
 /*
 *  Copyright 2019  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 "containmentinterface.h"
 
 // local
 #include "view.h"
 #include "../lattecorona.h"
 #include "../layout/genericlayout.h"
 #include "../settings/universalsettings.h"
 
 // Qt
 #include <QDebug>
 
 // Plasma
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 #include <PlasmaQuick/AppletQuickItem>
 
 // KDE
 #include <KLocalizedString>
 #include <KPluginMetaData>
 
 namespace Latte {
 namespace ViewPart {
 
 ContainmentInterface::ContainmentInterface(Latte::View *parent)
     : QObject(parent),
       m_view(parent)
 {
     m_corona = qobject_cast<Latte::Corona *>(m_view->corona());
 
-    m_tasksModel = new TasksModel(this);
+    m_latteTasksModel = new TasksModel(this);
 
     m_appletsExpandedConnectionsTimer.setInterval(2000);
     m_appletsExpandedConnectionsTimer.setSingleShot(true);
 
     connect(&m_appletsExpandedConnectionsTimer, &QTimer::timeout, this, &ContainmentInterface::updateAppletsTracking);
 
     connect(m_view, &View::containmentChanged
             , this, [&]() {
         if (m_view->containment()) {
             connect(m_view->containment(), &Plasma::Containment::appletAdded, this, &ContainmentInterface::updateAppletsTracking);
 
             m_appletsExpandedConnectionsTimer.start();
         }
     });
 }
 
 ContainmentInterface::~ContainmentInterface()
 {
 }
 
 void ContainmentInterface::identifyMainItem()
 {
     if (m_mainItem) {
         return;
     }
 
     if (QQuickItem *graphicItem = m_view->containment()->property("_plasma_graphicObject").value<QQuickItem *>()) {
         const auto &childItems = graphicItem->childItems();
 
         for (QQuickItem *item : childItems) {
             if (item->objectName() == "containmentViewLayout" ) {
                 m_mainItem = item;
                 identifyMethods();
                 return;
             }
         }
     }
 }
 
 void ContainmentInterface::identifyMethods()
 {
     int aeIndex = m_mainItem->metaObject()->indexOfMethod("activateEntryAtIndex(QVariant)");
     int niIndex = m_mainItem->metaObject()->indexOfMethod("newInstanceForEntryAtIndex(QVariant)");
     int sbIndex = m_mainItem->metaObject()->indexOfMethod("setShowAppletShortcutBadges(QVariant,QVariant,QVariant,QVariant)");
     int afiIndex = m_mainItem->metaObject()->indexOfMethod("appletIdForIndex(QVariant)");
 
     m_activateEntryMethod = m_mainItem->metaObject()->method(aeIndex);
     m_appletIdForIndexMethod = m_mainItem->metaObject()->method(afiIndex);
     m_newInstanceMethod = m_mainItem->metaObject()->method(niIndex);
     m_showShortcutsMethod = m_mainItem->metaObject()->method(sbIndex);
 }
 
 bool ContainmentInterface::applicationLauncherHasGlobalShortcut() const
 {
     if (!containsApplicationLauncher()) {
         return false;
     }
 
     uint launcherAppletId = applicationLauncherId();
 
     const auto applets = m_view->containment()->applets();
 
     for (auto applet : applets) {
         if (applet->id() == launcherAppletId) {
             return !applet->globalShortcut().isEmpty();
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::applicationLauncherInPopup() const
 {
     if (!containsApplicationLauncher()) {
         return false;
     }
 
     uint launcherAppletId = applicationLauncherId();
     QString launcherPluginId;
 
     const auto applets = m_view->containment()->applets();
 
     for (auto applet : applets) {
         if (applet->id() == launcherAppletId) {
             launcherPluginId = applet->kPackage().metadata().pluginId();
         }
     }
 
     return launcherPluginId != "org.kde.plasma.kickerdash";
 }
 
 bool ContainmentInterface::containsApplicationLauncher() const
 {
     return (applicationLauncherId() >= 0);
 }
 
 bool ContainmentInterface::isCapableToShowShortcutBadges()
 {
     identifyMainItem();
 
     if (!m_view->latteTasksArePresent() && m_view->tasksPresent()) {
         return false;
     }
 
     return m_showShortcutsMethod.isValid();
 }
 
 int ContainmentInterface::applicationLauncherId() const
 {
     const auto applets = m_view->containment()->applets();
 
     auto launcherId{-1};
 
     for (auto applet : applets) {
         const auto provides = applet->kPackage().metadata().value(QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.launchermenu"))) {
             if (!applet->globalShortcut().isEmpty()) {
                 return applet->id();
             } else if (launcherId == -1) {
                 launcherId = applet->id();
             }
         }
     }
 
     return launcherId;
 }
 
 bool ContainmentInterface::updateBadgeForLatteTask(const QString identifier, const QString value)
 {
     if (!m_view->latteTasksArePresent()) {
         return false;
     }
 
     const auto &applets = m_view->containment()->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("updateBadge(QVariant,QVariant)");
 
                         if (methodIndex == -1) {
                             continue;
                         }
 
                         QMetaMethod method = metaObject->method(methodIndex);
 
                         if (method.invoke(item, Q_ARG(QVariant, identifier), Q_ARG(QVariant, value))) {
                             return true;
                         }
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::activatePlasmaTask(const int index)
 {
     bool containsPlasmaTaskManager{m_view->tasksPresent() && !m_view->latteTasksArePresent()};
 
     if (!containsPlasmaTaskManager) {
         return false;
     }
 
     const auto &applets = m_view->containment()->applets();
 
     for (auto *applet : applets) {
         const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                 const auto &childItems = appletInterface->childItems();
 
                 if (childItems.isEmpty()) {
                     continue;
                 }
 
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 for (QQuickItem *item : childItems) {
                     if (auto *metaObject = item->metaObject()) {
                         int methodIndex{metaObject->indexOfMethod("activateTaskAtIndex(QVariant)")};
 
                         if (methodIndex == -1) {
                             continue;
                         }
 
                         QMetaMethod method = metaObject->method(methodIndex);
 
                         if (method.invoke(item, Q_ARG(QVariant, index - 1))) {
                             showShortcutBadges(false, true);
 
                             return true;
                         }
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::newInstanceForPlasmaTask(const int index)
 {
     bool containsPlasmaTaskManager{m_view->tasksPresent() && !m_view->latteTasksArePresent()};
 
     if (!containsPlasmaTaskManager) {
         return false;
     }
 
     const auto &applets = m_view->containment()->applets();
 
     for (auto *applet : applets) {
         const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                 const auto &childItems = appletInterface->childItems();
 
                 if (childItems.isEmpty()) {
                     continue;
                 }
 
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 for (QQuickItem *item : childItems) {
                     if (auto *metaObject = item->metaObject()) {
                         int methodIndex{metaObject->indexOfMethod("ewInstanceForTaskAtIndex(QVariant)")};
 
                         if (methodIndex == -1) {
                             continue;
                         }
 
                         QMetaMethod method = metaObject->method(methodIndex);
 
                         if (method.invoke(item, Q_ARG(QVariant, index - 1))) {
                             showShortcutBadges(false, true);
 
                             return true;
                         }
                     }
                 }
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::activateEntry(const int index)
 {
     identifyMainItem();
 
     if (!m_activateEntryMethod.isValid()) {
         return false;
     }
 
     return m_activateEntryMethod.invoke(m_mainItem, Q_ARG(QVariant, index));
 }
 
 bool ContainmentInterface::newInstanceForEntry(const int index)
 {
     identifyMainItem();
 
     if (!m_newInstanceMethod.isValid()) {
         return false;
     }
 
     return m_newInstanceMethod.invoke(m_mainItem, Q_ARG(QVariant, index));
 }
 
 bool ContainmentInterface::hideShortcutBadges()
 {
     identifyMainItem();
 
     if (!m_showShortcutsMethod.isValid()) {
         return false;
     }
 
     return m_showShortcutsMethod.invoke(m_mainItem, Q_ARG(QVariant, false), Q_ARG(QVariant, false), Q_ARG(QVariant, false), Q_ARG(QVariant, -1));
 }
 
 bool ContainmentInterface::showOnlyMeta()
 {
     if (!m_corona->universalSettings()->kwin_metaForwardedToLatte()) {
         return false;
     }
 
     return showShortcutBadges(false, true);
 }
 
 bool ContainmentInterface::showShortcutBadges(const bool showLatteShortcuts, const bool showMeta)
 {
     identifyMainItem();
 
     if (!m_showShortcutsMethod.isValid() || !isCapableToShowShortcutBadges()) {
         return false;
     }
 
     int appLauncherId = m_corona->universalSettings()->kwin_metaForwardedToLatte() && showMeta ? applicationLauncherId() : -1;
 
     return m_showShortcutsMethod.invoke(m_mainItem, Q_ARG(QVariant, showLatteShortcuts), Q_ARG(QVariant, true), Q_ARG(QVariant, showMeta), Q_ARG(QVariant, appLauncherId));
 }
 
 int ContainmentInterface::appletIdForIndex(const int index)
 {
     identifyMainItem();
 
     if (!m_appletIdForIndexMethod.isValid()) {
         return false;
     }
 
     QVariant appletId{-1};
 
     m_appletIdForIndexMethod.invoke(m_mainItem, Q_RETURN_ARG(QVariant, appletId), Q_ARG(QVariant, index));
 
     return appletId.toInt();
 }
 
 
 void ContainmentInterface::deactivateApplets()
 {
     if (!m_view->containment() || !m_view->inReadyState()) {
         return;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (ai) {
             ai->setExpanded(false);
         }
     }
 }
 
 bool ContainmentInterface::appletIsExpandable(const int id)
 {
     if (!m_view->containment() || !m_view->inReadyState()) {
         return false;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         if (applet && applet->id() == (uint)id) {
             if (m_view->layout() && m_view->layout()->isInternalContainment(applet)) {
                 return true;
             }
 
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 return appletIsExpandable(ai);
             }
         }
     }
 
     return false;
 }
 
 bool ContainmentInterface::appletIsExpandable(PlasmaQuick::AppletQuickItem *appletQuickItem)
 {
     if (!appletQuickItem || !m_view->inReadyState()) {
         return false;
     }
 
     return (appletQuickItem->fullRepresentation() != nullptr
             && appletQuickItem->preferredRepresentation() != appletQuickItem->fullRepresentation());
 }
 
 bool ContainmentInterface::hasExpandedApplet() const
 {
     return m_expandedAppletIds.count() > 0;
 }
 
 void ContainmentInterface::addExpandedApplet(const int &id)
 {
     if (m_expandedAppletIds.contains(id) && appletIsExpandable(id)) {
         return;
     }
 
     bool isExpanded = hasExpandedApplet();
 
     m_expandedAppletIds << id;
 
     if (isExpanded != hasExpandedApplet()) {
         emit hasExpandedAppletChanged();
     }
 
     emit expandedAppletStateChanged();
 }
 
 void ContainmentInterface::removeExpandedApplet(const int &id)
 {
     if (!m_expandedAppletIds.contains(id)) {
         return;
     }
 
     bool isExpanded = hasExpandedApplet();
 
     m_expandedAppletIds.removeAll(id);
 
     if (isExpanded != hasExpandedApplet()) {
         emit hasExpandedAppletChanged();
     }
 
     emit expandedAppletStateChanged();
 }
 
-QAbstractListModel *ContainmentInterface::tasksModel() const
+QAbstractListModel *ContainmentInterface::latteTasksModel() const
 {
-    return m_tasksModel;
+    return m_latteTasksModel;
 }
 
 void ContainmentInterface::on_appletExpandedChanged()
 {
     PlasmaQuick::AppletQuickItem *appletItem = static_cast<PlasmaQuick::AppletQuickItem *>(QObject::sender());
 
     if (appletItem) {
         if (appletItem->isExpanded()) {
             addExpandedApplet(appletItem->applet()->id());
         } else {
             removeExpandedApplet(appletItem->applet()->id());
         }
     }
 }
 
 bool ContainmentInterface::appletIsExpanded(const int id)
 {
     return m_expandedAppletIds.contains(id);
 }
 
 void ContainmentInterface::toggleAppletExpanded(const int id)
 {
     if (!m_view->containment() || !m_view->inReadyState()) {
         return;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         if (applet->id() == (uint)id && !m_view->layout()->isInternalContainment(applet)/*block for internal containments*/) {
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 if (appletIsExpandable(ai)) {
                     ai->setExpanded(!ai->isExpanded());
                 } else {
                     emit applet->activated();
                 }
             }
         }
     }
 }
 
 void ContainmentInterface::updateAppletsTracking()
 {
     if (!m_view->containment()) {
         return;
     }
 
     for (const auto applet : m_view->containment()->applets()) {
         if (m_view->layout() && m_view->layout()->isInternalContainment(applet)) {
             //! internal containment case
             Plasma::Containment *internalC = m_view->layout()->internalContainmentOf(applet);
             PlasmaQuick::AppletQuickItem *contAi = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (contAi && !m_appletsExpandedConnections.contains(contAi)) {
                 m_appletsExpandedConnections[contAi] = connect(contAi, &PlasmaQuick::AppletQuickItem::expandedChanged, this, &ContainmentInterface::on_appletExpandedChanged);
 
                 connect(contAi, &QObject::destroyed, this, [&, contAi](){
                     m_appletsExpandedConnections.remove(contAi);
                     removeExpandedApplet(contAi->applet()->id());
                 });
             }
 
             for (const auto internalApplet : internalC->applets()) {
                 PlasmaQuick::AppletQuickItem *ai = internalApplet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
                 if (ai && !m_appletsExpandedConnections.contains(ai) ){
                     m_appletsExpandedConnections[ai] = connect(ai, &PlasmaQuick::AppletQuickItem::expandedChanged, this, &ContainmentInterface::on_appletExpandedChanged);
 
                     connect(ai, &QObject::destroyed, this, [&, ai](){
                         m_appletsExpandedConnections.remove(ai);
                         removeExpandedApplet(ai->applet()->id());
                     });
                 }
             }
         } else {
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (!ai) {
                 continue;
             }
 
             KPluginMetaData meta = applet->kPackage().metadata();
 
             if (meta.pluginId() == "org.kde.latte.plasmoid") {
-                m_tasksModel->addTask(ai);
+                m_latteTasksModel->addTask(ai);
             } else if (!m_appletsExpandedConnections.contains(ai)) {
                 m_appletsExpandedConnections[ai] = connect(ai, &PlasmaQuick::AppletQuickItem::expandedChanged, this, &ContainmentInterface::on_appletExpandedChanged);
 
                 connect(ai, &QObject::destroyed, this, [&, ai](){
                     m_appletsExpandedConnections.remove(ai);
                     removeExpandedApplet(ai->applet()->id());
                 });
             }
         }
     }
 }
 
 
 }
 }
diff --git a/app/view/containmentinterface.h b/app/view/containmentinterface.h
index e7eb5485..8ff86031 100644
--- a/app/view/containmentinterface.h
+++ b/app/view/containmentinterface.h
@@ -1,130 +1,130 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef VIEWCONTAINMENTINTERFACE_H
 #define VIEWCONTAINMENTINTERFACE_H
 
 // local
 #include "tasksmodel.h"
 
 // Qt
 #include <QMetaMethod>
 #include <QObject>
 #include <QPointer>
 #include <QQuickItem>
 #include <QTimer>
 
 namespace PlasmaQuick {
 class AppletQuickItem;
 }
 
 namespace Latte {
 class Corona;
 class View;
 }
 
 
 namespace Latte {
 namespace ViewPart {
 
 class ContainmentInterface: public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool hasExpandedApplet READ hasExpandedApplet NOTIFY hasExpandedAppletChanged)
 
-    Q_PROPERTY(QAbstractListModel *tasksModel READ tasksModel() NOTIFY tasksModelChanged)
+    Q_PROPERTY(QAbstractListModel *latteTasksModel READ latteTasksModel() NOTIFY latteTasksModelChanged)
 
 public:
     ContainmentInterface(Latte::View *parent);
     virtual ~ContainmentInterface();
 
     bool hasExpandedApplet() const;
 
     bool applicationLauncherInPopup() const;
     bool applicationLauncherHasGlobalShortcut() const;
     bool containsApplicationLauncher() const;
     bool isCapableToShowShortcutBadges();
 
     bool activateEntry(const int index);
     bool newInstanceForEntry(const int index);
 
     bool activatePlasmaTask(const int index);
     bool newInstanceForPlasmaTask(const int index);
 
     bool hideShortcutBadges();
     bool showOnlyMeta();
     bool showShortcutBadges(const bool showLatteShortcuts, const bool showMeta);
 
     //! this is updated from external apps e.g. a thunderbird plugin
     bool updateBadgeForLatteTask(const QString identifier, const QString value);
 
     int applicationLauncherId() const;
     int appletIdForIndex(const int index);
 
-    QAbstractListModel *tasksModel() const;
+    QAbstractListModel *latteTasksModel() const;
 
 public slots:
     Q_INVOKABLE void deactivateApplets();
     Q_INVOKABLE void toggleAppletExpanded(const int id);
 
     Q_INVOKABLE bool appletIsExpandable(const int id);
     Q_INVOKABLE bool appletIsExpanded(const int id);
 
 signals:
     void hasExpandedAppletChanged();
     void expandedAppletStateChanged();
-    void tasksModelChanged();
+    void latteTasksModelChanged();
 
 private slots:
     void identifyMainItem();
     void identifyMethods();
 
     void updateAppletsTracking();
     void on_appletExpandedChanged();
 
 private:
     void addExpandedApplet(const int &id);
     void removeExpandedApplet(const int &id);
 
     bool appletIsExpandable(PlasmaQuick::AppletQuickItem *appletQuickItem);
 
 private:
     QMetaMethod m_activateEntryMethod;
     QMetaMethod m_appletIdForIndexMethod;
     QMetaMethod m_newInstanceMethod;
     QMetaMethod m_showShortcutsMethod;
 
     QPointer<Latte::Corona> m_corona;
     QPointer<Latte::View> m_view;
     QPointer<QQuickItem> m_mainItem;
 
     //! startup timer to initialize
     //! applets tracking
     QTimer m_appletsExpandedConnectionsTimer;
 
-    TasksModel *m_tasksModel;
+    TasksModel *m_latteTasksModel;
 
     QHash<PlasmaQuick::AppletQuickItem *, QMetaObject::Connection> m_appletsExpandedConnections;
     QList<int> m_expandedAppletIds;
 };
 
 }
 }
 
 #endif
diff --git a/app/view/tasksmodel.cpp b/app/view/tasksmodel.cpp
index f8fa2a61..43243d5e 100644
--- a/app/view/tasksmodel.cpp
+++ b/app/view/tasksmodel.cpp
@@ -1,88 +1,97 @@
 /*
 *  Copyright 2020  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 "tasksmodel.h"
 
 // Qt
 #include <QDebug>
 
 namespace Latte {
 namespace ViewPart {
 
 TasksModel::TasksModel(QObject *parent)
     : QAbstractListModel(parent)
 {
 }
 
+int TasksModel::count() const
+{
+    return m_tasks.count();
+}
+
 int TasksModel::rowCount(const QModelIndex &parent) const
 {
     return m_tasks.count();
 }
 
 QVariant TasksModel::data(const QModelIndex &index, int role) const
 {
     bool rowIsValid = (index.row()>=0 && index.row()<m_tasks.count());
     if (!rowIsValid) {
         return QVariant();
     }
 
     if (role == Qt::UserRole) {
         return QVariant::fromValue(m_tasks[index.row()]);
     }
 
     return QVariant();
 }
 
 
 QHash<int, QByteArray> TasksModel::roleNames() const{
     QHash<int, QByteArray> roles;
     roles[Qt::UserRole] = "tasks";
     return roles;
 }
 
 void TasksModel::addTask(QObject *plasmoid)
 {
     if (plasmoid && m_tasks.contains(plasmoid)) {
         return;
     }
 
     beginInsertRows(QModelIndex(), rowCount(), rowCount());
     m_tasks << plasmoid;
     endInsertRows();
 
     connect(plasmoid, &QObject::destroyed, this, [&, plasmoid](){
         removeTask(plasmoid);
     });
+
+    emit countChanged();
 }
 
 void TasksModel::removeTask(QObject *plasmoid)
 {
     if (!plasmoid || (plasmoid && !m_tasks.contains(plasmoid))) {
         return;
     }
 
     int iex = m_tasks.indexOf(plasmoid);
 
     beginRemoveRows(QModelIndex(), iex, iex);
     m_tasks.removeAll(plasmoid);
     endRemoveRows();
+
+    emit countChanged();
 }
 
 }
 }
diff --git a/app/view/tasksmodel.h b/app/view/tasksmodel.h
index b4fd2678..1b0a1e80 100644
--- a/app/view/tasksmodel.h
+++ b/app/view/tasksmodel.h
@@ -1,49 +1,55 @@
 /*
 *  Copyright 2020  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef VIEWTASKSMODEL_H
 #define VIEWTASKSMODEL_H
 
 #include <QAbstractListModel>
 
 namespace Latte {
 namespace ViewPart {
 
 class TasksModel : public QAbstractListModel
 {
     Q_OBJECT
+    Q_PROPERTY(int count READ count NOTIFY countChanged)
 
 public:
     TasksModel(QObject *parent = nullptr);
 
+    int count() const;
+
     int rowCount(const QModelIndex &parent = QModelIndex()) const override;
     QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
     QHash<int, QByteArray> roleNames() const override;
 
    void addTask(QObject *plasmoid);
    void removeTask(QObject *plasmoid);
 
+signals:
+   void countChanged();
+
 private:
     QList<QObject *> m_tasks;
 };
 
 }
 }
 
 #endif
diff --git a/containment/package/contents/ui/Upgrader.qml b/containment/package/contents/ui/Upgrader.qml
index 6cb6084b..eea193de 100644
--- a/containment/package/contents/ui/Upgrader.qml
+++ b/containment/package/contents/ui/Upgrader.qml
@@ -1,113 +1,113 @@
 /*
 *  Copyright 2020  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 import QtQuick 2.1
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 
 Item{
     Component.onCompleted:  {
         v010_upgrade();
     }
 
     function v010_upgrade() {
         root.upgrader_v010_alignment();
 
         if (!plasmoid.configuration.shadowsUpgraded) {
             if (plasmoid.configuration.shadows > 0) {
                 plasmoid.configuration.appletShadowsEnabled = true;
             } else {
                 plasmoid.configuration.appletShadowsEnabled = false;
             }
 
             plasmoid.configuration.shadowsUpgraded = true;
         }
 
         if (!plasmoid.configuration.tasksUpgraded) {
             v010_tasksMigrateTimer.start();
         }
 
     }
 
     Item {
         id: v010_tasksUpgrader
         Repeater {
             id: v010_tasksRepeater
-            model: latteView && !plasmoid.configuration.tasksUpgraded ? latteView.extendedInterface.tasksModel : null
+            model: latteView && !plasmoid.configuration.tasksUpgraded ? latteView.extendedInterface.latteTasksModel : null
             Item {
                 id: tasksApplet
                 Component.onCompleted: {
                     if (index === 0) {
                         console.log(" !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!");
                         console.log(" !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!");
                         console.log(" !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!");
                         console.log(" !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!");
                         console.log(" !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! !!!!!!!!!!!!!!!!");
                         console.log(" Migrating Tasks Applet for v0.10...");
                         tasks.configuration.launchersGroup = plasmoid.configuration.launchersGroup;
                         tasks.configuration.showWindowActions = plasmoid.configuration.showWindowActions;
                         tasks.configuration.showWindowsOnlyFromLaunchers = plasmoid.configuration.showWindowsOnlyFromLaunchers;
                         tasks.configuration.groupTasksByDefault = plasmoid.configuration.groupTasksByDefault;
                         tasks.configuration.showOnlyCurrentScreen = plasmoid.configuration.showOnlyCurrentScreen;
                         tasks.configuration.showOnlyCurrentDesktop = plasmoid.configuration.showOnlyCurrentDesktop;
                         tasks.configuration.showOnlyCurrentActivity = plasmoid.configuration.showOnlyCurrentActivity;
                         tasks.configuration.showInfoBadge = plasmoid.configuration.showInfoBadge;
                         tasks.configuration.showProgressBadge = plasmoid.configuration.showProgressBadge;
                         tasks.configuration.showAudioBadge = plasmoid.configuration.showAudioBadge;
                         tasks.configuration.audioBadgeActionsEnabled = plasmoid.configuration.audioBadgeActionsEnabled;
                         tasks.configuration.infoBadgeProminentColorEnabled = plasmoid.configuration.infoBadgeProminentColorEnabled;
                         tasks.configuration.animationLauncherBouncing = plasmoid.configuration.animationLauncherBouncing;
                         tasks.configuration.animationWindowInAttention = plasmoid.configuration.animationWindowInAttention;
                         tasks.configuration.animationNewWindowSliding = plasmoid.configuration.animationNewWindowSliding;
                         tasks.configuration.animationWindowAddedInGroup = plasmoid.configuration.animationWindowAddedInGroup;
                         tasks.configuration.animationWindowRemovedFromGroup = plasmoid.configuration.animationWindowRemovedFromGroup;
                         tasks.configuration.scrollTasksEnabled = plasmoid.configuration.scrollTasksEnabled;
                         tasks.configuration.autoScrollTasksEnabled = plasmoid.configuration.autoScrollTasksEnabled;
                         tasks.configuration.manualScrollTasksType = plasmoid.configuration.manualScrollTasksType;
                         tasks.configuration.leftClickAction = plasmoid.configuration.leftClickAction;
                         tasks.configuration.middleClickAction = plasmoid.configuration.middleClickAction;
                         tasks.configuration.hoverAction = plasmoid.configuration.hoverAction;
                         tasks.configuration.taskScrollAction = plasmoid.configuration.taskScrollAction;
                         tasks.configuration.modifierClickAction = plasmoid.configuration.modifierClickAction;
                         tasks.configuration.modifier = plasmoid.configuration.modifier;
                         tasks.configuration.modifierClick = plasmoid.configuration.modifierClick;
                         console.log("Migrating Tasks Applet for v0.10 succeeded ...");
 
                         plasmoid.configuration.tasksUpgraded = true;
                     }
                 }
             }
         }
     }
 
 
     //! v0.10 Timer to check that first-upgrade process ended
     //! when View does not have any Tasks plasmoid
     Timer {
         id: v010_tasksMigrateTimer
         interval: 10000
         onTriggered: {
             plasmoid.configuration.tasksUpgraded = true;
             console.log("Tasks Migration ended....");
         }
     }
 }
diff --git a/shell/package/contents/configuration/LatteDockConfiguration.qml b/shell/package/contents/configuration/LatteDockConfiguration.qml
index 3af7c009..b315812d 100644
--- a/shell/package/contents/configuration/LatteDockConfiguration.qml
+++ b/shell/package/contents/configuration/LatteDockConfiguration.qml
@@ -1,705 +1,705 @@
 /*
 *  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.7
 import QtQuick.Controls 1.4
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 import QtQuick.Window 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.components 3.0 as PlasmaComponents3
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import QtQuick.Controls.Styles.Plasma 2.0 as Styles
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.kquickcontrolsaddons 2.0 as KQuickControlAddons
 
 import org.kde.latte.core 0.2 as LatteCore
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "pages" as Pages
 import "../controls" as LatteExtraControls
 
 FocusScope {
     id: dialog
 
     readonly property bool basicLevel: !advancedLevel
     readonly property bool advancedLevel: viewConfig.inAdvancedMode
 
     readonly property bool inConfigureAppletsMode: plasmoid.configuration.inConfigureAppletsMode || !LatteCore.WindowSystem.compositingActive
 
     //! max size based on screen resolution
     //!    TODO: if we can access availableScreenGeometry.height this can be improved, currently
     //!    we use 100px. or 50px. in order to give space for othe views to be shown and to have also
     //!    some space around the settings window
     property int maxHeight: plasmoid.formFactor === PlasmaCore.Types.Horizontal ?
                                 viewConfig.availableScreenGeometry.height - (latteView.editThickness - latteView.normalThickness) - 16 :
                                 viewConfig.availableScreenGeometry.height - 2 * units.largeSpacing
     property int maxWidth: 0.6 * latteView.screenGeometry.width
 
     //! propose size based on font size
     property int proposedWidth: 0.82 * proposedHeight + units.smallSpacing * 2
     property int proposedHeight: 36 * theme.mSize(theme.defaultFont).height
 
     //! chosen size to be applied, if the user has set or not a different scale for the settings window
     property int chosenWidth: userScaleWidth !== 1 ? userScaleWidth * proposedWidth : proposedWidth
     property int chosenHeight: userScaleHeight !== 1 ? userScaleHeight * heightLevel * proposedHeight : heightLevel * proposedHeight
 
     readonly property int optionsWidth: appliedWidth - units.smallSpacing * 10
 
     //! user set scales based on its preference, e.g. 96% of the proposed size
     property real userScaleWidth: 1
     property real userScaleHeight: 1
 
     readonly property real heightLevel: (dialog.advancedLevel ? 100 : 1)
 
     onHeightChanged: viewConfig.syncGeometry();
 
     //! applied size in order to not be out of boundaries
     //! width can be between 200px - maxWidth
     //! height can be between 400px - maxHeight
     property int appliedWidth: Math.min(maxWidth, Math.max(200, chosenWidth))
     property int appliedHeight: Math.min(maxHeight, Math.max(400, chosenHeight))
 
     width: appliedWidth
     height: appliedHeight
 
     Layout.minimumWidth: width
     Layout.minimumHeight: height
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft
     LayoutMirroring.childrenInherit: true
 
     readonly property bool viewIsPanel: latteView.type === LatteCore.Types.PanelView
 
     property bool panelIsVertical: plasmoid.formFactor === PlasmaCore.Types.Vertical
     property int subGroupSpacing: units.largeSpacing + units.smallSpacing * 1.5
 
     property color bC: theme.backgroundColor
     property color transparentBackgroundColor: Qt.rgba(bC.r, bC.g, bC.b, 0.7)
 
     onAdvancedLevelChanged: {
         //! switch to appearancePage when effectsPage becomes hidden because
         //! advancedLevel was disabled by the user
         if (!advancedLevel && tabGroup.currentTab === effectsPage) {
             tabGroup.currentTab = appearancePage;
             tabBar.currentTab = appearanceTabBtn;
         }
     }
 
     Component.onCompleted: {
         updateScales();
     }
 
     Connections {
         target: latteView.positioner
         onCurrentScreenNameChanged: dialog.updateScales();
     }
 
     function updateScales() {
         userScaleWidth = universalSettings.screenWidthScale(latteView.positioner.currentScreenName);
         userScaleHeight = universalSettings.screenHeightScale(latteView.positioner.currentScreenName);
     }
 
     PlasmaCore.FrameSvgItem{
         id: backgroundFrameSvgItem
         anchors.fill: parent
         imagePath: "dialogs/background"
         enabledBorders: viewConfig.enabledBorders
 
         onEnabledBordersChanged: viewConfig.updateEffects()
         Component.onCompleted: viewConfig.updateEffects()
     }
 
     MouseArea{
         id: backgroundMouseArea
         anchors.fill: parent
         hoverEnabled: true
 
         property bool blockWheel: false
         property bool updatingWidthScale: false
         property bool updatingHeightScale: false
         property bool wheelTriggeredOnce: false
         property real scaleStep: 0.04
 
         onWheel: {
             var metaModifier = (wheel.modifiers & Qt.MetaModifier);
             var ctrlModifier = (wheel.modifiers & Qt.ControlModifier);
 
             if (blockWheel || !(metaModifier || ctrlModifier)){
                 return;
             }
 
             updatingWidthScale = metaModifier || (dialog.advancedLevel && ctrlModifier);
             updatingHeightScale = dialog.basicLevel && ctrlModifier;
 
             blockWheel = true;
             wheelTriggeredOnce = true;
             scrollDelayer.start();
 
             var angle = wheel.angleDelta.y / 8;
 
             //positive direction
             if (angle > 12) {
                 var scales;
                 if (updatingWidthScale) {
                     userScaleWidth = userScaleWidth + scaleStep;
                 }
 
                 if (updatingHeightScale) {
                     userScaleHeight = userScaleHeight + scaleStep;
                 }
 
                 universalSettings.setScreenScales(latteView.positioner.currentScreenName, userScaleWidth, userScaleHeight);
                 viewConfig.syncGeometry();
                 //negative direction
             } else if (angle < -12) {
                 if (updatingWidthScale) {
                     userScaleWidth = userScaleWidth - scaleStep;
                 }
 
                 if (updatingHeightScale) {
                     userScaleHeight = userScaleHeight - scaleStep;
                 }
                 universalSettings.setScreenScales(latteView.positioner.currentScreenName, userScaleWidth, userScaleHeight);
                 viewConfig.syncGeometry();
             }
         }
     }
 
     PlasmaComponents.Button {
         id: backgroundMouseAreaTooltip
         anchors.fill: parent
         opacity: 0
         //tooltip: i18n("You can use Ctrl/Meta + Scroll Wheel to alter the window size")
 
         onHoveredChanged: {
             if (!hovered) {
                 backgroundMouseArea.wheelTriggeredOnce = false;
             }
         }
     }
 
     PlasmaComponents.Label{
         anchors.top: parent.top
         anchors.horizontalCenter: parent.horizontalCenter
         text: backgroundMouseArea.updatingWidthScale ?
                   i18nc("view settings width scale","Width scale at %0%").arg(userScaleWidth * 100) :
                   i18nc("view settings height scale","Height scale at %0%").arg(userScaleHeight * 100)
         visible: backgroundMouseAreaTooltip.hovered && backgroundMouseArea.wheelTriggeredOnce
     }
 
     //! 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: 75
         onTriggered: backgroundMouseArea.blockWheel = false;
     }
 
     ColumnLayout {
         id: content
 
         Layout.minimumWidth: width
         Layout.minimumHeight: calculatedHeight
         Layout.preferredWidth: width
         Layout.preferredHeight: calculatedHeight
         width: (dialog.appliedWidth - units.smallSpacing * 2)
 
         anchors.horizontalCenter: parent.horizontalCenter
         anchors.top: parent.top
         spacing: units.smallSpacing
 
         property int calculatedHeight: header.height + headerSpacer.height+ tabBar.height + pagesBackground.height + actionButtons.height + spacing * 3
 
         Keys.onPressed: {
             if (event.key === Qt.Key_Escape) {
                 viewConfig.hideConfigWindow();
             }
         }
 
         Component.onCompleted: forceActiveFocus();
 
         RowLayout {
             id: header
             Layout.fillWidth: true
 
             spacing: 0
 
             Item {
                 Layout.alignment: Qt.AlignLeft | Qt.AlignTop
                 Layout.fillWidth: false
                 Layout.topMargin: units.smallSpacing
                 Layout.preferredWidth: width
                 Layout.preferredHeight: height
 
                 width: Qt.application.layoutDirection !== Qt.RightToLeft ? logo.width + latteTxt.width + units.smallSpacing : logo.width + units.smallSpacing
                 height: logo.height
 
                 LatteCore.IconItem {
                     id: logo
 
                     width: Math.round(1.4 * latteTxtMetrics.font.pixelSize)
                     height: width
 
                     smooth: true
                     source: "latte-dock"
                     usesPlasmaTheme: false
                 }
 
                 PlasmaComponents.Label {
                     id: latteTxtMetrics
                     text: i18n("Latte")
                     width: 0
                     font.pointSize: 2 * theme.defaultFont.pointSize
                     visible: false
                 }
 
                 PlasmaCore.SvgItem{
                     id: latteTxt
 
                     width: 2.2 * height
                     height: 0.4 * latteTxtMetrics.font.pixelSize
 
                     visible: Qt.application.layoutDirection !== Qt.RightToLeft
 
                     anchors.left: logo.right
                     anchors.verticalCenter: logo.verticalCenter
 
                     svg: PlasmaCore.Svg{
                         imagePath: universalSettings.trademarkIconPath()
                     }
                 }
             }
 
             Item{
                 id: headerSpacer
                 Layout.minimumHeight: advancedSettings.height + 2*units.smallSpacing
             }
 
             ColumnLayout {
                 PlasmaComponents3.ToolButton {
                     id: pinButton
 
                     Layout.fillWidth: false
                     Layout.fillHeight: false
                     Layout.preferredWidth: width
                     Layout.preferredHeight: height
                     Layout.alignment: Qt.AlignRight | Qt.AlignVCenter
                     Layout.bottomMargin: units.smallSpacing * 1.5
                     //!avoid editMode box shadow
                     Layout.topMargin: units.smallSpacing * 2
                     Layout.rightMargin: units.smallSpacing
 
                     icon.name: "window-pin"
                     checkable: true
 
                     width: 7 * units.smallSpacing
                     height: width
 
                     property bool inStartup: true
 
                     onClicked: {
                         plasmoid.configuration.configurationSticker = checked
                         viewConfig.setSticker(checked)
                     }
 
                     Component.onCompleted: {
                         checked = plasmoid.configuration.configurationSticker
                         viewConfig.setSticker(plasmoid.configuration.configurationSticker)
                     }
                 }
 
                 RowLayout {
                     id: advancedSettings
                     Layout.fillWidth: true
                     Layout.rightMargin: units.smallSpacing * 2
                     Layout.alignment: Qt.AlignRight | Qt.AlignTop
 
                     PlasmaComponents.Label {
                         Layout.fillWidth: true
                         Layout.alignment: Qt.AlignRight
                     }
 
                     PlasmaComponents.Label {
                         id: advancedLbl
                         Layout.alignment: Qt.AlignRight
                       //  opacity: dialog.basicLevel ? basicOpacity : 1
 
                         //! TODO: the term here is not accurate because the expert settings mode
                         //! is used currently. In the future this term will be rethought if
                         //! it must remain or be changed
                         text: i18nc("advanced settings", "Advanced")
 
                         readonly property real textColorBrightness: colorBrightness(theme.textColor)
                         readonly property real basicOpacity: textColorBrightness > 127 ? 0.7 : 0.3
 
                         color: {
                             if (dialog.basicLevel) {
                                 return textColorBrightness > 127 ? Qt.darker(theme.textColor, 1.4) : Qt.lighter(theme.textColor, 2.8);
                             }
 
                             return theme.textColor;
                         }
 
                         function colorBrightness(color) {
                             return colorBrightnessFromRGB(color.r * 255, color.g * 255, color.b * 255);
                         }
 
                         // formula for brightness according to:
                         // https://www.w3.org/TR/AERT/#color-contrast
                         function colorBrightnessFromRGB(r, g, b) {
                             return (r * 299 + g * 587 + b * 114) / 1000
                         }
 
                         MouseArea {
                             id: advancedMouseArea
                             anchors.fill: parent
                             hoverEnabled: true
                             onClicked: {
                                 advancedSwitch.checked = !advancedSwitch.checked;
                             }
                         }
                     }
 
                     LatteComponents.Switch {
                         id: advancedSwitch
                         checked: viewConfig.inAdvancedMode
 
                         onCheckedChanged: viewConfig.inAdvancedMode = checked;
                     }
                 }
             }
         }
 
         PlasmaComponents.TabBar {
             id: tabBar
             Layout.fillWidth: true
             Layout.maximumWidth: (dialog.appliedWidth - units.smallSpacing * 2)
 
             PlasmaComponents.TabButton {
                 id: behaviorTabBtn
                 text: i18n("Behavior")
                 tab: behaviorPage
             }
             PlasmaComponents.TabButton {
                 id: appearanceTabBtn
                 text: i18n("Appearance")
                 tab: appearancePage
             }
             PlasmaComponents.TabButton {
                 id: effectsTabBtn
                 text: i18n("Effects")
                 tab: effectsPage
                 visible: dialog.advancedLevel
             }
 
             Repeater {
                 id: tasksTabButtonRepeater
-                model: latteView.extendedInterface.tasksModel
+                model: latteView.extendedInterface.latteTasksModel
 
                 PlasmaComponents.TabButton {
                     text: index >= 1 ? i18nc("tasks header and index","Tasks <%0>").arg(index+1) : i18n("Tasks")
                     tab: tasksRepeater.itemAt(index)
                 }
             }
         }
 
         Rectangle {
             id: pagesBackground
             Layout.fillWidth: true
             Layout.fillHeight: false
             Layout.minimumWidth: dialog.appliedWidth - units.smallSpacing * 4
             Layout.minimumHeight: height
             Layout.maximumHeight: height
 
             width: dialog.appliedWidth - units.smallSpacing * 3
             height: availableFreeHeight + units.smallSpacing * 4
 
             color: transparentBackgroundColor
             border.width: 1
             border.color: theme.backgroundColor
 
             //fix the height binding loop when showing the configuration window
             property int availableFreeHeight: dialog.appliedHeight - header.height - headerSpacer.height - tabBar.height - actionButtons.height - 2 * units.smallSpacing
 
             PlasmaExtras.ScrollArea {
                 id: scrollArea
 
                 anchors.fill: parent
                 verticalScrollBarPolicy: Qt.ScrollBarAsNeeded
                 horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
 
                 flickableItem.flickableDirection: Flickable.VerticalFlick
 
                 PlasmaComponents.TabGroup {
                     id: tabGroup
 
                     width: currentTab.Layout.maximumWidth
                     height: currentTab.Layout.maximumHeight
 
                     Pages.BehaviorConfig {
                         id: behaviorPage
                     }
 
                     Pages.AppearanceConfig {
                         id: appearancePage
                     }
 
                     Pages.EffectsConfig {
                         id: effectsPage
                     }
                 }
             }
 
             Repeater {
                 id: tasksRepeater
                 //! needs to be out of TabGroup otherwise the Repeater is consider as TabGroup direct children
                 //! and thus only the first Tasks tab is shown
-                model: latteView.extendedInterface.tasksModel
+                model: latteView.extendedInterface.latteTasksModel
 
                 //! Reparent TasksPages when all of them are loaded
                 //! this way we avoid warnings from ::stackAfter
                 //! After startup any new TasksPages can be added directly
                 property bool isReady: false
                 property int pages: 0
 
                 Pages.TasksConfig {
                     id: tasksPage
                     Component.onCompleted: {
                         if (tasksRepeater.isReady) {
                             parent = tabGroup;
                         } else {
                             tasksRepeater.pages = tasksRepeater.pages + 1;
                         }
                     }
                 }
 
                 onPagesChanged: {
-                    if (pages === latteView.extendedInterface.tasksModel.rowCount()) {
+                    if (pages === latteView.extendedInterface.latteTasksModel.count) {
                         //! Reparent TasksPages when all of them are loaded
                         //! this way we avoid warnings from ::stackAfter
                         for(var i=0; i<pages; ++i) {
                             itemAt(i).parent = tabGroup;
                         }
 
                         isReady = true;
                     }
                 }
             }
         }
 
         RowLayout {
             id: actionButtons
             Layout.fillWidth: true
             Layout.alignment: Qt.AlignHCenter | Qt.AlignBottom
 
             spacing: units.largeSpacing
 
             Connections{
                 target: latteView.layout
                 onViewsCountChanged: actionButtons.updateEnabled();
             }
 
             function updateEnabled() {
                 var screenFreeEdges = latteView.layout.qmlFreeEdges(latteView.positioner.currentScreenId);
                 actionsComboBtn.buttonEnabled = screenFreeEdges.length > 0;
                 if (actionsModel.count > 0) {
                     actionsModel.get(0).enabled = actionsComboBtn.buttonEnabled;
                 }
                 removeView.enabled = latteView.layout.viewsCount>1 /*&& !(latteView.layout.viewsWithTasks()===1 && latteView.tasksPresent())*/
             }
 
             LatteComponents.ComboBoxButton {
                 id: actionsComboBtn
                 Layout.fillWidth: true
                 implicitWidth: removeView.implicitWidth
                 implicitHeight: removeView.implicitHeight
 
                 buttonEnabled: true
                 buttonText: i18n("New Dock")
                 buttonIconSource: "list-add"
                 buttonToolTip: i18n("Add a new dock")
 
                 comboBoxEnabled: true
                 comboBoxBlankSpaceForEmptyIcons: true
                 comboBoxPopUpAlignRight: Qt.application.layoutDirection === Qt.RightToLeft
                 comboBoxEnabledRole: "enabled"
                 comboBoxTextRole: "name"
                 comboBoxIconRole: "icon"
                 comboBoxMinimumPopUpWidth: actionsModel.count > 1 ? dialog.width / 2 : 150
 
                 property var centralLayoutsNames: []
                 property var sharedLayoutsNames: []
 
                 Component.onCompleted: {
                     comboBox.model = actionsModel;
                     actionButtons.updateEnabled();
                 }
 
                 ListModel {
                     id: actionsModel
                 }
 
                 Connections{
                     target: actionsComboBtn.comboBox
 
                     Component.onCompleted:{
                         actionsComboBtn.addModel();
                         actionButtons.updateEnabled();
                     }
 
                     onActivated: {
                         if (index==0) {
                             latteView.copyView();
                         } else if (index>=1) {
                             var layouts = actionsComboBtn.sharedLayoutsNames.concat(actionsComboBtn.centralLayoutsNames);
 
                             latteView.positioner.hideDockDuringMovingToLayout(layouts[index-1]);
                         }
 
                         actionsComboBtn.comboBox.currentIndex = -1;
                     }
 
                     onEnabledChanged: {
                         if (enabled) {
                             actionsComboBtn.addModel();
                         } else {
                             actionsComboBtn.emptyModel();
                         }
                     }
                 }
 
                 Connections{
                     target: actionsComboBtn.button
 
                     onClicked: latteView.layout.addNewView();
                 }
 
                 Connections{
                     target: latteView
                     onTypeChanged: actionsComboBtn.updateCopyText()
                 }
 
                 function addModel() {
                     actionsModel.clear();
 
                     var copy = {actionId: 'copy:', enabled: true, name: '', icon: 'edit-copy'};
                     actionsModel.append(copy);
 
                     updateCopyText();
 
                     var tempCentralLayouts = layoutsManager.centralLayoutsNames();
                     var tempSharedLayouts = layoutsManager.sharedLayoutsNames();
 
                     if (tempSharedLayouts.length > 0) {
                         var curIndex = tempSharedLayouts.indexOf(latteView.layout.name);
                         if (curIndex >=0) {
                             tempSharedLayouts.splice(curIndex,1);
                         }
 
                         sharedLayoutsNames = tempSharedLayouts;
                         var icon = "document-share";
 
                         for(var i=0; i<sharedLayoutsNames.length; ++i) {
                             var layout = {actionId: 'move:', enabled: true, name: i18n("Move to: %0").arg(sharedLayoutsNames[i]), icon: icon};
                             actionsModel.append(layout);
                         }
                     }
 
 
                     if (tempCentralLayouts.length > 0) {
                         var curIndex = tempCentralLayouts.indexOf(latteView.layout.name);
                         if (curIndex >=0) {
                             tempCentralLayouts.splice(curIndex,1);
                         }
 
                         centralLayoutsNames = tempCentralLayouts;
                         var iconArrow = Qt.application.layoutDirection === Qt.RightToLeft ? 'arrow-left' : 'arrow-right';
 
                         for(var i=0; i<centralLayoutsNames.length; ++i) {
                             var layout = {actionId: 'move:', enabled: true, name: i18n("Move to: %0").arg(centralLayoutsNames[i]), icon: iconArrow};
                             actionsModel.append(layout);
                         }
                     }
 
                     actionsComboBtn.comboBox.currentIndex = -1;
                 }
 
                 function emptyModel() {
                     actionsModel.clear();
                     var copy = {actionId: 'copy:', enabled: true, name: '', icon: 'edit-copy'};
                     actionsModel.append(copy);
                     updateCopyText();
                     actionsComboBtn.comboBox.currentIndex = -1;
                 }
 
                 function updateCopyText() {
                     var copyText = latteView.type === LatteCore.Types.DockView ? i18n("Copy Dock") : i18n("Copy Panel")
                     actionsModel.get(0).name = copyText;
                 }
             }
 
             PlasmaComponents.Button {
                 id: removeView
                 Layout.fillWidth: true
 
                 text: i18n("Remove")
                 iconSource: "delete"
                 opacity: latteView.layout.viewsCount > 1 ? 1 : 0
                 tooltip: i18n("Remove current dock")
 
                 onClicked: latteView.removeView()
             }
 
             PlasmaComponents.Button {
                 id: closeButton
                 Layout.fillWidth: true
 
                 text: i18n("Close")
                 iconSource: "dialog-close"
                 tooltip: i18n("Close settings window")
 
                 onClicked: viewConfig.hideConfigWindow();
             }
         }
     }
 
     //! HACK FOR X11 environments
     //! show an inner shadow similar to Latte::View editShadow in order to
     //! not break the visual user experience
     LatteExtraControls.InnerShadow{
         width: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? dialog.width + 2*shadowSize : shadowSize
         height: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? shadowSize : dialog.height + 2*shadowSize
 
         shadowSize: latteView.effects.editShadow
         shadowOpacity: Math.max(0.35, maxOpacity)
         shadowDirection: plasmoid.location
 
         visible: !LatteCore.WindowSystem.isPlatformWayland && LatteCore.WindowSystem.compositingActive
 
         readonly property real maxOpacity: LatteCore.WindowSystem.compositingActive && !plasmoid.configuration.inConfigureAppletsMode ?
                                                plasmoid.configuration.editBackgroundOpacity : 1
     }
 }