File indexing completed on 2024-04-28 13:26:02

 /*
     SPDX-FileCopyrightText: 2021 Michail Vourlakos <mvourlakos@gmail.com>
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "layoutmanager.h"
 
 // local
 #include <plugin/lattetypes.h>
 
 // Qt
 #include <QtMath>
 
 // KDE
 #include <KDeclarative/ConfigPropertyMap>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Applet>
 #include <PlasmaQuick/AppletQuickItem>
 
 #define ISAPPLETLOCKEDOPTION "lockZoom"
 #define ISCOLORINGBLOCKEDOPTION "userBlocksColorizing"
 
 namespace Latte{
 namespace Containment{
 
 const int LayoutManager::JUSTIFYSPLITTERID;
 
 LayoutManager::LayoutManager(QObject *parent)
     : QObject(parent)
 {
     m_option[ISAPPLETLOCKEDOPTION] = "lockedZoomApplets";
     m_option[ISCOLORINGBLOCKEDOPTION] = "userBlocksColorizingApplets";
 
     connect(this, &LayoutManager::rootItemChanged, this, &LayoutManager::onRootItemChanged);
 
     m_hasRestoredAppletsTimer.setInterval(2000);
     m_hasRestoredAppletsTimer.setSingleShot(true);
     connect(&m_hasRestoredAppletsTimer, &QTimer::timeout, this, [&]() {
         m_hasRestoredApplets = true;
         emit hasRestoredAppletsChanged();
     });
 }
 
 bool LayoutManager::hasRestoredApplets() const
 {
     return m_hasRestoredApplets;
 }
 
 int LayoutManager::splitterPosition() const
 {
     return m_splitterPosition;
 }
 
 void LayoutManager::setSplitterPosition(const int &position)
 {
     if (m_splitterPosition == position) {
         return;
     }
 
     m_splitterPosition = position;
     emit splitterPositionChanged();
 }
 
 int LayoutManager::splitterPosition2() const
 {
     return m_splitterPosition2;
 }
 
 void LayoutManager::setSplitterPosition2(const int &position)
 {
     if (m_splitterPosition2 == position) {
         return;
     }
 
     m_splitterPosition2 = position;
     emit splitterPosition2Changed();
 }
 
 QList<int> LayoutManager::appletOrder() const
 {
     return m_appletOrder;
 }
 
 void LayoutManager::setAppletOrder(const QList<int> &order)
 {
     if (m_appletOrder == order) {
         return;
     }
 
     m_appletOrder = order;
     emit appletOrderChanged();
 }
 
 QList<int> LayoutManager::lockedZoomApplets() const
 {
     return m_lockedZoomApplets;
 }
 
 void LayoutManager::setLockedZoomApplets(const QList<int> &applets)
 {
     if (m_lockedZoomApplets == applets) {
         return;
     }
 
     m_lockedZoomApplets = applets;
     emit lockedZoomAppletsChanged();
 }
 
 QList<int> LayoutManager::order() const
 {
     return m_order;
 }
 
 void LayoutManager::setOrder(const QList<int> &order)
 {
     if (m_order == order) {
         return;
     }
 
     m_order = order;
     emit orderChanged();
 }
 
 QList<int> LayoutManager::userBlocksColorizingApplets() const
 {
     return m_userBlocksColorizingApplets;
 }
 
 void LayoutManager::setUserBlocksColorizingApplets(const QList<int> &applets)
 {
     if (m_userBlocksColorizingApplets == applets) {
         return;
     }
 
     m_userBlocksColorizingApplets = applets;
     emit userBlocksColorizingAppletsChanged();
 }
 
 QList<int> LayoutManager::appletsInScheduledDestruction() const
 {
     return m_appletsInScheduledDestruction.keys();
 }
 
 void LayoutManager::setAppletInScheduledDestruction(const int &id, const bool &enabled)
 {
     if (m_appletsInScheduledDestruction.contains(id) && !enabled) {
         m_appletsInScheduledDestruction.remove(id);
         emit appletsInScheduledDestructionChanged();
     } else if (!m_appletsInScheduledDestruction.contains(id) && enabled) {
         m_appletsInScheduledDestruction[id] = appletItem(id);
         emit appletsInScheduledDestructionChanged();
     }
 }
 
 
 QObject *LayoutManager::plasmoid() const
 {
     return m_plasmoid;
 }
 
 void LayoutManager::setPlasmoid(QObject *plasmoid)
 {
     if (m_plasmoid == plasmoid) {
         return;
     }
 
     m_plasmoid = plasmoid;
 
     if (m_plasmoid) {
         m_configuration = qobject_cast<KDeclarative::ConfigPropertyMap *>(m_plasmoid->property("configuration").value<QObject *>());
     }
 
     emit plasmoidChanged();
 }
 
 QQuickItem *LayoutManager::rootItem() const
 {
     return m_rootItem;
 }
 
 void LayoutManager::setRootItem(QQuickItem *root)
 {
     if (m_rootItem == root) {
         return;
     }
 
     m_rootItem = root;
     emit rootItemChanged();
 }
 
 QQuickItem *LayoutManager::dndSpacer() const
 {
     return m_dndSpacer;
 }
 
 void LayoutManager::setDndSpacer(QQuickItem *dnd)
 {
     if (m_dndSpacer == dnd) {
         return;
     }
 
     m_dndSpacer = dnd;
     emit dndSpacerChanged();
 }
 
 QQuickItem *LayoutManager::mainLayout() const
 {
     return m_mainLayout;
 }
 
 void LayoutManager::setMainLayout(QQuickItem *main)
 {
     if (main == m_mainLayout) {
         return;
     }
 
     m_mainLayout = main;
     emit mainLayoutChanged();
 }
 
 QQuickItem *LayoutManager::startLayout() const
 {
     return m_startLayout;
 }
 
 void LayoutManager::setStartLayout(QQuickItem *start)
 {
     if (m_startLayout == start) {
         return;
     }
 
     m_startLayout = start;
     emit startLayoutChanged();
 }
 
 QQuickItem *LayoutManager::endLayout() const
 {
     return m_endLayout;
 }
 
 void LayoutManager::setEndLayout(QQuickItem *end)
 {
     if (m_endLayout == end) {
         return;
     }
 
     m_endLayout = end;
     emit endLayoutChanged();
 }
 
 QQuickItem *LayoutManager::metrics() const
 {
     return m_metrics;
 }
 
 void LayoutManager::setMetrics(QQuickItem *metrics)
 {
     if (m_metrics == metrics) {
         return;
     }
 
     m_metrics = metrics;
     emit metricsChanged();
 }
 
 void LayoutManager::updateOrder()
 {
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
 
     auto nextorder = m_appletOrder;
 
     if (alignment==Latte::Types::Justify) {
         nextorder.insert(m_splitterPosition-1, JUSTIFYSPLITTERID);
         nextorder.insert(m_splitterPosition2-1, JUSTIFYSPLITTERID);
     }
 
     setOrder(nextorder);
 }
 
 void LayoutManager::onRootItemChanged()
 {
     if (!m_rootItem) {
         return;
     }
 
     auto rootMetaObject = m_rootItem->metaObject();
     int createAppletItemIndex = rootMetaObject->indexOfMethod("createAppletItem(QVariant)");
     m_createAppletItemMethod = rootMetaObject->method(createAppletItemIndex);
 
     int createJustifySplitterIndex = rootMetaObject->indexOfMethod("createJustifySplitter()");
     m_createJustifySplitterMethod = rootMetaObject->method(createJustifySplitterIndex);
 
     int initAppletContainerIndex = rootMetaObject->indexOfMethod("initAppletContainer(QVariant,QVariant)");
     m_initAppletContainerMethod = rootMetaObject->method(initAppletContainerIndex);
 }
 
 bool LayoutManager::isValidApplet(const int &id)
 {
     //! should be loaded after m_plasmoid has been set properly
     if (!m_plasmoid) {
         return false;
     }
 
     QList<QObject *> applets = m_plasmoid->property("applets").value<QList<QObject *>>();
 
     for(int i=0; i<applets.count(); ++i) {
         uint appletid = applets[i]->property("id").toUInt();
         if (id>0 && appletid == (uint)id) {
             return true;
         }
     }
 
     return false;
 }
 
 //! Actions
 void LayoutManager::restore()
 {
     QList<int> appletIdsOrder = toIntList((*m_configuration)["appletOrder"].toString());
     QList<QObject *> applets = m_plasmoid->property("applets").value<QList<QObject *>>();
 
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
     int splitterPosition = (*m_configuration)["splitterPosition"].toInt();
     int splitterPosition2 = (*m_configuration)["splitterPosition2"].toInt();
 
     if (alignment==Latte::Types::Justify) {
         if (splitterPosition!=-1 && splitterPosition2!=-1) {
             appletIdsOrder.insert(splitterPosition-1, -1);
             appletIdsOrder.insert(splitterPosition2-1, -1);
         } else {
             appletIdsOrder.insert(0, -1);
             appletIdsOrder << -1;
         }
     }
 
     QList<int> invalidApplets;
 
     //! track invalid applets, meaning applets that have not be loaded properly
     for (int i=0; i<appletIdsOrder.count(); ++i) {
         int aid = appletIdsOrder[i];
 
         if (aid>0 && !isValidApplet(aid)) {
             invalidApplets << aid;
         }
     }
 
     //! remove invalid applets from the ids order
     for (int i=0; i<invalidApplets.count(); ++i) {
         appletIdsOrder.removeAll(invalidApplets[i]);
     }
 
     //! order valid applets based on the cleaned applet ids order
     QList<QObject *> orderedApplets;
 
     for (int i=0; i<appletIdsOrder.count(); ++i) {
         if (appletIdsOrder[i] == -1) {
             orderedApplets << nullptr;
             continue;
         }
 
         for(int j=0; j<applets.count(); ++j) {
             if (applets[j]->property("id").toInt() == appletIdsOrder[i]) {
                 orderedApplets << applets[j];
                 break;
             }
         }
     }
 
     QList<int> orphanedIds;
     for(int i=0; i<applets.count(); ++i) {
         uint id = applets[i]->property("id").toUInt();
 
         if (!appletIdsOrder.contains(id)) {
             orphanedIds << id;
         }
     }
 
     //Validator
     QList<int> validateAppletsOrder;
     for (int i=0; i<orderedApplets.count(); ++i) {
         if (orderedApplets[i] == nullptr) {
             validateAppletsOrder << -1;
             continue;
         }
 
         validateAppletsOrder << orderedApplets[i]->property("id").toUInt();
     }
 
     for(int i=0; i<applets.count(); ++i) {
         if (!orderedApplets.contains(applets[i])) {
             //! after order has been loaded correctly all renaming applets that do not have specified position are added in the end
             orderedApplets<<applets[i];
         }
     }
 
     qDebug() << "org.kde.latte ::: applets found :: " << applets.count() << " : " << appletIdsOrder << " :: " << splitterPosition << " : " << splitterPosition2 << " | " << alignment;
     qDebug() << "org.kde.latte ::: applets orphaned added in the end:: " << orphanedIds;
     qDebug() << "org.kde.latte ::: applets recorded order :: " << appletIdsOrder;
     qDebug() << "org.kde.latte ::: applets produced order ?? " << validateAppletsOrder;
 
     if (alignment != Latte::Types::Justify) {
         for (int i=0; i<orderedApplets.count(); ++i) {
             if (orderedApplets[i] == nullptr) {
                 continue;
             }
 
             QVariant appletItemVariant;
             QVariant appletVariant; appletVariant.setValue(orderedApplets[i]);
             m_createAppletItemMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, appletItemVariant), Q_ARG(QVariant, appletVariant));
             QQuickItem *appletItem = appletItemVariant.value<QQuickItem *>();
             appletItem->setParentItem(m_mainLayout);
         }
     } else {
         QQuickItem *parentlayout = m_startLayout;
 
         for (int i=0; i<orderedApplets.count(); ++i) {
             if (orderedApplets[i] == nullptr) {
                 QVariant splitterItemVariant;
                 m_createJustifySplitterMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, splitterItemVariant));
                 QQuickItem *splitterItem = splitterItemVariant.value<QQuickItem *>();
 
                 if (parentlayout == m_startLayout) {
                     //! first splitter as last child in startlayout
                     splitterItem->setParentItem(parentlayout);
                     parentlayout = m_mainLayout;
                 } else if (parentlayout == m_mainLayout) {
                     //! second splitter as first child in endlayout
                     parentlayout = m_endLayout;
                     splitterItem->setParentItem(parentlayout);
                 }
 
                 continue;
             }
 
             QVariant appletItemVariant;
             QVariant appletVariant; appletVariant.setValue(orderedApplets[i]);
             m_createAppletItemMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, appletItemVariant), Q_ARG(QVariant, appletVariant));
             QQuickItem *appletItem = appletItemVariant.value<QQuickItem *>();
             appletItem->setParentItem(parentlayout);
         }
     }
 
     restoreOptions();
     save(); //will restore also a valid applets ids order
     cleanupOptions();
     initSaveConnections();
     m_hasRestoredAppletsTimer.start();
 }
 
 void LayoutManager::initSaveConnections()
 {
     connect(this, &LayoutManager::appletOrderChanged, this, &LayoutManager::cleanupOptions);
     connect(this, &LayoutManager::splitterPositionChanged, this, &LayoutManager::saveOptions);
     connect(this, &LayoutManager::splitterPosition2Changed, this, &LayoutManager::saveOptions);
     connect(this, &LayoutManager::lockedZoomAppletsChanged, this, &LayoutManager::saveOptions);
     connect(this, &LayoutManager::userBlocksColorizingAppletsChanged, this, &LayoutManager::saveOptions);
 }
 
 void LayoutManager::restoreOptions()
 {
     restoreOption(ISAPPLETLOCKEDOPTION);
     restoreOption(ISCOLORINGBLOCKEDOPTION);
 }
 
 void LayoutManager::restoreOption(const char *option)
 {
     QList<int> applets = toIntList((*m_configuration)[m_option[option]].toString());
 
     if (option == ISAPPLETLOCKEDOPTION) {
         setLockedZoomApplets(applets);
     } else if (option == ISCOLORINGBLOCKEDOPTION) {
         setUserBlocksColorizingApplets(applets);
     }
 }
 
 bool LayoutManager::isJustifySplitter(const QQuickItem *item) const
 {
     return item && (item->property("isInternalViewSplitter").toBool() == true);
 }
 
 bool LayoutManager::isMasqueradedIndex(const int &x, const int &y)
 {
     return (x==y && x<=MASQUERADEDINDEXTOPOINTBASE && y<=MASQUERADEDINDEXTOPOINTBASE);
 }
 
 int LayoutManager::masquearadedIndex(const int &x, const int &y)
 {
     return qAbs(x - MASQUERADEDINDEXTOPOINTBASE);
 }
 
 QPoint LayoutManager::indexToMasquearadedPoint(const int &index)
 {
     return QPoint(MASQUERADEDINDEXTOPOINTBASE-index, MASQUERADEDINDEXTOPOINTBASE-index);
 }
 
 void LayoutManager::reorderParabolicSpacers()
 {
     QQuickItem *startParabolicSpacer = m_mainLayout->property("startParabolicSpacer").value<QQuickItem *>();
     QQuickItem *endParabolicSpacer = m_mainLayout->property("endParabolicSpacer").value<QQuickItem *>();
 
     if (!startParabolicSpacer || !endParabolicSpacer) {
         return;
     }
 
     insertAtLayoutTail(m_mainLayout, startParabolicSpacer);
     insertAtLayoutHead(m_mainLayout, endParabolicSpacer);
 }
 
 void LayoutManager::save()
 {
     QList<int> appletIds;
 
     reorderParabolicSpacers();
 
     auto collectLayoutAppletIds = [](QQuickItem *layout, QList<int> &appletIds) {
         int childCount = 0;
         for (int i=0; i<layout->childItems().count(); ++i) {
             QQuickItem *item = layout->childItems()[i];
             bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
             bool isParabolicEdgeSpacer = item->property("isParabolicEdgeSpacer").toBool();
             if (!isInternalSplitter && !isParabolicEdgeSpacer) {
                 QVariant appletVariant = item->property("applet");
                 if (!appletVariant.isValid()) {
                     continue;
                 }
 
                 QObject *applet = appletVariant.value<QObject *>();
 
                 if (!applet) {
                     continue;
                 }
 
                 uint id = applet->property("id").toUInt();
 
                 if (id>0) {
                     childCount++;
                     appletIds << id;
                 }
             }
         }
         return childCount;
     };
 
     int startChilds = collectLayoutAppletIds(m_startLayout, appletIds);
     int mainChilds  = collectLayoutAppletIds(m_mainLayout,  appletIds);
     int endChilds   = collectLayoutAppletIds(m_endLayout,   appletIds);
 
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
 
     if (alignment == Latte::Types::Justify) {
         setSplitterPosition(startChilds + 1);
         setSplitterPosition2(startChilds + 1 + mainChilds + 1);
     } else {
         int splitterPosition = (*m_configuration)["splitterPosition"].toInt();
         int splitterPosition2 = (*m_configuration)["splitterPosition2"].toInt();
 
         setSplitterPosition(splitterPosition);
         setSplitterPosition2(splitterPosition2);
     }
 
     //! are not writing in config file for some cases mentioned in class header so they are not used
     //(*m_configuration)["splitterPosition"] = QVariant(startChilds + 1);
     //(*m_configuration)["splitterPosition2"] = QVariant(startChilds + 1 + mainChilds + 1);
     //(*m_configuration)["appletOrder"] = appletIds.join(";");
 
     setAppletOrder(appletIds);
 
     //! publish updated order
     updateOrder();
 
     //! save applet order
     QString appletsserialized = toStr(appletIds);
 
     if ((*m_configuration)["appletOrder"] != appletsserialized) {
         m_configuration->insert("appletOrder", appletsserialized);
         emit m_configuration->valueChanged("appletOrder", appletsserialized);
     }
 }
 
 void LayoutManager::saveOptions()
 {    
     QString lockedserialized =  toStr(m_lockedZoomApplets);
     if ((*m_configuration)[m_option[ISAPPLETLOCKEDOPTION]] != lockedserialized) {
         m_configuration->insert(m_option[ISAPPLETLOCKEDOPTION], lockedserialized);
         emit m_configuration->valueChanged(m_option[ISAPPLETLOCKEDOPTION], lockedserialized);
     }
 
     QString colorsserialized = toStr(m_userBlocksColorizingApplets);
     if ((*m_configuration)[m_option[ISCOLORINGBLOCKEDOPTION]] != colorsserialized) {
         m_configuration->insert(m_option[ISCOLORINGBLOCKEDOPTION], colorsserialized);
         emit m_configuration->valueChanged(m_option[ISCOLORINGBLOCKEDOPTION], colorsserialized);
     }
 
     if ((*m_configuration)["splitterPosition"] != m_splitterPosition) {
         m_configuration->insert("splitterPosition", m_splitterPosition);
         emit m_configuration->valueChanged(m_option["splitterPosition"], m_splitterPosition);
     }
 
     if ((*m_configuration)["splitterPosition2"] != m_splitterPosition2) {
         m_configuration->insert("splitterPosition2", m_splitterPosition2);
         emit m_configuration->valueChanged(m_option["splitterPosition2"], m_splitterPosition2);
     }
 }
 
 void LayoutManager::setOption(const int &appletId, const QString &property, const QVariant &value)
 {
     if (property == ISAPPLETLOCKEDOPTION) {
         bool enabled = value.toBool();
 
         if (enabled && !m_lockedZoomApplets.contains(appletId)) {
             QList<int> applets = m_lockedZoomApplets; applets << appletId;
             setLockedZoomApplets(applets);
         } else if (!enabled && m_lockedZoomApplets.contains(appletId)) {
             QList<int> applets = m_lockedZoomApplets; applets.removeAll(appletId);
             setLockedZoomApplets(applets);
         }
     } else if (property == ISCOLORINGBLOCKEDOPTION) {
         bool enabled = value.toBool();
 
         if (enabled && !m_userBlocksColorizingApplets.contains(appletId)) {
             QList<int> applets = m_userBlocksColorizingApplets; applets << appletId;
             setUserBlocksColorizingApplets(applets);
         } else if (!enabled && m_userBlocksColorizingApplets.contains(appletId)) {
             QList<int> applets = m_userBlocksColorizingApplets; applets.removeAll(appletId);
             setUserBlocksColorizingApplets(applets);
         }
     }
 }
 
 void LayoutManager::insertBefore(QQuickItem *hoveredItem, QQuickItem *item)
 {
     if (!hoveredItem || !item || hoveredItem == item) {
         return;
     }
 
     item->setParentItem(hoveredItem->parentItem());
     item->stackBefore(hoveredItem);
 }
 
 void LayoutManager::insertAfter(QQuickItem *hoveredItem, QQuickItem *item)
 {
     if (!hoveredItem || !item || hoveredItem == item) {
         return;
     }
 
     item->setParentItem(hoveredItem->parentItem());
     item->stackAfter(hoveredItem);
 }
 
 void LayoutManager::insertAtLayoutTail(QQuickItem *layout, QQuickItem *item)
 {
     if (!layout || !item) {
         return;
     }
 
     if (layout->childItems().count() > 0) {
         if (layout == m_endLayout && isJustifySplitter(layout->childItems()[0])) {
             //! this way we ignore the justify splitter in start layout
             insertAfter(layout->childItems()[0], item);
         } else {
             insertBefore(layout->childItems()[0], item);
         }
         return;
     }
 
     item->setParentItem(layout);
 }
 
 void LayoutManager::insertAtLayoutHead(QQuickItem *layout, QQuickItem *item)
 {
     if (!layout || !item) {
         return;
     }
 
     int count = layout->childItems().count();
 
     if (count > 0) {
         if (layout == m_startLayout && isJustifySplitter(layout->childItems()[count-1])) {
             //! this way we ignore the justify splitter in end layout
             insertBefore(layout->childItems()[count-1], item);
         } else {
             insertAfter(layout->childItems()[count-1], item);
         }
         return;
     }
 
     item->setParentItem(layout);
 }
 
 void LayoutManager::insertAtLayoutIndex(QQuickItem *layout, QQuickItem *item, const int &index)
 {
     if (!layout || !item) {
         return;
     }
 
     if (index == 0) {
         insertAtLayoutTail(layout, item);
     } else if (index >= layout->childItems().count()) {
         insertAtLayoutHead(layout, item);
     } else {
         insertBefore(layout->childItems()[index], item);
     }
 }
 
 bool LayoutManager::insertAtLayoutCoordinates(QQuickItem *layout, QQuickItem *item, int x, int y)
 {
     if (!layout || !item || !m_plasmoid || !layout->contains(QPointF(x,y))) {
         return false;
     }
 
     bool horizontal = (m_plasmoid->property("formFactor").toInt() != Plasma::Types::Vertical);
     bool vertical = !horizontal;
     int rowspacing = qMax(0, layout->property("rowSpacing").toInt());
     int columnspacing = qMax(0, layout->property("columnSpacing").toInt());
 
     if (horizontal) {
         y = layout->height() / 2;
     } else {
         x = layout->width() / 2;
     }
 
     //! child renamed at hovered
     QQuickItem *hovered = layout->childAt(x, y);
 
     //if we got a place inside the space between 2 applets, we have to find it manually
     if (!hovered) {
         int size = layout->childItems().count();
         if (horizontal) {
             for (int i = 0; i < size; ++i) {
                 if (i>=layout->childItems().count()) {
                     break;
                 }
 
                 QQuickItem *candidate = layout->childItems()[i];
                 int right = candidate->x() + candidate->width() + rowspacing;
                 if (x>=candidate->x() && x<right) {
                     hovered = candidate;
                     break;
                 }
             }
         } else {
             for (int i = 0; i < size; ++i) {
                 if (i>=layout->childItems().count()) {
                     break;
                 }
 
                 QQuickItem *candidate = layout->childItems()[i];
                 int bottom = candidate->y() + candidate->height() + columnspacing;
                 if (y>=candidate->y() && y<bottom) {
                     hovered = candidate;
                     break;
                 }
             }
         }
     }
 
     if (hovered == item && item->parentItem() == layout) {
         //! already hovered and in correct position
         return true;
     }
 
     if (hovered) {
         if ((vertical && y < (hovered->y() + hovered->height()/2) && hovered->height() > 1) ||
                 (horizontal && x < (hovered->x() + hovered->width()/2) && hovered->width() > 1)) {
             insertBefore(hovered, item);
         } else {
             insertAfter(hovered, item);
         }
 
         return true;
     }
 
     return false;
 }
 
 QQuickItem *LayoutManager::firstSplitter()
 {
     for(int i=0; i<m_startLayout->childItems().count(); ++i) {
         QQuickItem *item = m_startLayout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         if (isInternalSplitter) {
             return item;
         }
     }
 
     for(int i=0; i<m_mainLayout->childItems().count(); ++i) {
         QQuickItem *item = m_mainLayout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         if (isInternalSplitter) {
             return item;
         }
     }
 
     for(int i=0; i<m_endLayout->childItems().count(); ++i) {
         QQuickItem *item = m_endLayout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         if (isInternalSplitter) {
             return item;
         }
     }
 
     return nullptr;
 }
 
 QQuickItem *LayoutManager::lastSplitter()
 {
     for(int i=m_endLayout->childItems().count()-1; i>=0; --i) {
         QQuickItem *item = m_endLayout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         if (isInternalSplitter) {
             return item;
         }
     }
 
     for(int i=m_mainLayout->childItems().count()-1; i>=0; --i) {
         QQuickItem *item = m_mainLayout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         if (isInternalSplitter) {
             return item;
         }
     }
 
     for(int i=m_endLayout->childItems().count()-1; i>=0; --i) {
         QQuickItem *item = m_endLayout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         if (isInternalSplitter) {
             return item;
         }
     }
 
     return nullptr;
 }
 
 QQuickItem *LayoutManager::appletItemInLayout(QQuickItem *layout, const int &id)
 {
     if (!layout) {
         return nullptr;
     }
 
     for(int i=0; i<layout->childItems().count(); ++i) {
         QQuickItem *item = layout->childItems()[i];
         bool isInternalSplitter = item->property("isInternalViewSplitter").toBool();
         bool isParabolicEdgeSpacer = item->property("isParabolicEdgeSpacer").toBool();
         if (!isInternalSplitter && !isParabolicEdgeSpacer) {
             QVariant appletVariant = item->property("applet");
             if (!appletVariant.isValid()) {
                 continue;
             }
 
             QObject *applet = appletVariant.value<QObject *>();
 
             if (!applet) {
                 continue;
             }
 
             int tempid = applet->property("id").toInt();
 
             if (id == tempid) {
                 return item;
             }
         }
     }
 
     return nullptr;
 }
 
 QQuickItem *LayoutManager::appletItem(const int &id)
 {
     QQuickItem *item = appletItemInLayout(m_mainLayout, id);
 
     if (!item) {
         item = appletItemInLayout(m_startLayout, id);
     }
 
     if (!item) {
         item = appletItemInLayout(m_endLayout, id);
     }
 
     return item;
 }
 
 int LayoutManager::dndSpacerIndex()
 {
     if (m_dndSpacer->parentItem() != m_startLayout
             && m_dndSpacer->parentItem() != m_mainLayout
             && m_dndSpacer->parentItem() != m_endLayout) {
         return -1;
     }
 
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
     int index = -1;
 
     if (alignment == Latte::Types::Justify) {
         for(int i=0; i<m_startLayout->childItems().count(); ++i) {
             QQuickItem *item = m_startLayout->childItems()[i];
             bool isparabolicspacer = item->property("isParabolicEdgeSpacer").toBool();
 
             if (isparabolicspacer) {
                 continue;
             }
 
             index++;
             if (item == m_dndSpacer) {
                 return index;
             }
         }
     }
 
     for(int i=0; i<m_mainLayout->childItems().count(); ++i) {
         QQuickItem *item = m_mainLayout->childItems()[i];       
         bool isparabolicspacer = item->property("isParabolicEdgeSpacer").toBool();
 
         if (isparabolicspacer) {
             continue;
         }
 
         index++;
         if (item == m_dndSpacer) {
             return index;
         }
     }
 
     if (alignment == Latte::Types::Justify) {
         for(int i=0; i<m_endLayout->childItems().count(); ++i) {
             QQuickItem *item = m_endLayout->childItems()[i];
             bool isparabolicspacer = item->property("isParabolicEdgeSpacer").toBool();
 
             if (isparabolicspacer) {
                 continue;
             }
 
             index++;
             if (item == m_dndSpacer) {
                 return index;
             }
         }
     }
 
     return -1;
 }
 
 
 void LayoutManager::requestAppletsOrder(const QList<int> &order)
 {
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
     QQuickItem *nextlayout = alignment != Latte::Types::Justify ? m_mainLayout : m_startLayout;
     QQuickItem *previousitem = nullptr;
 
     int addedsplitters{0};
 
     for (int i=0; i<order.count(); ++i) {
         QQuickItem *currentitem;
 
         if (alignment != Latte::Types::Justify || order[i] != JUSTIFYSPLITTERID) {
             currentitem = appletItem(order[i]);
         } else if (alignment == Latte::Types::Justify && order[i] == JUSTIFYSPLITTERID) {
             currentitem = addedsplitters == 0 ? firstSplitter() : lastSplitter();
             addedsplitters++;
         }
 
 
         if (previousitem) {
             insertAfter(previousitem, currentitem);
         } else {
             insertAtLayoutTail(nextlayout, currentitem);
         }
 
         previousitem = currentitem;
 
         if (alignment == Latte::Types::Justify && order[i] == JUSTIFYSPLITTERID) {
             nextlayout = addedsplitters == 1 ? m_mainLayout : m_endLayout;
         }
     }
 
     if (alignment == Latte::Types::Justify) {
         moveAppletsBasedOnJustifyAlignment();
         save();
     }
 }
 
 void LayoutManager::requestAppletsInLockedZoom(const QList<int> &applets)
 {
     setLockedZoomApplets(applets);
 }
 
 void LayoutManager::requestAppletsDisabledColoring(const QList<int> &applets)
 {
     setUserBlocksColorizingApplets(applets);
 }
 
 int LayoutManager::distanceFromTail(QQuickItem *layout, QPointF pos) const
 {
     return (int)qSqrt(qPow(pos.x() - 0, 2) + qPow(pos.y() - 0, 2));
 }
 
 int LayoutManager::distanceFromHead(QQuickItem *layout, QPointF pos) const
 {
     float rightX = layout->width() - 1;
     float rightY = layout->height() - 1;
     return  (int)qSqrt(qPow(pos.x() - rightX, 2) + qPow(pos.y() - rightY, 2));
 }
 
 void LayoutManager::insertAtCoordinates(QQuickItem *item, const int &x, const int &y)
 {
     if (!m_configuration || !item) {
         return;
     }
 
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
 
     bool result{false};
 
     if (alignment == Latte::Types::Justify) {
         QPointF startPos = m_startLayout->mapFromItem(m_rootItem, QPointF(x, y));
         result = insertAtLayoutCoordinates(m_startLayout, item, startPos.x(), startPos.y());
 
         if (!result) {
             QPointF endPos = m_endLayout->mapFromItem(m_rootItem, QPointF(x, y));
             result = insertAtLayoutCoordinates(m_endLayout, item, endPos.x(), endPos.y());
         }
     }
 
     if (!result) {
         QPointF mainPos = m_mainLayout->mapFromItem(m_rootItem, QPointF(x, y));
         //! in javascript direct insertAtCoordinates was usedd ???
         result = insertAtLayoutCoordinates(m_mainLayout, item, mainPos.x(), mainPos.y());
     }
 
     if (result) {
         return;
     }
 
     //! item was not added because it does not hover any of the layouts and layout items
     //! so the place that will be added is specified by the distance of the item from the layouts
 
     QPointF startrelpos = m_startLayout->mapFromItem(m_rootItem, QPointF(x, y));
     QPointF endrelpos = m_endLayout->mapFromItem(m_rootItem, QPointF(x, y));
     QPointF mainrelpos = m_mainLayout->mapFromItem(m_rootItem, QPointF(x, y));
 
     int starttaildistance = distanceFromTail(m_startLayout, startrelpos);
     int startheaddistance = distanceFromHead(m_startLayout, startrelpos);
     int maintaildistance = distanceFromTail(m_mainLayout, mainrelpos);
     int mainheaddistance = distanceFromHead(m_mainLayout, mainrelpos);
     int endtaildistance = distanceFromTail(m_endLayout, endrelpos);
     int endheaddistance = distanceFromHead(m_endLayout, endrelpos);
 
     int startdistance = qMin(starttaildistance, startheaddistance);
     int maindistance = qMin(maintaildistance, mainheaddistance);
     int enddistance = qMin(endtaildistance, endheaddistance);
 
     if (alignment != Latte::Types::Justify || (maindistance < startdistance && maindistance < enddistance)) {
         if (maintaildistance <= mainheaddistance) {
             insertAtLayoutTail(m_mainLayout, item);
         } else {
             insertAtLayoutHead(m_mainLayout, item);
         }
     } else if (startdistance < maindistance && startdistance < enddistance) {
         if (maintaildistance <= mainheaddistance) {
             insertAtLayoutTail(m_startLayout, item);
         } else {
             insertAtLayoutHead(m_startLayout, item);
         }
     } else {
         if (endtaildistance <= endheaddistance) {
             insertAtLayoutTail(m_endLayout, item);
         } else {
             insertAtLayoutHead(m_endLayout, item);
         }
     }
 }
 
 void LayoutManager::cleanupOptions()
 {
     auto inlockedzoomcurrent = m_lockedZoomApplets;
     QList<int> inlockedzoomnext;
     for(int i=0; i<inlockedzoomcurrent.count(); ++i) {
         if (m_appletOrder.contains(inlockedzoomcurrent[i])) {
             inlockedzoomnext << inlockedzoomcurrent[i];
         }
     }
     setLockedZoomApplets(inlockedzoomnext);
 
     auto disabledcoloringcurrent = m_userBlocksColorizingApplets;
     QList <int> disabledcoloringnext;
     for(int i=0; i<disabledcoloringcurrent.count(); ++i) {
         if (m_appletOrder.contains(disabledcoloringcurrent[i])) {
             disabledcoloringnext << disabledcoloringcurrent[i];
         }
     }
     setUserBlocksColorizingApplets(disabledcoloringnext);
 }
 
 void LayoutManager::addAppletItem(QObject *applet, int index)
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout || index < 0) {
         return;
     }
 
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
     QVariant appletItemVariant;
     QVariant appletVariant; appletVariant.setValue(applet);
     m_createAppletItemMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, appletItemVariant), Q_ARG(QVariant, appletVariant));
     QQuickItem *aitem = appletItemVariant.value<QQuickItem *>();
 
     if (m_dndSpacer) {
         m_dndSpacer->setParentItem(m_rootItem);
     }
 
     QQuickItem *previousItem{nullptr};
 
     if (index >= m_order.count()) {
         // do nothing it should be added at the end
     } else {
         if (alignment == Latte::Types::Justify && m_order[index] == JUSTIFYSPLITTERID) {
             if (index<m_splitterPosition2-1) {
                 previousItem = firstSplitter();
             } else {
                 previousItem = lastSplitter();
             }
         } else {
             previousItem = appletItem(m_order[index]);
         }
     }
 
     if (previousItem) {
         insertBefore(previousItem, aitem);
     } else {
         if (alignment == Latte::Types::Justify) {
             insertAtLayoutHead(m_endLayout, aitem);
         } else {
             insertAtLayoutHead(m_mainLayout, aitem);
         }
     }
 
     if (alignment == Latte::Types::Justify) {
         moveAppletsBasedOnJustifyAlignment();
     }
 
     save();
 }
 
 void LayoutManager::addAppletItem(QObject *applet, int x, int y)
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout) {
         return;
     }    
 
     PlasmaQuick::AppletQuickItem *aqi = qobject_cast<PlasmaQuick::AppletQuickItem *>(applet);
 
     if (aqi && aqi->applet() && !aqi->applet()->destroyed() && m_appletsInScheduledDestruction.contains(aqi->applet()->id())) {
         int id = aqi->applet()->id();
         QVariant appletContainerVariant; appletContainerVariant.setValue(m_appletsInScheduledDestruction[id]);
         QVariant appletVariant; appletVariant.setValue(applet);
         m_initAppletContainerMethod.invoke(m_rootItem, Q_ARG(QVariant, appletContainerVariant), Q_ARG(QVariant, appletVariant));
         setAppletInScheduledDestruction(id, false);
         return;
     }
 
     QVariant appletItemVariant;
     QVariant appletVariant; appletVariant.setValue(applet);
     m_createAppletItemMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, appletItemVariant), Q_ARG(QVariant, appletVariant));
     QQuickItem *appletItem = appletItemVariant.value<QQuickItem *>();
 
     if (m_dndSpacer->parentItem() == m_mainLayout
             || m_dndSpacer->parentItem() == m_startLayout
             || m_dndSpacer->parentItem() == m_endLayout) {
         insertBefore(m_dndSpacer, appletItem);
 
         QQuickItem *currentlayout = m_dndSpacer->parentItem();
         m_dndSpacer->setParentItem(m_rootItem);
 
         if (currentlayout == m_startLayout) {
             reorderSplitterInStartLayout();
         } else if (currentlayout ==m_endLayout) {
             reorderSplitterInEndLayout();
         }
     } else if (x >= 0 && y >= 0) {
         // If the provided position is valid, use it.
         insertAtCoordinates(appletItem, x , y);
     } else {
         // Fall through to adding at the end of main layout.
         appletItem->setParentItem(m_mainLayout);
     }
 
     save();
 }
 
 void LayoutManager::removeAppletItem(QObject *applet)
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout) {
         return;
     }
 
     PlasmaQuick::AppletQuickItem *aqi = qobject_cast<PlasmaQuick::AppletQuickItem *>(applet);
 
     if (!aqi) {
         return;
     }
 
     int id = aqi->applet()->id();
 
     if (aqi->applet() && aqi->applet()->destroyed() && !m_appletsInScheduledDestruction.contains(id)/*this way we really delete it in the end*/) {
         setAppletInScheduledDestruction(id, true);
         return;
     }
 
     destroyAppletContainer(aqi->applet());
 }
 
 void LayoutManager::destroyAppletContainer(QObject *applet)
 {
     if (!applet || !m_startLayout || !m_mainLayout || !m_endLayout) {
         return;
     }
 
     Plasma::Applet *ca = qobject_cast<Plasma::Applet *>(applet);
 
     if (!ca) {
         qDebug() << "org.kde.destroy destroying applet could not succeed Plasma/Applet was not identified...";
         return;
     }
 
     int id = ca->id();
 
     bool destroyed{false};
 
     if (m_appletsInScheduledDestruction.contains(id)) {
         //! when deleted from scheduled destruction
         m_appletsInScheduledDestruction[id]->setVisible(false);
         m_appletsInScheduledDestruction[id]->setParentItem(m_rootItem);
         m_appletsInScheduledDestruction[id]->deleteLater();
         setAppletInScheduledDestruction(id, false);
         destroyed = true;
     } else {
         //! when deleted directly for Plasma::Applet destruction e.g. synced applets
         for (int i=0; i<=2; ++i) {
             if (destroyed) {
                 break;
             }
 
             QQuickItem *layout = (i==0 ? m_startLayout : (i==1 ? m_mainLayout : m_endLayout));
 
             if (layout->childItems().count() > 0) {
                 int size = layout->childItems().count();
                 for (int j=size-1; j>=0; --j) {
                     QQuickItem *item = layout->childItems()[j];
                     bool issplitter = item->property("isInternalViewSplitter").toBool();
                     if (issplitter) {
                         continue;
                     }
 
                     QVariant appletVariant = item->property("applet");
                     if (!appletVariant.isValid()) {
                         continue;
                     }
                     PlasmaQuick::AppletQuickItem *appletitem = appletVariant.value<PlasmaQuick::AppletQuickItem *>();
 
                     if (appletitem && appletitem->applet() == applet) {
                         item->setVisible(false);
                         item->setParentItem(m_rootItem);
                         item->deleteLater();
                         destroyed = true;
                         break;
                     }
                 }
             }
         }
     }
 
     if (destroyed) {
         save();
     }
 }
 
 void LayoutManager::reorderSplitterInStartLayout()
 {
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
 
     if (alignment != Latte::Types::Justify) {
         return;
     }
 
     int size = m_startLayout->childItems().count();
 
     if (size > 0) {
         QQuickItem *splitter{nullptr};
 
         for (int i=0; i<size; ++i) {
             QQuickItem *item = m_startLayout->childItems()[i];
             bool issplitter = item->property("isInternalViewSplitter").toBool();
 
             if (issplitter && i<size-1) {
                 splitter = item;
                 break;
             }
         }
 
         if (splitter) {
             insertAfter(m_startLayout->childItems()[size-1],splitter);
         }
     }
 }
 
 void LayoutManager::reorderSplitterInEndLayout()
 {
     Latte::Types::Alignment alignment = static_cast<Latte::Types::Alignment>((*m_configuration)["alignment"].toInt());
 
     if (alignment != Latte::Types::Justify) {
         return;
     }
 
     int size = m_endLayout->childItems().count();
 
     if (size > 0) {
         QQuickItem *splitter{nullptr};
 
         for (int i=0; i<size; ++i) {
             QQuickItem *item = m_endLayout->childItems()[i];
             bool issplitter = item->property("isInternalViewSplitter").toBool();
 
             if (issplitter && i!=0) {
                 splitter = item;
                 break;
             }
         }
 
         if (splitter) {
             insertBefore(m_endLayout->childItems()[0],splitter);
         }
     }
 }
 
 void LayoutManager::addJustifySplittersInMainLayout()
 {
     if (!m_configuration || !m_mainLayout) {
         return;
     }
 
     destroyJustifySplitters();
 
     int splitterPosition = (*m_configuration)["splitterPosition"].toInt();
     int splitterPosition2 = (*m_configuration)["splitterPosition2"].toInt();
 
     int splitterIndex = (splitterPosition >= 1 ? splitterPosition - 1 : -1);
     int splitterIndex2 = (splitterPosition2 >= 1 ? splitterPosition2 - 1 : -1);
 
     //! First Splitter
     QVariant splitterItemVariant;
     m_createJustifySplitterMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, splitterItemVariant));
     QQuickItem *splitterItem = splitterItemVariant.value<QQuickItem *>();
 
     int size = m_mainLayout->childItems().count()-2; //we need to remove parabolic spacers
 
     splitterItem->setParentItem(m_mainLayout);
 
     if (size>0 && splitterIndex>=0) {
         bool atend = (splitterIndex >= size);
         int validindex = (atend ? size-1 : splitterIndex) + 1; //we need to take into account first parabolic spacer
         QQuickItem *currentitem = m_mainLayout->childItems()[validindex];
 
         if (atend) {
             splitterItem->stackAfter(currentitem);
         } else {
             splitterItem->stackBefore(currentitem);
         }
     } else if (size>0) {
         //! add in first position
         QQuickItem *currentitem = m_mainLayout->childItems()[0];
         splitterItem->stackBefore(currentitem);
     }
 
     //! Second Splitter
     QVariant splitterItemVariant2;
     m_createJustifySplitterMethod.invoke(m_rootItem, Q_RETURN_ARG(QVariant, splitterItemVariant2));
     QQuickItem *splitterItem2 = splitterItemVariant2.value<QQuickItem *>();
 
     int size2 = m_mainLayout->childItems().count()-2; //we need to remove parabolic spacers
 
     splitterItem2->setParentItem(m_mainLayout);
 
     if (size2>0 && splitterIndex2>=0) {
         bool atend = (splitterIndex2 >= size2);
         int validindex2 = (atend ? size2-1 : splitterIndex2) + 1; //we need to take into account first parabolic spacer
         QQuickItem *currentitem2 = m_mainLayout->childItems()[validindex2];
 
         if (atend) {
             splitterItem2->stackAfter(currentitem2);
         } else {
             splitterItem2->stackBefore(currentitem2);
         }
     } else if (size2>1){
         //! add in last position
         QQuickItem *currentitem2 = m_mainLayout->childItems()[size2-1+1]; //we need to take into account first parabolic spacer
         splitterItem2->stackAfter(currentitem2);
     }
 }
 
 void LayoutManager::destroyJustifySplitters()
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout) {
         return;
     }
 
     for (int i=0; i<=2; ++i) {
         QQuickItem *layout = (i==0 ? m_startLayout : (i==1 ? m_mainLayout : m_endLayout));
 
         if (layout->childItems().count() > 0) {
             int size = layout->childItems().count();
             for (int j=size-1; j>=0; --j) {
                 QQuickItem *item = layout->childItems()[j];
                 bool issplitter = item->property("isInternalViewSplitter").toBool();
                 if (issplitter) {
                     item->deleteLater();
                 }
             }
         }
     }
 }
 
 void LayoutManager::joinLayoutsToMainLayout()
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout) {
         return;
     }
 
     if (m_startLayout->childItems().count() > 0) {
         int size = m_startLayout->childItems().count();
         for (int i=size-1; i>=0; --i) {
             QQuickItem *lastStartLayoutItem = m_startLayout->childItems()[i];
             QQuickItem *firstMainLayoutItem = m_mainLayout->childItems().count() > 0 ? m_mainLayout->childItems()[0] : nullptr;
 
             lastStartLayoutItem->setParentItem(m_mainLayout);
 
             if (firstMainLayoutItem) {
                 lastStartLayoutItem->stackBefore(firstMainLayoutItem);
             }
         }
     }
 
     if (m_endLayout->childItems().count() > 0) {
         int size = m_endLayout->childItems().count();
         for (int i=0; i<size; ++i) {
             QQuickItem *firstEndLayoutItem = m_endLayout->childItems()[0];
             QQuickItem *lastMainLayoutItem = m_mainLayout->childItems().count() > 0 ? m_mainLayout->childItems()[m_mainLayout->childItems().count()-1] : nullptr;
 
             firstEndLayoutItem->setParentItem(m_mainLayout);
 
             if (lastMainLayoutItem) {
                 firstEndLayoutItem->stackAfter(lastMainLayoutItem);
             }
         }
     }
 
     destroyJustifySplitters();
 }
 
 void LayoutManager::moveAppletsBasedOnJustifyAlignment()
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout) {
         return;
     }
 
     reorderParabolicSpacers();
 
     QList<QQuickItem *> appletlist;
 
     appletlist << m_startLayout->childItems();
     appletlist << m_mainLayout->childItems();
     appletlist << m_endLayout->childItems();
 
     bool firstSplitterFound{false};
     bool secondSplitterFound{false};
     int splitter1{-1};
     int splitter2{-1};
 
     for(int i=0; i<appletlist.count(); ++i) {
         bool issplitter = appletlist[i]->property("isInternalViewSplitter").toBool();
         bool isparabolicspacer = appletlist[i]->property("isParabolicEdgeSpacer").toBool();
 
         if (!firstSplitterFound) {
             insertAtLayoutIndex(m_startLayout, appletlist[i], i);
             if (issplitter) {
                 firstSplitterFound = true;
                 splitter1 = i;
             }
         } else if (firstSplitterFound && !secondSplitterFound) {
             if (issplitter) {
                 secondSplitterFound = true;
                 splitter2 = i;
                 insertAtLayoutTail(m_endLayout, appletlist[i]);
             } else {
                 insertAtLayoutIndex(m_mainLayout, appletlist[i], i-splitter1);
             }
         } else if (firstSplitterFound && secondSplitterFound) {
             insertAtLayoutIndex(m_endLayout, appletlist[i], i-splitter2);
         }
     }
 
     reorderParabolicSpacers();
 }
 
 void LayoutManager::printAppletList(QList<QQuickItem *> list)
 {
     for(int i=0; i<list.count(); ++i) {
         bool issplitter = list[i]->property("isInternalViewSplitter").toBool();
         bool isparabolicspacer = list[i]->property("isParabolicEdgeSpacer").toBool();
 
         if (issplitter) {
             qDebug() << i << " __ JUSTIFY SPLITTER";
             continue;
         }
 
         if (isparabolicspacer) {
             qDebug() << i << " __ PARABOLICSPACER";
             continue;
         }
 
         QVariant appletVariant = list[i]->property("applet");
         if (!appletVariant.isValid()) {
             continue;
         }
         PlasmaQuick::AppletQuickItem *appletitem = appletVariant.value<PlasmaQuick::AppletQuickItem *>();
 
         if (appletitem) {
             qDebug() << i << " __ " << appletitem->applet()->pluginMetaData().pluginId();
         }
     }
 }
 
 QList<int> LayoutManager::toIntList(const QString &serialized)
 {
     QList<int> list;
     QStringList items = serialized.split(";");
     items.removeAll(QString());
 
     for(const auto &item: items) {
         list << item.toInt();
     }
 
     return list;
 }
 
 QString LayoutManager::toStr(const QList<int> &list)
 {
     QString str;
     QStringList strlist;
 
     for(const auto &num: list) {
         strlist << QString::number(num);
     }
 
     return strlist.join(";");
 }
 
 }
 }