diff --git a/app/view/positioner.cpp b/app/view/positioner.cpp
index 9fbcdfb6..420318bf 100644
--- a/app/view/positioner.cpp
+++ b/app/view/positioner.cpp
@@ -1,657 +1,659 @@
 /*
 *  Copyright 2018  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "positioner.h"
 
 // local
 #include "effects.h"
 #include "view.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../settings/universalsettings.h"
 #include "../../liblatte2/types.h"
 
 // Qt
 #include <QDebug>
 
 // KDE
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 namespace Latte {
 namespace ViewPart {
 
 Positioner::Positioner(Latte::View *parent)
     : QObject(parent),
       m_view(parent)
 {
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(2000);
     connect(&m_screenSyncTimer, &QTimer::timeout, this, &Positioner::reconsiderScreen);
 
     //! under X11 it was identified that windows many times especially under screen changes
     //! don't end up at the correct position and size. This timer will enforce repositionings
     //! and resizes every 500ms if the window hasn't end up to correct values and until this
     //! is achieved
     m_validateGeometryTimer.setSingleShot(true);
     m_validateGeometryTimer.setInterval(500);
     connect(&m_validateGeometryTimer, &QTimer::timeout, this, &Positioner::syncGeometry);
 
     m_corona = qobject_cast<Latte::Corona *>(m_view->corona());
 
     if (m_corona) {
         if (KWindowSystem::isPlatformX11()) {
             m_corona->wm()->registerIgnoredWindow(m_view->winId());
+        } else {
+            connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
+                if (m_waylandWindowId.isNull()) {
+                    m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", m_view->geometry());
+                    m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
+                }
+            });
         }
 
         m_screenSyncTimer.setInterval(qMax(m_corona->universalSettings()->screenTrackerInterval() - 500, 1000));
         connect(m_corona->universalSettings(), &UniversalSettings::screenTrackerIntervalChanged, this, [&]() {
             m_screenSyncTimer.setInterval(qMax(m_corona->universalSettings()->screenTrackerInterval() - 500, 1000));
         });
 
         connect(m_corona, &Latte::Corona::viewLocationChanged, this, [&]() {
             //! check if an edge has been freed for a primary dock
             //! from another screen
             if (m_view->onPrimary()) {
                 m_screenSyncTimer.start();
             }
         });
     }
 
     init();
 }
 
 Positioner::~Positioner()
 {
     m_inDelete = true;
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? m_view->winId() : m_waylandWindowId);
 
     m_screenSyncTimer.stop();
     m_validateGeometryTimer.stop();
 }
 
 void Positioner::init()
 {
     //! connections
     connect(this, &Positioner::screenGeometryChanged, this, &Positioner::syncGeometry);
 
     connect(m_view, &QQuickWindow::xChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::yChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::widthChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::heightChanged, this, &Positioner::validateDockGeometry);
     connect(m_view, &QQuickWindow::screenChanged, this, &Positioner::currentScreenChanged);
     connect(m_view, &QQuickWindow::screenChanged, this, &Positioner::screenChanged);
 
     connect(m_view, &Latte::View::behaveAsPlasmaPanelChanged, this, &Positioner::syncGeometry);
     connect(m_view, &Latte::View::maxThicknessChanged, this, &Positioner::syncGeometry);
     connect(m_view, &Latte::View::maxLengthChanged, this, &Positioner::syncGeometry);
     connect(m_view, &Latte::View::offsetChanged, this, &Positioner::syncGeometry);
 
     connect(m_view, &Latte::View::absoluteGeometryChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view, &Latte::View::locationChanged, this, [&]() {
         updateFormFactor();
         syncGeometry();
     });
 
     connect(m_view, &Latte::View::normalThicknessChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view->effects(), &Latte::ViewPart::Effects::drawShadowsChanged, this, [&]() {
         if (!m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(m_view->effects(), &Latte::ViewPart::Effects::innerShadowChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             syncGeometry();
         }
     });
 
     connect(qGuiApp, &QGuiApplication::screenAdded, this, &Positioner::screenChanged);
     connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &Positioner::screenChanged);
 
     initSignalingForLocationChangeSliding();
 }
 
 int Positioner::currentScreenId() const
 {
     auto *latteCorona = qobject_cast<Latte::Corona *>(m_view->corona());
 
     if (latteCorona) {
         return latteCorona->screenPool()->id(m_screenToFollowId);
     }
 
     return -1;
 }
 
 QString Positioner::currentScreenName() const
 {
     return m_screenToFollowId;
 }
 
 bool Positioner::setCurrentScreen(const QString id)
 {
     QScreen *nextScreen{qGuiApp->primaryScreen()};
 
     if (id != "primary") {
         for (const auto scr : qGuiApp->screens()) {
             if (scr && scr->name() == id) {
                 nextScreen = scr;
                 break;
             }
         }
     }
 
     if (m_screenToFollow == nextScreen) {
         return true;
     }
 
     if (nextScreen) {
         if (m_view->layout()) {
             auto freeEdges = m_view->layout()->freeEdges(nextScreen);
 
             if (!freeEdges.contains(m_view->location())) {
                 return false;
             } else {
                 m_goToScreen = nextScreen;
 
                 //! asynchronous call in order to not crash from configwindow
                 //! deletion from sliding out animation
                 QTimer::singleShot(100, [this]() {
                     emit hideDockDuringScreenChangeStarted();
                 });
             }
         }
     }
 
     return true;
 }
 
 //! this function updates the dock's associated screen.
 //! updateScreenId = true, update also the m_screenToFollowId
 //! updateScreenId = false, do not update the m_screenToFollowId
 //! that way an explicit dock can be shown in another screen when
 //! there isnt a tasks dock running in the system and for that
 //! dock its first origin screen is stored and that way when
 //! that screen is reconnected the dock will return to its original
 //! place
 void Positioner::setScreenToFollow(QScreen *scr, bool updateScreenId)
 {
     if (!scr || (scr && (m_screenToFollow == scr) && (m_view->screen() == scr))) {
         return;
     }
 
     qDebug() << "setScreenToFollow() called for screen:" << scr->name() << " update:" << updateScreenId;
 
     m_screenToFollow = scr;
 
     if (updateScreenId) {
         m_screenToFollowId = scr->name();
     }
 
     qDebug() << "adapting to screen...";
     m_view->setScreen(scr);
 
     if (m_view->containment()) {
         m_view->containment()->reactToScreenChange();
     }
 
     connect(scr, &QScreen::geometryChanged, this, &Positioner::screenGeometryChanged);
     syncGeometry();
     m_view->updateAbsoluteGeometry(true);
     qDebug() << "setScreenToFollow() ended...";
 
     emit screenGeometryChanged();
     emit currentScreenChanged();
 }
 
 //! the main function which decides if this dock is at the
 //! correct screen
 void Positioner::reconsiderScreen()
 {
     if (m_inDelete) {
         return;
     }
 
     qDebug() << "reconsiderScreen() called...";
     qDebug() << "  Delayer  ";
 
     for (const auto scr : qGuiApp->screens()) {
         qDebug() << "      D, found screen: " << scr->name();
     }
 
     bool screenExists{false};
 
     //!check if the associated screen is running
     for (const auto scr : qGuiApp->screens()) {
         if (m_screenToFollowId == scr->name()
             || (m_view->onPrimary() && scr == qGuiApp->primaryScreen())) {
             screenExists = true;
         }
     }
 
     qDebug() << "dock screen exists  ::: " << screenExists;
 
     //! 1.a primary dock must be always on the primary screen
     if (m_view->onPrimary() && (m_screenToFollowId != qGuiApp->primaryScreen()->name()
                                 || m_screenToFollow != qGuiApp->primaryScreen()
                                 || m_view->screen() != qGuiApp->primaryScreen())) {
         using Plasma::Types;
         QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                                      Types::TopEdge, Types::RightEdge};
 
         edges = m_view->layout() ? m_view->layout()->availableEdgesForView(qGuiApp->primaryScreen(), m_view) : edges;
 
         //change to primary screen only if the specific edge is free
         qDebug() << "updating the primary screen for dock...";
         qDebug() << "available primary screen edges:" << edges;
         qDebug() << "dock location:" << m_view->location();
 
         if (edges.contains(m_view->location())) {
             //! case 1
             qDebug() << "reached case 1: of updating dock primary screen...";
             setScreenToFollow(qGuiApp->primaryScreen());
         }
     } else if (!m_view->onPrimary()) {
         //! 2.an explicit dock must be always on the correct associated screen
         //! there are cases that window manager misplaces the dock, this function
         //! ensures that this dock will return at its correct screen
         for (const auto scr : qGuiApp->screens()) {
             if (scr && scr->name() == m_screenToFollowId) {
                 qDebug() << "reached case 2: updating the explicit screen for dock...";
                 setScreenToFollow(scr);
                 break;
             }
         }
     }
 
     syncGeometry();
     qDebug() << "reconsiderScreen() ended...";
 }
 
 void Positioner::screenChanged(QScreen *scr)
 {
     m_screenSyncTimer.start();
 
     //! this is needed in order to update the struts on screen change
     //! and even though the geometry has been set correctly the offsets
     //! of the screen must be updated to the new ones
     if (m_view->visibility() && m_view->visibility()->mode() == Latte::Types::AlwaysVisible) {
         m_view->updateAbsoluteGeometry(true);
     }
 }
 
 void Positioner::syncGeometry()
 {
     if (!(m_view->screen() && m_view->containment()) || m_inDelete) {
         return;
     }
 
     bool found{false};
 
     qDebug() << "syncGeometry() called...";
 
-    if (KWindowSystem::isPlatformWayland() && m_waylandWindowId.isNull()) {
-        m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", m_view->geometry());
-        m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
-    }
-
     //! before updating the positioning and geometry of the dock
     //! we make sure that the dock is at the correct screen
     if (m_view->screen() != m_screenToFollow) {
         qDebug() << "Sync Geometry screens inconsistent!!!! ";
 
         if (m_screenToFollow) {
             qDebug() << "Sync Geometry screens inconsistent for m_screenToFollow:" << m_screenToFollow->name() << " dock screen:" << m_view->screen()->name();
         }
 
         if (!m_screenSyncTimer.isActive()) {
             m_screenSyncTimer.start();
         }
     } else {
         found = true;
     }
 
     //! if the dock isnt at the correct screen the calculations
     //! are not executed
     if (found) {
         //! compute the free screen rectangle for vertical panels only once
         //! this way the costly QRegion computations are calculated only once
         //! instead of two times (both inside the resizeWindow and the updatePosition)
         QRegion freeRegion;;
         QRect maximumRect;
         QRect availableScreenRect{m_view->screen()->geometry()};
 
         if (m_view->formFactor() == Plasma::Types::Vertical) {
             QString layoutName = m_view->layout() ? m_view->layout()->name() : QString();
             auto latteCorona = qobject_cast<Latte::Corona *>(m_view->corona());
             int fixedScreen = m_view->onPrimary() ? latteCorona->screenPool()->primaryScreenId() : m_view->containment()->screen();
 
             freeRegion = latteCorona->availableScreenRegionWithCriteria(fixedScreen, layoutName);
             maximumRect = maximumNormalGeometry();
             QRegion availableRegion = freeRegion.intersected(maximumRect);
             availableScreenRect = freeRegion.intersected(maximumRect).boundingRect();
             float area = 0;
 
             //! it is used to choose which or the availableRegion rectangles will
             //! be the one representing dock geometry
             for (int i = 0; i < availableRegion.rectCount(); ++i) {
                 QRect rect = availableRegion.rects().at(i);
                 //! the area of each rectangle in calculated in squares of 50x50
                 //! this is a way to avoid enourmous numbers for area value
                 float tempArea = (float)(rect.width() * rect.height()) / 2500;
 
                 if (tempArea > area) {
                     availableScreenRect = rect;
                     area = tempArea;
                 }
             }
 
             if (availableRegion.rectCount() > 1 && m_view->behaveAsPlasmaPanel()) {
                 m_view->effects()->setForceDrawCenteredBorders(true);
             } else {
                 m_view->effects()->setForceDrawCenteredBorders(false);
             }
         } else {
             m_view->effects()->setForceDrawCenteredBorders(false);
         }
 
         m_view->effects()->updateEnabledBorders();
         resizeWindow(availableScreenRect);
         updatePosition(availableScreenRect);
 
         qDebug() << "syncGeometry() calculations for screen: " << m_view->screen()->name() << " _ " << m_view->screen()->geometry();
         qDebug() << "syncGeometry() calculations for edge: " << m_view->location();
     }
 
     qDebug() << "syncGeometry() ended...";
 
     // qDebug() << "dock geometry:" << qRectToStr(geometry());
 }
 
 void Positioner::validateDockGeometry()
 {
     if (m_view->geometry() != m_validGeometry) {
         m_validateGeometryTimer.start();
     }
 }
 
 //! this is used mainly from vertical panels in order to
 //! to get the maximum geometry that can be used from the dock
 //! based on their alignment type and the location dock
 QRect Positioner::maximumNormalGeometry()
 {
     int xPos = 0;
     int yPos = m_view->screen()->geometry().y();;
     int maxHeight = m_view->screen()->geometry().height();
     int maxWidth = m_view->normalThickness();
     QRect maxGeometry;
     maxGeometry.setRect(0, 0, maxWidth, maxHeight);
 
     switch (m_view->location()) {
         case Plasma::Types::LeftEdge:
             xPos = m_view->screen()->geometry().x();
             maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
             break;
 
         case Plasma::Types::RightEdge:
             xPos = m_view->screen()->geometry().right() - maxWidth + 1;
             maxGeometry.setRect(xPos, yPos, maxWidth, maxHeight);
             break;
 
         default:
             //! bypass clang warnings
             break;
     }
 
     //! this is needed in order to preserve that the top dock will be above
     //! the others in case flag bypasswindowmanagerhint hasn't be set,
     //! such a case is the AlwaysVisible mode
     if (m_view->location() == Plasma::Types::TopEdge) {
         KWindowSystem::setState(m_view->winId(), NET::KeepAbove);
     } else {
         KWindowSystem::clearState(m_view->winId(), NET::KeepAbove);
     }
 
     return maxGeometry;
 }
 
 void Positioner::updatePosition(QRect availableScreenRect)
 {
     QRect screenGeometry{availableScreenRect};
     QPoint position;
     position = {0, 0};
 
     const auto length = [&](int length) -> int {
         float offs = static_cast<float>(m_view->offset());
         return static_cast<int>(length * ((1 - m_view->maxLength()) / 2) + length * (offs / 100));
     };
     int cleanThickness = m_view->normalThickness() - m_view->effects()->innerShadow();
 
     switch (m_view->location()) {
         case Plasma::Types::TopEdge:
             if (m_view->behaveAsPlasmaPanel()) {
                 position = {screenGeometry.x() + length(screenGeometry.width()), screenGeometry.y()};
             } else {
                 position = {screenGeometry.x(), screenGeometry.y()};
             }
 
             break;
 
         case Plasma::Types::BottomEdge:
             if (m_view->behaveAsPlasmaPanel()) {
                 position = {screenGeometry.x() + length(screenGeometry.width()),
                             screenGeometry.y() + screenGeometry.height() - cleanThickness
                            };
             } else {
                 position = {screenGeometry.x(), screenGeometry.y() + screenGeometry.height() - m_view->height()};
             }
 
             break;
 
         case Plasma::Types::RightEdge:
             if (m_view->behaveAsPlasmaPanel()) {
                 position = {availableScreenRect.right() - cleanThickness + 1,
                             availableScreenRect.y() + length(availableScreenRect.height())
                            };
             } else {
                 position = {availableScreenRect.right() - m_view->width() + 1, availableScreenRect.y()};
             }
 
             break;
 
         case Plasma::Types::LeftEdge:
             if (m_view->behaveAsPlasmaPanel()) {
                 position = {availableScreenRect.x(), availableScreenRect.y() + length(availableScreenRect.height())};
             } else {
                 position = {availableScreenRect.x(), availableScreenRect.y()};
             }
 
             break;
 
         default:
             qWarning() << "wrong location, couldn't update the panel position"
                        << m_view->location();
     }
 
     m_validGeometry.setTopLeft(position);
 
     m_view->setPosition(position);
 
     if (m_view->surface()) {
         m_view->surface()->setPosition(position);
     }
 }
 
 void Positioner::resizeWindow(QRect availableScreenRect)
 {
     QSize screenSize = m_view->screen()->size();
     QSize size = (m_view->formFactor() == Plasma::Types::Vertical) ? QSize(m_view->maxThickness(), availableScreenRect.height()) : QSize(screenSize.width(), m_view->maxThickness());
 
     if (m_view->formFactor() == Plasma::Types::Vertical) {
         //qDebug() << "MAXIMUM RECT :: " << maximumRect << " - AVAILABLE RECT :: " << availableRect;
         if (m_view->behaveAsPlasmaPanel()) {
             size.setWidth(m_view->normalThickness());
             size.setHeight(static_cast<int>(m_view->maxLength() * availableScreenRect.height()));
         }
     } else {
         if (m_view->behaveAsPlasmaPanel()) {
             size.setWidth(static_cast<int>(m_view->maxLength() * screenSize.width()));
             size.setHeight(m_view->normalThickness());
         }
     }
 
     m_validGeometry.setSize(size);
 
     m_view->setMinimumSize(size);
     m_view->setMaximumSize(size);
     m_view->resize(size);
 
     if (m_view->formFactor() == Plasma::Types::Horizontal) {
         emit windowSizeChanged();
     }
 }
 
 void Positioner::updateFormFactor()
 {
     if (!m_view->containment())
         return;
 
     switch (m_view->location()) {
         case Plasma::Types::TopEdge:
         case Plasma::Types::BottomEdge:
             m_view->containment()->setFormFactor(Plasma::Types::Horizontal);
             break;
 
         case Plasma::Types::LeftEdge:
         case Plasma::Types::RightEdge:
             m_view->containment()->setFormFactor(Plasma::Types::Vertical);
             break;
 
         default:
             qWarning() << "wrong location, couldn't update the panel position" << m_view->location();
     }
 }
 
 void Positioner::initSignalingForLocationChangeSliding()
 {
     //! signals to handle the sliding-in/out during location changes
     connect(this, &Positioner::hideDockDuringLocationChangeStarted, this, &Positioner::onHideWindowsForSlidingOut);
 
     connect(m_view, &View::locationChanged, this, [&]() {
         if (m_goToLocation != Plasma::Types::Floating) {
             m_goToLocation = Plasma::Types::Floating;
             QTimer::singleShot(100, [this]() {
                 m_view->effects()->setAnimationsBlocked(false);
                 emit showDockAfterLocationChangeFinished();
                 m_view->showSettingsWindow();
 
                 if (m_view->layout()) {
                     //! This is needed in case the edge is occupied and the occupying
                     //! view must be deleted
                     m_view->layout()->syncLatteViewsToScreens();
                 }
 
                 emit edgeChanged();
             });
         }
     });
 
     //! signals to handle the sliding-in/out during screen changes
     connect(this, &Positioner::hideDockDuringScreenChangeStarted, this, &Positioner::onHideWindowsForSlidingOut);
 
     connect(this, &Positioner::currentScreenChanged, this, [&]() {
         if (m_goToScreen) {
             m_goToScreen = nullptr;
             QTimer::singleShot(100, [this]() {
                 m_view->effects()->setAnimationsBlocked(false);
                 emit showDockAfterScreenChangeFinished();
                 m_view->showSettingsWindow();
 
                 if (m_view->layout()) {
                     //! This is needed in case the edge is occupied and the occupying
                     //! view must be deleted
                     m_view->layout()->syncLatteViewsToScreens();
                 }
 
                 emit edgeChanged();
             });
         }
     });
 
     //! signals to handle the sliding-in/out during moving to another layout
     connect(this, &Positioner::hideDockDuringMovingToLayoutStarted, this, &Positioner::onHideWindowsForSlidingOut);
 
     connect(m_view, &View::layoutChanged, this, [&]() {
         if (!m_moveToLayout.isEmpty() && m_view->layout()) {
             m_moveToLayout = "";
             QTimer::singleShot(100, [this]() {
                 m_view->effects()->setAnimationsBlocked(false);
                 emit showDockAfterMovingToLayoutFinished();
                 m_view->showSettingsWindow();
                 emit edgeChanged();
             });
         }
     });
 
     //!    ----  both cases   ----  !//
     //! this is used for both location and screen change cases, this signal
     //! is send when the sliding-out animation has finished
     connect(this, &Positioner::hideDockDuringLocationChangeFinished, this, [&]() {
         m_view->effects()->setAnimationsBlocked(true);
 
         if (m_goToLocation != Plasma::Types::Floating) {
             m_view->setLocation(m_goToLocation);
         } else if (m_goToScreen) {
             setScreenToFollow(m_goToScreen);
         } else if (!m_moveToLayout.isEmpty()) {
             m_view->moveToLayout(m_moveToLayout);
         }
     });
 }
 
 bool Positioner::inLocationChangeAnimation()
 {
     return ((m_goToLocation != Plasma::Types::Floating) || (m_moveToLayout != "") || m_goToScreen);
 }
 
 void Positioner::hideDockDuringLocationChange(int goToLocation)
 {
     m_goToLocation = static_cast<Plasma::Types::Location>(goToLocation);
     emit hideDockDuringLocationChangeStarted();
 }
 
 void Positioner::hideDockDuringMovingToLayout(QString layoutName)
 {
     m_moveToLayout = layoutName;
     emit hideDockDuringMovingToLayoutStarted();
 }
 
 }
 }
diff --git a/app/view/screenedgeghostwindow.cpp b/app/view/screenedgeghostwindow.cpp
index 04fd4c07..9cdfc5e2 100644
--- a/app/view/screenedgeghostwindow.cpp
+++ b/app/view/screenedgeghostwindow.cpp
@@ -1,316 +1,318 @@
 /*
 *  Copyright 2018 Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "screenedgeghostwindow.h"
 
 // local
 #include "view.h"
 
 // Qt
 #include <QDebug>
 #include <QSurfaceFormat>
 #include <QQuickView>
 #include <QTimer>
 
 // KDE
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // X11
 #include <NETWM>
 
 namespace Latte {
 namespace ViewPart {
 
 ScreenEdgeGhostWindow::ScreenEdgeGhostWindow(Latte::View *view) :
     m_latteView(view)
 {
     m_corona = qobject_cast<Latte::Corona *>(view->corona());
 
     setColor(QColor(Qt::transparent));
     setDefaultAlphaBuffer(true);
 
     setFlags(Qt::FramelessWindowHint
              | Qt::WindowStaysOnTopHint
              | Qt::NoDropShadowWindowHint
              | Qt::WindowDoesNotAcceptFocus);
 
     m_fixGeometryTimer.setSingleShot(true);
     m_fixGeometryTimer.setInterval(500);
     connect(&m_fixGeometryTimer, &QTimer::timeout, this, &ScreenEdgeGhostWindow::fixGeometry);
 
     //! this timer is used in order to avoid fast enter/exit signals during first
     //! appearing after edge activation
     m_delayedMouseTimer.setSingleShot(true);
     m_delayedMouseTimer.setInterval(50);
     connect(&m_delayedMouseTimer, &QTimer::timeout, this, [this]() {
         if (m_delayedContainsMouse) {
             setContainsMouse(true);
         } else {
             setContainsMouse(false);
         }
     });
 
     connect(this, &QQuickView::xChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
     connect(this, &QQuickView::yChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
     connect(this, &QQuickView::widthChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
     connect(this, &QQuickView::heightChanged, this, &ScreenEdgeGhostWindow::startGeometryTimer);
 
     connect(m_latteView, &Latte::View::absoluteGeometryChanged, this, &ScreenEdgeGhostWindow::updateGeometry);
     connect(m_latteView, &Latte::View::screenGeometryChanged, this, &ScreenEdgeGhostWindow::updateGeometry);
     connect(m_latteView, &Latte::View::locationChanged, this, &ScreenEdgeGhostWindow::updateGeometry);
     connect(m_latteView, &QQuickView::screenChanged, this, [this]() {
         setScreen(m_latteView->screen());
         updateGeometry();
     });
 
 
     if (!KWindowSystem::isPlatformWayland()) {
         //! IMPORTANT!!! ::: This fixes a bug when closing an Activity all views from all Activities are
         //!  disappearing! With this code parts they reappear!!!
         m_visibleHackTimer1.setInterval(400);
         m_visibleHackTimer2.setInterval(2500);
         m_visibleHackTimer1.setSingleShot(true);
         m_visibleHackTimer2.setSingleShot(true);
 
         connectionsHack << connect(this, &QWindow::visibleChanged, this, [&]() {
             if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
                 m_visibleHackTimer1.start();
                 m_visibleHackTimer2.start();
             } else if (!m_inDelete) {
                 //! For some reason when the window is hidden in the edge under X11 afterwards
                 //! is losing its window flags
                 KWindowSystem::setType(winId(), NET::Dock);
                 KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
                 KWindowSystem::setOnAllDesktops(winId(), true);
             }
         });
 
         connectionsHack << connect(&m_visibleHackTimer1, &QTimer::timeout, this, [&]() {
             if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
                 setVisible(true);
                 //qDebug() << "Ghost Edge:: Enforce reshow from timer 1...";
             } else {
                 //qDebug() << "Ghost Edge:: No needed reshow from timer 1...";
             }
         });
 
         connectionsHack << connect(&m_visibleHackTimer2, &QTimer::timeout, this, [&]() {
             if (!m_inDelete && m_latteView && m_latteView->layout() && !isVisible()) {
                 setVisible(true);
                 //qDebug() << "Ghost Edge:: Enforce reshow from timer 2...";
             } else {
                 //qDebug() << "Ghost Edge:: No needed reshow from timer 2...";
             }
         });
     }
 
     setupWaylandIntegration();
 
     if (KWindowSystem::isPlatformX11()) {
         m_corona->wm()->registerIgnoredWindow(winId());
+    } else {
+        connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
+            if (m_waylandWindowId.isNull()) {
+                m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
+                m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
+            }
+        });
     }
 
     setScreen(m_latteView->screen());
     setVisible(true);
     updateGeometry();
     hideWithMask();
 }
 
 ScreenEdgeGhostWindow::~ScreenEdgeGhostWindow()
 {
     m_inDelete = true;
 
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     m_latteView = nullptr;
 
     // clear mode
     m_visibleHackTimer1.stop();
     m_visibleHackTimer2.stop();
     for (auto &c : connectionsHack) {
         disconnect(c);
     }
 
     if (m_shellSurface) {
         delete m_shellSurface;
     }
 }
 
 int ScreenEdgeGhostWindow::location()
 {
     return (int)m_latteView->location();
 }
 
 Latte::View *ScreenEdgeGhostWindow::parentView()
 {
     return m_latteView;
 }
 
 KWayland::Client::PlasmaShellSurface *ScreenEdgeGhostWindow::surface()
 {
     return m_shellSurface;
 }
 
 void ScreenEdgeGhostWindow::updateGeometry()
 {
-    if (KWindowSystem::isPlatformWayland() && m_waylandWindowId.isNull()) {
-        m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
-        m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
-    }
-
     QRect newGeometry;
     int thickness;
     if (KWindowSystem::compositingActive()) {
         thickness == 6;
     } else {
         thickness == 2;
     };
 
     if (m_latteView->location() == Plasma::Types::BottomEdge) {
         newGeometry.setX(m_latteView->absoluteGeometry().left());
         newGeometry.setY(m_latteView->screenGeometry().bottom() - thickness);
     } else if (m_latteView->location() == Plasma::Types::TopEdge) {
         newGeometry.setX(m_latteView->absoluteGeometry().left());
         newGeometry.setY(m_latteView->screenGeometry().top());
     } else if (m_latteView->location() == Plasma::Types::LeftEdge) {
         newGeometry.setX(m_latteView->screenGeometry().left());
         newGeometry.setY(m_latteView->absoluteGeometry().top());
     } else if (m_latteView->location() == Plasma::Types::RightEdge) {
         newGeometry.setX(m_latteView->screenGeometry().right() - thickness);
         newGeometry.setY(m_latteView->absoluteGeometry().top());
     }
 
     if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
         newGeometry.setWidth(qMin(m_latteView->absoluteGeometry().width(), m_latteView->screenGeometry().width() - 1));
         newGeometry.setHeight(thickness + 1);
     } else {
         newGeometry.setWidth(thickness + 1);
         newGeometry.setHeight(qMin(m_latteView->absoluteGeometry().height(), m_latteView->screenGeometry().height() - 1));
     }
 
     m_calculatedGeometry = newGeometry;
 
     fixGeometry();
 }
 
 void ScreenEdgeGhostWindow::fixGeometry()
 {
     if (!m_calculatedGeometry.isEmpty()
             && (m_calculatedGeometry.x() != x() || m_calculatedGeometry.y() != y()
                 || m_calculatedGeometry.width() != width() || m_calculatedGeometry.height() != height())) {
         setMinimumSize(m_calculatedGeometry.size());
         setMaximumSize(m_calculatedGeometry.size());
         resize(m_calculatedGeometry.size());
         setPosition(m_calculatedGeometry.x(), m_calculatedGeometry.y());
 
         if (m_shellSurface) {
             m_shellSurface->setPosition(m_calculatedGeometry.topLeft());
         }
     }
 }
 
 void ScreenEdgeGhostWindow::startGeometryTimer()
 {
     m_fixGeometryTimer.start();
 }
 
 void ScreenEdgeGhostWindow::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
 
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland screen edge ghost window surface was created...";
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setSkipTaskbar(true);
         m_shellSurface->setPanelTakesFocus(false);
         m_shellSurface->setRole(PlasmaShellSurface::Role::Panel);
         m_shellSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AutoHide);
     }
 }
 
 bool ScreenEdgeGhostWindow::containsMouse() const
 {
     return m_containsMouse;
 }
 
 void ScreenEdgeGhostWindow::setContainsMouse(bool contains)
 {
     if (m_containsMouse == contains) {
         return;
     }
 
     m_containsMouse = contains;
     emit containsMouseChanged(contains);
 }
 
 bool ScreenEdgeGhostWindow::event(QEvent *e)
 {
     if (e->type() == QEvent::DragEnter) {
         m_delayedContainsMouse = false;
         m_delayedMouseTimer.stop();
         setContainsMouse(true);
         emit dragEntered();
     } else if (e->type() == QEvent::Enter || e->type() == QEvent::DragEnter) {
         m_delayedContainsMouse = true;
         if (!m_delayedMouseTimer.isActive()) {
             m_delayedMouseTimer.start();
         }
     } else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave) {
         m_delayedContainsMouse = false;
         if (!m_delayedMouseTimer.isActive()) {
             m_delayedMouseTimer.start();
         }
     }
 
     return QQuickView::event(e);
 }
 
 void ScreenEdgeGhostWindow::hideWithMask()
 {
     QRect maskGeometry{0, 0, 1, 1};
 
     setMask(maskGeometry);
 }
 
 void ScreenEdgeGhostWindow::showWithMask()
 {
     setMask(QRect());
 }
 
 }
 }
diff --git a/app/view/settings/primaryconfigview.cpp b/app/view/settings/primaryconfigview.cpp
index fdede6cd..54d5ead8 100644
--- a/app/view/settings/primaryconfigview.cpp
+++ b/app/view/settings/primaryconfigview.cpp
@@ -1,734 +1,736 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "primaryconfigview.h"
 
 // local
 #include <config-latte.h>
 #include "secondaryconfigview.h"
 #include "../effects.h"
 #include "../panelshadows_p.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../layouts/manager.h"
 #include "../../layout/genericlayout.h"
 #include "../../settings/universalsettings.h"
 #include "../../shortcuts/globalshortcuts.h"
 #include "../../shortcuts/shortcutstracker.h"
 #include "../../wm/abstractwindowinterface.h"
 
 // Qt
 #include <QFontMetrics>
 #include <QQuickItem>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedContext>
 #include <KDeclarative/KDeclarative>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Package>
 
 namespace Latte {
 namespace ViewPart {
 
 PrimaryConfigView::PrimaryConfigView(Plasma::Containment *containment, Latte::View *view, QWindow *parent)
     : PlasmaQuick::ConfigView(containment, parent),
       m_latteView(view)
 {
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona());
 
     setupWaylandIntegration();
 
     if (KWindowSystem::isPlatformX11()) {
         m_corona->wm()->registerIgnoredWindow(winId());
+    } else {
+        connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
+            if (m_waylandWindowId.isNull()) {
+                m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
+                m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
+            }
+        });
     }
 
     setScreen(m_latteView->screen());
 
     if (containment) {
         setIcon(qGuiApp->windowIcon());
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(100);
 
     connect(this, &PrimaryConfigView::availableScreenGeometryChanged, this, &PrimaryConfigView::syncGeometry);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::saveConfig);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::updateShowInlineProperties);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::syncGeometry);
 
     connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() {
         setScreen(m_latteView->screen());
         setFlags(wFlags());
 
         if (KWindowSystem::isPlatformX11()) {
 #if KF5_VERSION_MINOR >= 45
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager | NET::SkipSwitcher);
 #else
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
 #endif
 
             KWindowSystem::setOnAllDesktops(winId(), true);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &PrimaryConfigView::syncGeometry);
     connections << connect(containment, &Plasma::Containment::immutabilityChanged, this, &PrimaryConfigView::immutabilityChanged);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 
     connections << connect(m_latteView, &Latte::View::availableScreenRectChangedForViewParts, this, &PrimaryConfigView::updateAvailableScreenGeometry);
 
     if (m_corona) {
         connections << connect(m_corona, &Latte::Corona::raiseViewsTemporaryChanged, this, &PrimaryConfigView::raiseDocksTemporaryChanged);
     }
 
     if (m_latteView->layout()) {
         emit m_latteView->layout()->setLastConfigViewFor(m_latteView);
     }
 }
 
 PrimaryConfigView::~PrimaryConfigView()
 {
     qDebug() << "ConfigView deleting ...";
 
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     deleteSecondaryWindow();
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 }
 
 void PrimaryConfigView::init()
 {
     qDebug() << "dock config view : initialization started...";
     m_originalByPassWM = m_latteView->byPassWM();
     m_originalMode = m_latteView->visibility()->mode();
 
     loadConfig();
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
     PanelShadows::self()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), m_corona->globalShortcuts()->shortcutsTracker());
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
 
     if (m_corona) {
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), m_corona->universalSettings());
         rootContext()->setContextProperty(QStringLiteral("layoutsManager"), m_corona->layoutsManager());
     }
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedockconfigurationui";
 
     updateEnabledBorders();
     updateAvailableScreenGeometry();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     qDebug() << "dock config view : initialization ended...";
 }
 
 inline Qt::WindowFlags PrimaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint /*| Qt::WindowStaysOnTopHint*/) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QQuickView *PrimaryConfigView::secondaryWindow()
 {
     return m_secConfigView;
 }
 
 void PrimaryConfigView::createSecondaryWindow()
 {
     if (m_secConfigView) {
         return;
     }
 
     m_secConfigView = new SecondaryConfigView(m_latteView, this);
     m_secConfigView->init();
 }
 
 void PrimaryConfigView::deleteSecondaryWindow()
 {
     if (m_secConfigView) {
         auto secWindow = m_secConfigView;
         m_secConfigView = nullptr;
         secWindow->deleteLater();
 
         if (KWindowSystem::isPlatformX11()) {
             //! this is needed in order for subtracked mask of secondary window to
             //! be released properly when changing for Advanced to Basic mode.
             //! Under wayland this is not needed because masks do not break any visuals.
             m_latteView->effects()->updateMask();
         }
     }
 }
 
 void PrimaryConfigView::updateAvailableScreenGeometry()
 {
     int currentScrId = m_latteView->positioner()->currentScreenId();
     m_availableScreenGeometry = m_corona->availableScreenRect(currentScrId);
 
     emit availableScreenGeometryChanged();
 }
 
 QRect PrimaryConfigView::availableScreenGeometry() const
 {
     return m_availableScreenGeometry;
 }
 
 QRect PrimaryConfigView::geometryWhenVisible() const
 {
     return m_geometryWhenVisible;
 }
 
 void PrimaryConfigView::requestActivate()
 {
     if (KWindowSystem::isPlatformWayland() && m_shellSurface) {
         if (m_waylandWindowId.isNull()) {
             m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
         }
 
         m_corona->wm()->requestActivate(m_waylandWindowId);
     } else {
         QQuickView::requestActivate();
     }
 }
 
 void PrimaryConfigView::syncGeometry()
 {
     if (!m_latteView || !m_latteView->layout() || !m_latteView->containment() || !rootObject()) {
         return;
     }
 
-    if (KWindowSystem::isPlatformWayland() && m_waylandWindowId.isNull()) {
-        m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
-        m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
-    }
-
     const QSize size(rootObject()->width(), rootObject()->height());
     setMaximumSize(size);
     setMinimumSize(size);
     resize(size);
 
     const auto location = m_latteView->containment()->location();
     const auto scrGeometry = m_latteView->screenGeometry();
     const auto availGeometry = m_availableScreenGeometry;
 
     int clearThickness = m_latteView->editThickness();
 
     QPoint position{0, 0};
 
     int xPos{0};
     int yPos{0};
 
     switch (m_latteView->formFactor()) {
     case Plasma::Types::Horizontal: {
         if (m_complexity == Latte::Types::ExpertSettings) {
             if (qApp->isLeftToRight()) {
                 xPos = availGeometry.x() + availGeometry.width() - size.width();
             } else {
                 xPos = availGeometry.x();
             }
         } else {
             xPos = scrGeometry.center().x() - size.width() / 2;
         }
 
         if (location == Plasma::Types::TopEdge) {
             yPos = scrGeometry.y() + clearThickness;
         } else if (location == Plasma::Types::BottomEdge) {
             yPos = scrGeometry.y() + scrGeometry.height() - clearThickness - size.height();
         }
     }
         break;
 
     case Plasma::Types::Vertical: {
         if (location == Plasma::Types::LeftEdge) {
             xPos = scrGeometry.x() + clearThickness;
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         } else if (location == Plasma::Types::RightEdge) {
             xPos = scrGeometry.x() + scrGeometry.width() - clearThickness - size.width();
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         }
     }
         break;
 
     default:
         qWarning() << "no sync geometry, wrong formFactor";
         break;
     }
 
     position = {xPos, yPos};
 
     updateEnabledBorders();
 
     m_geometryWhenVisible = QRect(position.x(), position.y(), size.width(), size.height());
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 
     updateShowInlineProperties();
 
     emit m_latteView->configWindowGeometryChanged();
 }
 
 void PrimaryConfigView::syncSlideEffect()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto slideLocation = WindowSystem::AbstractWindowInterface::Slide::None;
 
     switch (m_latteView->containment()->location()) {
     case Plasma::Types::TopEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Top;
         break;
 
     case Plasma::Types::RightEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Right;
         break;
 
     case Plasma::Types::BottomEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Bottom;
         break;
 
     case Plasma::Types::LeftEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Left;
         break;
 
     default:
         qDebug() << staticMetaObject.className() << "wrong location";
         break;
     }
 
     m_corona->wm()->slideWindow(*this, slideLocation);
 }
 
 void PrimaryConfigView::showEvent(QShowEvent *ev)
 {
     QQuickWindow::showEvent(ev);
 
     if (!m_latteView) {
         return;
     }
 
     m_corona->wm()->setViewExtraFlags(*this);
     setFlags(wFlags());
 
     m_corona->wm()->enableBlurBehind(*this);
 
     syncGeometry();
     syncSlideEffect();
 
     if (m_latteView && m_latteView->containment())
         m_latteView->containment()->setUserConfiguring(true);
 
     m_screenSyncTimer.start();
     QTimer::singleShot(400, this, &PrimaryConfigView::syncGeometry);
 
     emit showSignal();
 }
 
 void PrimaryConfigView::hideEvent(QHideEvent *ev)
 {
     if (!m_latteView) {
         deleteLater();
         //QQuickWindow::hideEvent(ev);
         return;
     }
 
     if (m_latteView->containment()) {
         m_latteView->containment()->setUserConfiguring(false);
     }
 
     // QQuickWindow::hideEvent(ev);
 
     const auto mode = m_latteView->visibility()->mode();
 
     if ((mode == Types::AlwaysVisible || mode == Types::WindowsGoBelow)
             && !(m_originalMode == Types::AlwaysVisible || m_originalMode == Types::WindowsGoBelow)) {
         //! mode changed to AlwaysVisible OR WindowsGoBelow FROM Dodge mode
         if (m_originalByPassWM) {
             //! if original by pass is active
             m_latteView->layout()->recreateView(m_latteView->containment());
         }
     } else if (m_latteView->byPassWM() != m_originalByPassWM) {
         m_latteView->layout()->recreateView(m_latteView->containment());
     }
 
     deleteLater();
 }
 
 void PrimaryConfigView::focusOutEvent(QFocusEvent *ev)
 {
     Q_UNUSED(ev);
 
     const auto *focusWindow = qGuiApp->focusWindow();
 
     if (!m_latteView
             || (focusWindow && (focusWindow->flags().testFlag(Qt::Popup)
                                 || focusWindow->flags().testFlag(Qt::ToolTip)))
             || m_latteView->alternativesIsShown()) {
         return;
     }
 
     if (!m_blockFocusLost && !m_latteView->containsMouse()
             && (!m_secConfigView || (m_secConfigView && !m_secConfigView->isActive()))) {
         hideConfigWindow();
     }
 }
 
 void PrimaryConfigView::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland primary settings surface was created...";
 
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setSkipTaskbar(true);
 #if KF5_VERSION_MINOR >= 47
         m_shellSurface->setSkipSwitcher(true);
 #endif
 
         syncGeometry();
     }
 }
 
 bool PrimaryConfigView::event(QEvent *e)
 {
     if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
 
                 if (m_shellSurface) {
                     break;
                 }
 
                 setupWaylandIntegration();
                 break;
 
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 if (m_shellSurface) {
                     delete m_shellSurface;
                     m_shellSurface = nullptr;
                     qDebug() << "WAYLAND config window surface was deleted...";
                 }
 
                 break;
             }
         }
     }
 
     return PlasmaQuick::ConfigView::event(e);
 }
 
 
 void PrimaryConfigView::immutabilityChanged(Plasma::Types::ImmutabilityType type)
 {
     if (type != Plasma::Types::Mutable && isVisible())
         hideConfigWindow();
 }
 
 bool PrimaryConfigView::sticker() const
 {
     return m_blockFocusLost;
 }
 
 void PrimaryConfigView::setSticker(bool blockFocusLost)
 {
     if (m_blockFocusLost == blockFocusLost)
         return;
 
     m_blockFocusLost = blockFocusLost;
 }
 
 bool PrimaryConfigView::showInlineProperties() const
 {
     return m_showInlineProperties;
 }
 void PrimaryConfigView::setShowInlineProperties(bool show)
 {
     if (m_showInlineProperties == show) {
         return;
     }
 
     m_showInlineProperties = show;
     emit showInlinePropertiesChanged();
 }
 
 void PrimaryConfigView::updateShowInlineProperties()
 {
     if (!m_latteView) {
         return;
     }
 
     bool showSecWindow{false};
     bool complexityApprovedSecWindow{false};
 
 
     if (m_complexity != Latte::Types::BasicSettings
             && !(m_complexity == Latte::Types::ExpertSettings && m_latteView->formFactor() == Plasma::Types::Vertical)) {
         showSecWindow = true;
         complexityApprovedSecWindow = true;
     }
 
     //! consider screen geometry for showing or not the secondary window
     if (!geometryWhenVisible().isNull()) {
         createSecondaryWindow();
 
         if (m_secConfigView->geometryWhenVisible().intersects(geometryWhenVisible())) {
             showSecWindow = false;
         } else if (complexityApprovedSecWindow) {
             showSecWindow = true;
         }
     }
 
     if (showSecWindow) {
         if (!m_secConfigView) {
             createSecondaryWindow();
         }
 
         if (KWindowSystem::isPlatformWayland()) {
             QTimer::singleShot(150, m_secConfigView, SLOT(show()));
         } else {
             QTimer::singleShot(150, [this]() {
                 m_secConfigView->setVisible(true);
             });
         }
 
         setShowInlineProperties(false);
     } else {
         deleteSecondaryWindow();
         setShowInlineProperties(true);
     }
 
     // qDebug() << " showSecWindow:" << showSecWindow << " _ " << " inline:"<< !showSecWindow;
 }
 
 int PrimaryConfigView::complexity() const
 {
     return (int)m_complexity;
 }
 
 void PrimaryConfigView::setComplexity(int complexity)
 {
     if ((int)m_complexity == complexity) {
         return;
     }
 
     m_complexity = static_cast<Latte::Types::SettingsComplexity>(complexity);
 
     emit complexityChanged();
 }
 
 void PrimaryConfigView::hideConfigWindow()
 {
     if (m_shellSurface) {
         //!NOTE: Avoid crash in wayland environment with qt5.9
         close();
     } else {
         hide();
     }
 }
 
 void PrimaryConfigView::updateLaunchersForGroup(int groupInt)
 {
     Types::LaunchersGroup group = (Types::LaunchersGroup)groupInt;
 
     //! when the layout/global launchers list is empty then the current dock launchers are used for them
     //! as a start point
     if (m_corona &&  m_latteView->layout()) {
         if ((group == Types::LayoutLaunchers && m_latteView->layout()->launchers().isEmpty())
                 || (group == Types::GlobalLaunchers && m_corona->universalSettings()->launchers().isEmpty())) {
 
             Plasma::Containment *c = m_latteView->containment();
 
             const auto &applets = c->applets();
 
             for (auto *applet : applets) {
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 if (meta.pluginId() == "org.kde.latte.plasmoid") {
                     if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                         const auto &childItems = appletInterface->childItems();
 
                         if (childItems.isEmpty()) {
                             continue;
                         }
 
                         for (QQuickItem *item : childItems) {
                             if (auto *metaObject = item->metaObject()) {
                                 // not using QMetaObject::invokeMethod to avoid warnings when calling
                                 // this on applets that don't have it or other child items since this
                                 // is pretty much trial and error.
                                 // Also, "var" arguments are treated as QVariant in QMetaObject
 
                                 int methodIndex = metaObject->indexOfMethod("getLauncherList()");
 
                                 if (methodIndex == -1) {
                                     continue;
                                 }
 
                                 QMetaMethod method = metaObject->method(methodIndex);
 
                                 QVariant launchers;
 
                                 if (method.invoke(item, Q_RETURN_ARG(QVariant, launchers))) {
                                     if (group == Types::LayoutLaunchers) {
                                         m_latteView->layout()->setLaunchers(launchers.toStringList());
                                     } else if (group == Types::GlobalLaunchers) {
                                         m_corona->universalSettings()->setLaunchers(launchers.toStringList());
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 
 }
 
 //!BEGIN borders
 Plasma::FrameSvg::EnabledBorders PrimaryConfigView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void PrimaryConfigView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::BottomBorder : ~Plasma::FrameSvg::TopBorder;
         break;
 
     case Plasma::Types::LeftEdge:
         borders &= ~Plasma::FrameSvg::LeftBorder;
         break;
 
     case Plasma::Types::RightEdge:
         borders &= ~Plasma::FrameSvg::RightBorder;
         break;
 
     case Plasma::Types::BottomEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::TopBorder : ~Plasma::FrameSvg::BottomBorder;
         break;
 
     default:
         break;
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
 
         PanelShadows::self()->addWindow(this, m_enabledBorders);
 
         emit enabledBordersChanged();
     }
 }
 //!END borders
 
 //!BEGIN configuration
 void PrimaryConfigView::loadConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
     auto config = m_latteView->containment()->config();
     int complexity = config.readEntry("settingsComplexity", (int)Latte::Types::BasicSettings);
     setComplexity(static_cast<Latte::Types::SettingsComplexity>(complexity));
 }
 
 void PrimaryConfigView::saveConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto config = m_latteView->containment()->config();
     config.writeEntry("settingsComplexity", (int)m_complexity);
     config.sync();
 }
 //!END configuration
 
 }
 }
 
diff --git a/app/view/settings/secondaryconfigview.cpp b/app/view/settings/secondaryconfigview.cpp
index b792b948..2e716ecd 100644
--- a/app/view/settings/secondaryconfigview.cpp
+++ b/app/view/settings/secondaryconfigview.cpp
@@ -1,450 +1,452 @@
 /*
 *  Copyright 2018  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "secondaryconfigview.h"
 
 // local
 #include <config-latte.h>
 #include "primaryconfigview.h"
 #include "../panelshadows_p.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../wm/abstractwindowinterface.h"
 
 // Qt
 #include <QFontMetrics>
 #include <QQuickItem>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedContext>
 #include <KDeclarative/KDeclarative>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Package>
 
 namespace Latte {
 namespace ViewPart {
 
 SecondaryConfigView::SecondaryConfigView(Latte::View *view, QWindow *parent)
     : QQuickView(nullptr),
       m_latteView(view)
 {
     m_parent = qobject_cast<PrimaryConfigView *>(parent);
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona());
 
     setupWaylandIntegration();
 
     if (KWindowSystem::isPlatformX11()) {
         m_corona->wm()->registerIgnoredWindow(winId());
+    } else {
+        connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
+            if (m_waylandWindowId.isNull()) {
+                m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
+                m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
+            }
+        });
     }
 
     setResizeMode(QQuickView::SizeViewToRootObject);
     setScreen(m_latteView->screen());
 
     if (m_latteView && m_latteView->containment()) {
         setIcon(qGuiApp->windowIcon());
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(100);
 
     connections << connect(m_parent, &PrimaryConfigView::availableScreenGeometryChanged, this, &SecondaryConfigView::syncGeometry);
 
     connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() {
         setScreen(m_latteView->screen());
         setFlags(wFlags());
 
         if (KWindowSystem::isPlatformX11()) {
 #if KF5_VERSION_MINOR >= 45
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager | NET::SkipSwitcher);
 #else
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
 #endif
 
             KWindowSystem::setOnAllDesktops(winId(), true);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &SecondaryConfigView::syncGeometry);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 }
 
 SecondaryConfigView::~SecondaryConfigView()
 {
     qDebug() << "SecDockConfigView deleting ...";
 
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 }
 
 void SecondaryConfigView::init()
 {
     qDebug() << "dock secondary config view : initialization started...";
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
     PanelShadows::self()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
     rootContext()->setContextProperty(QStringLiteral("plasmoid"), m_latteView->containment()->property("_plasma_graphicObject").value<QObject *>());
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedocksecondaryconfigurationui";
 
     updateEnabledBorders();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     if (m_parent && KWindowSystem::isPlatformX11()) {
         m_parent->requestActivate();
     }
 
     qDebug() << "dock secondary config view : initialization ended...";
 }
 
 inline Qt::WindowFlags SecondaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint /*| Qt::WindowStaysOnTopHint*/) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QRect SecondaryConfigView::geometryWhenVisible() const
 {
     return m_geometryWhenVisible;
 }
 
 void SecondaryConfigView::requestActivate()
 {
     if (KWindowSystem::isPlatformWayland() && m_shellSurface) {
         if (m_waylandWindowId.isNull()) {
             m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
         }
 
         m_corona->wm()->requestActivate(m_waylandWindowId);
     } else {
         QQuickView::requestActivate();
     }
 }
 
 void SecondaryConfigView::syncGeometry()
 {
     if (!m_latteView || !m_latteView->layout() || !m_latteView->containment() || !m_parent || !rootObject()) {
         return;
     }
 
-    if (KWindowSystem::isPlatformWayland() && m_waylandWindowId.isNull()) {
-        m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
-        m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
-    }
-
     const QSize size(rootObject()->width(), rootObject()->height());
     setMaximumSize(size);
     setMinimumSize(size);
     resize(size);
 
     const auto location = m_latteView->containment()->location();
     const auto scrGeometry = m_latteView->screenGeometry();
     const auto availGeometry = m_parent->availableScreenGeometry();
 
     int clearThickness = m_latteView->editThickness();
 
     int secondaryConfigSpacing = 2 * m_latteView->fontPixelSize();
 
     QPoint position{0, 0};
 
     int xPos{0};
     int yPos{0};
 
     switch (m_latteView->containment()->formFactor()) {
     case Plasma::Types::Horizontal: {
         if (qApp->isLeftToRight()) {
             xPos = availGeometry.x() + secondaryConfigSpacing;
         } else {
             xPos = availGeometry.x() + availGeometry.width() - size.width() - secondaryConfigSpacing;
         }
 
         if (location == Plasma::Types::TopEdge) {
             yPos = scrGeometry.y() + clearThickness;
         } else if (location == Plasma::Types::BottomEdge) {
             yPos = scrGeometry.y() + scrGeometry.height() - clearThickness - size.height();
         }
     }
         break;
 
     case Plasma::Types::Vertical: {
         yPos = availGeometry.y() + secondaryConfigSpacing;
 
         if (location == Plasma::Types::LeftEdge) {
             xPos = scrGeometry.x() + clearThickness;
         } else if (location == Plasma::Types::RightEdge) {
             xPos = scrGeometry.x() + scrGeometry.width() - clearThickness - size.width();
         }
     }
         break;
 
     default:
         qWarning() << "no sync geometry, wrong formFactor";
         break;
     }
 
     position = {xPos, yPos};
 
     updateEnabledBorders();
 
     m_geometryWhenVisible = QRect(position.x(), position.y(), size.width(), size.height());
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 
     //! after placement request to activate the main config window in order to avoid
     //! rare cases of closing settings window from secondaryConfigView->focusOutEvent
     if (m_parent && KWindowSystem::isPlatformX11()) {
         m_parent->requestActivate();
     }
 }
 
 void SecondaryConfigView::syncSlideEffect()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto slideLocation = WindowSystem::AbstractWindowInterface::Slide::None;
 
     switch (m_latteView->containment()->location()) {
     case Plasma::Types::TopEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Top;
         break;
 
     case Plasma::Types::RightEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Right;
         break;
 
     case Plasma::Types::BottomEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Bottom;
         break;
 
     case Plasma::Types::LeftEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Left;
         break;
 
     default:
         qDebug() << staticMetaObject.className() << "wrong location";
         break;
     }
 
     m_corona->wm()->slideWindow(*this, slideLocation);
 }
 
 void SecondaryConfigView::showEvent(QShowEvent *ev)
 {
     QQuickWindow::showEvent(ev);
 
     if (!m_latteView) {
         return;
     }
 
     m_corona->wm()->setViewExtraFlags(*this);
     setFlags(wFlags());
 
     m_corona->wm()->enableBlurBehind(*this);
 
     syncGeometry();
     syncSlideEffect();
 
     m_screenSyncTimer.start();
     QTimer::singleShot(400, this, &SecondaryConfigView::syncGeometry);
 
     emit showSignal();
 }
 
 void SecondaryConfigView::focusOutEvent(QFocusEvent *ev)
 {
     Q_UNUSED(ev);
 
     const auto *focusWindow = qGuiApp->focusWindow();
 
     if ((focusWindow && (focusWindow->flags().testFlag(Qt::Popup)
                          || focusWindow->flags().testFlag(Qt::ToolTip)))
             || m_latteView->alternativesIsShown()) {
         return;
     }
 
     const auto parent = qobject_cast<PrimaryConfigView *>(m_parent);
 
     if (!m_latteView->containsMouse() && parent && !parent->sticker() && !parent->isActive()) {
         parent->hideConfigWindow();
     }
 }
 
 void SecondaryConfigView::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland secondary settings surface was created...";
 
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setSkipTaskbar(true);
 #if KF5_VERSION_MINOR >= 47
         m_shellSurface->setSkipSwitcher(true);
 #endif
 
         syncGeometry();
     }
 }
 
 bool SecondaryConfigView::event(QEvent *e)
 {
     if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
 
                 if (m_shellSurface) {
                     break;
                 }
 
                 setupWaylandIntegration();
                 break;
 
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 if (m_shellSurface) {
                     delete m_shellSurface;
                     m_shellSurface = nullptr;
                     qDebug() << "WAYLAND secondary config window surface was deleted...";
                 }
 
                 break;
             }
         }
     }
 
     return QQuickView::event(e);
 }
 
 void SecondaryConfigView::hideConfigWindow()
 {
     if (m_shellSurface) {
         //!NOTE: Avoid crash in wayland environment with qt5.9
         close();
     } else {
         hide();
     }
 }
 
 //!BEGIN borders
 Plasma::FrameSvg::EnabledBorders SecondaryConfigView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void SecondaryConfigView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge:
         borders &= ~Plasma::FrameSvg::TopBorder;
         break;
 
     case Plasma::Types::LeftEdge:
         borders &= ~Plasma::FrameSvg::LeftBorder;
         break;
 
     case Plasma::Types::RightEdge:
         borders &= ~Plasma::FrameSvg::RightBorder;
         break;
 
     case Plasma::Types::BottomEdge:
         borders &=  ~Plasma::FrameSvg::BottomBorder;
         break;
 
     default:
         break;
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
 
         PanelShadows::self()->addWindow(this, m_enabledBorders);
 
         emit enabledBordersChanged();
     }
 }
 
 //!END borders
 
 }
 }
 
diff --git a/app/wm/abstractwindowinterface.h b/app/wm/abstractwindowinterface.h
index ecb2c383..9abf1753 100644
--- a/app/wm/abstractwindowinterface.h
+++ b/app/wm/abstractwindowinterface.h
@@ -1,171 +1,173 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #ifndef ABSTRACTWINDOWINTERFACE_H
 #define ABSTRACTWINDOWINTERFACE_H
 
 // local
 #include "schemecolors.h"
 #include "tasktools.h"
 #include "windowinfowrap.h"
 #include "tracker/trackerwindows.h"
 #include "../liblatte2/types.h"
 #include "../liblatte2/extras.h"
 
 // C++
 #include <unordered_map>
 #include <list>
 
 // Qt
 #include <QObject>
 #include <QWindow>
 #include <QDialog>
 #include <QMap>
 #include <QRect>
 #include <QPoint>
 #include <QPointer>
 #include <QScreen>
 #include <QTimer>
 
 // KDE
 #include <KSharedConfig>
 #include <KActivities/Consumer>
 
 // Plasma
 #include <Plasma>
 
 namespace Latte {
 class Corona;
 namespace WindowSystem {
 namespace Tracker {
 class Schemes;
 class Windows;
 }
 }
 }
 
 namespace Latte {
 namespace WindowSystem {
 
 class AbstractWindowInterface : public QObject
 {
     Q_OBJECT
 
 public:
     enum class Slide
     {
         None,
         Top,
         Left,
         Bottom,
         Right,
     };
 
     explicit AbstractWindowInterface(QObject *parent = nullptr);
     virtual ~AbstractWindowInterface();
 
     virtual void setViewExtraFlags(QWindow &view) = 0;
     virtual void setViewStruts(QWindow &view, const QRect &rect
                                , Plasma::Types::Location location) = 0;
     virtual void setWindowOnActivities(QWindow &window, const QStringList &activities) = 0;
 
     virtual void removeViewStruts(QWindow &view) const = 0;
 
     virtual WindowId activeWindow() const = 0;
     virtual WindowInfoWrap requestInfo(WindowId wid) const = 0;
     virtual WindowInfoWrap requestInfoActive() const = 0;
 
     virtual void setKeepAbove(const QDialog &dialog, bool above = true) const = 0;
     virtual void skipTaskBar(const QDialog &dialog) const = 0;
     virtual void slideWindow(QWindow &view, Slide location) const = 0;
     virtual void enableBlurBehind(QWindow &view) const = 0;
     virtual void setEdgeStateFor(QWindow *view, bool active) const = 0;
 
     virtual void releaseMouseEventFor(WindowId wid) const = 0;
 
     virtual void requestActivate(WindowId wid) const = 0;
     virtual void requestClose(WindowId wid) const = 0;
     virtual void requestMoveWindow(WindowId wid, QPoint from) const = 0;
     virtual void requestToggleIsOnAllDesktops(WindowId wid) const = 0;
     virtual void requestToggleKeepAbove(WindowId wid) const = 0;
     virtual void requestToggleMinimized(WindowId wid) const = 0;
     virtual void requestToggleMaximized(WindowId wid) const = 0;
 
     virtual bool windowCanBeDragged(WindowId wid) const = 0;
 
     virtual QIcon iconFor(WindowId wid) const = 0;
     virtual WindowId winIdFor(QString appId, QRect geometry) const = 0;
     virtual AppData appDataFor(WindowId wid) const = 0;
 
     QString currentDesktop() const;
     QString currentActivity() const;
 
     virtual void registerIgnoredWindow(WindowId wid);
     virtual void unregisterIgnoredWindow(WindowId wid);
 
     void switchToNextActivity();
     void switchToPreviousActivity();
 
     virtual void switchToNextVirtualDesktop() const = 0;
     virtual void switchToPreviousVirtualDesktop() const = 0;
 
     Latte::Corona *corona();
     Tracker::Schemes *schemesTracker();
     Tracker::Windows *windowsTracker() const;
 
 signals:
     void activeWindowChanged(WindowId wid);
     void windowChanged(WindowId winfo);
     void windowAdded(WindowId wid);
     void windowRemoved(WindowId wid);
     void currentDesktopChanged();
     void currentActivityChanged();
 
+    void latteWindowAdded();
+
 protected:
     QString m_currentDesktop;
     QString m_currentActivity;
 
     //! windows that must be ignored from tracking, a good example are Latte::Views and
     //! their Configuration windows
     QList<WindowId> m_ignoredWindows;
 
     QPointer<KActivities::Consumer> m_activities;
 
     //! Sending too fast plenty of signals for the same window
     //! has no reason and can create HIGH CPU usage. This Timer
     //! can delay the batch sending of signals for the same window
     WindowId m_windowChangedWaiting;
     QTimer m_windowWaitingTimer;
 
     //! Plasma taskmanager rules ile
     KSharedConfig::Ptr rulesConfig;
 
     void considerWindowChanged(WindowId wid);
 
 private:
     Latte::Corona *m_corona;
     Tracker::Schemes *m_schemesTracker;
     Tracker::Windows *m_windowsTracker;
 };
 
 }
 }
 
 #endif // ABSTRACTWINDOWINTERFACE_H
diff --git a/app/wm/waylandinterface.cpp b/app/wm/waylandinterface.cpp
index 642ec5ec..ea77b5c4 100644
--- a/app/wm/waylandinterface.cpp
+++ b/app/wm/waylandinterface.cpp
@@ -1,679 +1,693 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "waylandinterface.h"
 
 // local
 #include "view/screenedgeghostwindow.h"
 #include "view/view.h"
 #include "../lattecorona.h"
 #include "../liblatte2/extras.h"
 
 // Qt
 #include <QDebug>
 #include <QTimer>
 #include <QApplication>
 #include <QSignalMapper>
 #include <QtX11Extras/QX11Info>
 #include <QRasterWindow>
 
 // KDE
 #include <KWindowSystem>
 #include <KWindowInfo>
 #include <KWayland/Client/surface.h>
 
 #if KF5_VERSION_MINOR >= 52
 #include <KWayland/Client/plasmavirtualdesktop.h>
 #endif
 
 // X11
 #include <NETWM>
 
 using namespace KWayland::Client;
 
 namespace Latte {
 
 class Private::GhostWindow : public QRasterWindow
 {
     Q_OBJECT
 
 public:
     WindowSystem::WindowId m_winId;
 
     GhostWindow(WindowSystem::WaylandInterface *waylandInterface)
         : m_waylandInterface(waylandInterface) {
         setFlags(Qt::FramelessWindowHint
                  | Qt::WindowStaysOnTopHint
                  | Qt::NoDropShadowWindowHint
                  | Qt::WindowDoesNotAcceptFocus);
 
+        connect(m_waylandInterface, &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, &GhostWindow::identifyWinId);
+
         setupWaylandIntegration();
         show();
     }
 
     ~GhostWindow() {
         m_waylandInterface->unregisterIgnoredWindow(m_winId);
         delete m_shellSurface;
     }
 
     void setGeometry(const QRect &rect) {
         if (geometry() == rect) {
             return;
         }
 
-        if (m_winId.isNull()) {
-            m_winId = m_waylandInterface->winIdFor("latte-dock", geometry());
-            m_waylandInterface->registerIgnoredWindow(m_winId);
-        }
+        m_validGeometry = rect;
 
         setMinimumSize(rect.size());
         setMaximumSize(rect.size());
         resize(rect.size());
 
         m_shellSurface->setPosition(rect.topLeft());
     }
 
     void setupWaylandIntegration() {
         using namespace KWayland::Client;
 
         if (m_shellSurface)
             return;
 
         Surface *s{Surface::fromWindow(this)};
 
         if (!s)
             return;
 
         m_shellSurface = m_waylandInterface->waylandCoronaInterface()->createSurface(s, this);
         qDebug() << "wayland ghost window surface was created...";
 
         m_shellSurface->setSkipTaskbar(true);
         m_shellSurface->setPanelTakesFocus(false);
         m_shellSurface->setRole(PlasmaShellSurface::Role::Panel);
         m_shellSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::AlwaysVisible);
     }
 
     KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
     WindowSystem::WaylandInterface *m_waylandInterface{nullptr};
+
+    //! geometry() function under wayland does not return nice results
+    QRect m_validGeometry;
+
+public slots:
+    void identifyWinId() {
+        if (m_winId.isNull()) {
+            m_winId = m_waylandInterface->winIdFor("latte-dock", m_validGeometry);
+            m_waylandInterface->registerIgnoredWindow(m_winId);
+        }
+    }
 };
 
 namespace WindowSystem {
 
 WaylandInterface::WaylandInterface(QObject *parent)
     : AbstractWindowInterface(parent)
 {
     m_corona = qobject_cast<Latte::Corona *>(parent);
 }
 
 WaylandInterface::~WaylandInterface()
 {
 }
 
 void WaylandInterface::init()
 {
 }
 
 void WaylandInterface::initWindowManagement(KWayland::Client::PlasmaWindowManagement *windowManagement)
 {
     if (m_windowManagement == windowManagement) {
         return;
     }
 
     m_windowManagement = windowManagement;
 
     connect(m_windowManagement, &PlasmaWindowManagement::windowCreated, this, &WaylandInterface::windowCreatedProxy);
     connect(m_windowManagement, &PlasmaWindowManagement::activeWindowChanged, this, [&]() noexcept {
                 auto w = m_windowManagement->activeWindow();
                 if (!w || (w && (!m_ignoredWindows.contains(w->internalId() && !isPlasmaDesktop(w)))) ) {
                     emit activeWindowChanged(w ? w->internalId() : 0);
                 }
 
             }, Qt::QueuedConnection);
 }
 
 #if KF5_VERSION_MINOR >= 52
 void WaylandInterface::initVirtualDesktopManagement(KWayland::Client::PlasmaVirtualDesktopManagement *virtualDesktopManagement)
 {
     if (m_virtualDesktopManagement == virtualDesktopManagement) {
         return;
     }
 
     m_virtualDesktopManagement = virtualDesktopManagement;
 
     connect(m_virtualDesktopManagement, &KWayland::Client::PlasmaVirtualDesktopManagement::desktopCreated, this,
             [this](const QString &id, quint32 position) {
         addDesktop(id, position);
     });
 
     connect(m_virtualDesktopManagement, &KWayland::Client::PlasmaVirtualDesktopManagement::desktopRemoved, this,
             [this](const QString &id) {
         m_desktops.removeAll(id);
 
         if (m_currentDesktop == id) {
             setCurrentDesktop(QString());
         }
     });
 }
 
 void WaylandInterface::addDesktop(const QString &id, quint32 position)
 {
     if (m_desktops.contains(id)) {
         return;
     }
 
     m_desktops.append(id);
 
     const KWayland::Client::PlasmaVirtualDesktop *desktop = m_virtualDesktopManagement->getVirtualDesktop(id);
 
     QObject::connect(desktop, &KWayland::Client::PlasmaVirtualDesktop::activated, this,
                      [desktop, this]() {
         setCurrentDesktop(desktop->id());
     }
     );
 
     if (desktop->isActive()) {
         setCurrentDesktop(id);
     }
 }
 
 void WaylandInterface::setCurrentDesktop(QString desktop)
 {
     if (m_currentDesktop == desktop) {
         return;
     }
 
     m_currentDesktop = desktop;
     emit currentDesktopChanged();
 }
 #endif
 
 KWayland::Client::PlasmaShell *WaylandInterface::waylandCoronaInterface() const
 {
     return m_corona->waylandCoronaInterface();
 }
 
 //! Register Latte Ignored Windows in order to NOT be tracked
 void WaylandInterface::registerIgnoredWindow(WindowId wid)
 {
     if (!wid.isNull() && !m_ignoredWindows.contains(wid)) {
         m_ignoredWindows.append(wid);
 
         KWayland::Client::PlasmaWindow *w = windowFor(wid);
 
         if (mapper && w) {
             mapper->removeMappings(w);
         }
 
         emit windowChanged(wid);
     }
 }
 
 void WaylandInterface::unregisterIgnoredWindow(WindowId wid)
 {
     if (m_ignoredWindows.contains(wid)) {
         m_ignoredWindows.removeAll(wid);
         emit windowRemoved(wid);
     }
 }
 
 void WaylandInterface::setViewExtraFlags(QWindow &view)
 {
     Q_UNUSED(view)
 }
 
 void WaylandInterface::setViewStruts(QWindow &view, const QRect &rect, Plasma::Types::Location location)
 {
     if (!m_ghostWindows.contains(view.winId())) {
         m_ghostWindows[view.winId()] = new Private::GhostWindow(this);
     }
 
     auto w = m_ghostWindows[view.winId()];
 
     switch (location) {
     case Plasma::Types::TopEdge:
     case Plasma::Types::BottomEdge:
         w->setGeometry({rect.x() + rect.width() / 2, rect.y(), 1, rect.height()});
         break;
 
     case Plasma::Types::LeftEdge:
     case Plasma::Types::RightEdge:
         w->setGeometry({rect.x(), rect.y() + rect.height() / 2, rect.width(), 1});
         break;
 
     default:
         break;
     }
 }
 
 void WaylandInterface::switchToNextVirtualDesktop() const
 {
 #if KF5_VERSION_MINOR >= 52
     if (!m_virtualDesktopManagement || m_desktops.count() <= 1) {
         return;
     }
 
     int curPos = m_desktops.indexOf(m_currentDesktop);
     int nextPos = curPos + 1;
 
     if (curPos == m_desktops.count()-1) {
         nextPos = 0;
     }
 
     KWayland::Client::PlasmaVirtualDesktop *desktopObj = m_virtualDesktopManagement->getVirtualDesktop(m_desktops[nextPos]);
 
     if (desktopObj) {
         desktopObj->requestActivate();
     }
 #endif
 }
 
 void WaylandInterface::switchToPreviousVirtualDesktop() const
 {
 #if KF5_VERSION_MINOR >= 52
     if (!m_virtualDesktopManagement || m_desktops.count() <= 1) {
         return;
     }
 
     int curPos = m_desktops.indexOf(m_currentDesktop);
     int nextPos = curPos - 1;
 
     if (curPos == 0) {
         nextPos = m_desktops.count()-1;
     }
 
     KWayland::Client::PlasmaVirtualDesktop *desktopObj = m_virtualDesktopManagement->getVirtualDesktop(m_desktops[nextPos]);
 
     if (desktopObj) {
         desktopObj->requestActivate();
     }
 #endif
 }
 
 void WaylandInterface::setWindowOnActivities(QWindow &window, const QStringList &activities)
 {
     //! needs to updated to wayland case
     // KWindowSystem::setOnActivities(view.winId(), activities);
 }
 
 void WaylandInterface::removeViewStruts(QWindow &view) const
 {
     delete m_ghostWindows.take(view.winId());
 }
 
 WindowId WaylandInterface::activeWindow() const
 {
     if (!m_windowManagement) {
         return 0;
     }
 
     auto wid = m_windowManagement->activeWindow();
 
     return wid ? wid->internalId() : 0;
 }
 
 void WaylandInterface::setKeepAbove(const QDialog &dialog, bool above) const
 {
     if (above) {
         KWindowSystem::setState(dialog.winId(), NET::KeepAbove);
     } else {
         KWindowSystem::clearState(dialog.winId(), NET::KeepAbove);
     }
 }
 
 void WaylandInterface::skipTaskBar(const QDialog &dialog) const
 {
     KWindowSystem::setState(dialog.winId(), NET::SkipTaskbar);
 }
 
 void WaylandInterface::slideWindow(QWindow &view, AbstractWindowInterface::Slide location) const
 {
     auto slideLocation = KWindowEffects::NoEdge;
 
     switch (location) {
     case Slide::Top:
         slideLocation = KWindowEffects::TopEdge;
         break;
 
     case Slide::Bottom:
         slideLocation = KWindowEffects::BottomEdge;
         break;
 
     case Slide::Left:
         slideLocation = KWindowEffects::LeftEdge;
         break;
 
     case Slide::Right:
         slideLocation = KWindowEffects::RightEdge;
         break;
 
     default:
         break;
     }
 
     KWindowEffects::slideWindow(view.winId(), slideLocation, -1);
 }
 
 void WaylandInterface::enableBlurBehind(QWindow &view) const
 {
     KWindowEffects::enableBlurBehind(view.winId());
 }
 
 void WaylandInterface::setEdgeStateFor(QWindow *view, bool active) const
 {
     ViewPart::ScreenEdgeGhostWindow *window = qobject_cast<ViewPart::ScreenEdgeGhostWindow *>(view);
 
     if (!window) {
         return;
     }
 
     if (window->parentView()->surface() && window->parentView()->visibility()
             && (window->parentView()->visibility()->mode() == Types::DodgeActive
                 || window->parentView()->visibility()->mode() == Types::DodgeMaximized
                 || window->parentView()->visibility()->mode() == Types::DodgeAllWindows
                 || window->parentView()->visibility()->mode() == Types::AutoHide)) {
         if (active) {
             window->showWithMask();
             window->surface()->requestHideAutoHidingPanel();
         } else {
             window->hideWithMask();
             window->surface()->requestShowAutoHidingPanel();
         }
     }
 }
 
 WindowInfoWrap WaylandInterface::requestInfoActive() const
 {
     if (!m_windowManagement) {
         return {};
     }
 
     auto w = m_windowManagement->activeWindow();
 
     if (!w) return {};
 
     return  requestInfo(w->internalId());
 }
 
 WindowInfoWrap WaylandInterface::requestInfo(WindowId wid) const
 {
     WindowInfoWrap winfoWrap;
 
     auto w = windowFor(wid);
 
     if (w) {
         if (isPlasmaDesktop(w)) {
             winfoWrap.setIsValid(true);
             winfoWrap.setIsPlasmaDesktop(true);
             winfoWrap.setWid(wid);
         } else if (isValidWindow(w)) {
             winfoWrap.setIsValid(true);
             winfoWrap.setWid(wid);
             winfoWrap.setIsActive(w->isActive());
             winfoWrap.setIsMinimized(w->isMinimized());
             winfoWrap.setIsMaxVert(w->isMaximized());
             winfoWrap.setIsMaxHoriz(w->isMaximized());
             winfoWrap.setIsFullscreen(w->isFullscreen());
             winfoWrap.setIsShaded(w->isShaded());
             winfoWrap.setIsOnAllDesktops(w->isOnAllDesktops());
             winfoWrap.setIsOnAllActivities(true);
             winfoWrap.setGeometry(w->geometry());
             winfoWrap.setHasSkipTaskbar(w->skipTaskbar());
             winfoWrap.setDisplay(w->title());
 #if KF5_VERSION_MINOR >= 52
             winfoWrap.setDesktops(w->plasmaVirtualDesktops());
 #endif
             winfoWrap.setActivities(QStringList());
         }
     } else {
         return {};
     }
 
     return winfoWrap;
 }
 
 AppData WaylandInterface::appDataFor(WindowId wid) const
 {
     auto window = windowFor(wid);
 
     const AppData &data = appDataFromUrl(windowUrlFromMetadata(window->appId(),
-                    window->pid(), rulesConfig));
+                                                               window->pid(), rulesConfig));
 
     return data;
 }
 
 KWayland::Client::PlasmaWindow *WaylandInterface::windowFor(WindowId wid) const
 {
     auto it = std::find_if(m_windowManagement->windows().constBegin(), m_windowManagement->windows().constEnd(), [&wid](PlasmaWindow * w) noexcept {
             return w->isValid() && w->internalId() == wid;
 });
 
     if (it == m_windowManagement->windows().constEnd()) {
         return nullptr;
     }
 
     return *it;
 }
 
 QIcon WaylandInterface::iconFor(WindowId wid) const
 {
     auto window = windowFor(wid);
 
     if (window) {
         return window->icon();
     }
 
 
     return QIcon();
 }
 
 WindowId WaylandInterface::winIdFor(QString appId, QRect geometry) const
 {
     auto it = std::find_if(m_windowManagement->windows().constBegin(), m_windowManagement->windows().constEnd(), [&appId, &geometry](PlasmaWindow * w) noexcept {
         return w->isValid() && w->appId() == appId && w->geometry() == geometry;
     });
 
     if (it == m_windowManagement->windows().constEnd()) {
         return QVariant();
     }
 
     return (*it)->internalId();
 }
 
 
 bool WaylandInterface::windowCanBeDragged(WindowId wid) const
 {
     WindowInfoWrap winfo = requestInfo(wid);
     return (winfo.isValid() && !winfo.isMinimized() && !winfo.isPlasmaDesktop());
 }
 
 void WaylandInterface::releaseMouseEventFor(WindowId wid) const
 {
     // this isnt really needed under wayland
 }
 
 void WaylandInterface::requestActivate(WindowId wid) const
 {
     auto w = windowFor(wid);
 
     if (w) {
         w->requestActivate();
     }
 }
 
 void WaylandInterface::requestClose(WindowId wid) const
 {
     auto w = windowFor(wid);
 
     if (w) {
         w->requestClose();
     }
 }
 
 
 void WaylandInterface::requestMoveWindow(WindowId wid, QPoint from) const
 {
     if (windowCanBeDragged(wid)) {
         auto w = windowFor(wid);
 
         if (w && isValidWindow(w)) {
             w->requestMove();
         }
     }
 }
 
 void WaylandInterface::requestToggleIsOnAllDesktops(WindowId wid) const
 {
 #if KF5_VERSION_MINOR >= 52
     auto w = windowFor(wid);
 
     if (w && isValidWindow(w) && m_desktops.count() > 1) {
         if (w->isOnAllDesktops()) {
             w->requestEnterVirtualDesktop(m_currentDesktop);
         } else {
             const QStringList &now = w->plasmaVirtualDesktops();
 
             foreach (const QString &desktop, now) {
                 w->requestLeaveVirtualDesktop(desktop);
             }
         }
     }
 #endif
 }
 
 void WaylandInterface::requestToggleKeepAbove(WindowId wid) const
 {
     auto w = windowFor(wid);
 
     if (w) {
         w->requestToggleKeepAbove();
     }
 }
 
 void WaylandInterface::requestToggleMinimized(WindowId wid) const
 {
     auto w = windowFor(wid);
 
     if (w && isValidWindow(w)) {
 #if KF5_VERSION_MINOR >= 52
         if (!m_currentDesktop.isEmpty()) {
             w->requestEnterVirtualDesktop(m_currentDesktop);
         }
 #endif
         w->requestToggleMinimized();
     }
 }
 
 void WaylandInterface::requestToggleMaximized(WindowId wid) const
 {
     auto w = windowFor(wid);
 
-    if (w && isValidWindow(w)) {   
+    if (w && isValidWindow(w)) {
 #if KF5_VERSION_MINOR >= 52
         if (!m_currentDesktop.isEmpty()) {
             w->requestEnterVirtualDesktop(m_currentDesktop);
         }
 #endif
         w->requestToggleMaximized();
-    }   
+    }
 }
 
 bool WaylandInterface::isPlasmaDesktop(const KWayland::Client::PlasmaWindow *w) const
 {
     if (!w || (w->appId() != QLatin1String("org.kde.plasmashell"))) {
         return false;
     }
 
     bool hasScreenGeometry{false};
 
     for (const auto scr : qGuiApp->screens()) {
         if (!w->geometry().isEmpty() && w->geometry() == scr->geometry()) {
             hasScreenGeometry = true;
             break;
         }
     }
 
     return hasScreenGeometry;
 }
 
 bool WaylandInterface::isValidWindow(const KWayland::Client::PlasmaWindow *w) const
 {
     //! DEPRECATED comment is case we must reenable this
     //! because wayland does not have any way yet to identify the window type
     //! a trick is to just consider windows as valid when they can be shown in the
     //! taskbar. Of course that creates issues with plasma native dialogs
     //! e.g. widgets explorer, Activities etc. that are not used to hide
     //! the dodge views appropriately
 
     return w->isValid() && !isPlasmaDesktop(w) && !m_ignoredWindows.contains(w->internalId());
 }
 
 void WaylandInterface::windowCreatedProxy(KWayland::Client::PlasmaWindow *w)
 {
     if (!isValidWindow(w)) return;
 
     if (!mapper) mapper = new QSignalMapper(this);
 
     mapper->setMapping(w, w);
 
     connect(w, &PlasmaWindow::unmapped, this, [ &, win = w]() noexcept {
         mapper->removeMappings(win);
         emit windowRemoved(win->internalId());
     });
 
     connect(w, SIGNAL(activeChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(titleChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(fullscreenChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(geometryChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(maximizedChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(minimizedChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(shadedChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(skipTaskbarChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(onAllDesktopsChanged()), mapper, SLOT(map()) );
     connect(w, SIGNAL(virtualDesktopChanged()), mapper, SLOT(map()) );
 
 #if KF5_VERSION_MINOR >= 52
     connect(w, &KWayland::Client::PlasmaWindow::plasmaVirtualDesktopEntered, this,
             [w, this] {
         mapper->map(w);
     });
 
     connect(w, &KWayland::Client::PlasmaWindow::plasmaVirtualDesktopLeft, this,
             [w, this] {
         mapper->map(w);
     });
 #endif
 
     connect(mapper, static_cast<void (QSignalMapper::*)(QObject *)>(&QSignalMapper::mapped)
             , this, [&](QObject * w) noexcept {
         //qDebug() << "window changed:" << qobject_cast<PlasmaWindow *>(w)->appId();
         PlasmaWindow *pW = qobject_cast<PlasmaWindow*>(w);
 
         if (pW && !m_ignoredWindows.contains(pW->internalId() && !isPlasmaDesktop(pW) )) {
             considerWindowChanged(pW->internalId());
         }
     });
 
     emit windowAdded(w->internalId());
+
+    if (w->appId() == "latte-dock") {
+        emit latteWindowAdded();
+    }
 }
 
 }
 }
 
 #include "waylandinterface.moc"