diff --git a/app/layout/genericlayout.cpp b/app/layout/genericlayout.cpp
index a069b43c..88e6ef24 100644
--- a/app/layout/genericlayout.cpp
+++ b/app/layout/genericlayout.cpp
@@ -1,1563 +1,1577 @@
 /*
 *  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 "genericlayout.h"
 
 // local
 #include "abstractlayout.h"
 #include "storage.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../layouts/importer.h"
 #include "../layouts/manager.h"
 #include "../layouts/synchronizer.h"
 #include "../shortcuts/shortcutstracker.h"
 #include "../view/view.h"
 #include "../view/positioner.h"
 
 // Qt
 #include <QDebug>
 #include <QScreen>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 
 // KDE
 #include <KConfigGroup>
 
 namespace Latte {
 namespace Layout {
 
 GenericLayout::GenericLayout(QObject *parent, QString layoutFile, QString assignedName)
     : AbstractLayout (parent, layoutFile, assignedName),
       m_storage(new Storage(this))
 {
 }
 
 GenericLayout::~GenericLayout()
 {
 }
 
 Type GenericLayout::type() const
 {
     return Type::Generic;
 }
 
 void GenericLayout::unloadContainments()
 {
     if (!m_corona) {
         return;
     }
 
     //!disconnect signals in order to avoid crashes when the layout is unloading
     disconnect(this, &GenericLayout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRectChanged);
     disconnect(this, &GenericLayout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRegionChanged);
     disconnect(m_corona->activityConsumer(), &KActivities::Consumer::currentActivityChanged, this, &GenericLayout::updateLastUsedActivity);
 
     qDebug() << "Layout - " + name() + " unload: containments ... size ::: " << m_containments.size()
              << " ,latteViews in memory ::: " << m_latteViews.size()
              << " ,hidden latteViews in memory :::  " << m_waitingLatteViews.size();
 
     for (const auto view : m_latteViews) {
         view->disconnectSensitiveSignals();
     }
 
     for (const auto view : m_waitingLatteViews) {
         view->disconnectSensitiveSignals();
     }
 
     m_unloadedContainmentsIds.clear();
 
     QList<Plasma::Containment *> systrays;
 
     //!identify systrays and unload them first
     for (const auto containment : m_containments) {
         if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
             systrays.append(containment);
         }
     }
 
     while (!systrays.isEmpty()) {
         Plasma::Containment *systray = systrays.at(0);
         m_unloadedContainmentsIds << QString::number(systray->id());
         systrays.removeFirst();
         m_containments.removeAll(systray);
         delete systray;
     }
 
     while (!m_containments.isEmpty()) {
         Plasma::Containment *containment = m_containments.at(0);
         m_unloadedContainmentsIds << QString::number(containment->id());
         m_containments.removeFirst();
         delete containment;
     }
 }
 
 void GenericLayout::unloadLatteViews()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "Layout - " + name() + " unload: latteViews ... size: " << m_latteViews.size();
 
     qDeleteAll(m_latteViews);
     qDeleteAll(m_waitingLatteViews);
     m_latteViews.clear();
     m_waitingLatteViews.clear();
 }
 
 bool GenericLayout::blockAutomaticLatteViewCreation() const
 {
     return m_blockAutomaticLatteViewCreation;
 }
 
 void GenericLayout::setBlockAutomaticLatteViewCreation(bool block)
 {
     if (m_blockAutomaticLatteViewCreation == block) {
         return;
     }
 
     m_blockAutomaticLatteViewCreation = block;
 }
 
 bool GenericLayout::configViewIsShown() const
 {
     for (const auto view : m_latteViews) {
         if (view && view->settingsWindowIsShown()) {
             return true;
         }
     }
 
     return false;
 }
 
 bool GenericLayout::isActive() const
 {
     if (!m_corona) {
         return false;
     }
 
     GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(m_layoutName);
 
     if (generic) {
         return true;
     } else {
         return false;
     }
 }
 
 bool GenericLayout::isCurrent() const
 {
     if (!m_corona) {
         return false;
     }
 
     return name() == m_corona->layoutsManager()->currentLayoutName();
 }
 
 int GenericLayout::viewsCount(int screen) const
 {
     if (!m_corona) {
         return 0;
     }
 
     QScreen *scr = m_corona->screenPool()->screenForId(screen);
 
     int views{0};
 
     for (const auto view : m_latteViews) {
         if (view && view->screen() == scr && !view->containment()->destroyed()) {
             ++views;
         }
     }
 
     return views;
 }
 
 int GenericLayout::viewsCount(QScreen *screen) const
 {
     if (!m_corona) {
         return 0;
     }
 
     int views{0};
 
     for (const auto view : m_latteViews) {
         if (view && view->screen() == screen && !view->containment()->destroyed()) {
             ++views;
         }
     }
 
     return views;
 }
 
 int GenericLayout::viewsCount() const
 {
     if (!m_corona) {
         return 0;
     }
 
     int views{0};
 
     for (const auto view : m_latteViews) {
         if (view && view->containment() && !view->containment()->destroyed()) {
             ++views;
         }
     }
 
     return views;
 }
 
 QList<int> GenericLayout::qmlFreeEdges(int screen) const
 {
     if (!m_corona) {
         const QList<int> emptyEdges;
         return emptyEdges;
     }
 
     const auto edges = freeEdges(screen);
     QList<int> edgesInt;
 
     for (const Plasma::Types::Location &edge : edges) {
         edgesInt.append(static_cast<int>(edge));
     }
 
     return edgesInt;
 }
 
 QList<Plasma::Types::Location> GenericLayout::freeEdges(QScreen *scr) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                 Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     for (const auto view : m_latteViews) {
         if (view && view->positioner()->currentScreenName() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 QList<Plasma::Types::Location> GenericLayout::freeEdges(int screen) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                 Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     QScreen *scr = m_corona->screenPool()->screenForId(screen);
 
     for (const auto view : m_latteViews) {
         if (view && scr && view->positioner()->currentScreenName() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 int GenericLayout::viewsWithTasks() const
 {
     if (!m_corona) {
         return 0;
     }
 
     int result = 0;
 
     for (const auto view : m_latteViews) {
         if (view->tasksPresent()) {
             result++;
         }
     }
 
     return result;
 }
 
 QStringList GenericLayout::unloadedContainmentsIds()
 {
     return m_unloadedContainmentsIds;
 }
 
 Latte::Corona *GenericLayout::corona()
 {
     return m_corona;
 }
 
 Types::ViewType GenericLayout::latteViewType(int containmentId) const
 {
     for (const auto view : m_latteViews) {
         if (view->containment() && view->containment()->id() == containmentId) {
             return view->type();
         }
     }
 
     return Types::DockView;
 }
 
 Latte::View *GenericLayout::highestPriorityView()
 {
     QList<Latte::View *> views = sortedLatteViews();
 
     return (views.count() > 0 ? views[0] : nullptr);
 }
 
 Latte::View *GenericLayout::lastConfigViewFor()
 {
     if (!latteViews().contains(m_lastConfigViewFor)) {
         m_lastConfigViewFor = nullptr;
         return nullptr;
     }
 
     return m_lastConfigViewFor;
 }
 
 void GenericLayout::setLastConfigViewFor(Latte::View *view)
 {
     if (m_lastConfigViewFor == view) {
         return;
     }
 
     m_lastConfigViewFor = view;
     emit lastConfigViewForChanged(view);
 }
 
 Latte::View *GenericLayout::viewForContainment(Plasma::Containment *containment)
 {
     if (m_containments.contains(containment) && m_latteViews.contains(containment)) {
         return m_latteViews[containment];
     }
 
     return nullptr;
 }
 
 QList<Latte::View *> GenericLayout::latteViews()
 {
     return m_latteViews.values();
 }
 
 QList<Latte::View *> GenericLayout::sortedLatteViews(QList<Latte::View *> views)
 {
     QList<Latte::View *> sortedViews = views.isEmpty() ? latteViews() : views;
 
     qDebug() << " -------- ";
 
     for (int i = 0; i < sortedViews.count(); ++i) {
         qDebug() << i << ". " << sortedViews[i]->screen()->name() << " - " << sortedViews[i]->location();
     }
 
     //! sort the views based on screens and edges priorities
     //! views on primary screen have higher priority and
     //! for views in the same screen the priority goes to
     //! Bottom,Left,Top,Right
     for (int i = 0; i < sortedViews.size(); ++i) {
         for (int j = 0; j < sortedViews.size() - i - 1; ++j) {
             if (viewAtLowerScreenPriority(sortedViews[j], sortedViews[j + 1])
                     || (sortedViews[j]->screen() == sortedViews[j + 1]->screen()
                         && viewAtLowerEdgePriority(sortedViews[j], sortedViews[j + 1]))) {
                 Latte::View *temp = sortedViews[j + 1];
                 sortedViews[j + 1] = sortedViews[j];
                 sortedViews[j] = temp;
             }
         }
     }
 
     Latte::View *highestPriorityView{nullptr};
 
     for (int i = 0; i < sortedViews.size(); ++i) {
         if (sortedViews[i]->isPreferredForShortcuts()) {
             highestPriorityView = sortedViews[i];
             sortedViews.removeAt(i);
             break;
         }
     }
 
     if (highestPriorityView) {
         sortedViews.prepend(highestPriorityView);
     }
 
     qDebug() << " -------- sorted -----";
 
     for (int i = 0; i < sortedViews.count(); ++i) {
         qDebug() << i << ". " << sortedViews[i]->isPreferredForShortcuts() << " - " << sortedViews[i]->screen()->name() << " - " << sortedViews[i]->location();
     }
 
     return sortedViews;
 }
 
 bool GenericLayout::viewAtLowerScreenPriority(Latte::View *test, Latte::View *base)
 {
     if (!base || ! test) {
         return true;
     }
 
     if (base->screen() == test->screen()) {
         return false;
     } else if (base->screen() != qGuiApp->primaryScreen() && test->screen() == qGuiApp->primaryScreen()) {
         return false;
     } else if (base->screen() == qGuiApp->primaryScreen() && test->screen() != qGuiApp->primaryScreen()) {
         return true;
     } else {
         int basePriority = -1;
         int testPriority = -1;
 
         for (int i = 0; i < qGuiApp->screens().count(); ++i) {
             if (base->screen() == qGuiApp->screens()[i]) {
                 basePriority = i;
             }
 
             if (test->screen() == qGuiApp->screens()[i]) {
                 testPriority = i;
             }
         }
 
         if (testPriority <= basePriority) {
             return true;
         } else {
             return false;
         }
 
     }
 
     qDebug() << "viewAtLowerScreenPriority : shouldn't had reached here...";
     return false;
 }
 
 bool GenericLayout::viewAtLowerEdgePriority(Latte::View *test, Latte::View *base)
 {
     if (!base || ! test) {
         return true;
     }
 
     QList<Plasma::Types::Location> edges{Plasma::Types::RightEdge, Plasma::Types::TopEdge,
                 Plasma::Types::LeftEdge, Plasma::Types::BottomEdge};
 
     int testPriority = -1;
     int basePriority = -1;
 
     for (int i = 0; i < edges.count(); ++i) {
         if (edges[i] == base->location()) {
             basePriority = i;
         }
 
         if (edges[i] == test->location()) {
             testPriority = i;
         }
     }
 
     if (testPriority < basePriority) {
         return true;
     } else {
         return false;
     }
 }
 
 bool GenericLayout::viewDataAtLowerScreenPriority(const ViewData &test, const ViewData &base) const
 {
     if (test.onPrimary && base.onPrimary) {
         return false;
     } else if (!base.onPrimary && test.onPrimary) {
         return false;
     } else if (base.onPrimary && !test.onPrimary) {
         return true;
     } else {
         return test.screenId <= base.screenId;
     }
 }
 
 bool GenericLayout::viewDataAtLowerStatePriority(const ViewData &test, const ViewData &base) const
 {
     if (test.active == base.active) {
         return false;
     } else if (!base.active && test.active) {
         return false;
     } else if (base.active && !test.active) {
         return true;
     }
 
     return false;
 }
 
 bool GenericLayout::viewDataAtLowerEdgePriority(const ViewData &test, const ViewData &base) const
 {
     QList<Plasma::Types::Location> edges{Plasma::Types::RightEdge, Plasma::Types::TopEdge,
                 Plasma::Types::LeftEdge, Plasma::Types::BottomEdge};
 
     int testPriority = -1;
     int basePriority = -1;
 
     for (int i = 0; i < edges.count(); ++i) {
         if (edges[i] == base.location) {
             basePriority = i;
         }
 
         if (edges[i] == test.location) {
             testPriority = i;
         }
     }
 
     if (testPriority < basePriority) {
         return true;
     } else {
         return false;
     }
 }
 
 QList<ViewData> GenericLayout::sortedViewsData(const QList<ViewData> &viewsData)
 {
     QList<ViewData> sortedData = viewsData;
 
     //! sort the views based on screens and edges priorities
     //! views on primary screen have higher priority and
     //! for views in the same screen the priority goes to
     //! Bottom,Left,Top,Right
     for (int i = 0; i < sortedData.size(); ++i) {
         for (int j = 0; j < sortedData.size() - i - 1; ++j) {
             if (viewDataAtLowerStatePriority(sortedData[j], sortedData[j + 1])
                     || viewDataAtLowerScreenPriority(sortedData[j], sortedData[j + 1])
                     || (!viewDataAtLowerScreenPriority(sortedData[j], sortedData[j + 1])
                         && viewDataAtLowerEdgePriority(sortedData[j], sortedData[j + 1])) ) {
                 ViewData temp = sortedData[j + 1];
                 sortedData[j + 1] = sortedData[j];
                 sortedData[j] = temp;
             }
         }
     }
 
     return sortedData;
 }
 
 
 const QList<Plasma::Containment *> *GenericLayout::containments()
 {
     return &m_containments;
 }
 
 QList<Latte::View *> GenericLayout::viewsWithPlasmaShortcuts()
 {
     QList<Latte::View *> views;
 
     if (!m_corona) {
         return views;
     }
 
     QList<int> appletsWithShortcuts = m_corona->globalShortcuts()->shortcutsTracker()->appletsWithPlasmaShortcuts();
 
     for (const auto &appletId : appletsWithShortcuts) {
         for (const auto view : m_latteViews) {
             bool found{false};
             for (const auto applet : view->containment()->applets()) {
                 if (appletId == applet->id()) {
                     if (!views.contains(view)) {
                         views.append(view);
                         found = true;
                         break;
                     }
                 }
             }
 
             if (found) {
                 break;
             }
         }
     }
 
     return views;
 }
 
 
 //! Containments Actions
 void GenericLayout::addContainment(Plasma::Containment *containment)
 {
     if (!containment || m_containments.contains(containment)) {
         return;
     }
 
     bool containmentInLayout{false};
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) {
         m_containments.append(containment);
         containmentInLayout = true;
     } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         QString layoutId = containment->config().readEntry("layoutId", QString());
 
         if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
             m_containments.append(containment);
             containmentInLayout = true;
         }
     }
 
     if (containmentInLayout) {
         if (!blockAutomaticLatteViewCreation()) {
             addView(containment);
         } else {
             qDebug() << "delaying LatteView creation for containment :: " << containment->id();
         }
 
         connect(containment, &QObject::destroyed, this, &GenericLayout::containmentDestroyed);
     }
 }
 
 void GenericLayout::appletCreated(Plasma::Applet *applet)
 {
     //! In Multiple Layout the orphaned systrays must be assigned to layouts
     //! when the user adds them
     KConfigGroup appletSettings = applet->containment()->config().group("Applets").group(QString::number(applet->id())).group("Configuration");
 
     int systrayId = appletSettings.readEntry("SystrayContainmentId", -1);
 
     if (systrayId != -1) {
         uint sId = (uint)systrayId;
 
         for (const auto containment : m_corona->containments()) {
             if (containment->id() == sId) {
                 containment->config().writeEntry("layoutId", m_layoutName);
             }
 
             addContainment(containment);
         }
     }
 }
 
 void GenericLayout::containmentDestroyed(QObject *cont)
 {
     if (!m_corona) {
         return;
     }
 
     Plasma::Containment *containment = static_cast<Plasma::Containment *>(cont);
 
     if (containment) {
         int containmentIndex = m_containments.indexOf(containment);
 
         if (containmentIndex >= 0) {
             m_containments.removeAt(containmentIndex);
         }
 
         qDebug() << "Layout " << name() << " :: containment destroyed!!!!";
         auto view = m_latteViews.take(containment);
 
         if (!view) {
             view = m_waitingLatteViews.take(containment);
         }
 
         if (view) {
             view->disconnectSensitiveSignals();
 
             view->deleteLater();
 
             emit viewEdgeChanged();
             emit viewsCountChanged();
         }
     }
 }
 
 void GenericLayout::destroyedChanged(bool destroyed)
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "dock containment destroyed changed!!!!";
     Plasma::Containment *sender = qobject_cast<Plasma::Containment *>(QObject::sender());
 
     if (!sender) {
         return;
     }
 
     if (destroyed) {
         m_waitingLatteViews[sender] = m_latteViews.take(static_cast<Plasma::Containment *>(sender));
     } else {
         m_latteViews[sender] = m_waitingLatteViews.take(static_cast<Plasma::Containment *>(sender));
     }
 
     emit viewEdgeChanged();
     emit viewsCountChanged();
 }
 
 void GenericLayout::renameLayout(QString newName)
 {
     if (!m_corona || m_corona->layoutsManager()->memoryUsage() != Types::MultipleLayouts) {
         return;
     }
 
     if (m_layoutFile != Layouts::Importer::layoutFilePath(newName)) {
         setFile(Layouts::Importer::layoutFilePath(newName));
     }
 
     setName(newName);
 
     for (const auto containment : m_containments) {
         qDebug() << "Cont ID :: " << containment->id();
         containment->config().writeEntry("layoutId", m_layoutName);
     }
 }
 
 void GenericLayout::addNewView()
 {
     if (!m_corona) {
         return;
     }
 
     m_corona->addViewForLayout(name());
     emit viewEdgeChanged();
 }
 
 void GenericLayout::addView(Plasma::Containment *containment, bool forceOnPrimary, int explicitScreen, Layout::ViewsMap *occupied)
 {
     qDebug() << "Layout :::: " << m_layoutName << " ::: addView was called... m_containments :: " << m_containments.size();
 
     if (!containment || !m_corona || !containment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     qDebug() << "step 1...";
 
     if (!m_storage->isLatteContainment(containment))
         return;
 
     qDebug() << "step 2...";
 
     for (auto *dock : m_latteViews) {
         if (dock->containment() == containment)
             return;
     }
 
     qDebug() << "step 3...";
 
     QScreen *nextScreen{qGuiApp->primaryScreen()};
 
     bool onPrimary = containment->config().readEntry("onPrimary", true);
     int id = containment->screen();
 
     if (id == -1 && explicitScreen == -1) {
         id = containment->lastScreen();
     }
 
     if (onPrimary) {
         id = m_corona->screenPool()->primaryScreenId();
     } else if (explicitScreen > -1) {
         id = explicitScreen;
     }
 
     Plasma::Types::Location edge = containment->location();
 
     QString connector = m_corona->screenPool()->hasId(id) ? m_corona->screenPool()->connector(id) : "";
 
     qDebug() << "Adding view - containment id:" << containment->id() << " ,screen :" << id << " - " << connector
              << " ,onprimary:" << onPrimary << " - "  << " edge:" << edge << " ,screenName:" << qGuiApp->primaryScreen()->name() << " ,forceOnPrimary:" << forceOnPrimary;
 
     if (occupied && m_corona->screenPool()->hasId(id) && (*occupied).contains(connector) && (*occupied)[connector].contains(edge)) {
         qDebug() << "Rejected : adding view because the edge is already occupied by a higher priority view ! : " << (*occupied)[connector][edge];
         return;
     }
 
     if (id >= 0 && !onPrimary && !forceOnPrimary) {
         qDebug() << "Add view - connector : " << connector;
         bool found{false};
 
         if (m_corona->screenPool()->hasId(id)) {
             for (const auto scr : qGuiApp->screens()) {
                 if (scr && scr->name() == connector) {
                     found = true;
                     nextScreen = scr;
                     break;
                 }
             }
         }
 
         if (!found) {
             qDebug() << "Rejected : adding explicit view, screen not available ! : " << connector;
             return;
         }
 
         //! explicit dock can not be added at explicit screen when that screen is the same with
         //! primary screen and that edge is already occupied by a primary dock
         if (nextScreen == qGuiApp->primaryScreen() && primaryDockOccupyEdge(containment->location())) {
             qDebug() << "Rejected : adding explicit view, primary dock occupies edge at screen ! : " << connector;
             return;
         }
     }
 
     if (id >= 0 && onPrimary) {
         qDebug() << "add dock - connector : " << connector;
 
         for (const auto view : m_latteViews) {
             auto testContainment = view->containment();
 
             int testScreenId = testContainment->screen();
 
             if (testScreenId == -1) {
                 testScreenId = testContainment->lastScreen();
             }
 
             bool testOnPrimary = testContainment->config().readEntry("onPrimary", true);
             Plasma::Types::Location testLocation = static_cast<Plasma::Types::Location>((int)testContainment->config().readEntry("location", (int)Plasma::Types::BottomEdge));
 
             if (!testOnPrimary && m_corona->screenPool()->primaryScreenId() == testScreenId && testLocation == containment->location()) {
                 qDebug() << "Rejected explicit latteView and removing it in order add an onPrimary with higher priority at screen: " << connector;
                 auto viewToDelete = m_latteViews.take(testContainment);
                 viewToDelete->disconnectSensitiveSignals();
                 viewToDelete->deleteLater();
             }
         }
     }
 
     qDebug() << "Adding view passed ALL checks" << " ,onPrimary:" << onPrimary << " ,screen:" << nextScreen->name() << " !!!";
 
     //! it is used to set the correct flag during the creation
     //! of the window... This of course is also used during
     //! recreations of the window between different visibility modes
     auto mode = static_cast<Types::Visibility>(containment->config().readEntry("visibility", static_cast<int>(Types::DodgeActive)));
     bool byPassWM{false};
 
     if (mode == Types::AlwaysVisible || mode == Types::WindowsGoBelow) {
         byPassWM = false;
     } else {
         byPassWM = containment->config().readEntry("byPassWM", false);
     }
 
     auto latteView = new Latte::View(m_corona, nextScreen, byPassWM);
 
     latteView->init();
     latteView->setContainment(containment);
 
     //! force this special dock case to become primary
     //! even though it isnt
     if (forceOnPrimary) {
         qDebug() << "Enforcing onPrimary:true as requested for LatteView...";
         latteView->setOnPrimary(true);
     }
 
     latteView->setLayout(this);
 
     //! Qt 5.9 creates a crash for this in wayland, that is why the check is used
     //! but on the other hand we need this for copy to work correctly and show
     //! the copied dock under X11
     //if (!KWindowSystem::isPlatformWayland()) {
     latteView->show();
     //}
 
     m_latteViews[containment] = latteView;
 
     emit viewsCountChanged();
 }
 
 
 bool GenericLayout::initToCorona(Latte::Corona *corona)
 {
     if (m_corona) {
         return false;
     }
 
     m_corona = corona;
 
     for (const auto containment : m_corona->containments()) {
         if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) {
             addContainment(containment);
         } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             QString layoutId = containment->config().readEntry("layoutId", QString());
 
             if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
                 addContainment(containment);
             }
         }
     }
 
     qDebug() << "Layout ::::: " << name() << " added containments ::: " << m_containments.size();
 
     updateLastUsedActivity();
 
     //! signals
     connect(m_corona->activityConsumer(), &KActivities::Consumer::currentActivityChanged,
             this, &GenericLayout::updateLastUsedActivity);
 
     connect(m_corona, &Plasma::Corona::containmentAdded, this, &GenericLayout::addContainment);
 
     //!connect signals after adding the containment
     connect(this, &GenericLayout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRectChanged);
     connect(this, &GenericLayout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRegionChanged);
 
     emit viewsCountChanged();
 
     return true;
 }
 
 void GenericLayout::updateLastUsedActivity()
 {
     if (!m_corona) {
         return;
     }
 
     if (!m_lastUsedActivity.isEmpty() && !m_corona->layoutsManager()->synchronizer()->activities().contains(m_lastUsedActivity)) {
         clearLastUsedActivity();
     }
 
     QString currentId = m_corona->activitiesConsumer()->currentActivity();
 
     QStringList appliedActivitiesIds = appliedActivities();
 
     if (m_lastUsedActivity != currentId
             && (appliedActivitiesIds.contains(currentId)
                 || m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout)) {
         m_lastUsedActivity = currentId;
 
         emit lastUsedActivityChanged();
     }
 }
 
 void GenericLayout::assignToLayout(Latte::View *latteView, QList<Plasma::Containment *> containments)
 {
     if (!m_corona) {
         return;
     }
 
     if (latteView) {
         m_latteViews[latteView->containment()] = latteView;
         m_containments << containments;
 
         for (const auto containment : containments) {
             containment->config().writeEntry("layoutId", name());
 
             if (latteView->containment() != containment) {
                 //! assign signals only to systrays
                 //! the View::setLayout() is responsible for the View::Containment signals
                 connect(containment, &QObject::destroyed, this, &GenericLayout::containmentDestroyed);
                 connect(containment, &Plasma::Applet::destroyedChanged, this, &GenericLayout::destroyedChanged);
                 connect(containment, &Plasma::Containment::appletCreated, this, &GenericLayout::appletCreated);
             }
         }
 
         latteView->setLayout(this);
 
         emit viewsCountChanged();
     }
 
     //! sync the original layout file for integrity
     if (m_corona && m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         m_storage->syncToLayoutFile(false);
     }
 }
 
 QList<Plasma::Containment *> GenericLayout::unassignFromLayout(Latte::View *latteView)
 {
     QList<Plasma::Containment *> containments;
 
     if (!m_corona) {
         return containments;
     }
 
     containments << latteView->containment();
 
     for (const auto containment : m_containments) {
         Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent());
 
         //! add systrays from that latteView
         if (parentApplet && parentApplet->containment() && parentApplet->containment() == latteView->containment()) {
             containments << containment;
             //! unassign signals only to systrays
             //! the View::setLayout() is responsible for the View::Containment signals
             disconnect(containment, &QObject::destroyed, this, &GenericLayout::containmentDestroyed);
             disconnect(containment, &Plasma::Applet::destroyedChanged, this, &GenericLayout::destroyedChanged);
             disconnect(containment, &Plasma::Containment::appletCreated, this, &GenericLayout::appletCreated);
         }
     }
 
     for (const auto containment : containments) {
         m_containments.removeAll(containment);
     }
 
     if (containments.size() > 0) {
         m_latteViews.remove(latteView->containment());
     }
 
     //! sync the original layout file for integrity
     if (m_corona && m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         m_storage->syncToLayoutFile(false);
     }
 
     return containments;
 }
 
 void GenericLayout::recreateView(Plasma::Containment *containment, bool delayed)
 {
     if (!m_corona || m_viewsToRecreate.contains(containment) || !containment || !m_latteViews.contains(containment)) {
         return;
     }
 
     int delay = delayed ? 350 : 0;
     m_viewsToRecreate << containment;
 
     //! give the time to config window to close itself first and then recreate the dock
     //! step:1 remove the latteview
     QTimer::singleShot(delay, [this, containment]() {
         auto view = m_latteViews[containment];
         view->disconnectSensitiveSignals();
 
         //! step:2 add the new latteview
         connect(view, &QObject::destroyed, this, [this, containment]() {
             auto view = m_latteViews.take(containment);
             QTimer::singleShot(250, this, [this, containment]() {
                 if (!m_latteViews.contains(containment)) {
                     qDebug() << "recreate - step 2: adding dock for containment:" << containment->id();
                     addView(containment);
                     m_viewsToRecreate.removeAll(containment);
                 }
             });
         });
 
         view->deleteLater();
     });
 }
 
 
 bool GenericLayout::latteViewExists(Plasma::Containment *containment)
 {
     if (!m_corona) {
         return false;
     }
 
     return m_latteViews.keys().contains(containment);
 }
 
 QList<Plasma::Types::Location> GenericLayout::availableEdgesForView(QScreen *scr, Latte::View *forView) const
 {
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                 Types::TopEdge, Types::RightEdge};
 
     if (!m_corona) {
         return edges;
     }
 
     for (const auto view : m_latteViews) {
         //! make sure that availabe edges takes into account only views that should be excluded,
         //! this is why the forView should not be excluded
         if (view && view != forView && view->positioner()->currentScreenName() == scr->name()) {
             edges.removeOne(view->location());
         }
     }
 
     return edges;
 }
 
 bool GenericLayout::explicitDockOccupyEdge(int screen, Plasma::Types::Location location) const
 {
     if (!m_corona) {
         return false;
     }
 
     for (const auto containment : m_containments) {
         if (m_storage->isLatteContainment(containment)) {
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             int id = containment->lastScreen();
             Plasma::Types::Location contLocation = containment->location();
 
             if (!onPrimary && id == screen && contLocation == location) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool GenericLayout::primaryDockOccupyEdge(Plasma::Types::Location location) const
 {
     if (!m_corona) {
         return false;
     }
 
     for (const auto containment : m_containments) {
         if (m_storage->isLatteContainment(containment)) {
             bool onPrimary = containment->config().readEntry("onPrimary", true);
             Plasma::Types::Location contLocation = containment->location();
 
             if (onPrimary && contLocation == location) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 bool GenericLayout::mapContainsId(const Layout::ViewsMap *map, uint viewId) const
 {
     for(const auto &scr : map->keys()) {
         for(const auto &edge : (*map)[scr].keys()) {
             if ((*map)[scr][edge] == viewId) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 //! screen name, location, containmentId
 Layout::ViewsMap GenericLayout::validViewsMap(Layout::ViewsMap *occupiedMap)
 {
     Layout::ViewsMap map;
 
     if (!m_corona) {
         return map;
     }
 
     if (occupiedMap != nullptr) {
         map = (*occupiedMap);
     }
 
     QString prmScreenName = qGuiApp->primaryScreen()->name();
 
     //! first step: primary docks must be placed in primary screen free edges
     for (const auto containment : m_containments) {
         if (m_storage->isLatteContainment(containment)) {
             int screenId = 0;
 
             //! valid screen id
             if (latteViewExists(containment)) {
                 screenId = m_latteViews[containment]->positioner()->currentScreenId();
             } else {
                 screenId = containment->screen();
 
                 if (screenId == -1) {
                     screenId = containment->lastScreen();
                 }
             }
 
             bool onPrimary{true};
 
             //! valid onPrimary flag
             if (latteViewExists(containment)) {
                 onPrimary = m_latteViews[containment]->onPrimary();
             } else {
                 onPrimary = containment->config().readEntry("onPrimary", true);
             }
 
             //! valid location
             Plasma::Types::Location location = containment->location();
 
             if (onPrimary && !map[prmScreenName].contains(location)) {
                 map[prmScreenName][location] = containment->id();
             }
         }
     }
 
     //! second step: explicit docks must be placed in their screens if the screen edge is free
     for (const auto containment : m_containments) {
         if (m_storage->isLatteContainment(containment)) {
             int screenId = 0;
 
             //! valid screen id
             if (latteViewExists(containment)) {
                 screenId = m_latteViews[containment]->positioner()->currentScreenId();
             } else {
                 screenId = containment->screen();
 
                 if (screenId == -1) {
                     screenId = containment->lastScreen();
                 }
             }
 
             bool onPrimary{true};
 
             //! valid onPrimary flag
             if (latteViewExists(containment)) {
                 onPrimary = m_latteViews[containment]->onPrimary();
             } else {
                 onPrimary = containment->config().readEntry("onPrimary", true);
             }
 
             //! valid location
             Plasma::Types::Location location = containment->location();
 
             if (!onPrimary) {
                 QString expScreenName = m_corona->screenPool()->connector(screenId);
 
                 if (m_corona->screenPool()->screenExists(screenId) && !map[expScreenName].contains(location)) {
                     map[expScreenName][location] = containment->id();
                 }
             }
         }
     }
 
     return map;
 }
 
 
 //! the central functions that updates loading/unloading latteviews
 //! concerning screen changed (for multi-screen setups mainly)
 void GenericLayout::syncLatteViewsToScreens(Layout::ViewsMap *occupiedMap)
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "START of SyncLatteViewsToScreens ....";
     qDebug() << "LAYOUT ::: " << name();
     qDebug() << "screen count changed -+-+ " << qGuiApp->screens().size();
 
     Layout::ViewsMap viewsMap = validViewsMap(occupiedMap);
 
     if (occupiedMap != nullptr) {
         qDebug() << "Occupied map used :: " << *occupiedMap;
     }
 
     QString prmScreenName = qGuiApp->primaryScreen()->name();
 
     qDebug() << "PRIMARY SCREEN :: " << prmScreenName;
     qDebug() << "LATTEVIEWS MAP :: " << viewsMap;
 
     //! add views
     for (const auto containment : m_containments) {
         int screenId = containment->screen();
 
         if (screenId == -1) {
             screenId = containment->lastScreen();
         }
 
         if (!latteViewExists(containment) && mapContainsId(&viewsMap, containment->id())) {
             qDebug() << "syncLatteViewsToScreens: view must be added... for containment:" << containment->id() << " at screen:" << m_corona->screenPool()->connector(screenId);
             addView(containment);
         }
     }
 
     //! remove views
     QList<Plasma::Containment *> viewsToDelete;
 
     for (auto view : m_latteViews) {
         auto containment = view->containment();
         if (containment && !mapContainsId(&viewsMap, containment->id())) {
             viewsToDelete << containment;
         }
     }
 
     while(!viewsToDelete.isEmpty()) {
         auto containment = viewsToDelete.takeFirst();
         auto view = m_latteViews.take(containment);
         qDebug() << "syncLatteViewsToScreens: view must be deleted... for containment:" << containment->id() << " at screen:" << view->positioner()->currentScreenName();
         view->disconnectSensitiveSignals();
         view->deleteLater();
     }
 
     //! reconsider views
     for (const auto view : m_latteViews) {
         if (view->containment() && mapContainsId(&viewsMap, view->containment()->id())) {
             //! if the dock will not be deleted its a very good point to reconsider
             //! if the screen in which is running is the correct one
             qDebug() << "syncLatteViewsToScreens: view must consider its screen... for containment:" << view->containment()->id() << " at screen:" << view->positioner()->currentScreenName();
             view->reconsiderScreen();
         }
     }
 
     qDebug() << "end of, syncLatteViewsToScreens ....";
 }
 
 QList<int> GenericLayout::containmentSystrays(Plasma::Containment *containment) const
 {
     QList<int> trays;
 
     if (m_storage->isLatteContainment(containment)) {
-        int systrayId = -1;
         auto applets = containment->config().group("Applets");
 
         for (const auto &applet : applets.groupList()) {
             KConfigGroup appletSettings = applets.group(applet).group("Configuration");
             int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
             if (tSysId != -1) {
                 trays << tSysId;
             }
         }
     }
 
     return trays;
 }
 
 
-QString GenericLayout::reportHtml()
+QString GenericLayout::reportHtml(const ScreenPool *screenPool)
 {
     //qDebug() << "DBUS CALL ::: " << identifier << " - " << value;
     auto locationText = [this](const int &location) {
         switch (location) {
         case Plasma::Types::BottomEdge: return i18nc("bottom edge", "Bottom");
         case Plasma::Types::LeftEdge: return i18nc("left edge", "Left");
         case Plasma::Types::TopEdge: return i18nc("top edge", "Top");
         case Plasma::Types::RightEdge: return i18nc("right edge", "Right");
         }
 
         return QString();
     };
 
     auto idsLineStr = [this](const QList<int> list) {
         QString line;
 
         for(int i=0; i<list.count(); ++i) {
             if(i!=0) {
                 line += ", ";
             }
             line += "["+QString::number(list[i]) + "]";
         }
 
         return line;
     };
 
     ///////!  main report layout code
 
     QString report;
 
     int activeViews = m_latteViews.count();
 
     report += "<table cellspacing='8'>";
     report += "<tr>";
-    report += "<td><b>" + i18nc("active docks panels","Active:") +"</b></td>";
-    report += "<td><b>" + (activeViews == 0 ? "--" : QString::number(activeViews)) +"</b></td>";
+    report += "<td><b>" + i18nc("active docks panels","Active Views:") +"</b></td>";
+    if (activeViews == 0) {
+        report += "<td><b> -- </b></td>";
+    } else {
+        report += "<td><b><font color='blue'>" + QString::number(activeViews) +"</font></b></td>";
+    }
     report += "</tr>";
 
     //! latte containment ids, systrays
     QHash<int, QList<int>> systrays;
     QList<int> assignedSystrays;
     QList<int> orphanSystrays;
 
     if (isActive()) {
         //! organize systrays
         for (const auto containment : m_containments) {
             QList<int> trays = containmentSystrays(containment);
             if (trays.count() > 0) {
                 systrays[containment->id()] = trays;
                 assignedSystrays << trays;
             }
         }
 
         //! orphan systrays
         for (const auto containment : m_containments) {
             if (!m_storage->isLatteContainment(containment) && !assignedSystrays.contains(containment->id())) {
                 orphanSystrays << containment->id();
             }
         }
+    } else {
+        m_storage->systraysInformation(systrays, assignedSystrays, orphanSystrays);
     }
 
     report += "<tr>";
     report += "<td><b>" + i18n("Orphan Systrays:") +"</b></td>";
-    report += "<td><b>" + (orphanSystrays.count() == 0 ? "--" : idsLineStr(orphanSystrays)) +"</b></td>";
+    if (orphanSystrays.count() == 0) {
+        report += "<td><b> -- </b></td>";
+    } else {
+        report += "<td><b><font color='red'>" + idsLineStr(orphanSystrays) +"</font></b></td>";
+    }
     report += "</tr>";
     report += "</table>";
 
     report += "<table cellspacing='14'>";
     report += "<tr><td align='center'><b>" + i18nc("view id","ID") + "</b></td>" +
             "<td align='center'><b>" + i18n("Screen") + "</b></td>" +
             "<td align='center'><b>" + i18nc("screen edge","Edge") + "</b></td>" +
             "<td align='center'><b>" + i18nc("active dock/panel","Active") + "</b></td>" +
             "<td align='center'><b>" + i18n("Systrays") + "</b></td>";
 
     report += "<tr><td colspan='5'><hr></td></tr>";
 
     QList<ViewData> viewsData;
 
     if (isActive()) {
         //! collect viewData results
         for (const auto containment : m_containments) {
             if (m_storage->isLatteContainment(containment)) {
                 ViewData vData;
                 vData.id = containment->id();
                 vData.active = latteViewExists(containment);
                 vData.location = containment->location();
 
                 //! onPrimary / Screen Id
                 int screenId = -1;
                 bool onPrimary = true;
 
                 if (latteViewExists(containment)) {
                     screenId = m_latteViews[containment]->positioner()->currentScreenId();
                     onPrimary = m_latteViews[containment]->onPrimary();
                 } else {
                     screenId = containment->screen();
                     onPrimary = containment->config().readEntry("onPrimary", true);
 
                     if (screenId == -1) {
                         screenId = containment->lastScreen();
                     }
                 }
 
                 vData.onPrimary = onPrimary;
                 vData.screenId = screenId;
                 vData.systrays = containmentSystrays(containment);
 
                 viewsData << vData;
             }
         }
+    } else {
+        viewsData = m_storage->viewsData(systrays);
     }
 
     //! sort views data
     viewsData = sortedViewsData(viewsData);
 
     //! print viewData results
     for (int i=0; i<viewsData.count(); ++i) {
         report += "<tr>";
 
         //! view id
         QString idStr = "[" + QString::number(viewsData[i].id) + "]";
         if(viewsData[i].active) {
             idStr = "<b>" + idStr + "</b>";
         }
         report += "<td align='center'>" + idStr + "</td>";
 
         //! screen
         QString screenStr = "[" + i18nc("primary screen","Primary") + "]";
         if (viewsData[i].active && viewsData[i].onPrimary) {
             screenStr = "<font color='green'>" + screenStr + "</font>";
         }
         if (!viewsData[i].onPrimary) {
-            screenStr = m_corona->screenPool()->connector(viewsData[i].screenId);
+            screenStr = screenPool->connector(viewsData[i].screenId);
         }
         if(viewsData[i].active) {
             screenStr = "<b>" + screenStr + "</b>";
         }
         report += "<td align='center'>" + screenStr + "</td>";
 
         //! edge
         QString edgeStr = locationText(viewsData[i].location);
         if(viewsData[i].active) {
             edgeStr = "<b>" + edgeStr + "</b>";
         }
         report += "<td align='center'>" + edgeStr + "</td>" ;
 
         //! active
-        QString activeStr = "";
+        QString activeStr = " -- ";
         if(viewsData[i].active) {
             activeStr = "<b>" + i18n("Yes") + "</b>";
         }
         report += "<td align='center'>" + activeStr + "</td>" ;
 
         //! systrays
-        QString systraysStr = idsLineStr(viewsData[i].systrays);
+        QString systraysStr = " -- ";
+        if (viewsData[i].systrays.count() > 0) {
+            systraysStr = idsLineStr(viewsData[i].systrays);
+        }
         if(viewsData[i].active) {
             systraysStr = "<b>" + systraysStr + "</b>";
         }
         report += "<td align='center'>" + systraysStr + "</td>";
 
         report += "</tr>";
     }
 
     report += "</table>";
 
     report += "<br/><hr>";
 
     QStringList errorsList;
     bool broken = m_storage->layoutIsBroken(errorsList);
 
     if (!broken) {
         report += "<font color='green'>" + i18n("No errors were identified for this layout...") + "</font><br/>";
     } else {
         report += "<font color='red'><b>" + i18n("Errors:") + "</b></font><br/>";
         for(int i=0; i<errorsList.count(); ++i) {
             report += "<font color='red'><b>[" + QString::number(i) + "] - " + errorsList[i] + "</b></font><br/>";
         }
     }
 
     return report;
 }
 
 QList<int> GenericLayout::viewsScreens()
 {
     QList<int> screens;
 
     if (isActive()) {
         for (const auto containment : m_containments) {
             if (m_storage->isLatteContainment(containment)) {
                 int screenId = -1;
 
                 //! valid screen id
                 if (latteViewExists(containment)) {
                     screenId = m_latteViews[containment]->positioner()->currentScreenId();
                 } else {
                     screenId = containment->screen();
 
                     if (screenId == -1) {
                         screenId = containment->lastScreen();
                     }
                 }
 
                 if (screenId!=-1 &&!screens.contains(screenId)) {
                     screens << screenId;
                 }
             }
         }
 
         return screens;
     } else {
         return m_storage->viewsScreens();
     }
 }
 
 
 //! STORAGE
 
 bool GenericLayout::isWritable() const
 {
     return m_storage->isWritable();
 }
 
 void GenericLayout::lock()
 {
     m_storage->lock();
 }
 
 void GenericLayout::unlock()
 {
     m_storage->unlock();
 }
 
 void GenericLayout::syncToLayoutFile(bool removeLayoutId)
 {
     m_storage->syncToLayoutFile(removeLayoutId);
 }
 
 void GenericLayout::copyView(Plasma::Containment *containment)
 {
     m_storage->copyView(containment);
     emit viewEdgeChanged();
 }
 
 void GenericLayout::importToCorona()
 {
     m_storage->importToCorona();
 }
 
 bool GenericLayout::layoutIsBroken() const
 {
     QStringList errors;
     return m_storage->layoutIsBroken(errors);
 }
 
 }
 }
diff --git a/app/layout/genericlayout.h b/app/layout/genericlayout.h
index 249cc2cd..8f3296d3 100644
--- a/app/layout/genericlayout.h
+++ b/app/layout/genericlayout.h
@@ -1,221 +1,222 @@
 /*
 *  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 GENERICLAYOUT_H
 #define GENERICLAYOUT_H
 
 // local
 #include "abstractlayout.h"
 #include "../../liblatte2/types.h"
 
 // Qt
 #include <QObject>
 #include <QQuickView>
 #include <QPointer>
 #include <QScreen>
 
 // Plasma
 #include <Plasma>
 
 namespace Plasma {
 class Applet;
 class Containment;
 class Types;
 }
 
 namespace Latte {
 class Corona;
+class ScreenPool;
 class View;
 }
 
 namespace Latte {
 namespace Layout {
 class Storage;
 }
 }
 
 namespace Latte {
 namespace Layout {
 
 struct ViewData
 {
     int id; //view id
     bool active; //is active
     bool onPrimary; //on primary
     int screenId; //explicit screen id
     int location; //edge location
     QList<int> systrays;
 };
 
 //! This is  views map in the following structure:
 //! SCREEN_NAME -> EDGE -> VIEWID
 typedef QHash<QString, QHash<Plasma::Types::Location, uint>> ViewsMap;
 
 class GenericLayout : public AbstractLayout
 {
     Q_OBJECT
     Q_PROPERTY(int viewsCount READ viewsCount NOTIFY viewsCountChanged)
 
 public:   
     GenericLayout(QObject *parent, QString layoutFile, QString assignedName = QString());
     ~GenericLayout() override;
 
     virtual const QStringList appliedActivities() = 0; // to move at an interface
 
     void importToCorona();
     bool initToCorona(Latte::Corona *corona);
 
     bool isActive() const; //! is loaded and running
     virtual bool isCurrent() const;
     bool isWritable() const;
     bool layoutIsBroken() const;
 
     virtual bool configViewIsShown() const;
 
     virtual int viewsCount(int screen) const;
     virtual int viewsCount(QScreen *screen) const;
     virtual int viewsCount() const;
 
     Type type() const override;
 
     Latte::Corona *corona();
 
     QStringList unloadedContainmentsIds();
 
     virtual Types::ViewType latteViewType(int containmentId) const;
     const QList<Plasma::Containment *> *containments();
 
     Latte::View *highestPriorityView();
     Latte::View *viewForContainment(Plasma::Containment *containment);
     virtual QList<Latte::View *> sortedLatteViews(QList<Latte::View *> views = QList<Latte::View *>());
     virtual QList<Latte::View *> viewsWithPlasmaShortcuts();
     virtual QList<Latte::View *> latteViews();
     ViewsMap validViewsMap(ViewsMap *occupiedMap = nullptr);
     virtual void syncLatteViewsToScreens(Layout::ViewsMap *occupiedMap = nullptr);
 
     void syncToLayoutFile(bool removeLayoutId = false);
 
     void lock(); //! make it only read-only
     void renameLayout(QString newName);
     virtual void unloadContainments();
     void unloadLatteViews();
     void unlock(); //! make it writable which it should be the default
 
     virtual void setLastConfigViewFor(Latte::View *view);
     virtual Latte::View *lastConfigViewFor();
 
     //! this function needs the layout to have first set the corona through initToCorona() function
     virtual void addView(Plasma::Containment *containment, bool forceOnPrimary = false, int explicitScreen = -1, Layout::ViewsMap *occupied = nullptr);
     void copyView(Plasma::Containment *containment);
     void recreateView(Plasma::Containment *containment, bool delayed = true);
     bool latteViewExists(Plasma::Containment *containment);
 
     //! Available edges for specific view in that screen
     virtual QList<Plasma::Types::Location> availableEdgesForView(QScreen *scr, Latte::View *forView) const;
     //! All free edges in that screen
     virtual QList<Plasma::Types::Location> freeEdges(QScreen *scr) const;
     virtual QList<Plasma::Types::Location> freeEdges(int screen) const;
 
     //! Bind this latteView and its relevant containments(including systrays)
     //! to this layout. It is used for moving a Latte::View from layout to layout)
     void assignToLayout(Latte::View *latteView, QList<Plasma::Containment *> containments);
     //! Unassign that latteView from this layout (this is used for moving a latteView
     //! from layout to layout) and returns all the containments relevant to
     //! that latteView
     QList<Plasma::Containment *> unassignFromLayout(Latte::View *latteView);
 
-    QString reportHtml();
+    QString reportHtml(const ScreenPool *screenPool);
     QList<int> viewsScreens();
 
 public slots:
     Q_INVOKABLE void addNewView();
     Q_INVOKABLE int viewsWithTasks() const;
     virtual Q_INVOKABLE QList<int> qmlFreeEdges(int screen) const;  //change <Plasma::Types::Location> to <int> types
 
 signals:
     void activitiesChanged(); // to move at an interface
     void viewsCountChanged();
     void viewEdgeChanged();
 
     //! used from ConfigView(s) in order to be informed which is one should be shown
     void lastConfigViewForChanged(Latte::View *view);
 
     //! used from LatteView(s) in order to exist only one each time that has the highest priority
     //! to use the global shortcuts activations
     void preferredViewForShortcutsChanged(Latte::View *view);
 
 protected:
     void updateLastUsedActivity();
 
 protected:
     Latte::Corona *m_corona{nullptr};
 
     QList<Plasma::Containment *> m_containments;
 
     QHash<const Plasma::Containment *, Latte::View *> m_latteViews;
     QHash<const Plasma::Containment *, Latte::View *> m_waitingLatteViews;
 
 private slots:
     void addContainment(Plasma::Containment *containment);
     void appletCreated(Plasma::Applet *applet);
     void destroyedChanged(bool destroyed);
     void containmentDestroyed(QObject *cont);
 
 private:
     //! It can be used in order for LatteViews to not be created automatically when
     //! their corresponding containments are created e.g. copyView functionality
     bool blockAutomaticLatteViewCreation() const;
     void setBlockAutomaticLatteViewCreation(bool block);
 
     bool explicitDockOccupyEdge(int screen, Plasma::Types::Location location) const;
     bool primaryDockOccupyEdge(Plasma::Types::Location location) const;
 
     bool viewAtLowerScreenPriority(Latte::View *test, Latte::View *base);
     bool viewAtLowerEdgePriority(Latte::View *test, Latte::View *base);
 
     bool viewDataAtLowerEdgePriority(const ViewData &test, const ViewData &base) const;
     bool viewDataAtLowerScreenPriority(const ViewData &test, const ViewData &base) const;
     bool viewDataAtLowerStatePriority(const ViewData &test, const ViewData &base) const;
 
     bool mapContainsId(const ViewsMap *map, uint viewId) const;
 
     QList<int> containmentSystrays(Plasma::Containment *containment) const;
 
     QList<ViewData> sortedViewsData(const QList<ViewData> &viewsData);
 
 private:
     bool m_blockAutomaticLatteViewCreation{false};
 
     QPointer<Latte::View> m_lastConfigViewFor;
 
     QStringList m_unloadedContainmentsIds;
 
     QPointer<Storage> m_storage;
 
     //! try to avoid crashes from recreating the same views all the time
     QList<const Plasma::Containment *> m_viewsToRecreate;
 
     friend class Storage;
     friend class Latte::View;
 };
 
 }
 }
 
 #endif
diff --git a/app/layout/storage.cpp b/app/layout/storage.cpp
index c5fad741..0723645d 100644
--- a/app/layout/storage.cpp
+++ b/app/layout/storage.cpp
@@ -1,697 +1,768 @@
 /*
 *  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 "storage.h"
 
 // local
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../layouts/manager.h"
 #include "../layouts/importer.h"
 #include "../view/view.h"
 // Qt
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 
 // KDE
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 
 namespace Latte {
 namespace Layout {
 
 Storage::Storage(GenericLayout *parent)
     : QObject(parent),
       m_layout(parent)
 {
 }
 
 Storage::~Storage()
 {
 }
 
 bool Storage::isWritable() const
 {
     QFileInfo layoutFileInfo(m_layout->file());
 
     if (layoutFileInfo.exists() && !layoutFileInfo.isWritable()) {
         return false;
     } else {
         return true;
     }
 }
 
 bool Storage::isLatteContainment(Plasma::Containment *containment) const
 {
     if (!containment) {
         return false;
     }
 
     if (containment->pluginMetaData().pluginId() == "org.kde.latte.containment") {
         return true;
     }
 
     return false;
 }
 
 bool Storage::isLatteContainment(const KConfigGroup &group) const
 {
     QString pluginId = group.readEntry("plugin", "");
     return pluginId == "org.kde.latte.containment";
 }
 
 void Storage::lock()
 {
     QFileInfo layoutFileInfo(m_layout->file());
 
     if (layoutFileInfo.exists() && layoutFileInfo.isWritable()) {
         QFile(m_layout->file()).setPermissions(QFileDevice::ReadUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 }
 
 void Storage::unlock()
 {
     QFileInfo layoutFileInfo(m_layout->file());
 
     if (layoutFileInfo.exists() && !layoutFileInfo.isWritable()) {
         QFile(m_layout->file()).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 }
 
 void Storage::importToCorona()
 {
     if (!m_layout->corona()) {
         return;
     }
 
     //! Setting mutable for create a containment
     m_layout->corona()->setImmutability(Plasma::Types::Mutable);
 
     QString temp1FilePath = QDir::homePath() + "/.config/lattedock.copy1.bak";
     //! we need to copy first the layout file because the kde cache
     //! may not have yet been updated (KSharedConfigPtr)
     //! this way we make sure at the latest changes stored in the layout file
     //! will be also available when changing to Multiple Layouts
     QString tempLayoutFilePath = QDir::homePath() + "/.config/lattedock.layout.bak";
 
     //! WE NEED A WAY TO COPY A CONTAINMENT!!!!
     QFile tempLayoutFile(tempLayoutFilePath);
     QFile copyFile(temp1FilePath);
     QFile layoutOriginalFile(m_layout->file());
 
     if (tempLayoutFile.exists()) {
         tempLayoutFile.remove();
     }
 
     if (copyFile.exists())
         copyFile.remove();
 
     layoutOriginalFile.copy(tempLayoutFilePath);
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(tempLayoutFilePath);
     KSharedConfigPtr newFile = KSharedConfig::openConfig(temp1FilePath);
     KConfigGroup copyGroup = KConfigGroup(newFile, "Containments");
     KConfigGroup current_containments = KConfigGroup(filePtr, "Containments");
 
     current_containments.copyTo(&copyGroup);
 
     copyGroup.sync();
 
     //! update ids to unique ones
     QString temp2File = newUniqueIdsLayoutFromFile(temp1FilePath);
 
 
     //! Finally import the configuration
     importLayoutFile(temp2File);
 }
 
 void Storage::syncToLayoutFile(bool removeLayoutId)
 {
     if (!m_layout->corona() || !isWritable()) {
         return;
     }
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(m_layout->file());
 
     KConfigGroup oldContainments = KConfigGroup(filePtr, "Containments");
     oldContainments.deleteGroup();
     oldContainments.sync();
 
     qDebug() << " LAYOUT :: " << m_layout->name() << " is syncing its original file.";
 
     for (const auto containment : *m_layout->containments()) {
         if (removeLayoutId) {
             containment->config().writeEntry("layoutId", "");
         }
 
         KConfigGroup newGroup = oldContainments.group(QString::number(containment->id()));
         containment->config().copyTo(&newGroup);
 
         if (!removeLayoutId) {
             newGroup.writeEntry("layoutId", "");
             newGroup.sync();
         }
     }
 
     oldContainments.sync();
 }
 
 void Storage::copyView(Plasma::Containment *containment)
 {
     if (!containment || !m_layout->corona())
         return;
 
     qDebug() << "copying containment layout";
     //! Setting mutable for create a containment
     m_layout->corona()->setImmutability(Plasma::Types::Mutable);
 
     QString temp1File = QDir::homePath() + "/.config/lattedock.copy1.bak";
 
     //! WE NEED A WAY TO COPY A CONTAINMENT!!!!
     QFile copyFile(temp1File);
 
     if (copyFile.exists())
         copyFile.remove();
 
     KSharedConfigPtr newFile = KSharedConfig::openConfig(temp1File);
     KConfigGroup copied_conts = KConfigGroup(newFile, "Containments");
     KConfigGroup copied_c1 = KConfigGroup(&copied_conts, QString::number(containment->id()));
 
     containment->config().copyTo(&copied_c1);
 
     //!investigate if there multiple systray(s) in the containment to copy also
 
     //! systrayId, systrayAppletId
     QHash<int, QString> systraysInfo;
     auto applets = containment->config().group("Applets");
 
     for (const auto &applet : applets.groupList()) {
         KConfigGroup appletSettings = applets.group(applet).group("Configuration");
 
         int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
         if (tSysId != -1) {
             systraysInfo[tSysId] = applet;
             qDebug() << "systray with id "<< tSysId << " was found in the containment... ::: " << tSysId;
         }
     }
 
     if (systraysInfo.count() > 0) {
         for(const auto systrayId : systraysInfo.keys()) {
             Plasma::Containment *systray{nullptr};
 
             for (const auto containment : m_layout->corona()->containments()) {
                 if (containment->id() == systrayId) {
                     systray = containment;
                     break;
                 }
             }
 
             if (systray) {
                 KConfigGroup copied_systray = KConfigGroup(&copied_conts, QString::number(systray->id()));
                 systray->config().copyTo(&copied_systray);
             }
         }
     }
     //! end of systray specific code
 
     //! update ids to unique ones
     QString temp2File = newUniqueIdsLayoutFromFile(temp1File);
 
 
     //! Don't create LatteView when the containment is created because we must update
     //! its screen settings first
     m_layout->setBlockAutomaticLatteViewCreation(true);
     //! Finally import the configuration
     QList<Plasma::Containment *> importedDocks = importLayoutFile(temp2File);
 
     Plasma::Containment *newContainment{nullptr};
 
     if (importedDocks.size() == 1) {
         newContainment = importedDocks[0];
     }
 
     if (!newContainment || !newContainment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto config = newContainment->config();
 
     //in multi-screen environment the copied dock is moved to alternative screens first
     const auto screens = qGuiApp->screens();
     auto dock =  m_layout->viewForContainment(containment);
 
     bool setOnExplicitScreen = false;
 
     int dockScrId = -1;
     int copyScrId = -1;
 
     if (dock) {
         dockScrId = dock->positioner()->currentScreenId();
         qDebug() << "COPY DOCK SCREEN ::: " << dockScrId;
 
         if (dockScrId != -1 && screens.count() > 1) {
             for (const auto scr : screens) {
                 copyScrId = m_layout->corona()->screenPool()->id(scr->name());
 
                 //the screen must exist and not be the same with the original dock
                 if (copyScrId > -1 && copyScrId != dockScrId) {
                     QList<Plasma::Types::Location> fEdges = m_layout->freeEdges(copyScrId);
 
                     if (fEdges.contains((Plasma::Types::Location)containment->location())) {
                         ///set this containment to an explicit screen
                         config.writeEntry("onPrimary", false);
                         config.writeEntry("lastScreen", copyScrId);
                         newContainment->setLocation(containment->location());
 
                         qDebug() << "COPY DOCK SCREEN NEW SCREEN ::: " << copyScrId;
 
                         setOnExplicitScreen = true;
                         break;
                     }
                 }
             }
         }
     }
 
     if (!setOnExplicitScreen) {
         QList<Plasma::Types::Location> edges = m_layout->freeEdges(newContainment->screen());
 
         if (edges.count() > 0) {
             newContainment->setLocation(edges.at(0));
         } else {
             newContainment->setLocation(Plasma::Types::BottomEdge);
         }
 
         config.writeEntry("onPrimary", true);
         config.writeEntry("lastScreen", dockScrId);
     }
 
     newContainment->config().sync();
 
     if (setOnExplicitScreen && copyScrId > -1) {
         qDebug() << "Copy Dock in explicit screen ::: " << copyScrId;
         m_layout->addView(newContainment, false, copyScrId);
         newContainment->reactToScreenChange();
     } else {
         qDebug() << "Copy Dock in current screen...";
         m_layout->addView(newContainment, false, dockScrId);
     }
 
     m_layout->setBlockAutomaticLatteViewCreation(false);
 }
 
 QList<Plasma::Containment *> Storage::importLayoutFile(QString file)
 {
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(file);
     auto newContainments = m_layout->corona()->importLayout(KConfigGroup(filePtr, ""));
 
     ///Find latte and systray containments
     qDebug() << " imported containments ::: " << newContainments.length();
 
     QList<Plasma::Containment *> importedDocks;
     //QList<Plasma::Containment *> systrays;
 
     for (const auto containment : newContainments) {
         if (isLatteContainment(containment)) {
             qDebug() << "new latte containment id: " << containment->id();
             importedDocks << containment;
         }
     }
 
     return importedDocks;
 }
 
+void Storage::systraysInformation(QHash<int, QList<int>> &systrays, QList<int> &assignedSystrays, QList<int> &orphanSystrays)
+{
+    systrays.clear();
+    assignedSystrays.clear();
+    orphanSystrays.clear();
+
+    KSharedConfigPtr lFile = KSharedConfig::openConfig(m_layout->file());
+    KConfigGroup containmentGroups = KConfigGroup(lFile, "Containments");
+
+    //! assigned systrays
+    for (const auto &cId : containmentGroups.groupList()) {
+        if (isLatteContainment(containmentGroups.group(cId))) {
+            auto applets = containmentGroups.group(cId).group("Applets");
+
+            for (const auto &applet : applets.groupList()) {
+                KConfigGroup appletSettings = applets.group(applet).group("Configuration");
+                int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
+
+                if (tSysId != -1) {
+                    assignedSystrays << tSysId;
+                    systrays[cId.toInt()].append(tSysId);
+                }
+            }
+        }
+    }
+
+    //! orphan systrays
+    for (const auto &cId : containmentGroups.groupList()) {
+        if (!isLatteContainment(containmentGroups.group(cId)) && !assignedSystrays.contains(cId.toInt())) {
+            orphanSystrays << cId.toInt();
+        }
+    }
+}
+
+QList<ViewData> Storage::viewsData(const QHash<int, QList<int>> &systrays)
+{
+    QList<ViewData> viewsData;
+
+    KSharedConfigPtr lFile = KSharedConfig::openConfig(m_layout->file());
+    KConfigGroup containmentGroups = KConfigGroup(lFile, "Containments");
+
+    for (const auto &cId : containmentGroups.groupList()) {
+        if (isLatteContainment(containmentGroups.group(cId))) {
+            ViewData vData;
+            int id = cId.toInt();
+
+            //! id
+            vData.id = id;
+
+            //! active
+            vData.active = false;
+
+            //! onPrimary
+            vData.onPrimary = containmentGroups.group(cId).readEntry("onPrimary", true);
+
+            //! Screen
+            vData.screenId = containmentGroups.group(cId).readEntry("lastScreen", -1);
+
+            //! location
+            vData.location = containmentGroups.group(cId).readEntry("location", (int)Plasma::Types::BottomEdge);
+
+            //! systrays
+            vData.systrays = systrays[id];
+
+            viewsData << vData;
+        }
+    }
+
+    return viewsData;
+}
+
 QList<int> Storage::viewsScreens()
 {
     QList<int> screens;
 
     KSharedConfigPtr lFile = KSharedConfig::openConfig(m_layout->file());
 
     KConfigGroup containmentGroups = KConfigGroup(lFile, "Containments");
 
     for (const auto &cId : containmentGroups.groupList()) {
         if (isLatteContainment(containmentGroups.group(cId))) {
             int screenId = containmentGroups.group(cId).readEntry("lastScreen", -1);
 
             if (screenId != -1 && !screens.contains(screenId)) {
                 screens << screenId;
             }
         }
     }
 
     return screens;
 }
 
 QString Storage::availableId(QStringList all, QStringList assigned, int base)
 {
     bool found = false;
 
     int i = base;
 
     while (!found && i < 32000) {
         QString iStr = QString::number(i);
 
         if (!all.contains(iStr) && !assigned.contains(iStr)) {
             return iStr;
         }
 
         i++;
     }
 
     return QString("");
 }
 
 QString Storage::newUniqueIdsLayoutFromFile(QString file)
 {
     if (!m_layout->corona()) {
         return QString();
     }
 
     QString tempFile = QDir::homePath() + "/.config/lattedock.copy2.bak";
 
     QFile copyFile(tempFile);
 
     if (copyFile.exists()) {
         copyFile.remove();
     }
 
     //! BEGIN updating the ids in the temp file
     QStringList allIds;
     allIds << m_layout->corona()->containmentsIds();
     allIds << m_layout->corona()->appletsIds();
 
     QStringList toInvestigateContainmentIds;
     QStringList toInvestigateAppletIds;
     QStringList toInvestigateSystrayContIds;
 
     //! first is the systray containment id
     QHash<QString, QString> systrayParentContainmentIds;
     QHash<QString, QString> systrayAppletIds;
 
     //qDebug() << "Ids:" << allIds;
 
     //qDebug() << "to copy containments: " << toCopyContainmentIds;
     //qDebug() << "to copy applets: " << toCopyAppletIds;
 
     QStringList assignedIds;
     QHash<QString, QString> assigned;
 
     KSharedConfigPtr filePtr = KSharedConfig::openConfig(file);
     KConfigGroup investigate_conts = KConfigGroup(filePtr, "Containments");
 
     //! Record the containment and applet ids
     for (const auto &cId : investigate_conts.groupList()) {
         toInvestigateContainmentIds << cId;
         auto appletsEntries = investigate_conts.group(cId).group("Applets");
         toInvestigateAppletIds << appletsEntries.groupList();
 
         //! investigate for systrays
         for (const auto &appletId : appletsEntries.groupList()) {
             KConfigGroup appletSettings = appletsEntries.group(appletId).group("Configuration");
 
             int tSysId = appletSettings.readEntry("SystrayContainmentId", -1);
 
             //! It is a systray !!!
             if (tSysId != -1) {
                 QString tSysIdStr = QString::number(tSysId);
                 toInvestigateSystrayContIds << tSysIdStr;
                 systrayParentContainmentIds[tSysIdStr] = cId;
                 systrayAppletIds[tSysIdStr] = appletId;
                 qDebug() << "systray was found in the containment...";
             }
         }
     }
 
     //! Reassign containment and applet ids to unique ones
     for (const auto &contId : toInvestigateContainmentIds) {
         QString newId = availableId(allIds, assignedIds, 12);
 
         assignedIds << newId;
         assigned[contId] = newId;
     }
 
     for (const auto &appId : toInvestigateAppletIds) {
         QString newId = availableId(allIds, assignedIds, 40);
 
         assignedIds << newId;
         assigned[appId] = newId;
     }
 
     qDebug() << "ALL CORONA IDS ::: " << allIds;
     qDebug() << "FULL ASSIGNMENTS ::: " << assigned;
 
     for (const auto &cId : toInvestigateContainmentIds) {
         QString value = assigned[cId];
 
         if (assigned.contains(value)) {
             QString value2 = assigned[value];
 
             if (cId != assigned[cId] && !value2.isEmpty() && cId == value2) {
                 qDebug() << "PROBLEM APPEARED !!!! FOR :::: " << cId << " .. fixed ..";
                 assigned[cId] = cId;
                 assigned[value] = value;
             }
         }
     }
 
     for (const auto &aId : toInvestigateAppletIds) {
         QString value = assigned[aId];
 
         if (assigned.contains(value)) {
             QString value2 = assigned[value];
 
             if (aId != assigned[aId] && !value2.isEmpty() && aId == value2) {
                 qDebug() << "PROBLEM APPEARED !!!! FOR :::: " << aId << " .. fixed ..";
                 assigned[aId] = aId;
                 assigned[value] = value;
             }
         }
     }
 
     qDebug() << "FIXED FULL ASSIGNMENTS ::: " << assigned;
 
     //! update applet ids in their containment order and in MultipleLayouts update also the layoutId
     for (const auto &cId : investigate_conts.groupList()) {
         //! Update options that contain applet ids
         //! (appletOrder) and (lockedZoomApplets) and (userBlocksColorizingApplets)
         QStringList options;
         options << "appletOrder" << "lockedZoomApplets" << "userBlocksColorizingApplets";
 
         for (const auto &settingStr : options) {
             QString order1 = investigate_conts.group(cId).group("General").readEntry(settingStr, QString());
 
             if (!order1.isEmpty()) {
                 QStringList order1Ids = order1.split(";");
                 QStringList fixedOrder1Ids;
 
                 for (int i = 0; i < order1Ids.count(); ++i) {
                     fixedOrder1Ids.append(assigned[order1Ids[i]]);
                 }
 
                 QString fixedOrder1 = fixedOrder1Ids.join(";");
                 investigate_conts.group(cId).group("General").writeEntry(settingStr, fixedOrder1);
             }
         }
 
         if (m_layout->corona()->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             investigate_conts.group(cId).writeEntry("layoutId", m_layout->name());
         }
     }
 
     //! must update also the systray id in its applet
     for (const auto &systrayId : toInvestigateSystrayContIds) {
         KConfigGroup systrayParentContainment = investigate_conts.group(systrayParentContainmentIds[systrayId]);
         systrayParentContainment.group("Applets").group(systrayAppletIds[systrayId]).group("Configuration").writeEntry("SystrayContainmentId", assigned[systrayId]);
         systrayParentContainment.sync();
     }
 
     investigate_conts.sync();
 
     //! Copy To Temp 2 File And Update Correctly The Ids
     KSharedConfigPtr file2Ptr = KSharedConfig::openConfig(tempFile);
     KConfigGroup fixedNewContainmets = KConfigGroup(file2Ptr, "Containments");
 
     for (const auto &contId : investigate_conts.groupList()) {
         QString pluginId = investigate_conts.group(contId).readEntry("plugin", "");
 
         if (pluginId != "org.kde.desktopcontainment") { //!don't add ghost containments
             KConfigGroup newContainmentGroup = fixedNewContainmets.group(assigned[contId]);
             investigate_conts.group(contId).copyTo(&newContainmentGroup);
 
             newContainmentGroup.group("Applets").deleteGroup();
 
             for (const auto &appId : investigate_conts.group(contId).group("Applets").groupList()) {
                 KConfigGroup appletGroup = investigate_conts.group(contId).group("Applets").group(appId);
                 KConfigGroup newAppletGroup = fixedNewContainmets.group(assigned[contId]).group("Applets").group(assigned[appId]);
                 appletGroup.copyTo(&newAppletGroup);
             }
         }
     }
 
     fixedNewContainmets.sync();
 
     return tempFile;
 }
 
 bool Storage::appletGroupIsValid(KConfigGroup appletGroup)
 {
     return !( appletGroup.keyList().count() == 0
               && appletGroup.groupList().count() == 1
               && appletGroup.groupList().at(0) == "Configuration"
               && appletGroup.group("Configuration").keyList().count() == 1
               && appletGroup.group("Configuration").hasKey("PreloadWeight") );
 }
 
 bool Storage::layoutIsBroken(QStringList &errors) const
 {
     if (m_layout->file().isEmpty() || !QFile(m_layout->file()).exists()) {
         return false;
     }
 
     QStringList ids;
     QStringList conts;
     QStringList applets;
 
     KSharedConfigPtr lFile = KSharedConfig::openConfig(m_layout->file());
 
     if (!m_layout->corona()) {
         KConfigGroup containmentsEntries = KConfigGroup(lFile, "Containments");
         ids << containmentsEntries.groupList();
         conts << ids;
 
         for (const auto &cId : containmentsEntries.groupList()) {
             auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
             QStringList validAppletIds;
             bool updated{false};
 
             for (const auto &appletId : appletsEntries.groupList()) {
                 KConfigGroup appletGroup = appletsEntries.group(appletId);
 
                 if (appletGroupIsValid(appletGroup)) {
                     validAppletIds << appletId;
                 } else {
                     updated = true;
                     //! heal layout file by removing applet config records that are not used any more
                     qDebug() << "Layout: " << m_layout->name() << " removing deprecated applet : " << appletId;
                     appletsEntries.deleteGroup(appletId);
                 }
             }
 
             if (updated) {
                 appletsEntries.sync();
             }
 
             ids << validAppletIds;
             applets << validAppletIds;
         }
     } else {
         for (const auto containment : *m_layout->containments()) {
             ids << QString::number(containment->id());
             conts << QString::number(containment->id());
 
             for (const auto applet : containment->applets()) {
                 ids << QString::number(applet->id());
                 applets << QString::number(applet->id());
             }
         }
     }
 
     QSet<QString> idsSet = QSet<QString>::fromList(ids);
 
     /* a different way to count duplicates
     QMap<QString, int> countOfStrings;
 
     for (int i = 0; i < ids.count(); i++) {
         countOfStrings[ids[i]]++;
     }*/
 
     if (idsSet.count() != ids.count()) {
         qDebug() << "   ----   ERROR - BROKEN LAYOUT :: " << m_layout->name() << " ----";
 
         if (!m_layout->corona()) {
             qDebug() << "   --- storaged file : " << m_layout->file();
         } else {
             if (m_layout->corona()->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
                 qDebug() << "   --- in multiple layouts hidden file : " << Layouts::Importer::layoutFilePath(AbstractLayout::MultipleLayoutsName);
             } else {
                 qDebug() << "   --- in active layout file : " << m_layout->file();
             }
         }
 
         qDebug() << "Containments :: " << conts;
         qDebug() << "Applets :: " << applets;
 
         for (const QString &c : conts) {
             if (applets.contains(c)) {
                 QString errorStr = i18n("Same applet and containment id found ::: ") + c;
                 qDebug() << "Error: " << errorStr;
                 errors << errorStr;
             }
         }
 
         for (int i = 0; i < ids.count(); ++i) {
             for (int j = i + 1; j < ids.count(); ++j) {
                 if (ids[i] == ids[j]) {
-                    QString errorStr = i18n("Applets with same id ::: ") + ids[i];
+                    QString errorStr = i18n("Differrent applets with same id ::: ") + ids[i];
                     qDebug() << "Error: " << errorStr;
                     errors << errorStr;
                 }
             }
         }
 
         qDebug() << "  -- - -- - -- - -- - - -- - - - - -- - - - - ";
 
         if (!m_layout->corona()) {
             KConfigGroup containmentsEntries = KConfigGroup(lFile, "Containments");
 
             for (const auto &cId : containmentsEntries.groupList()) {
                 auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
                 qDebug() << " CONTAINMENT : " << cId << " APPLETS : " << appletsEntries.groupList();
             }
         } else {
             for (const auto containment : *m_layout->containments()) {
                 QStringList appletsIds;
 
                 for (const auto applet : containment->applets()) {
                     appletsIds << QString::number(applet->id());
                 }
 
                 qDebug() << " CONTAINMENT : " << containment->id() << " APPLETS : " << appletsIds.join(",");
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 }
 }
diff --git a/app/layout/storage.h b/app/layout/storage.h
index e1a947ac..8e02a33c 100644
--- a/app/layout/storage.h
+++ b/app/layout/storage.h
@@ -1,78 +1,84 @@
 /*
 *  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 LAYOUTSTORAGE_H
 #define LAYOUTSTORAGE_H
 
 #include "genericlayout.h"
 
 // Qt
 #include <QObject>
 
 namespace Plasma{
 class Containment;
 }
 
 namespace Latte {
 namespace Layout {
 
 class Storage : public QObject
 {
     Q_OBJECT
 
 public:
     Storage(GenericLayout *parent);
     ~Storage() override;
 
     bool isWritable() const;
     bool isLatteContainment(Plasma::Containment *containment) const;
     bool isLatteContainment(const KConfigGroup &group) const;
     bool layoutIsBroken(QStringList &errors) const;
 
     void importToCorona();
     void lock(); //! make it only read-only
     void unlock(); //! make it writable which it should be the default
 
     void copyView(Plasma::Containment *containment);
     void syncToLayoutFile(bool removeLayoutId);
 
-    QList<int> viewsScreens();
-
     /// STATIC
     //! Check if an applet config group is valid or belongs to removed applet
     static bool appletGroupIsValid(KConfigGroup appletGroup);
 
+    //! Functions used from Layout Reports
+    //! [containment id, list<systrays ids>], list<systrays ids>, list[systrays ids]
+    void systraysInformation(QHash<int, QList<int>> &systrays, QList<int> &assignedSystrays, QList<int> &orphanSystrays);
+    //! list<screens ids>
+    QList<int> viewsScreens();
+    //! list<ViewData>
+    QList<ViewData> viewsData(const QHash<int, QList<int>> &systrays);
+
 private:
     //! STORAGE !////
     QString availableId(QStringList all, QStringList assigned, int base);
     //! provides a new file path based the provided file. The new file
     //! has updated ids for containments and applets based on the corona
     //! loaded ones
     QString newUniqueIdsLayoutFromFile(QString file);
     //! imports a layout file and returns the containments for the docks
     QList<Plasma::Containment *> importLayoutFile(QString file);
 
 private:
     GenericLayout *m_layout;
 };
 
 }
 }
 
 #endif
diff --git a/app/screenpool.cpp b/app/screenpool.cpp
index e6107fbd..efa44c5d 100644
--- a/app/screenpool.cpp
+++ b/app/screenpool.cpp
@@ -1,370 +1,374 @@
 /*
  *  Copyright 2016 Marco Martin <mart@kde.org>
  *
  *   This program is free software; you can redistribute it and/or modify
  *   it under the terms of the GNU Library General Public License as
  *   published by the Free Software Foundation; either version 2, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  *   GNU General Public License for more details
  *
  *   You should have received a copy of the GNU Library General Public
  *   License along with this program; if not, write to the
  *   Free Software Foundation, Inc.,
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  */
 
 #include "screenpool.h"
 
 // local
 #include <config-latte.h>
 
 // Qt
 #include <QDebug>
 #include <QFile>
 #include <QGuiApplication>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedString>
 
 // X11
 #if HAVE_X11
     #include <QtX11Extras/QX11Info>
     #include <xcb/xcb.h>
     #include <xcb/randr.h>
     #include <xcb/xcb_event.h>
 #endif
 
 namespace Latte {
 
 ScreenPool::ScreenPool(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_configGroup(KConfigGroup(config, QStringLiteral("ScreenConnectors")))
 {
     qApp->installNativeEventFilter(this);
 
     m_configSaveTimer.setSingleShot(true);
     connect(&m_configSaveTimer, &QTimer::timeout, this, [this]() {
         m_configGroup.sync();
     });
 }
 
 void ScreenPool::load()
 {
     m_primaryConnector = QString();
     m_connectorForId.clear();
     m_idForConnector.clear();
 
     QScreen *primary = qGuiApp->primaryScreen();
 
     if (primary) {
         m_primaryConnector = primary->name();
 
         if (!m_primaryConnector.isEmpty()) {
             //m_connectorForId[0] = m_primaryConnector;
             //m_idForConnector[m_primaryConnector] = 0;
         }
     }
 
     //restore the known ids to connector mappings
     for (const QString &key : m_configGroup.keyList()) {
         QString connector = m_configGroup.readEntry(key, QString());
         qDebug() << "connector :" << connector << " - " << key;
 
         if (!key.isEmpty() && !connector.isEmpty() &&
             !m_connectorForId.contains(key.toInt()) &&
             !m_idForConnector.contains(connector)) {
             m_connectorForId[key.toInt()] = connector;
             m_idForConnector[connector] = key.toInt();
             qDebug() << "Known Screen - " << connector << " - " << key.toInt();
         } else if (m_idForConnector.value(connector) != key.toInt()) {
             m_configGroup.deleteEntry(key);
         }
     }
 
     // if there are already connected unknown screens, map those
     // all needs to be populated as soon as possible, otherwise
     // containment->screen() will return an incorrect -1
     // at startup, if it' asked before corona::addOutput()
     // is performed, driving to the creation of a new containment
     for (QScreen *screen : qGuiApp->screens()) {
         if (!m_idForConnector.contains(screen->name())) {
             insertScreenMapping(firstAvailableId(), screen->name());
         }
     }
 }
 
 ScreenPool::~ScreenPool()
 {
     m_configGroup.sync();
 }
 
 
 QString ScreenPool::reportHtml(const QList<int> &assignedScreens) const
 {
     QString report;
 
     report += "<table cellspacing='8'>";
     report += "<tr><td align='center'><b>" + i18nc("screen id","ID") + "</b></td>" +
             "<td align='center'><b>" + i18nc("screen name", "Name") + "</b></td>" +
             "<td align='center'><b>" + i18nc("screen type", "Type") + "</b></td>" +
             "<td align='center'><b>" + i18n("Docks/Panels") + "</b></td></tr>";
 
     report += "<tr><td colspan='4'><hr></td></tr>";
 
     for(const QString &connector : m_connectorForId) {
         int scrId = id(connector);
         bool hasViews = assignedScreens.contains(scrId);
         bool primary = m_primaryConnector == connector;
         bool secondary = !primary && screenExists(scrId);
 
         report += "<tr>";
 
         //! ScreenId
-        QString idStr = QString::number(scrId);
+        QString idStr = "[" + QString::number(scrId) + "]";
         if (primary || secondary) {
             idStr = "<b>" + idStr +"</b>";
         }
         report += "<td align='center'>" + idStr + "</td>";
 
         //! ScreenName and Primary flag
         QString connectorStr = connector;
         if (primary || secondary) {
             connectorStr = "<b>"+ connector + "</b>";
         }
         report += "<td align='center'>" + connectorStr + "</td>";
 
         //! ScreenType
         QString typeStr = "";
         if (primary) {
             typeStr = "<b><font color='green'>[" + i18nc("primary screen","Primary") + "]</font></b>";
         } else if (secondary) {
             typeStr = "<b>[" + i18nc("secondary screen","Secondary") + "]</b>";
+        } else {
+            typeStr = "<i>" + i18nc("inactive screen","inactive") + "</i>";
         }
 
         report += "<td align='center'>" + typeStr +"</td>";
 
         //! Screen has not assigned any docks/panels
         QString notAssignedStr = "";
         if (!hasViews) {
             notAssignedStr = "<font color='red'><i>[" + i18nc("it has not latte docks/panels", "none") + "]</i></font>";
+        } else {
+            notAssignedStr = " ✔ ";
         }
 
         report += "<td align='center'>" + notAssignedStr +"</td>";
 
         report += "</tr>";
     }
 
     report += "</table>";
 
     return report;
 }
 
 void ScreenPool::reload(QString path)
 {
     QFile rcfile(QString(path + "/lattedockrc"));
 
     if (rcfile.exists()) {
         qDebug() << "load screen connectors from ::: " << rcfile.fileName();
         KSharedConfigPtr newFile = KSharedConfig::openConfig(rcfile.fileName());
         m_configGroup = KConfigGroup(newFile, QStringLiteral("ScreenConnectors"));
         load();
     }
 
 
 
 }
 
 int ScreenPool::primaryScreenId() const
 {
     return id(qGuiApp->primaryScreen()->name());
 }
 
 QString ScreenPool::primaryConnector() const
 {
     return m_primaryConnector;
 }
 
 void ScreenPool::setPrimaryConnector(const QString &primary)
 {
     //the ":" check fixes the strange plasma/qt issues when changing layouts
     //there are case that the QScreen instead of the correct screen name
     //returns "0:0", this check prevents from breaking the screens database
     //from garbage ids
     if ((m_primaryConnector == primary) || primary.startsWith(":")) {
         return;
     }
 
     Q_ASSERT(m_idForConnector.contains(primary));
 
     /* int oldIdForPrimary = m_idForConnector.value(primary);
 
      m_idForConnector[primary] = 0;
      m_connectorForId[0] = primary;
      m_idForConnector[m_primaryConnector] = oldIdForPrimary;
      m_connectorForId[oldIdForPrimary] = m_primaryConnector;
      m_primaryConnector = primary;
     */
     save();
 }
 
 void ScreenPool::save()
 {
     QMap<int, QString>::const_iterator i;
 
     for (i = m_connectorForId.constBegin(); i != m_connectorForId.constEnd(); ++i) {
         m_configGroup.writeEntry(QString::number(i.key()), i.value());
     }
 
     //write to disck every 30 seconds at most
     m_configSaveTimer.start(30000);
 }
 
 void ScreenPool::insertScreenMapping(int id, const QString &connector)
 {
     //Q_ASSERT(!m_connectorForId.contains(id) || m_connectorForId.value(id) == connector);
     //Q_ASSERT(!m_idForConnector.contains(connector) || m_idForConnector.value(connector) == id);
 
     //the ":" check fixes the strange plasma/qt issues when changing layouts
     //there are case that the QScreen instead of the correct screen name
     //returns "0:0", this check prevents from breaking the screens database
     //from garbage ids
     if (connector.startsWith(":"))
         return;
 
     qDebug() << "add connector..." << connector;
 
     if (id == 0) {
         m_primaryConnector = connector;
     } else {
         m_connectorForId[id] = connector;
         m_idForConnector[connector] = id;
     }
 
     save();
 }
 
 int ScreenPool::id(const QString &connector) const
 {
     if (!m_idForConnector.contains(connector)) {
         return -1;
     }
 
     return m_idForConnector.value(connector);
 }
 
 QString ScreenPool::connector(int id) const
 {   
     Q_ASSERT(m_connectorForId.contains(id));
 
     return m_connectorForId.value(id);
 }
 
 int ScreenPool::firstAvailableId() const
 {
     //start counting from 10, first numbers will
     //be used for special cases.
     //e.g primaryScreen, id=0
     int i = 10;
 
     //find the first integer not stored in m_connectorForId
     //m_connectorForId is the only map, so the ids are sorted
     for (const int &existingId : m_connectorForId.keys()) {
         if (i != existingId) {
             return i;
         }
 
         ++i;
     }
 
     return i;
 }
 
 QList <int> ScreenPool::knownIds() const
 {
     return m_connectorForId.keys();
 }
 
 bool ScreenPool::hasId(int id) const
 {
     return ((id!=-1) && m_connectorForId.keys().contains(id));
 }
 
 bool ScreenPool::screenExists(int id) const
 {
     if (id != -1 && knownIds().contains(id)) {
         QString scrName = connector(id);
 
         for (const auto scr : qGuiApp->screens()) {
             if (scr->name() == scrName) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 QScreen *ScreenPool::screenForId(int id)
 {
     const auto screens = qGuiApp->screens();
     QScreen *screen{qGuiApp->primaryScreen()};
 
     if (id != -1 && knownIds().contains(id)) {
         QString scrName = connector(id);
 
         for (const auto scr : screens) {
             if (scr->name() == scrName) {
                 return scr;
             }
         }
     }
 
     return screen;
 }
 
 
 bool ScreenPool::nativeEventFilter(const QByteArray &eventType, void *message, long int *result)
 {
     Q_UNUSED(result);
 #if HAVE_X11
 
     // a particular edge case: when we switch the only enabled screen
     // we don't have any signal about it, the primary screen changes but we have the same old QScreen* getting recycled
     // see https://bugs.kde.org/show_bug.cgi?id=373880
     // if this slot will be invoked many times, their//second time on will do nothing as name and primaryconnector will be the same by then
     if (eventType != "xcb_generic_event_t") {
         return false;
     }
 
     xcb_generic_event_t *ev = static_cast<xcb_generic_event_t *>(message);
 
     const auto responseType = XCB_EVENT_RESPONSE_TYPE(ev);
 
     const xcb_query_extension_reply_t *reply = xcb_get_extension_data(QX11Info::connection(), &xcb_randr_id);
 
     if (responseType == reply->first_event + XCB_RANDR_SCREEN_CHANGE_NOTIFY) {
         if (qGuiApp->primaryScreen()->name() != primaryConnector()) {
             //new screen?
             if (id(qGuiApp->primaryScreen()->name()) < 0) {
                 insertScreenMapping(firstAvailableId(), qGuiApp->primaryScreen()->name());
             }
 
             //switch the primary screen in the pool
             setPrimaryConnector(qGuiApp->primaryScreen()->name());
 
             emit primaryPoolChanged();
         }
     }
 
 #endif
     return false;
 }
 
 }
 
 #include "moc_screenpool.cpp"
diff --git a/app/settings/settingsdialog.cpp b/app/settings/settingsdialog.cpp
index eef08047..f3400a01 100644
--- a/app/settings/settingsdialog.cpp
+++ b/app/settings/settingsdialog.cpp
@@ -1,2057 +1,2055 @@
 /*
  * Copyright 2017  Smith AR <audoban@openmailbox.org>
  *                 Michail Vourlakos <mvourlakos@gmail.com>
  *
  * This file is part of Latte-Dock
  *
  * Latte-Dock is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * Latte-Dock is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  *
  */
 
 #include "settingsdialog.h"
 
 // local
 #include "universalsettings.h"
 #include "ui_settingsdialog.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../layout/genericlayout.h"
 #include "../layout/centrallayout.h"
 #include "../layout/sharedlayout.h"
 #include "../layouts/importer.h"
 #include "../layouts/manager.h"
 #include "../layouts/synchronizer.h"
 #include "../liblatte2/types.h"
 #include "../plasma/extended/theme.h"
 #include "delegates/activitiesdelegate.h"
 #include "delegates/checkboxdelegate.h"
 #include "delegates/colorcmbboxdelegate.h"
 #include "delegates/layoutnamedelegate.h"
 #include "delegates/shareddelegate.h"
 
 // Qt
 #include <QButtonGroup>
 #include <QColorDialog>
 #include <QDesktopServices>
 #include <QDir>
 #include <QFileDialog>
 #include <QHeaderView>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QProcess>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QTemporaryDir>
 
 // KDE
 #include <KActivities/Controller>
 #include <KArchive/KTar>
 #include <KArchive/KArchiveEntry>
 #include <KArchive/KArchiveDirectory>
 #include <KLocalizedString>
 #include <KNotification>
 #include <KWindowSystem>
 #include <KNewStuff3/KNS3/DownloadDialog>
 
 namespace Latte {
 
 const int IDCOLUMN = 0;
 const int HIDDENTEXTCOLUMN = 1;
 const int COLORCOLUMN = 2;
 const int NAMECOLUMN = 3;
 const int MENUCOLUMN = 4;
 const int BORDERSCOLUMN = 5;
 const int ACTIVITYCOLUMN = 6;
 const int SHAREDCOLUMN = 7;
 
 const int SCREENTRACKERDEFAULTVALUE = 2500;
 const int OUTLINEDEFAULTWIDTH = 1;
 
 const QChar CheckMark{0x2714};
 
 SettingsDialog::SettingsDialog(QWidget *parent, Latte::Corona *corona)
     : QDialog(parent),
       ui(new Ui::SettingsDialog),
       m_corona(corona)
 {
     ui->setupUi(this);
 
     setAttribute(Qt::WA_DeleteOnClose, true);
     setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
     resize(m_corona->universalSettings()->layoutsWindowSize());
 
     connect(ui->buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked
             , this, &SettingsDialog::apply);
     connect(ui->buttonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked
             , this, &SettingsDialog::restoreDefaults);
 
     m_model = new QStandardItemModel(m_corona->layoutsManager()->layouts().count(), 6, this);
 
     ui->layoutsView->setModel(m_model);
     ui->layoutsView->horizontalHeader()->setStretchLastSection(true);
     ui->layoutsView->verticalHeader()->setVisible(false);
 
     connect(m_corona->layoutsManager(), &Layouts::Manager::currentLayoutNameChanged, this, &SettingsDialog::layoutsChanged);
     connect(m_corona->layoutsManager(), &Layouts::Manager::centralLayoutsChanged, this, &SettingsDialog::layoutsChanged);
 
     QString iconsPath(m_corona->kPackage().path() + "../../plasmoids/org.kde.latte.containment/contents/icons/");
 
     //!find the available colors
     QDir layoutDir(iconsPath);
     QStringList filter;
     filter.append(QString("*print.jpg"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
     QStringList colors;
 
     for (auto &file : files) {
         int colorEnd = file.lastIndexOf("print.jpg");
         QString color = file.remove(colorEnd, 9);
         colors.append(color);
     }
 
     ui->layoutsView->setItemDelegateForColumn(NAMECOLUMN, new LayoutNameDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(COLORCOLUMN, new ColorCmbBoxDelegate(this, iconsPath, colors));
     ui->layoutsView->setItemDelegateForColumn(MENUCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(BORDERSCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(ACTIVITYCOLUMN, new ActivitiesDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(SHAREDCOLUMN, new SharedDelegate(this));
 
     m_inMemoryButtons = new QButtonGroup(this);
     m_inMemoryButtons->addButton(ui->singleToolBtn, Latte::Types::SingleLayout);
     m_inMemoryButtons->addButton(ui->multipleToolBtn, Latte::Types::MultipleLayouts);
     m_inMemoryButtons->setExclusive(true);
 
     if (KWindowSystem::isPlatformWayland()) {
         m_inMemoryButtons->button(Latte::Types::MultipleLayouts)->setEnabled(false);
     }
 
     m_mouseSensitivityButtons = new QButtonGroup(this);
     m_mouseSensitivityButtons->addButton(ui->lowSensitivityBtn, Latte::Types::LowSensitivity);
     m_mouseSensitivityButtons->addButton(ui->mediumSensitivityBtn, Latte::Types::MediumSensitivity);
     m_mouseSensitivityButtons->addButton(ui->highSensitivityBtn, Latte::Types::HighSensitivity);
     m_mouseSensitivityButtons->setExclusive(true);
 
     ui->screenTrackerSpinBox->setValue(m_corona->universalSettings()->screenTrackerInterval());
     ui->outlineSpinBox->setValue(m_corona->themeExtended()->outlineWidth());
 
     //! About Menu
     QMenuBar *menuBar = new QMenuBar(this);
     // QMenuBar *rightAlignedMenuBar = new QMenuBar(menuBar);
 
     layout()->setMenuBar(menuBar);
     //menuBar->setCornerWidget(rightAlignedMenuBar);
 
     QMenu *fileMenu = new QMenu(i18n("File"), menuBar);
     menuBar->addMenu(fileMenu);
 
     QMenu *layoutMenu = new QMenu(i18n("Layout"), menuBar);
     //rightAlignedMenuBar->addMenu(helpMenu);
     menuBar->addMenu(layoutMenu);
 
     QMenu *helpMenu = new QMenu(i18n("Help"), menuBar);
     //rightAlignedMenuBar->addMenu(helpMenu);
     menuBar->addMenu(helpMenu);
 
     QAction *screensAction = fileMenu->addAction(i18n("Sc&reens..."));
     screensAction->setIcon(QIcon::fromTheme("document-properties"));
     screensAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_R));
 
     QAction *quitAction = fileMenu->addAction(i18n("&Quit Latte"));
     quitAction->setIcon(QIcon::fromTheme("application-exit"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
 
     m_editLayoutAction = layoutMenu->addAction(i18nc("edit layout","&Edit..."));
     m_editLayoutAction->setIcon(QIcon::fromTheme("document-edit"));
     m_editLayoutAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_E));
     m_editLayoutAction->setToolTip("You can edit layout file when layout is not active or locked");
 
     QAction *infoLayoutAction = layoutMenu->addAction(i18nc("layout information","&Information..."));
     infoLayoutAction->setIcon(QIcon::fromTheme("document-properties"));
     infoLayoutAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_I));
 
     QAction *aboutAction = helpMenu->addAction(i18n("About Latte"));
     aboutAction->setIcon(QIcon::fromTheme("latte-dock"));
 
     //! RTL support for labels in preferences
     if (qApp->layoutDirection() == Qt::RightToLeft) {
         ui->behaviorLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
         ui->mouseSensetivityLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
         ui->delayLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
     }
 
     loadSettings();
 
     //! SIGNALS
 
     connect(m_model, &QStandardItemModel::itemChanged, this, &SettingsDialog::itemChanged);
     connect(ui->layoutsView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, [&]() {
         updatePerLayoutButtonsState();
         updateApplyButtonsState();
     });
 
     connect(m_inMemoryButtons, static_cast<void(QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled),
             [ = ](int id, bool checked) {
         updateApplyButtonsState();
         updateSharedLayoutsStates();
         updateSharedLayoutsUiElements();
     });
 
     connect(m_mouseSensitivityButtons, static_cast<void(QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled),
             [ = ](int id, bool checked) {
         updateApplyButtonsState();
     });
 
     connect(ui->screenTrackerSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [ = ](int i) {
         updateApplyButtonsState();
     });
 
     connect(ui->outlineSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [ = ](int i) {
         updateApplyButtonsState();
     });
 
     connect(ui->autostartChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->badges3DStyleChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->metaPressChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->metaPressHoldChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->infoWindowChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->tabWidget, &QTabWidget::currentChanged, this, &SettingsDialog::updateApplyButtonsState);
 
     connect(ui->noBordersForMaximizedChkBox, &QCheckBox::stateChanged, this, [&]() {
         bool noBordersForMaximized = ui->noBordersForMaximizedChkBox->isChecked();
 
         if (noBordersForMaximized) {
             ui->layoutsView->setColumnHidden(BORDERSCOLUMN, false);
         } else {
             ui->layoutsView->setColumnHidden(BORDERSCOLUMN, true);
         }
 
         updateApplyButtonsState();
     });
 
     connect(aboutAction, &QAction::triggered, m_corona, &Latte::Corona::aboutApplication);
     connect(quitAction, &QAction::triggered, this, [&]() {
         close();
         m_corona->closeApplication();
     });
 
     connect(m_editLayoutAction, &QAction::triggered, this, [&]() {
         QString file = idForRow(ui->layoutsView->currentIndex().row());
 
         if (!file.isEmpty()) {
             QProcess::startDetached("kwrite \"" + file + "\"");
         }
     });
 
     connect(infoLayoutAction, &QAction::triggered, this, &SettingsDialog::showLayoutInformation);
     connect(screensAction, &QAction::triggered, this, &SettingsDialog::showScreensInformation);
 
     //! update all layouts view when runningActivities changed. This way we update immediately
     //! the running Activities in Activities checkboxes which are shown as bold
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged,
             this, [&]() {
         ui->layoutsView->update();
     });
 
     blockDeleteOnActivityStopped();
 }
 
 SettingsDialog::~SettingsDialog()
 {
     qDebug() << Q_FUNC_INFO;
 
     qDeleteAll(m_layouts);
 
     if (m_model) {
         delete m_model;
     }
 
     if (m_corona && m_corona->universalSettings()) {
         m_corona->universalSettings()->setLayoutsWindowSize(size());
 
         QStringList columnWidths;       
         columnWidths << QString::number(ui->layoutsView->columnWidth(COLORCOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(NAMECOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(MENUCOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(BORDERSCOLUMN));
 
         Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
 
         if (inMemoryOption == Latte::Types::MultipleLayouts) {
             columnWidths << QString::number(ui->layoutsView->columnWidth(ACTIVITYCOLUMN));
         } else {
             //! In Single Mode, keed recorded value for ACTIVITYCOLUMN
             QStringList currentWidths = m_corona->universalSettings()->layoutsColumnWidths();
             if (currentWidths.count()>=5) {
                 columnWidths << currentWidths[4];
             }
         }
 
         m_corona->universalSettings()->setLayoutsColumnWidths(columnWidths);
     }
 
     m_inMemoryButtons->deleteLater();
     m_mouseSensitivityButtons->deleteLater();
 
     for (const auto &tempDir : m_tempDirectories) {
         QDir tDir(tempDir);
 
         if (tDir.exists() && tempDir.startsWith("/tmp/")) {
             tDir.removeRecursively();
         }
     }
 }
 
 void SettingsDialog::blockDeleteOnActivityStopped()
 {
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged,
             this, [&]() {
         m_blockDeleteOnReject = true;
         m_activityClosedTimer.start();
     });
 
     m_activityClosedTimer.setSingleShot(true);
     m_activityClosedTimer.setInterval(500);
     connect(&m_activityClosedTimer, &QTimer::timeout, this, [&]() {
         m_blockDeleteOnReject = false;
     });
 }
 
 QStringList SettingsDialog::activities()
 {
     return m_corona->layoutsManager()->synchronizer()->activities();
 }
 
 QStringList SettingsDialog::availableActivities()
 {
     return m_availableActivities;
 }
 
 QStringList SettingsDialog::availableSharesFor(int row)
 {
     QStringList availables;
     QStringList regs;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QStringList shares = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
 
         if (i != row) {
             if (shares.isEmpty()) {
                 availables << id;
             } else {
                 regs << shares;
             }
         }
     }
 
     for (const auto r : regs) {
         availables.removeAll(r);
     }
 
     return availables;
 }
 
 void SettingsDialog::toggleCurrentPage()
 {
     if (ui->tabWidget->currentIndex() == 0) {
         ui->tabWidget->setCurrentIndex(1);
     } else {
         ui->tabWidget->setCurrentIndex(0);
     }
 }
 
 void SettingsDialog::on_newButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     //! find Default preset path
     for (const auto &preset : m_corona->layoutsManager()->presetsPaths()) {
         QString presetName = CentralLayout::layoutName(preset);
 
         if (presetName == "Default") {
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = uniqueLayoutName(i18n(prset_str));
 
             addLayoutForFile(preset, presetName, true, false);
             break;
         }
     }
 }
 
 void SettingsDialog::on_copyButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     //! Update original layout before copying if this layout is active
     if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         QString lName = (m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole)).toString();
 
         Layout::GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(lName);
         if (generic) {
             generic->syncToLayoutFile();
         }
     }
 
     QString tempDir = uniqueTempDirectory();
 
     QString id = m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
     QString color = m_model->data(m_model->index(row, COLORCOLUMN), Qt::BackgroundRole).toString();
     QString textColor = m_model->data(m_model->index(row, COLORCOLUMN), Qt::UserRole).toString();
     QString layoutName = uniqueLayoutName(m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString());
     bool menu = m_model->data(m_model->index(row, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
     bool disabledBorders = m_model->data(m_model->index(row, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
 
     QString copiedId = tempDir + "/" + layoutName + ".layout.latte";
     QFile(id).copy(copiedId);
 
     QFileInfo newFileInfo(copiedId);
 
     if (newFileInfo.exists() && !newFileInfo.isWritable()) {
         QFile(copiedId).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 
     CentralLayout *settings = new CentralLayout(this, copiedId);
     m_layouts[copiedId] = settings;
 
     insertLayoutInfoAtRow(row + 1, copiedId, color, textColor, layoutName, menu, disabledBorders, QStringList(), false);
 
     ui->layoutsView->selectRow(row + 1);
 }
 
 void SettingsDialog::on_downloadButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     KNS3::DownloadDialog dialog(QStringLiteral("latte-layouts.knsrc"), this);
     dialog.resize(m_corona->universalSettings()->downloadWindowSize());
     dialog.exec();
 
     bool layoutAdded{false};
 
     if (!dialog.changedEntries().isEmpty() || !dialog.installedEntries().isEmpty()) {
         for (const auto &entry : dialog.installedEntries()) {
             for (const auto &entryFile : entry.installedFiles()) {
                 Layouts::Importer::LatteFileVersion version = Layouts::Importer::fileVersion(entryFile);
 
                 if (version == Layouts::Importer::LayoutVersion2) {
                     layoutAdded = true;
                     addLayoutForFile(entryFile);
                     break;
                 }
             }
         }
     }
 
     m_corona->universalSettings()->setDownloadWindowSize(dialog.size());
 
     if (layoutAdded) {
         apply();
     }
 }
 
 void SettingsDialog::on_removeButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     QString layoutName = m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString();
 
     if (m_corona->layoutsManager()->synchronizer()->centralLayout(layoutName)) {
         return;
     }
 
     m_model->removeRow(row);
 
     updateApplyButtonsState();
 
     row = qMax(row - 1, 0);
 
     ui->layoutsView->selectRow(row);
 }
 
 void SettingsDialog::on_lockedButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     bool lockedModel = m_model->data(m_model->index(row, NAMECOLUMN), Qt::UserRole).toBool();
 
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(!lockedModel), Qt::UserRole);
 
     updatePerLayoutButtonsState();
     updateApplyButtonsState();
 }
 
 void SettingsDialog::on_sharedButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     if (isShared(row)) {
         m_model->setData(m_model->index(row, SHAREDCOLUMN), QStringList(), Qt::UserRole);
     } else {
         bool assigned{false};
         QStringList assignedList;
 
         QStringList availableShares = availableSharesFor(row);
 
         for (const auto &id : availableShares) {
             QString name = nameForId(id);
             if (m_corona->layoutsManager()->synchronizer()->layout(name)) {
                 assignedList << id;
                 m_model->setData(m_model->index(row, SHAREDCOLUMN), assignedList, Qt::UserRole);
                 assigned = true;
                 break;
             }
         }
 
         if (!assigned && availableShares.count()>0) {
             assignedList << availableShares[0];
             m_model->setData(m_model->index(row, SHAREDCOLUMN), assignedList, Qt::UserRole);
             assigned = true;
         }
     }
 
     updatePerLayoutButtonsState();
     updateApplyButtonsState();
 }
 
 void SettingsDialog::on_importButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
 
     QFileDialog *fileDialog = new QFileDialog(this, i18nc("import layout/configuration", "Import Layout/Configuration")
                                               , QDir::homePath()
                                               , QStringLiteral("layout.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog->setDefaultSuffix("layout.latte");
 
     QStringList filters;
     filters << QString(i18nc("import latte layout", "Latte Dock Layout file v0.2") + "(*.layout.latte)")
             << QString(i18nc("import latte layouts/configuration", "Latte Dock Full Configuration file (v0.1, v0.2)") + "(*.latterc)");
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished
             , fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected
             , this, [&](const QString & file) {
         Layouts::Importer::LatteFileVersion version = Layouts::Importer::fileVersion(file);
         qDebug() << "VERSION :::: " << version;
 
         if (version == Layouts::Importer::LayoutVersion2) {
             addLayoutForFile(file);
         } else if (version == Layouts::Importer::ConfigVersion1) {
             auto msg = new QMessageBox(this);
             msg->setIcon(QMessageBox::Warning);
             msg->setWindowTitle(i18n("Import: Configuration file version v0.1"));
             msg->setText(
                         i18n("You are going to import an old version <b>v0.1</b> configuration file.<br><b>Be careful</b>, importing the entire configuration <b>will erase all</b> your current configuration!!!<br><br> <i>Alternative, you can <b>import safely</b> from this file<br><b>only the contained layouts...</b></i>"));
             msg->setStandardButtons(QMessageBox::Cancel);
 
             QPushButton *fullBtn = new QPushButton(msg);
             QPushButton *layoutsBtn = new QPushButton(msg);
             fullBtn->setText(i18nc("import full configuration", "Full Configuration"));
             fullBtn->setIcon(QIcon::fromTheme("settings"));
             layoutsBtn->setText(i18nc("import only the layouts", "Only Layouts"));
             layoutsBtn->setIcon(QIcon::fromTheme("user-identity"));
 
             msg->addButton(fullBtn, QMessageBox::AcceptRole);
             msg->addButton(layoutsBtn, QMessageBox::AcceptRole);
 
             msg->setDefaultButton(layoutsBtn);
 
             connect(msg, &QMessageBox::finished, msg, &QMessageBox::deleteLater);
 
             msg->open();
 
             connect(layoutsBtn, &QPushButton::clicked
                     , this, [ &, file](bool check) {
                 importLayoutsFromV1ConfigFile(file);
             });
 
             connect(fullBtn, &QPushButton::clicked
                     , this, [ &, file](bool check) {
                 //!NOTE: Restart latte for import the new configuration
                 QProcess::startDetached(qGuiApp->applicationFilePath() + " --import-full \"" + file + "\"");
                 qGuiApp->exit();
             });
         } else if (version == Layouts::Importer::ConfigVersion2) {
             auto msg = new QMessageBox(this);
             msg->setIcon(QMessageBox::Warning);
             msg->setWindowTitle(i18n("Import: Configuration file version v0.2"));
             msg->setText(
                         i18n("You are going to import a <b>v0.2</b> configuration file.<br><b>Be careful</b>, importing <b>will erase all</b> your current configuration!!!<br><br><i>Would you like to proceed?</i>"));
             msg->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
             msg->setDefaultButton(QMessageBox::No);
 
             connect(msg, &QMessageBox::finished, this, [ &, msg, file](int result) {
                 if (result == QMessageBox::Yes) {
                     //!NOTE: Restart latte for import the new configuration
                     msg->deleteLater();
                     QProcess::startDetached(qGuiApp->applicationFilePath() + " --import-full \"" + file + "\"");
                     qGuiApp->exit();
                 }
             });
 
             msg->open();
         }
     });
 
     fileDialog->open();
 }
 
 bool SettingsDialog::importLayoutsFromV1ConfigFile(QString file)
 {
     KTar archive(file, QStringLiteral("application/x-tar"));
     archive.open(QIODevice::ReadOnly);
 
     //! if the file isnt a tar archive
     if (archive.isOpen()) {
         QDir tempDir{uniqueTempDirectory()};
 
         const auto archiveRootDir = archive.directory();
 
         for (const auto &name : archiveRootDir->entries()) {
             auto fileEntry = archiveRootDir->file(name);
             fileEntry->copyTo(tempDir.absolutePath());
         }
 
         QString name = Layouts::Importer::nameOfConfigFile(file);
 
         QString applets(tempDir.absolutePath() + "/" + "lattedock-appletsrc");
 
         if (QFile(applets).exists()) {
             if (m_corona->layoutsManager()->importer()->importOldLayout(applets, name, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + name + ".layout.latte", name, false);
             }
 
             QString alternativeName = name + "-" + i18nc("layout", "Alternative");
 
             if (m_corona->layoutsManager()->importer()->importOldLayout(applets, alternativeName, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + alternativeName + ".layout.latte", alternativeName, false);
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 void SettingsDialog::on_exportButton_clicked()
 {
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     QString layoutExported = m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
 
     //! Update ALL active original layouts before exporting,
     //! this is needed because the export method can export also the full configuration
     qDebug() << Q_FUNC_INFO;
 
     m_corona->layoutsManager()->synchronizer()->syncActiveLayoutsToOriginalFiles();
 
     QFileDialog *fileDialog = new QFileDialog(this, i18nc("export layout/configuration", "Export Layout/Configuration")
                                               , QDir::homePath(), QStringLiteral("layout.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptSave);
     fileDialog->setDefaultSuffix("layout.latte");
 
     QStringList filters;
     QString filter1(i18nc("export layout", "Latte Dock Layout file v0.2") + "(*.layout.latte)");
     QString filter2(i18nc("export full configuration", "Latte Dock Full Configuration file v0.2") + "(*.latterc)");
 
     filters << filter1
             << filter2;
 
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished
             , fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected
             , this, [ &, layoutExported](const QString & file) {
         auto showNotificationError = []() {
             auto notification = new KNotification("export-fail", KNotification::CloseOnTimeout);
             notification->setText(i18nc("export layout", "Failed to export layout"));
             notification->sendEvent();
         };
 
         if (QFile::exists(file) && !QFile::remove(file)) {
             showNotificationError();
             return;
         }
 
         if (file.endsWith(".layout.latte")) {
             if (!QFile(layoutExported).copy(file)) {
                 showNotificationError();
                 return;
             }
 
             QFileInfo newFileInfo(file);
 
             if (newFileInfo.exists() && !newFileInfo.isWritable()) {
                 QFile(file).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
             }
 
             CentralLayout layoutS(this, file);
             layoutS.setActivities(QStringList());
             layoutS.clearLastUsedActivity();
 
             //NOTE: The pointer is automatically deleted when the event is closed
             auto notification = new KNotification("export-done", KNotification::CloseOnTimeout);
             notification->setActions({i18nc("export layout", "Open location")});
             notification->setText(i18nc("export layout", "Layout exported successfully"));
 
             connect(notification, &KNotification::action1Activated
                     , this, [file]() {
                 QDesktopServices::openUrl({QFileInfo(file).canonicalPath()});
             });
 
             notification->sendEvent();
         } else if (file.endsWith(".latterc")) {
             auto showNotificationError = []() {
                 auto notification = new KNotification("export-fail", KNotification::CloseOnTimeout);
                 notification->setText(i18nc("import/export config", "Failed to export configuration"));
                 notification->sendEvent();
             };
 
             if (m_corona->layoutsManager()->importer()->exportFullConfiguration(file)) {
 
                 auto notification = new KNotification("export-done", KNotification::CloseOnTimeout);
                 notification->setActions({i18nc("import/export config", "Open location")});
                 notification->setText(i18nc("import/export config", "Full Configuration exported successfully"));
 
                 connect(notification, &KNotification::action1Activated
                         , this, [file]() {
                     QDesktopServices::openUrl({QFileInfo(file).canonicalPath()});
                 });
 
                 notification->sendEvent();
             } else {
                 showNotificationError();
             }
         }
     });
 
 
     fileDialog->open();
 }
 
 void SettingsDialog::requestImagesDialog(int row)
 {
     QStringList mimeTypeFilters;
     mimeTypeFilters << "image/jpeg" // will show "JPEG image (*.jpeg *.jpg)
                     << "image/png";  // will show "PNG image (*.png)"
 
     QFileDialog dialog(this);
     dialog.setMimeTypeFilters(mimeTypeFilters);
 
     QString background = m_model->data(m_model->index(row, COLORCOLUMN), Qt::BackgroundRole).toString();
 
     if (background.startsWith("/") && QFileInfo(background).exists()) {
         dialog.setDirectory(QFileInfo(background).absolutePath());
         dialog.selectFile(background);
     }
 
     if (dialog.exec()) {
         QStringList files = dialog.selectedFiles();
 
         if (files.count() > 0) {
             m_model->setData(m_model->index(row, COLORCOLUMN), files[0], Qt::BackgroundRole);
         }
     }
 }
 
 void SettingsDialog::requestColorsDialog(int row)
 {
     QColorDialog dialog(this);
     QString textColor = m_model->data(m_model->index(row, COLORCOLUMN), Qt::UserRole).toString();
     dialog.setCurrentColor(QColor(textColor));
 
     if (dialog.exec()) {
         qDebug() << dialog.selectedColor().name();
         m_model->setData(m_model->index(row, COLORCOLUMN), dialog.selectedColor().name(), Qt::UserRole);
     }
 }
 
 
 void SettingsDialog::accept()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (saveAllChanges()) {
         deleteLater();
     }
 }
 
 void SettingsDialog::reject()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (!m_blockDeleteOnReject) {
         deleteLater();
     }
 }
 
 void SettingsDialog::apply()
 {
     qDebug() << Q_FUNC_INFO;
     saveAllChanges();
 
     o_settings = currentSettings();
     o_settingsLayouts = currentLayoutsSettings();
 
     updateApplyButtonsState();
     updatePerLayoutButtonsState();
 }
 
 void SettingsDialog::restoreDefaults()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (ui->tabWidget->currentIndex() == 0) {
         //! Default layouts missing from layouts list
         for (const auto &preset : m_corona->layoutsManager()->presetsPaths()) {
             QString presetName = CentralLayout::layoutName(preset);
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = i18n(prset_str);
 
             if (!nameExistsInModel(presetName)) {
                 addLayoutForFile(preset, presetName);
             }
         }
     } else if (ui->tabWidget->currentIndex() == 1) {
         //! Defaults for general Latte settings
         ui->autostartChkBox->setChecked(true);
         ui->badges3DStyleChkBox->setChecked(true);
         ui->infoWindowChkBox->setChecked(true);
         ui->metaPressChkBox->setChecked(false);
         ui->metaPressHoldChkBox->setChecked(true);
         ui->noBordersForMaximizedChkBox->setChecked(false);
         ui->highSensitivityBtn->setChecked(true);
         ui->screenTrackerSpinBox->setValue(SCREENTRACKERDEFAULTVALUE);
         ui->outlineSpinBox->setValue(OUTLINEDEFAULTWIDTH);
     }
 }
 
 void SettingsDialog::addLayoutForFile(QString file, QString layoutName, bool newTempDirectory, bool showNotification)
 {
     if (layoutName.isEmpty()) {
         layoutName = CentralLayout::layoutName(file);
     }
 
     QString copiedId;
 
     if (newTempDirectory) {
         QString tempDir = uniqueTempDirectory();
         copiedId = tempDir + "/" + layoutName + ".layout.latte";
         QFile(file).copy(copiedId);
     } else {
         copiedId = file;
     }
 
     QFileInfo newFileInfo(copiedId);
 
     if (newFileInfo.exists() && !newFileInfo.isWritable()) {
         QFile(copiedId).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 
     if (m_layouts.contains(copiedId)) {
         CentralLayout *oldSettings = m_layouts.take(copiedId);
         delete oldSettings;
     }
 
     CentralLayout *settings = new CentralLayout(this, copiedId);
     m_layouts[copiedId] = settings;
 
     QString id = copiedId;
     QString color = settings->color();
     QString textColor = settings->textColor();
     QString background = settings->background();
     bool menu = settings->showInMenu();
     bool disabledBorders = settings->disableBordersForMaximizedWindows();
     bool locked = !settings->isWritable();
 
     layoutName = uniqueLayoutName(layoutName);
 
     int row = ascendingRowFor(layoutName);
 
     if (background.isEmpty()) {
         insertLayoutInfoAtRow(row, copiedId, color, QString(), layoutName, menu, disabledBorders, QStringList(), locked);
     } else {
         insertLayoutInfoAtRow(row, copiedId, background, textColor, layoutName, menu, disabledBorders, QStringList(), locked);
     }
 
     ui->layoutsView->selectRow(row);
 
     if (showNotification) {
         //NOTE: The pointer is automatically deleted when the event is closed
         auto notification = new KNotification("import-done", KNotification::CloseOnTimeout);
         notification->setText(i18nc("import-done", "Layout: <b>%0</b> imported successfully<br>").arg(layoutName));
         notification->sendEvent();
     }
 }
 
 void SettingsDialog::loadSettings()
 {
     m_initLayoutPaths.clear();
     m_model->clear();
     m_sharesMap.clear();
 
     int i = 0;
     QStringList brokenLayouts;
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         m_corona->layoutsManager()->synchronizer()->syncActiveLayoutsToOriginalFiles();
     }
 
     for (const auto layout : m_corona->layoutsManager()->layouts()) {
         QString layoutPath = QDir::homePath() + "/.config/latte/" + layout + ".layout.latte";
         m_initLayoutPaths.append(layoutPath);
 
         CentralLayout *central = new CentralLayout(this, layoutPath);
         m_layouts[layoutPath] = central;
 
         QString background = central->background();
 
         //! add central layout properties
         if (background.isEmpty()) {
             insertLayoutInfoAtRow(i, layoutPath, central->color(), QString(), central->name(),
                                   central->showInMenu(), central->disableBordersForMaximizedWindows(),
                                   central->activities(), !central->isWritable());
         } else {
             insertLayoutInfoAtRow(i, layoutPath, background, central->textColor(), central->name(),
                                   central->showInMenu(), central->disableBordersForMaximizedWindows(),
                                   central->activities(), !central->isWritable());
         }
 
         //! create initial SHARES maps
         QString shared = central->sharedLayoutName();
         if (!shared.isEmpty()) {
             m_sharesMap[shared].append(layoutPath);
         }
 
         qDebug() << "counter:" << i << " total:" << m_model->rowCount();
 
         i++;
 
         if (central->name() == m_corona->layoutsManager()->currentLayoutName()) {
             ui->layoutsView->selectRow(i - 1);
         }
 
         Layout::GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(central->name());
 
         if ((generic && generic->layoutIsBroken()) || (!generic && central->layoutIsBroken())) {
             brokenLayouts.append(central->name());
         }
     }
 
     //! update SHARES map keys in order to use the #settingsid(s)
     QStringList forremoval;
 
     //! remove these records after updating
     for (QHash<const QString, QStringList>::iterator i=m_sharesMap.begin(); i!=m_sharesMap.end(); ++i) {
         forremoval << i.key();
     }
 
     //! update keys
     for (QHash<const QString, QStringList>::iterator i=m_sharesMap.begin(); i!=m_sharesMap.end(); ++i) {
         QString shareid = idForRow(rowForName(i.key()));
         m_sharesMap[shareid] = i.value();
     }
 
     //! remove deprecated keys
     for (const auto &key : forremoval) {
         m_sharesMap.remove(key);
     }
 
     qDebug() << "SHARES MAP ::: " << m_sharesMap;
 
     for (QHash<const QString, QStringList>::iterator i=m_sharesMap.begin(); i!=m_sharesMap.end(); ++i) {
         int sharedPos = rowForId(i.key());
 
         if (sharedPos >= 0) {
             m_model->setData(m_model->index(sharedPos, SHAREDCOLUMN), i.value(), Qt::UserRole);
         }
     }
 
     recalculateAvailableActivities();
 
     m_model->setHorizontalHeaderItem(IDCOLUMN, new QStandardItem(QString("#path")));
     m_model->setHorizontalHeaderItem(COLORCOLUMN, new QStandardItem(QIcon::fromTheme("games-config-background"),
                                                                     QString(i18nc("column for layout background", "Background"))));
     m_model->setHorizontalHeaderItem(NAMECOLUMN, new QStandardItem(QString(i18nc("column for layout name", "Name"))));
     m_model->setHorizontalHeaderItem(MENUCOLUMN, new QStandardItem(QString(i18nc("column for layout to show in menu", "In Menu"))));
     m_model->setHorizontalHeaderItem(BORDERSCOLUMN, new QStandardItem(QString(i18nc("column for layout to hide borders for maximized windows", "Borderless"))));
     m_model->setHorizontalHeaderItem(ACTIVITYCOLUMN, new QStandardItem(QIcon::fromTheme("preferences-activities"),
                                                                        QString(i18nc("column for layout to show which activities is assigned to", "Activities"))));
     m_model->setHorizontalHeaderItem(SHAREDCOLUMN, new QStandardItem(QIcon::fromTheme("document-share"),
                                                                      QString(i18nc("column for shared layout to show which layouts is assigned to", "Shared To"))));
 
     //! this line should be commented for debugging layouts window functionality
     ui->layoutsView->setColumnHidden(IDCOLUMN, true);
     ui->layoutsView->setColumnHidden(HIDDENTEXTCOLUMN, true);
 
     if (m_corona->universalSettings()->canDisableBorders()) {
         ui->layoutsView->setColumnHidden(BORDERSCOLUMN, false);
     } else {
         ui->layoutsView->setColumnHidden(BORDERSCOLUMN, true);
     }
 
     ui->layoutsView->resizeColumnsToContents();
 
     QStringList columnWidths = m_corona->universalSettings()->layoutsColumnWidths();
 
     if (!columnWidths.isEmpty()) {
         for (int i=0; i<qMin(columnWidths.count(),4); ++i) {
             ui->layoutsView->setColumnWidth(COLORCOLUMN+i, columnWidths[i].toInt());
         }
     }
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) {
         ui->singleToolBtn->setChecked(true);
     } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         ui->multipleToolBtn->setChecked(true);
     }
 
     updatePerLayoutButtonsState();
     updateSharedLayoutsStates();
 
     ui->autostartChkBox->setChecked(m_corona->universalSettings()->autostart());
     ui->badges3DStyleChkBox->setChecked(m_corona->universalSettings()->badges3DStyle());
     ui->infoWindowChkBox->setChecked(m_corona->universalSettings()->showInfoWindow());
     ui->metaPressChkBox->setChecked(m_corona->universalSettings()->metaForwardedToLatte());
     ui->metaPressHoldChkBox->setChecked(m_corona->universalSettings()->metaPressAndHoldEnabled());
     ui->noBordersForMaximizedChkBox->setChecked(m_corona->universalSettings()->canDisableBorders());
 
     if (m_corona->universalSettings()->mouseSensitivity() == Types::LowSensitivity) {
         ui->lowSensitivityBtn->setChecked(true);
     } else if (m_corona->universalSettings()->mouseSensitivity() == Types::MediumSensitivity) {
         ui->mediumSensitivityBtn->setChecked(true);
     } else if (m_corona->universalSettings()->mouseSensitivity() == Types::HighSensitivity) {
         ui->highSensitivityBtn->setChecked(true);
     }
 
     o_settings = currentSettings();
     o_settingsLayouts = currentLayoutsSettings();
     updateApplyButtonsState();
     updateSharedLayoutsUiElements();
 
     //! there are broken layouts and the user must be informed!
     if (brokenLayouts.count() > 0) {
         auto msg = new QMessageBox(this);
         msg->setIcon(QMessageBox::Warning);
         msg->setWindowTitle(i18n("Layout Warning"));
         msg->setText(i18n("The layout(s) <b>%0</b> have <i>broken configuration</i>!!! Please <b>remove them</b> to improve the system stability...").arg(brokenLayouts.join(",")));
         msg->setStandardButtons(QMessageBox::Ok);
 
         msg->open();
     }
 }
 
 QList<int> SettingsDialog::currentSettings()
 {
     QList<int> settings;
     settings << m_inMemoryButtons->checkedId();
     settings << (int)ui->autostartChkBox->isChecked();
     settings << (int)ui->badges3DStyleChkBox->isChecked();
     settings << (int)ui->infoWindowChkBox->isChecked();
     settings << (int)ui->metaPressChkBox->isChecked();
     settings << (int)ui->metaPressHoldChkBox->isChecked();
     settings << (int)ui->noBordersForMaximizedChkBox->isChecked();
     settings << m_mouseSensitivityButtons->checkedId();
     settings << ui->screenTrackerSpinBox->value();
     settings << ui->outlineSpinBox->value();
     settings << m_model->rowCount();
 
     return settings;
 }
 
 QStringList SettingsDialog::currentLayoutsSettings()
 {
     QStringList layoutSettings;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString color = m_model->data(m_model->index(i, COLORCOLUMN), Qt::BackgroundRole).toString();
         QString textColor = m_model->data(m_model->index(i, COLORCOLUMN), Qt::UserRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         bool borders = m_model->data(m_model->index(i, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         QStringList lActivities = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
         QStringList shares = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
 
         layoutSettings << id;
         layoutSettings << color;
         layoutSettings << textColor;
         layoutSettings << name;
         layoutSettings << QString::number((int)locked);
         layoutSettings << QString::number((int)menu);
         layoutSettings << QString::number((int)borders);
         layoutSettings << lActivities;
         layoutSettings << shares;
     }
 
     return layoutSettings;
 }
 
 
 void SettingsDialog::insertLayoutInfoAtRow(int row, QString path, QString color, QString textColor, QString name, bool menu,
                                            bool disabledBorders, QStringList activities, bool locked)
 {
     QStandardItem *pathItem = new QStandardItem(path);
 
     QStandardItem *hiddenTextItem = new QStandardItem();
 
     QStandardItem *colorItem = new QStandardItem();
     colorItem->setSelectable(false);
 
     QStandardItem *nameItem = new QStandardItem(name);
     nameItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *menuItem = new QStandardItem();
     menuItem->setEditable(false);
     menuItem->setSelectable(true);
     menuItem->setText(menu ? CheckMark : QString());
     menuItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *bordersItem = new QStandardItem();
     bordersItem->setEditable(false);
     bordersItem->setSelectable(true);
     bordersItem->setText(disabledBorders ? CheckMark : QString());
     bordersItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *activitiesItem = new QStandardItem(activities.join(","));
 
     QStandardItem *sharesItem = new QStandardItem();
 
     QList<QStandardItem *> items;
 
     items.append(pathItem);
     items.append(hiddenTextItem);
     items.append(colorItem);
     items.append(nameItem);
     items.append(menuItem);
     items.append(bordersItem);
     items.append(activitiesItem);
     items.append(sharesItem);
 
     if (row > m_model->rowCount() - 1) {
         m_model->appendRow(items);
         row = m_model->rowCount() - 1;
 
         qDebug() << "append row at:" << row << " rows:" << m_model->rowCount();
     } else {
         m_model->insertRow(row, items);
         qDebug() << "insert row at:" << row << " rows:" << m_model->rowCount();
     }
 
     m_model->setData(m_model->index(row, IDCOLUMN), path, Qt::DisplayRole);
     m_model->setData(m_model->index(row, COLORCOLUMN), color, Qt::BackgroundRole);
     m_model->setData(m_model->index(row, COLORCOLUMN), textColor, Qt::UserRole);
 
     QFont font;
 
     if (m_corona->layoutsManager()->synchronizer()->layout(name)) {
         font.setBold(true);
     } else {
         font.setBold(false);
     }
 
     if (path.startsWith("/tmp/")) {
         font.setItalic(true);
     } else {
         font.setItalic(false);
     }
 
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(name), Qt::DisplayRole);
     m_model->setData(m_model->index(row, NAMECOLUMN), font, Qt::FontRole);
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(locked), Qt::UserRole);
 
     m_model->setData(m_model->index(row, ACTIVITYCOLUMN), activities, Qt::UserRole);
 }
 
 
 void SettingsDialog::on_switchButton_clicked()
 {
     if (ui->buttonBox->button(QDialogButtonBox::Apply)->isEnabled()) {
         //! thus there are changes in the settings
 
         QString lName;
         QStringList lActivities;
 
         if (m_inMemoryButtons->checkedId() == Latte::Types::MultipleLayouts) {
             lName = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole).toString();
             lActivities = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), ACTIVITYCOLUMN), Qt::UserRole).toStringList();
         }
 
         apply();
 
         if (!lName.isEmpty() && !lActivities.isEmpty()) {
             //! an activities-assigned layout is chosen and at the same time we are moving
             //! to multiple layouts state
             m_corona->layoutsManager()->switchToLayout(lName);
         }
     } else {
         QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
 
         if (value.isValid()) {
             m_corona->layoutsManager()->switchToLayout(value.toString());
         } else {
             qDebug() << "not valid layout";
         }
     }
 
     updatePerLayoutButtonsState();
 }
 
 void SettingsDialog::on_pauseButton_clicked()
 {
     ui->pauseButton->setEnabled(false);
 
     QString id = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), IDCOLUMN), Qt::DisplayRole).toString();
     CentralLayout *layout = m_layouts[id];
 
     if (layout) {
         m_corona->layoutsManager()->synchronizer()->pauseLayout(layout->name());
     }
 }
 
 void SettingsDialog::layoutsChanged()
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QModelIndex nameIndex = m_model->index(i, NAMECOLUMN);
         QVariant value = m_model->data(nameIndex);
 
         if (value.isValid()) {
             QString name = value.toString();
             QFont font;
 
             if (m_corona->layoutsManager()->currentLayoutName() == name) {
                 font.setBold(true);
                 // ui->layoutsView->selectRow(i);
             } else {
                 Layout::GenericLayout *layout = m_corona->layoutsManager()->synchronizer()->layout(name);
 
                 if (layout && (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts)) {
                     font.setBold(true);
                 } else {
                     font.setBold(false);
                 }
             }
 
             m_model->setData(nameIndex, font, Qt::FontRole);
         }
     }
 }
 
 void SettingsDialog::itemChanged(QStandardItem *item)
 {
     updatePerLayoutButtonsState();
 
     if (item->column() == ACTIVITYCOLUMN) {
         //! recalculate the available activities
         recalculateAvailableActivities();
     } else if (item->column() == NAMECOLUMN) {
         int currentRow = ui->layoutsView->currentIndex().row();
 
         QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
         QFont font = qvariant_cast<QFont>(m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::FontRole));
 
         if (m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name())) {
             font.setBold(true);
         } else {
             font.setBold(false);
         }
 
         if (m_layouts[id]->name() != name) {
             font.setItalic(true);
         } else {
             font.setItalic(false);
         }
 
         m_model->setData(m_model->index(currentRow, NAMECOLUMN), font, Qt::FontRole);
 
     } else if (item->column() == SHAREDCOLUMN) {
         updateSharedLayoutsStates();
     }
 
     updateApplyButtonsState();
 }
 
 void SettingsDialog::updateApplyButtonsState()
 {
     bool changed{false};
 
     //! Ok, Apply Buttons
     if ((o_settings != currentSettings())
             || (o_settingsLayouts != currentLayoutsSettings())) {
         changed = true;
     }
 
     if (changed) {
         ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
         ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
     } else {
         //ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
         ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
     }
 
     //! RestoreDefaults Button
     if (ui->tabWidget->currentIndex() == 0) {
         //! Check Default layouts missing from layouts list
 
         bool layoutMissing{false};
 
         for (const auto &preset : m_corona->layoutsManager()->presetsPaths()) {
             QString presetName = CentralLayout::layoutName(preset);
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = i18n(prset_str);
 
             if (!nameExistsInModel(presetName)) {
                 layoutMissing = true;
                 break;
             }
         }
 
         if (layoutMissing) {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(true);
         } else {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
         }
     } else if (ui->tabWidget->currentIndex() == 1) {
         //! Defaults for general Latte settings
 
         if (!ui->autostartChkBox->isChecked()
                 || ui->badges3DStyleChkBox->isChecked()
                 || ui->metaPressChkBox->isChecked()
                 || !ui->metaPressHoldChkBox->isChecked()
                 || !ui->infoWindowChkBox->isChecked()
                 || ui->noBordersForMaximizedChkBox->isChecked()
                 || !ui->highSensitivityBtn->isChecked()
                 || ui->screenTrackerSpinBox->value() != SCREENTRACKERDEFAULTVALUE
                 || ui->outlineSpinBox->value() != OUTLINEDEFAULTWIDTH ) {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(true);
         } else {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
         }
     }
 }
 
 void SettingsDialog::updatePerLayoutButtonsState()
 {
     int currentRow = ui->layoutsView->currentIndex().row();
 
     QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
     QString nameInModel = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
     QString originalName = m_layouts.contains(id) ? m_layouts[id]->name() : "";
     bool lockedInModel = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::UserRole).toBool();
     bool sharedInModel = !m_model->data(m_model->index(currentRow, SHAREDCOLUMN), Qt::UserRole).toStringList().isEmpty();
     bool editable = !isActive(originalName) && !lockedInModel;
 
     //! Switch Button
     if (id.startsWith("/tmp/") || originalName != nameInModel) {
         ui->switchButton->setEnabled(false);
     } else {
         ui->switchButton->setEnabled(true);
     }
 
     //! Pause Button
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) {
         ui->pauseButton->setVisible(false);
     } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         ui->pauseButton->setVisible(true);
 
         QStringList lActivities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         Latte::CentralLayout *layout = m_layouts[id];
 
         if (!lActivities.isEmpty() && layout && m_corona->layoutsManager()->synchronizer()->centralLayout(layout->name())) {
             ui->pauseButton->setEnabled(true);
         } else {
             ui->pauseButton->setEnabled(false);
         }
     }
 
     //! Remove Layout Button
     if (originalName != nameInModel
             || (originalName == m_corona->layoutsManager()->currentLayoutName())
             || (m_corona->layoutsManager()->synchronizer()->centralLayout(originalName))
             || lockedInModel) {
         ui->removeButton->setEnabled(false);
     } else {
         ui->removeButton->setEnabled(true);
     }
 
     //! Layout Locked Button
     if (lockedInModel) {
         ui->lockedButton->setChecked(true);
     } else {
         ui->lockedButton->setChecked(false);
     }
 
     //! Layout Shared Button
     if (sharedInModel) {
         ui->sharedButton->setChecked(true);
     } else {
         ui->sharedButton->setChecked(false);
     }
 
     if (editable) {
         m_editLayoutAction->setEnabled(true);
     } else {
         m_editLayoutAction->setEnabled(false);
     }
 }
 
 void SettingsDialog::updateSharedLayoutsStates()
 {
     bool inMultiple{inMultipleLayoutsLook()};
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QStringList shares = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
 
         if (shares.isEmpty() || !inMultiple) {
             QStandardItem *item = m_model->item(i, MENUCOLUMN);
             item->setEnabled(true);
             item = m_model->item(i, BORDERSCOLUMN);
             item->setEnabled(true);
             item = m_model->item(i, ACTIVITYCOLUMN);
             item->setEnabled(true);
         } else {
             QStandardItem *item = m_model->item(i, MENUCOLUMN);
             item->setEnabled(false);
             item = m_model->item(i, BORDERSCOLUMN);
             item->setEnabled(false);
             item = m_model->item(i, ACTIVITYCOLUMN);
             item->setEnabled(false);
         }
 
         //! refresh LayoutName
         QStandardItem *nameItem = m_model->item(i, NAMECOLUMN);
         nameItem->setEnabled(false);
         nameItem->setEnabled(true);
     }  
 }
 
 void SettingsDialog::updateSharedLayoutsUiElements()
 {
     //! UI Elements that need to be enabled/disabled
 
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
     if (inMemoryOption == Latte::Types::MultipleLayouts) {
         ui->layoutsView->setColumnHidden(SHAREDCOLUMN, false);
         ui->sharedButton->setVisible(true);
 
         //! column widths
         QStringList cWidths = m_corona->universalSettings()->layoutsColumnWidths();
 
         if (cWidths.count()>=5) {
             ui->layoutsView->setColumnWidth(ACTIVITYCOLUMN, cWidths[4].toInt());
         }
     } else {
         ui->layoutsView->setColumnHidden(SHAREDCOLUMN, true);
         ui->sharedButton->setVisible(false);
     }
 }
 
 void SettingsDialog::recalculateAvailableActivities()
 {
     QStringList tempActivities = m_corona->layoutsManager()->synchronizer()->activities();
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QStringList assigned = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         for (const auto &activity : assigned) {
             if (tempActivities.contains(activity)) {
                 tempActivities.removeAll(activity);
             }
         }
     }
 
     m_availableActivities = tempActivities;
 }
 
 bool SettingsDialog::dataAreAccepted()
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString layout1 = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         for (int j = i + 1; j < m_model->rowCount(); ++j) {
             QString temp = m_model->data(m_model->index(j, NAMECOLUMN), Qt::DisplayRole).toString();
 
             //!same layout name exists again
             if (layout1 == temp) {
                 auto msg = new QMessageBox(this);
                 msg->setIcon(QMessageBox::Warning);
                 msg->setWindowTitle(i18n("Layout Warning"));
                 msg->setText(i18n("There are layouts with the same name, that is not permitted!!! Please update these names to re-apply the changes..."));
                 msg->setStandardButtons(QMessageBox::Ok);
 
                 connect(msg, &QMessageBox::finished, this, [ &, i, j](int result) {
                     QItemSelectionModel::SelectionFlags flags = QItemSelectionModel::ClearAndSelect;
                     QModelIndex indexBase = m_model->index(i, NAMECOLUMN);
                     ui->layoutsView->selectionModel()->select(indexBase, flags);
 
                     QModelIndex indexOccurence = m_model->index(j, NAMECOLUMN);
                     ui->layoutsView->edit(indexOccurence);
                 });
 
 
                 msg->open();
 
                 return false;
             }
         }
     }
 
     return true;
 }
 
 void SettingsDialog::showLayoutInformation()
 {
     int currentRow = ui->layoutsView->currentIndex().row();
 
     QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
     QString name = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
 
     Layout::GenericLayout *genericActive= m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name());
     Layout::GenericLayout *generic = genericActive ? genericActive : m_layouts[id];
 
     auto msg = new QMessageBox(this);
-    //msg->setIcon(QMessageBox::Information);
-    msg->setWindowTitle(name + " " + i18n("Layout Information"));
-    msg->setText(generic->reportHtml());
+    msg->setWindowTitle(name);
+    msg->setText(generic->reportHtml(m_corona->screenPool()));
 
     msg->open();
 }
 
 void SettingsDialog::showScreensInformation()
 {
     QList<int> assignedScreens;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         Layout::GenericLayout *genericActive= m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name());
         Layout::GenericLayout *generic = genericActive ? genericActive : m_layouts[id];
 
         QList<int> vScreens = generic->viewsScreens();
 
         for (const int scrId : vScreens) {
             if (!assignedScreens.contains(scrId)) {
                 assignedScreens << scrId;
             }
         }
     }
 
     auto msg = new QMessageBox(this);
-    //msg->setIcon(QMessageBox::Information);
     msg->setWindowTitle(i18n("Screens Information"));
     msg->setText(m_corona->screenPool()->reportHtml(assignedScreens));
 
     msg->open();
 }
 
 bool SettingsDialog::saveAllChanges()
 {
     if (!dataAreAccepted()) {
         return false;
     }
 
     //! Update universal settings
     Latte::Types::MouseSensitivity sensitivity = static_cast<Latte::Types::MouseSensitivity>(m_mouseSensitivityButtons->checkedId());
     bool autostart = ui->autostartChkBox->isChecked();
     bool badges3DStyle = ui->badges3DStyleChkBox->isChecked();
     bool forwardMetaPress = ui->metaPressChkBox->isChecked();
     bool metaPressAndHold = ui->metaPressHoldChkBox->isChecked();
     bool showInfoWindow = ui->infoWindowChkBox->isChecked();
     bool noBordersForMaximized = ui->noBordersForMaximizedChkBox->isChecked();
 
     m_corona->universalSettings()->setMouseSensitivity(sensitivity);
     m_corona->universalSettings()->setAutostart(autostart);
     m_corona->universalSettings()->setBadges3DStyle(badges3DStyle);
     m_corona->universalSettings()->forwardMetaToLatte(forwardMetaPress);
     m_corona->universalSettings()->setMetaPressAndHoldEnabled(metaPressAndHold);
     m_corona->universalSettings()->setShowInfoWindow(showInfoWindow);
     m_corona->universalSettings()->setCanDisableBorders(noBordersForMaximized);
     m_corona->universalSettings()->setScreenTrackerInterval(ui->screenTrackerSpinBox->value());
 
     m_corona->themeExtended()->setOutlineWidth(ui->outlineSpinBox->value());
 
     //! Update Layouts
     QStringList knownActivities = activities();
 
     QTemporaryDir layoutTempDir;
 
     qDebug() << "Temporary Directory ::: " << layoutTempDir.path();
 
     QStringList fromRenamePaths;
     QStringList toRenamePaths;
     QStringList toRenameNames;
 
     QString switchToLayout;
 
     QHash<QString, Layout::GenericLayout *> activeLayoutsToRename;
 
     //! remove layouts that have been removed from the user
     for (const auto &initLayout : m_initLayoutPaths) {
         if (!idExistsInModel(initLayout)) {
             QFile(initLayout).remove();
 
             if (m_layouts.contains(initLayout)) {
                 CentralLayout *removedLayout = m_layouts.take(initLayout);
                 delete removedLayout;
             }
         }
     }
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString color = m_model->data(m_model->index(i, COLORCOLUMN), Qt::BackgroundRole).toString();
         QString textColor = m_model->data(m_model->index(i, COLORCOLUMN), Qt::UserRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         bool disabledBorders = m_model->data(m_model->index(i, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         QStringList lActivities = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         QStringList cleanedActivities;
 
         //!update only activities that are valid
         for (const auto &activity : lActivities) {
             if (knownActivities.contains(activity)) {
                 cleanedActivities.append(activity);
             }
         }
 
         //qDebug() << i << ". " << id << " - " << color << " - " << name << " - " << menu << " - " << lActivities;
         //! update the generic parts of the layouts
         Layout::GenericLayout *genericActive= m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name());
         Layout::GenericLayout *generic = genericActive ? genericActive : m_layouts[id];
 
         //! unlock read-only layout
         if (!generic->isWritable()) {
             generic->unlock();
         }
 
         if (color.startsWith("/")) {
             //it is image file in such case
             if (color != generic->background()) {
                 generic->setBackground(color);
             }
 
             if (generic->textColor() != textColor) {
                 generic->setTextColor(textColor);
             }
         } else {
             if (color != generic->color()) {
                 generic->setColor(color);
                 generic->setBackground(QString());
                 generic->setTextColor(QString());
             }
         }
 
         //! update only the Central-specific layout parts
         CentralLayout *centralActive= m_corona->layoutsManager()->synchronizer()->centralLayout(m_layouts[id]->name());
         CentralLayout *central = centralActive ? centralActive : m_layouts[id];
 
         if (central->showInMenu() != menu) {
             central->setShowInMenu(menu);
         }
 
         if (central->disableBordersForMaximizedWindows() != disabledBorders) {
             central->setDisableBordersForMaximizedWindows(disabledBorders);
         }
 
         if (central->activities() != cleanedActivities) {
             central->setActivities(cleanedActivities);
         }
 
         //! If the layout name changed OR the layout path is a temporary one
         if (generic->name() != name || (id.startsWith("/tmp/"))) {
             //! If the layout is Active in MultipleLayouts
             if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts && generic->isActive()) {
                 qDebug() << " Active Layout Should Be Renamed From : " << generic->name() << " TO :: " << name;
                 activeLayoutsToRename[name] = generic;
             }
 
             QString tempFile = layoutTempDir.path() + "/" + QString(generic->name() + ".layout.latte");
             qDebug() << "new temp file ::: " << tempFile;
 
             if ((m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) && (generic->name() == m_corona->layoutsManager()->currentLayoutName())) {
                 switchToLayout = name;
             }
 
             generic = m_layouts.take(id);
             delete generic;
 
             QFile(id).rename(tempFile);
 
             fromRenamePaths.append(id);
             toRenamePaths.append(tempFile);
             toRenameNames.append(name);
         }
     }
 
     //! this is necessary in case two layouts have to swap names
     //! so we copy first the layouts in a temp directory and afterwards all
     //! together we move them in the official layout directory
     for (int i = 0; i < toRenamePaths.count(); ++i) {
         QString newFile = QDir::homePath() + "/.config/latte/" + toRenameNames[i] + ".layout.latte";
         QFile(toRenamePaths[i]).rename(newFile);
 
         CentralLayout *nLayout = new CentralLayout(this, newFile);
         m_layouts[newFile] = nLayout;
 
         //! updating the #SETTINGSID in the model for the layout that was renamed
         for (int j = 0; j < m_model->rowCount(); ++j) {
             QString tId = m_model->data(m_model->index(j, IDCOLUMN), Qt::DisplayRole).toString();
 
             if (tId == fromRenamePaths[i]) {
                 m_model->setData(m_model->index(j, IDCOLUMN), newFile, Qt::DisplayRole);
                 m_initLayoutPaths.append(newFile);
 
                 QFont font = qvariant_cast<QFont>(m_model->data(m_model->index(j, NAMECOLUMN), Qt::FontRole));
 
                 font.setItalic(false);
                 m_model->setData(m_model->index(j, NAMECOLUMN), font, Qt::FontRole);
             }
         }
     }
 
     QString orphanedLayout;
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         for (const auto &newLayoutName : activeLayoutsToRename.keys()) {
             Layout::GenericLayout *layout = activeLayoutsToRename[newLayoutName];
             qDebug() << " Active Layout of Type: " << layout->type() << " Is Renamed From : " << activeLayoutsToRename[newLayoutName]->name() << " TO :: " << newLayoutName;
             layout->renameLayout(newLayoutName);
 
             if (layout->type() == Layout::Type::Central) {
                 CentralLayout *central = qobject_cast<CentralLayout *>(layout);
 
                 if (central->activities().isEmpty()) {
                     //! that means it is an active layout for orphaned Activities
                     orphanedLayout = newLayoutName;
                 }
             }
 
             //! broadcast the name change
             int row = rowForName(newLayoutName);
             QStandardItem *item = m_model->item(row, NAMECOLUMN);
             if (item) {
                 emit itemChanged(item);
             }
         }
     }
 
     //! lock layouts in the end when the user has chosen it
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
 
         Layout::GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name());
         Layout::GenericLayout *layout = generic ? generic : m_layouts[id];
 
         if (layout && locked && layout->isWritable()) {
             layout->lock();
         }
     }
 
     //! update SharedLayouts that are Active
     syncActiveShares();
 
     //! reload layouts in layoutsmanager
     m_corona->layoutsManager()->synchronizer()->loadLayouts();
 
     //! send to layout manager in which layout to switch
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
 
     if (m_corona->layoutsManager()->memoryUsage() != inMemoryOption) {
         Types::LayoutsMemoryUsage previousMemoryUsage = m_corona->layoutsManager()->memoryUsage();
         m_corona->layoutsManager()->setMemoryUsage(inMemoryOption);
 
         QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
         QString layoutName = value.toString();
 
         m_corona->layoutsManager()->switchToLayout(layoutName, previousMemoryUsage);
     } else {
         if (!switchToLayout.isEmpty()) {
             m_corona->layoutsManager()->switchToLayout(switchToLayout);
         } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             m_corona->layoutsManager()->synchronizer()->syncMultipleLayoutsToActivities(orphanedLayout);
         }
     }
 
     return true;
 }
 
 void SettingsDialog::syncActiveShares()
 {
     if (m_corona->layoutsManager()->memoryUsage() != Types::MultipleLayouts) {
         return;
     }
 
     QHash<const QString, QStringList> currentSharesIdMap;
     Layouts::SharesMap  currentSharesNamesMap;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         if (isShared(i)) {
             QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
             QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
             QStringList shareIds = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
             QStringList shareNames;
 
             for (const auto &shareid : shareIds) {
                 QString shareName = nameForId(shareid);
                 shareNames << shareName;
             }
 
             currentSharesIdMap[id] = shareIds;
             currentSharesNamesMap[name] = shareNames;
         }
     }
 
     QStringList deprecatedShares;
 
     for (const auto &oldSharesIds : m_sharesMap) {
         for(const auto &oldId : oldSharesIds) {
             QString oldShareName = nameForId(oldId);
             if (!m_corona->layoutsManager()->synchronizer()->mapHasRecord(oldShareName, currentSharesNamesMap)) {
                 deprecatedShares << oldShareName;
             }
         }
     }
 
     qDebug() << " CURRENT SHARES ID MAP  :: " << currentSharesIdMap;
     m_corona->layoutsManager()->synchronizer()->syncActiveShares(currentSharesNamesMap, deprecatedShares);
 
     m_sharesMap.clear();
     m_sharesMap = currentSharesIdMap;
 }
 
 void SettingsDialog::addActivityInCurrent(const QString &activityId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList activities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
     if (!activities.contains(activityId)) {
         activities << activityId;
         m_model->setData(m_model->index(currentRow, ACTIVITYCOLUMN), activities, Qt::UserRole);
     }
 }
 
 void SettingsDialog::removeActivityFromCurrent(const QString &activityId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList activities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
     if (activities.contains(activityId)) {
         activities.removeAll(activityId);
         m_model->setData(m_model->index(currentRow, ACTIVITYCOLUMN), activities, Qt::UserRole);
     }
 }
 
 void SettingsDialog::addShareInCurrent(const QString &layoutId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList shares = m_model->data(m_model->index(currentRow, SHAREDCOLUMN), Qt::UserRole).toStringList();
     if (!shares.contains(layoutId)) {
         shares << layoutId;
         m_model->setData(m_model->index(currentRow, SHAREDCOLUMN), shares, Qt::UserRole);
     }
 }
 
 void SettingsDialog::removeShareFromCurrent(const QString &layoutId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList shares = m_model->data(m_model->index(currentRow, SHAREDCOLUMN), Qt::UserRole).toStringList();
     if (shares.contains(layoutId)) {
         shares.removeAll(layoutId);
         m_model->setData(m_model->index(currentRow, SHAREDCOLUMN), shares, Qt::UserRole);
     }
 }
 
 bool SettingsDialog::idExistsInModel(QString id)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowId = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
 
         if (rowId == id) {
             return true;
         }
     }
 
     return false;
 }
 
 bool SettingsDialog::nameExistsInModel(QString name)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName == name) {
             return true;
         }
     }
 
     return false;
 }
 
 bool SettingsDialog::inMultipleLayoutsLook() const
 {
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
     return inMemoryOption == Latte::Types::MultipleLayouts;
 }
 
 bool SettingsDialog::isActive(QString layoutName) const
 {
     return (m_corona->layoutsManager()->synchronizer()->layout(layoutName) != nullptr);
 }
 
 bool SettingsDialog::isMenuCell(int column) const
 {
     return column == MENUCOLUMN;
 }
 
 bool SettingsDialog::isShared(int row) const
 {
     if (row >=0 ) {
         QStringList shares = m_model->data(m_model->index(row, SHAREDCOLUMN), Qt::UserRole).toStringList();
         if (!shares.isEmpty()) {
             return true;
         }
     }
 
     return false;
 }
 
 int SettingsDialog::ascendingRowFor(QString name)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName.toUpper() > name.toUpper()) {
             return i;
         }
     }
 
     return m_model->rowCount();
 }
 
 int SettingsDialog::rowForId(QString id) const
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowId = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
 
         if (rowId == id) {
             return i;
         }
     }
 
     return -1;
 }
 
 int SettingsDialog::rowForName(QString layoutName) const
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName == layoutName) {
             return i;
         }
     }
 
     return -1;
 }
 
 QString SettingsDialog::idForRow(int row) const
 {
     return m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
 }
 
 QString SettingsDialog::nameForId(QString id) const
 {
     int row = rowForId(id);
     return m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString();
 }
 
 QString SettingsDialog::uniqueTempDirectory()
 {
     QTemporaryDir tempDir;
     tempDir.setAutoRemove(false);
     m_tempDirectories.append(tempDir.path());
 
     return tempDir.path();
 }
 
 QString SettingsDialog::uniqueLayoutName(QString name)
 {
     int pos_ = name.lastIndexOf(QRegExp(QString("[-][0-9]+")));
 
     if (nameExistsInModel(name) && pos_ > 0) {
         name = name.left(pos_);
     }
 
     int i = 2;
 
     QString namePart = name;
 
     while (nameExistsInModel(name)) {
         name = namePart + "-" + QString::number(i);
         i++;
     }
 
     return name;
 }
 
 }//end of namespace