provide insertAtCoordinates at fastLayoutManager

containment/CMakeLists.txt

@@ -14,7 +14,8 @@ add_library(lattecontainmentplugin SHARED ${containment_SRCS})
 target_link_libraries(lattecontainmentplugin
                       Qt5::Core
                       Qt5::Qml
-                      Qt5::Quick)
+                      Qt5::Quick
+                      KF5::Plasma)
 
 install(TARGETS lattecontainmentplugin DESTINATION ${KDE_INSTALL_QMLDIR}/org/kde/latte/private/containment)
 install(FILES plugin/qmldir DESTINATION ${KDE_INSTALL_QMLDIR}/org/kde/latte/private/containment)

containment/package/contents/ui/DragDropArea.qml

@@ -146,7 +146,7 @@ DragDrop.DropArea {
             return;
         }
 
-        root.layoutManager().insertAtCoordinates2(dndSpacer, event.x, event.y)
+        fastLayoutManager.insertAtCoordinates(dndSpacer, event.x, event.y);
         dndSpacer.opacity = 1;
     }
 
@@ -164,7 +164,7 @@ DragDrop.DropArea {
             return;
         }
 
-        root.layoutManager().insertAtCoordinates2(dndSpacer, event.x, event.y)
+        fastLayoutManager.insertAtCoordinates(dndSpacer, event.x, event.y);
         dndSpacer.opacity = 1;
     }
 

containment/package/contents/ui/main.qml

@@ -944,9 +944,12 @@ Item {
 
     LatteContainment.LayoutManager{
         id:fastLayoutManager
+        plasmoidObj: plasmoid
+        rootItem: root
         mainLayout: layoutsContainer.mainLayout
         startLayout: layoutsContainer.startLayout
         endLayout: layoutsContainer.endLayout
+        metrics: _metrics
     }
 
     ///////////////BEGIN UI elements

containment/plugin/layoutmanager.cpp

@@ -20,7 +20,10 @@
 
 #include "layoutmanager.h"
 
-//Qt
+//! Plasma
+#include <Plasma>
+
+const int CHILDFOUNDID = 11;
 
 namespace Latte{
 namespace Containment{
@@ -30,6 +33,41 @@ LayoutManager::LayoutManager(QObject *parent)
 {
 }
 
+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<QQmlPropertyMap *>(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::mainLayout() const
 {
     return m_mainLayout;
@@ -75,7 +113,125 @@ void LayoutManager::setEndLayout(QQuickItem *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();
+}
+
 //! Actions
+
+bool LayoutManager::insertAtLayoutCoordinates(QQuickItem *layout, QQuickItem *item, int x, int y)
+{
+    if (!layout || !item || !m_plasmoid) {
+        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) {
+                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) {
+                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) {
+        QQuickItem *totals = m_metrics->property("totals").value<QQuickItem *>();
+        float neededspace = 1.5 * (m_metrics->property("iconSize").toFloat() + totals->property("lengthEdge").toFloat());
+
+        if ( ((vertical && ((y-neededspace) <= layout->height()) && (y>=0))
+                 || (horizontal && ((x-neededspace) <= layout->width()) && (x>=0)))
+             && layout->childItems().count()>0) {
+            //! last item
+            qDebug() << "org.kde.latte << last item ..";
+            hovered = layout->childItems()[layout->childItems().count()-1];
+        } else if ( ((vertical && (y >= -neededspace) && (y<=neededspace)))
+                     || (horizontal && (x >= -neededspace) && (x<=neededspace))
+                 && layout->childItems().count()>0) {
+            //! first item
+            qDebug() << "org.kde.latte << first item ..";
+            hovered = layout->childItems()[0];
+        } else {
+            return false;
+        }
+    }
+
+    item->setParentItem(layout);
+
+    if ((vertical && y < (hovered->y() + hovered->height()/2)) ||
+            (horizontal && x < hovered->x() + hovered->width()/2)) {
+        item->stackBefore(hovered);
+    } else {
+        item->stackAfter(hovered);
+    }
+
+    return true;
+}
+
+void LayoutManager::insertAtCoordinates(QQuickItem *item, const int &x, const int &y)
+{
+    bool result{false};
+
+    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());
+    }
+}
+
 void LayoutManager::moveAppletsInJustifyAlignment()
 {
     if (!m_startLayout || !m_mainLayout || !m_endLayout) {

containment/plugin/layoutmanager.h

@@ -23,6 +23,7 @@
 
 //Qt
 #include <QObject>
+#include <QQmlPropertyMap>
 #include <QQuickItem>
 
 namespace Latte{
@@ -31,13 +32,24 @@ namespace Containment{
 class LayoutManager : public QObject
 {
   Q_OBJECT
+    Q_PROPERTY(QObject *plasmoidObj READ plasmoid() WRITE setPlasmoid NOTIFY plasmoidChanged)
+
+    Q_PROPERTY(QQuickItem *rootItem READ rootItem WRITE setRootItem NOTIFY rootItemChanged)
     Q_PROPERTY(QQuickItem *mainLayout READ mainLayout WRITE setMainLayout NOTIFY mainLayoutChanged)
     Q_PROPERTY(QQuickItem *startLayout READ startLayout WRITE setStartLayout NOTIFY startLayoutChanged)
     Q_PROPERTY(QQuickItem *endLayout READ endLayout WRITE setEndLayout NOTIFY endLayoutChanged)
 
+    Q_PROPERTY(QQuickItem *metrics READ metrics WRITE setMetrics NOTIFY metricsChanged)
+
 public:
     LayoutManager(QObject *parent = nullptr);
 
+    QObject *plasmoid() const;
+    void setPlasmoid(QObject *plasmoid);
+
+    QQuickItem *rootItem() const;
+    void setRootItem(QQuickItem *root);
+
     QQuickItem *mainLayout() const;
     void setMainLayout(QQuickItem *main);
 
@@ -47,19 +59,34 @@ public:
     QQuickItem *endLayout() const;
     void setEndLayout(QQuickItem *end);
 
+    QQuickItem *metrics() const;
+    void setMetrics(QQuickItem *metrics);
+
 public slots:
     Q_INVOKABLE void moveAppletsInJustifyAlignment();
+    Q_INVOKABLE void insertAtCoordinates(QQuickItem *item, const int &x, const int &y);
 
 signals:
+    void plasmoidChanged();
+    void rootItemChanged();
     void mainLayoutChanged();
+    void metricsChanged();
     void startLayoutChanged();
     void endLayoutChanged();
 
 private:
+    bool insertAtLayoutCoordinates(QQuickItem *layout, QQuickItem *item, int x, int y);
+
+private:
+    QQuickItem *m_rootItem{nullptr};
+
     QQuickItem *m_mainLayout{nullptr};
     QQuickItem *m_startLayout{nullptr};
     QQuickItem *m_endLayout{nullptr};
+    QQuickItem *m_metrics{nullptr};
 
+    QObject *m_plasmoid{nullptr};
+    QQmlPropertyMap *m_configuration{nullptr};
 };
 }
 }