File indexing completed on 2024-04-14 05:24:24

 /*
     SPDX-FileCopyrightText: 2019 Michail Vourlakos <mvourlakos@gmail.com>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "genericlayout.h"
 
 // local
 #include "abstractlayout.h"
 #include "../apptypes.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../layouts/importer.h"
 #include "../layouts/manager.h"
 #include "../layouts/storage.h"
 #include "../layouts/synchronizer.h"
 #include "../shortcuts/shortcutstracker.h"
 #include "../templates/templatesmanager.h"
 #include "../view/clonedview.h"
 #include "../view/originalview.h"
 #include "../view/positioner.h"
 #include "../view/view.h"
 
 // Qt
 #include <QDebug>
 #include <QScreen>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Applet>
 #include <Plasma/Containment>
 
 // KDE
 #include <KActionCollection>
 #include <KConfigGroup>
 
 namespace Latte {
 namespace Layout {
 
 GenericLayout::GenericLayout(QObject *parent, QString layoutFile, QString assignedName)
     : AbstractLayout (parent, layoutFile, assignedName)
 {
 }
 
 GenericLayout::~GenericLayout()
 {
 }
 
 Type GenericLayout::type() const
 {
     return Type::Generic;
 }
 
 void GenericLayout::unloadContainments()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "Layout - " + name() + " : [unloadContainments]"
              << "containments ::: " << 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 *> subcontainments;
 
     //!identify subcontainments and unload them first
     for (const auto containment : m_containments) {
         if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
             subcontainments.append(containment);
         }
     }
 
     while (!subcontainments.isEmpty()) {
         Plasma::Containment *sub = subcontainments.at(0);
         m_unloadedContainmentsIds << QString::number(sub->id());
         subcontainments.removeFirst();
         m_containments.removeAll(sub);
         delete sub;
     }
 
     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() + " : [unloadLatteViews]"
              << "containments ::: " << m_containments.size()
              << " ,latteViews in memory ::: " << m_latteViews.size()
              << " ,hidden latteViews in memory :::  " << m_waitingLatteViews.size();
 
     //!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(this, &GenericLayout::activitiesChanged, this, &GenericLayout::updateLastUsedActivity);
     disconnect(m_corona->activitiesConsumer(), &KActivities::Consumer::currentActivityChanged, this, &GenericLayout::updateLastUsedActivity);
 
     for (const auto view : m_latteViews) {
         view->disconnectSensitiveSignals();
     }
 
     for (const auto view : m_waitingLatteViews) {
         view->disconnectSensitiveSignals();
     }
 
     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::isActive() const
 {
     return m_corona && m_hasInitializedContainments && (m_corona->layoutsManager()->synchronizer()->layout(m_layoutName) != nullptr);
 }
 
 bool GenericLayout::isCurrent()
 {
     if (!m_corona) {
         return false;
     }
 
     return m_corona->layoutsManager()->currentLayoutsNames().contains(name());
 }
 
 bool GenericLayout::hasCorona() const
 {
     return (m_corona!=nullptr);
 }
 
 void GenericLayout::setCorona(Latte::Corona *corona)
 {
     m_corona = corona;
 }
 
 QString GenericLayout::background() const
 {
     QString colorsPath = m_corona->kPackage().path() + "../../shells/org.kde.latte.shell/contents/images/canvas/";
 
     if (backgroundStyle() == Layout::PatternBackgroundStyle) {
         if (customBackground().isEmpty()) {
 
             return colorsPath + "defaultcustomprint.jpg";
         } else {
             return AbstractLayout::customBackground();
         }
     }
 
     return colorsPath + AbstractLayout::color() + "print.jpg";
 }
 
 QString GenericLayout::textColor() const
 {
     if (backgroundStyle() == Layout::PatternBackgroundStyle && customBackground().isEmpty() && customTextColor().isEmpty()) {
         return AbstractLayout::defaultCustomTextColor();
     }
 
     return AbstractLayout::textColor();
 }
 
 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->extendedInterface()->hasLatteTasks() || view->extendedInterface()->hasPlasmaTasks()) {
             result++;
         }
     }
 
     return result;
 }
 
 QStringList GenericLayout::unloadedContainmentsIds()
 {
     return m_unloadedContainmentsIds;
 }
 
 Latte::Corona *GenericLayout::corona() const
 {
     return m_corona;
 }
 
 Types::ViewType GenericLayout::latteViewType(uint 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()
 {
     return m_lastConfigViewFor;
 }
 
 void GenericLayout::setLastConfigViewFor(Latte::View *view)
 {
     if (m_lastConfigViewFor == view) {
         return;
     }
 
     m_lastConfigViewFor = view;
 
     if (view) {
         emit lastConfigViewForChanged(view);
     }
 }
 
 void GenericLayout::onLastConfigViewChangedFrom(Latte::View *view)
 {
     if (!m_latteViews.values().contains(view)) {
         setLastConfigViewFor(nullptr);
     }
 }
 
 Latte::View *GenericLayout::viewForContainment(uint id) const
 {
     for(auto view : m_latteViews) {
         if (view && view->containment()->id() == id) {
             return view;
         }
     }
 
     for(auto view : m_waitingLatteViews) {
         if (view && view->containment()->id() == id) {
             return view;
         }
     }
 
     return nullptr;
 }
 
 Plasma::Containment *GenericLayout::containmentForId(uint id) const
 {
     for(auto containment : m_containments) {
         if (containment->id() == id) {
             return containment;
         }
     }
 
     return nullptr;
 }
 
 bool GenericLayout::contains(Plasma::Containment *containment) const
 {
     return m_containments.contains(containment);
 }
 
 int GenericLayout::screenForContainment(Plasma::Containment *containment)
 {
     if (!containment) {
         return -1;
     }
 
     //! there is a pending update
     QString containmentid = QString::number(containment->id());
     if (m_pendingContainmentUpdates.containsId(containmentid)) {
         if (m_corona && m_pendingContainmentUpdates[containmentid].onPrimary) {
             return m_corona->screenPool()->primaryScreenId();
         } else {
             return m_pendingContainmentUpdates[containmentid].screen;
         }
     }
 
     //! there is a view present
     Latte::View *view{nullptr};
 
     if (m_latteViews.contains(containment)) {
         view = m_latteViews[containment];
     } else if (m_waitingLatteViews.contains(containment)) {
         view = m_waitingLatteViews[containment];
     }
 
     if (view && view->screen()) {
         return m_corona->screenPool()->id(view->screen()->name());
     }
 
     //! fallback scenario
     return containment->lastScreen();
 }
 
 bool GenericLayout::containsView(const int &containmentId) const
 {
     if (!isActive()) {
         return Layouts::Storage::self()->containsView(file(), containmentId);
     }
 
     for(auto containment : m_containments) {
         if ((int)containment->id() == containmentId && Layouts::Storage::self()->isLatteContainment(containment)) {
             return true;
         }
     }
 
     return false;
 }
 
 Latte::View *GenericLayout::viewForContainment(Plasma::Containment *containment) const
 {
     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::onlyOriginalViews()
 {
     QList<Latte::View *> viewslist;
 
     for (const auto v : m_latteViews) {
         if (v->isOriginal()) {
             viewslist << v;
         }
     }
 
     return viewslist;
 }
 
 QList<Latte::View *> GenericLayout::sortedLatteViews()
 {
     QScreen *primaryScreen = (m_corona ? m_corona->screenPool()->primaryScreen() : nullptr);
     return sortedLatteViews(latteViews(), primaryScreen);
 }
 
 QList<Latte::View *> GenericLayout::sortedLatteViews(QList<Latte::View *> views, QScreen *primaryScreen)
 {
     QList<Latte::View *> sortedViews = 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], primaryScreen)
                     || (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, QScreen *primaryScreen)
 {
     if (!base || ! test) {
         return true;
     }
 
     if (base->screen() == test->screen()) {
         return false;
     } else if (base->screen() != primaryScreen && test->screen() == primaryScreen) {
         return false;
     } else if (base->screen() == primaryScreen && test->screen() != 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 Latte::Data::View &test, const Latte::Data::View &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.screen <= base.screen;
     }
 }
 
 bool GenericLayout::viewDataAtLowerStatePriority(const Latte::Data::View &test, const Latte::Data::View &base) const
 {
     if (test.isActive == base.isActive) {
         return false;
     } else if (!base.isActive && test.isActive) {
         return false;
     } else if (base.isActive && !test.isActive) {
         return true;
     }
 
     return false;
 }
 
 bool GenericLayout::viewDataAtLowerEdgePriority(const Latte::Data::View &test, const Latte::Data::View &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.edge) {
             basePriority = i;
         }
 
         if (edges[i] == test.edge) {
             testPriority = i;
         }
     }
 
     if (testPriority < basePriority) {
         return true;
     } else {
         return false;
     }
 }
 
 QList<Latte::Data::View> GenericLayout::sortedViewsData(const QList<Latte::Data::View> &viewsData)
 {
     QList<Latte::Data::View> 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])) ) {
                 Latte::Data::View temp = sortedData[j + 1];
                 sortedData[j + 1] = sortedData[j];
                 sortedData[j] = temp;
             }
         }
     }
 
     return sortedData;
 }
 
 
 const QList<Plasma::Containment *> *GenericLayout::containments() const
 {
     return &m_containments;
 }
 
 QList<Latte::View *> GenericLayout::viewsWithPlasmaShortcuts()
 {
     QList<Latte::View *> views;
 
     if (!m_corona) {
         return views;
     }
 
     QList<uint> 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() == MemoryUsage::SingleLayout) {
         m_containments.append(containment);
         containmentInLayout = true;
     } else if (m_corona->layoutsManager()->memoryUsage() == MemoryUsage::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 subcontainments must be assigned to layouts
     //! when the user adds them
     KConfigGroup appletSettings = applet->containment()->config().group("Applets").group(QString::number(applet->id()));
 
     int subId = Layouts::Storage::self()->subContainmentId(appletSettings);
 
     if (Layouts::Storage::isValid(subId)) {
         uint sId = (uint)subId;
 
         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->positioner()->slideOutDuringExit(containment->location());
             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;
     }
 
     Latte::View *view;
 
     if (destroyed) {
         view = m_latteViews.take(static_cast<Plasma::Containment *>(sender));
         m_waitingLatteViews[sender] = view;
     } else {
         view = m_waitingLatteViews.take(static_cast<Plasma::Containment *>(sender));
         m_latteViews[sender] =view;
     }
 
     if (view) {
         emit m_corona->availableScreenRectChangedFrom(view);
         emit m_corona->availableScreenRegionChangedFrom(view);
         emit viewEdgeChanged();
         emit viewsCountChanged();
     }
 }
 
 void GenericLayout::renameLayout(QString newName)
 {
     if (!m_corona || m_corona->layoutsManager()->memoryUsage() != MemoryUsage::MultipleLayouts) {
         return;
     }
 
     if (m_layoutFile != Layouts::Importer::layoutUserFilePath(newName)) {
         setFile(Layouts::Importer::layoutUserFilePath(newName));
     }
 
     setName(newName);
 
     for (const auto containment : m_containments) {
         qDebug() << "Cont ID :: " << containment->id();
         containment->config().writeEntry("layoutId", m_layoutName);
     }
 }
 
 void GenericLayout::addView(Plasma::Containment *containment)
 {
     qDebug().noquote() << "Adding View: Called for layout:" << m_layoutName << "with m_containments.size() ::" << m_containments.size();
 
     if (!containment || !m_corona || !containment->kPackage().isValid()) {
         qWarning() << "Adding View: The requested containment plugin can not be located or loaded";
         return;
     }
 
     qDebug() << "Adding View:" << containment->id() << "- Step 1...";
 
     if (!Layouts::Storage::self()->isLatteContainment(containment)) {
         return;
     }
 
     qDebug() << "Adding View:" << containment->id() << "- Step 2...";
 
     if (hasLatteView(containment)) {
         return;
     }
 
     qDebug() << "Adding View:" << containment->id() << "- Step 3...";
 
     QScreen *nextScreen{m_corona->screenPool()->primaryScreen()};
     Data::View viewdata = Layouts::Storage::self()->view(this, containment);
     viewdata.screen = Layouts::Storage::self()->expectedViewScreenId(m_corona, viewdata);
 
     QString nextScreenName = m_corona->screenPool()->hasScreenId(viewdata.screen) ? m_corona->screenPool()->connector(viewdata.screen) : "";
 
     qDebug().noquote() << "Adding View:" << viewdata.id << "-"
                        << "IsClonedFrom:" << viewdata.isClonedFrom
                        << ", NextScreen:" << viewdata.screen << "-" << nextScreenName
                        << ", OnPrimary:" << viewdata.onPrimary
                        << ", Edge:" << viewdata.edge;
 
     if (!viewdata.onPrimary && Layouts::Storage::isValid(viewdata.screen)) {
         bool foundNextExplicitScreen{false};
 
         if (m_corona->screenPool()->isScreenActive(viewdata.screen)) {
             foundNextExplicitScreen = true;
             nextScreen = m_corona->screenPool()->screenForId(viewdata.screen);
         }
 
         if (!foundNextExplicitScreen) {
             qDebug().noquote() << "Adding View:" << viewdata.id << "- Rejected because Screen is not available :: " << nextScreenName;
             return;
         }
     }
 
     //! 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
             || mode == Types::WindowsCanCover
             || mode == Types::WindowsAlwaysCover) {
         byPassWM = false;
     } else {
         byPassWM = containment->config().readEntry("byPassWM", false);
     }
 
     Latte::View *latteView;
 
     if (!viewdata.isCloned()) {
         latteView = new Latte::OriginalView(m_corona, nextScreen, byPassWM);
     } else {
         auto view = viewForContainment((uint)viewdata.isClonedFrom);
 
         if (!containsView(viewdata.isClonedFrom) || !view) {
             qDebug().noquote() << "Adding View:" << viewdata.id << "- Clone did not find OriginalView and as such was stopped!!!";
             return;
         }
 
         auto originalview = qobject_cast<Latte::OriginalView *>(view);
         latteView = new Latte::ClonedView(m_corona, originalview, nextScreen, byPassWM);
     }
 
     qDebug().noquote() << "Adding View:" << viewdata.id << "- Passed ALL checks !!!";
     m_latteViews[containment] = latteView;
 
     latteView->init(containment);
     latteView->setContainment(containment);
     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();
     //}
 
     emit viewsCountChanged();
 }
 
 void GenericLayout::toggleHiddenState(QString viewName, QString screenName, Plasma::Types::Location edge)
 {
     if (!m_corona) {
         return;
     }
 
     QString validScreenName = m_corona->screenPool()->primaryScreen()->name();
     if (!screenName.isEmpty()) {
         validScreenName = screenName;
     }
 
     int viewsOnEdge{0};
 
     for(const auto view : latteViews()) {
         if ((viewName.isEmpty() || (!viewName.isEmpty() && viewName == view->name()))
                 && view->positioner()->currentScreenName() == validScreenName
                 && (edge == Plasma::Types::Floating || ((edge != Plasma::Types::Floating) && view->location() == edge))) {
             viewsOnEdge++;
         }
     }
 
     if (viewsOnEdge >= 1) {
         for(const auto view : latteViews()) {
             if ((viewName.isEmpty() || (!viewName.isEmpty() && viewName == view->name()))
                     && view->positioner()->currentScreenName() == validScreenName
                     && (edge == Plasma::Types::Floating || ((edge != Plasma::Types::Floating) && view->location() == edge))) {
                 view->visibility()->toggleHiddenState();
             }
         }
     }
 }
 
 bool GenericLayout::initCorona()
 {
     if (!m_corona) {
         return false;
     }
 
     connect(m_corona, &Plasma::Corona::containmentAdded, this, &GenericLayout::addContainment);
 
     updateLastUsedActivity();
 
     //! signals
     connect(this, &GenericLayout::activitiesChanged, this, &GenericLayout::updateLastUsedActivity);
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::currentActivityChanged, this, &GenericLayout::updateLastUsedActivity);
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged, this, &GenericLayout::updateLastUsedActivity);
 
     connect(this, &GenericLayout::lastConfigViewForChanged, m_corona->layoutsManager(), &Layouts::Manager::lastConfigViewChangedFrom);
     connect(m_corona->layoutsManager(), &Layouts::Manager::lastConfigViewChangedFrom, this, &GenericLayout::onLastConfigViewChangedFrom);
 
     //!connect signals after adding the containment
     connect(this, &GenericLayout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRectChanged);
     connect(this, &GenericLayout::viewsCountChanged, m_corona, &Plasma::Corona::availableScreenRegionChanged);
 
     return true;
 }
 
 bool GenericLayout::initContainments()
 {
     if (!m_corona || m_hasInitializedContainments) {
         return false;
     }
 
     qDebug() << "Layout ::::: " << name() << " added containments ::: " << m_containments.size();
 
     for(int pass=1; pass<=2; ++pass) {
         for (const auto containment : m_corona->containments()) {
             //! in first pass we load subcontainments
             //! in second pass we load main dock and panel containments
             //! this way subcontainments will be always available to find when the layout is activating
             //! for example during startup that clones must be created and subcontainments should be taken into account
             if ((pass==1 && Layouts::Storage::self()->isLatteContainment(containment)
                  || (pass==2 && !Layouts::Storage::self()->isLatteContainment(containment)))) {
                 continue;
             }
 
             if (m_corona->layoutsManager()->memoryUsage() == MemoryUsage::SingleLayout) {
                 addContainment(containment);
             } else if (m_corona->layoutsManager()->memoryUsage() == MemoryUsage::MultipleLayouts) {
                 QString layoutId = containment->config().readEntry("layoutId", QString());
 
                 if (!layoutId.isEmpty() && (layoutId == m_layoutName)) {
                     addContainment(containment);
                 }
             }
         }
     }
     m_hasInitializedContainments = true;
     emit viewsCountChanged();
     return true;
 }
 
 void GenericLayout::updateLastUsedActivity()
 {
     if (!m_corona) {
         return;
     }
 
     QString currentId = m_corona->activitiesConsumer()->currentActivity();
     QStringList appliedActivitiesIds = appliedActivities();
 
     if (appliedActivitiesIds.contains(Data::Layout::ALLACTIVITIESID)
             || (m_lastUsedActivity != currentId && appliedActivitiesIds.contains(currentId))) {
         m_lastUsedActivity = currentId;
         emit lastUsedActivityChanged();
     }
 }
 
 void GenericLayout::assignToLayout(Latte::View *latteView, QList<Plasma::Containment *> containments)
 {
     if (!m_corona || containments.isEmpty()) {
         return;
     }
 
     if (latteView) {
         m_latteViews[latteView->containment()] = latteView;
     }
 
     m_containments << containments;
 
     for (const auto containment : containments) {
         containment->config().writeEntry("layoutId", name());
 
         if (!latteView || (latteView && latteView->containment() != containment)) {
             //! assign signals only to subcontainments
             //! 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);
         }
     }
 
     if (latteView) {
         latteView->setLayout(this);
     }
 
     emit viewsCountChanged();
 
     //! sync the original layout file for integrity
     if (m_corona->layoutsManager()->memoryUsage() == MemoryUsage::MultipleLayouts) {
         Layouts::Storage::self()->syncToLayoutFile(this, false);
     }
 }
 
 QList<Plasma::Containment *> GenericLayout::unassignFromLayout(Plasma::Containment *latteContainment)
 {
     QList<Plasma::Containment *> containments;
 
     if (!m_corona || !latteContainment || !contains(latteContainment)) {
         return containments;
     }
 
     containments << latteContainment;
 
     for (const auto containment : m_containments) {
         Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent());
 
         //! add subcontainments from that latteView
         if (parentApplet && parentApplet->containment() && parentApplet->containment() == latteContainment) {
             containments << containment;
             //! unassign signals only to subcontainments
             //! 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(latteContainment);
     }
 
     //! sync the original layout file for integrity
     if (m_corona && m_corona->layoutsManager()->memoryUsage() == MemoryUsage::MultipleLayouts) {
         Layouts::Storage::self()->syncToLayoutFile(this, 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::hasLatteView(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 (Layouts::Storage::self()->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 (Layouts::Storage::self()->isLatteContainment(containment)) {
             bool onPrimary{false};
 
             if (m_latteViews.contains(containment)) {
                 onPrimary = m_latteViews[containment]->onPrimary();
             } else {
                 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].contains(viewId)) {
                 return true;
             }
         }
     }
 
     return false;
 }
 
 QString GenericLayout::mapScreenName(const ViewsMap *map, uint viewId) const
 {
     for(const auto &scr : map->keys()) {
         for(const auto &edge : (*map)[scr].keys()) {
             if ((*map)[scr][edge].contains(viewId)) {
                 return scr;
             }
         }
     }
 
     return QString::number(Latte::ScreenPool::NOSCREENID);
 }
 
 //! screen name, location, containmentId
 Layout::ViewsMap GenericLayout::validViewsMap()
 {
     Layout::ViewsMap map;
 
     if (!m_corona) {
         return map;
     }
 
     QString prmScreenName = m_corona->screenPool()->primaryScreen()->name();
 
     for (const auto containment : m_containments) {
         if (Layouts::Storage::self()->isLatteContainment(containment)
                 && !Layouts::Storage::self()->isClonedView(containment)) {
             Data::View view = hasLatteView(containment) ? m_latteViews[containment]->data() : Latte::Layouts::Storage::self()->view(this, containment);
             view.screen = Layouts::Storage::self()->expectedViewScreenId(m_corona, view);
 
             if (view.onPrimary) {
                 map[prmScreenName][view.edge] << containment->id();
             } else {
                 QString expScreenName = m_corona->screenPool()->connector(view.screen);
 
                 if (m_corona->screenPool()->isScreenActive(view.screen)) {
                     map[expScreenName][view.edge] << containment->id();
                 }
             }
         }
     }
 
     return map;
 }
 
 
 //! the central functions that updates loading/unloading latteviews
 //! concerning screen changed (for multi-screen setups mainly)
 void GenericLayout::syncLatteViewsToScreens()
 {
     if (!m_corona) {
         return;
     }
 
     qDebug() << "START of SyncLatteViewsToScreens ....";
     qDebug() << "LAYOUT ::: " << name();
     qDebug() << "screen count changed -+-+ " << qGuiApp->screens().size();
 
     //! Clear up pendingContainmentUpdates when no-needed any more
     QStringList clearpendings;
     for(int i=0; i<m_pendingContainmentUpdates.rowCount(); ++i) {
         auto viewdata = m_pendingContainmentUpdates[i];
         auto containment = containmentForId(viewdata.id.toUInt());
 
         if (containment) {
             if ((viewdata.onPrimary && containment->lastScreen() == m_corona->screenPool()->primaryScreenId())
                     || (!viewdata.onPrimary && containment->lastScreen() == viewdata.screen)) {
                 clearpendings << viewdata.id;
             }
         }
     }
 
     for(auto pendingid : clearpendings) {
         m_pendingContainmentUpdates.remove(pendingid);
     }
 
     if (m_pendingContainmentUpdates.rowCount() > 0) {
         qDebug () << "  Pending View updates still valid : ";
         m_pendingContainmentUpdates.print();
     }
 
     //! use valid views map based on active screens
     Layout::ViewsMap viewsMap = validViewsMap();
 
     QString prmScreenName = m_corona->screenPool()->primaryScreen()->name();
 
     qDebug() << "PRIMARY SCREEN :: " << prmScreenName;
     qDebug() << "LATTEVIEWS MAP :: " << viewsMap;
 
     //! add views
     for (const auto containment : m_containments) {
         if (!hasLatteView(containment) && mapContainsId(&viewsMap, containment->id())) {
             qDebug() << "syncLatteViewsToScreens: view must be added... for containment:" << containment->id() << " at screen:" << mapScreenName(&viewsMap, containment->id());
             addView(containment);
         }
     }
 
     //! remove views
     QList<Plasma::Containment *> viewsToDelete;
 
     for (auto view : m_latteViews) {
         auto containment = view->containment();
         if (containment && view->isOriginal() && !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() && view->isOriginal() && 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<Plasma::Containment *> GenericLayout::subContainmentsOf(uint id) const
 {
     QList<Plasma::Containment *> subs;
 
     auto containment = containmentForId(id);
 
     if (!containment || !Layouts::Storage::self()->isLatteContainment(containment)) {
         return subs;
     }
 
     auto applets = containment->config().group("Applets");
 
     for (const auto &applet : applets.groupList()) {
         int tSubId = Layouts::Storage::self()->subContainmentId(applets.group(applet));
 
         if (Layouts::Storage::isValid(tSubId)) {
             auto subcontainment = containmentForId(tSubId);
 
             if (subcontainment) {
                 subs << subcontainment;
             }
         }
     }
 
     return subs;
 }
 
 QList<int> GenericLayout::subContainmentsOf(Plasma::Containment *containment) const
 {
     QList<int> subs;
 
     if (Layouts::Storage::self()->isLatteContainment(containment)) {
         auto applets = containment->config().group("Applets");
 
         for (const auto &applet : applets.groupList()) {
             int tSubId = Layouts::Storage::self()->subContainmentId(applets.group(applet));
 
             if (Layouts::Storage::isValid(tSubId)) {
                 subs << tSubId;
             }
         }
     }
 
     return subs;
 }
 
 QList<int> GenericLayout::viewsExplicitScreens()
 {
     Data::ViewsTable views = viewsTable();
     QList<int> screens;
 
     for (int i=0; i<views.rowCount(); ++i) {
         if (!views[i].onPrimary && !screens.contains(views[i].screen)) {
             screens << views[i].screen;
         }
     }
 
     return screens;
 }
 
 //! STORAGE
 
 bool GenericLayout::isWritable() const
 {
     return Layouts::Storage::self()->isWritable(this);
 }
 
 void GenericLayout::lock()
 {
     Layouts::Storage::self()->lock(this);
 }
 
 void GenericLayout::unlock()
 {
     Layouts::Storage::self()->unlock(this);
 }
 
 void GenericLayout::syncToLayoutFile(bool removeLayoutId)
 {
     syncSettings();
     Layouts::Storage::self()->syncToLayoutFile(this, removeLayoutId);
 }
 
 bool GenericLayout::newView(const QString &templateName)
 {
     if (!isActive() || !m_corona->templatesManager()->hasViewTemplate(templateName)) {
         return false;
     }
 
     QString templatefilepath = m_corona->templatesManager()->viewTemplateFilePath(templateName);
     Data::ViewsTable templateviews = Layouts::Storage::self()->views(templatefilepath);
 
     if (templateviews.rowCount() <= 0) {
         return false;
     }
 
     Data::View nextdata = templateviews[0];
     int scrId = m_corona->screenPool()->primaryScreenId();
 
     QList<Plasma::Types::Location> freeedges = freeEdges(scrId);
 
     if (!freeedges.contains(nextdata.edge)) {
         nextdata.edge = (freeedges.count() > 0 ? freeedges[0] : Plasma::Types::BottomEdge);
     }
 
     nextdata.setState(Data::View::OriginFromViewTemplate, templatefilepath);
 
     newView(nextdata);
 
     return true;
 }
 
 Data::View GenericLayout::newView(const Latte::Data::View &nextViewData)
 {
     if (nextViewData.state() == Data::View::IsInvalid) {
         return Data::View();
     }
 
     Data::View result = Layouts::Storage::self()->newView(this, nextViewData);
     emit viewEdgeChanged();
 
     return result;
 }
 
 void GenericLayout::updateView(const Latte::Data::View &viewData)
 {
     //! storage -> storage [view scenario]
     if (!isActive()) {
         Layouts::Storage::self()->updateView(this, viewData);
         return;
     }
 
     //! active -> active [view scenario]
     Latte::View *view = viewForContainment(viewData.id.toUInt());
     bool viewMustBeDeleted = (view && !viewData.onPrimary && !m_corona->screenPool()->isScreenActive(viewData.screen));
 
     QString nextactivelayoutname = (viewData.state() == Data::View::OriginFromLayout && !viewData.originLayout().isEmpty() ? viewData.originLayout() : QString());
 
     if (view) {
         if (!viewMustBeDeleted) {
             QString scrName = Latte::Data::Screen::ONPRIMARYNAME;
 
             if (!viewData.onPrimary) {
                 if (m_corona->screenPool()->hasScreenId(viewData.screen)) {
                     scrName = m_corona->screenPool()->connector(viewData.screen);
                 } else {
                     scrName = "";
                 }
             }
 
             view->setName(viewData.name);
             view->positioner()->setNextLocation(nextactivelayoutname, viewData.screensGroup, scrName, viewData.edge, viewData.alignment);
             return;
         } else {
             //! viewMustBeDeleted
             m_latteViews.remove(view->containment());
             view->disconnectSensitiveSignals();
             delete view;
         }
     }
 
     //! inactiveinmemory -> active/inactiveinmemory [viewscenario]
     //! active -> inactiveinmemory                  [viewscenario]
     auto containment = containmentForId(viewData.id.toUInt());
     if (containment) {
         Layouts::Storage::self()->updateView(this, viewData);
 
         //! by using pendingContainmentUpdates we make sure that when containment->screen() will be
         //! called though reactToScreenChange() the proper screen will be returned
         if (!m_pendingContainmentUpdates.containsId(viewData.id)) {
             m_pendingContainmentUpdates << viewData;
         } else {
             m_pendingContainmentUpdates[viewData.id] = viewData;
         }
         containment->reactToScreenChange();
     }
 
     if (!nextactivelayoutname.isEmpty()) {
         m_corona->layoutsManager()->moveView(name(), viewData.id.toUInt(), nextactivelayoutname);
     }
 
     //! complete update circle and inform the others about the changes
     if (viewMustBeDeleted) {
         emit viewEdgeChanged();
         emit viewsCountChanged();
     }
 
     syncLatteViewsToScreens();
 }
 
 void GenericLayout::removeView(const Latte::Data::View &viewData)
 {
     if (!containsView(viewData.id.toInt())) {
         return;
     }
 
     if (!isActive()) {
         Layouts::Storage::self()->removeView(file(), viewData);
         return;
     }
 
     Plasma::Containment *viewcontainment = containmentForId(viewData.id.toUInt());
     destroyContainment(viewcontainment);
 }
 
 void GenericLayout::removeOrphanedSubContainment(const int &containmentId)
 {
     Data::ViewsTable views = viewsTable();
     QString cidstr = QString::number(containmentId);
 
     if (views.hasContainmentId(cidstr)) {
         return;
     }
 
     if (!isActive()) {
         Layouts::Storage::self()->removeContainment(file(), cidstr);
         return;
     }
 
     Plasma::Containment *orphanedcontainment = containmentForId(cidstr.toUInt());
     destroyContainment(orphanedcontainment);
 }
 
 void GenericLayout::destroyContainment(Plasma::Containment *containment)
 {
     if (!containment || !m_corona || !contains(containment)) {
         return;
     }
 
     containment->setImmutability(Plasma::Types::Mutable);
     containment->destroy();
 }
 
 QString GenericLayout::storedView(const int &containmentId)
 {
     return Layouts::Storage::self()->storedView(this, containmentId);
 }
 
 void GenericLayout::importToCorona()
 {
     Layouts::Storage::self()->importToCorona(this);
 }
 
 Data::ErrorsList GenericLayout::errors() const
 {
     return Layouts::Storage::self()->errors(this);
 }
 
 Data::WarningsList GenericLayout::warnings() const
 {
     return Layouts::Storage::self()->warnings(this);
 }
 
 Latte::Data::ViewsTable GenericLayout::viewsTable() const
 {
     return Layouts::Storage::self()->views(this);
 }
 
 }
 }