diff --git a/app/org.kde.latte-dock.appdata.xml.cmake b/app/org.kde.latte-dock.appdata.xml.cmake
index c17788af..3dbad4ed 100644
--- a/app/org.kde.latte-dock.appdata.xml.cmake
+++ b/app/org.kde.latte-dock.appdata.xml.cmake
@@ -1,181 +1,183 @@
 <?xml version="1.0" encoding="utf-8"?>
 <component type="desktop">
   <id>org.kde.latte-dock.desktop</id>
   <name>Latte</name>
   <name xml:lang="ar">لاتيه</name>
+  <name xml:lang="ast">Latte</name>
   <name xml:lang="ca">Latte</name>
   <name xml:lang="ca-valencia">Latte</name>
   <name xml:lang="cs">Latte</name>
   <name xml:lang="da">Latte</name>
   <name xml:lang="de">Latte</name>
   <name xml:lang="el">Latte</name>
   <name xml:lang="en-GB">Latte</name>
   <name xml:lang="es">Latte</name>
   <name xml:lang="eu">Latte</name>
   <name xml:lang="fi">Latte</name>
   <name xml:lang="gl">Latte</name>
   <name xml:lang="id">Latte</name>
   <name xml:lang="it">Latte</name>
   <name xml:lang="ko">Latte</name>
   <name xml:lang="nl">Latte</name>
   <name xml:lang="nn">Latte</name>
   <name xml:lang="pl">Latte</name>
   <name xml:lang="pt">Latte</name>
   <name xml:lang="pt-BR">Latte</name>
   <name xml:lang="ru">Latte</name>
   <name xml:lang="sk">Latte</name>
   <name xml:lang="sv">Latte</name>
   <name xml:lang="uk">Латте</name>
   <name xml:lang="x-test">xxLattexx</name>
   <name xml:lang="zh-CN">Latte</name>
   <name xml:lang="zh-TW">Latte</name>
   <summary>Dock for the masses</summary>
   <summary xml:lang="ar">رصيف للأمور الكبيرة</summary>
   <summary xml:lang="ca">Dock per a les masses</summary>
   <summary xml:lang="ca-valencia">Dock per a les masses</summary>
   <summary xml:lang="cs">Dok pro masy</summary>
   <summary xml:lang="da">Dok til masserne</summary>
   <summary xml:lang="de">Dock für die Massen</summary>
   <summary xml:lang="el">Πίνακες εφαρμογών για όλον τον κόσμο</summary>
   <summary xml:lang="en-GB">Dock for the masses</summary>
   <summary xml:lang="es">Un dock para las masas</summary>
   <summary xml:lang="eu">Jendartearen kaia</summary>
   <summary xml:lang="fi">Telakka massoille</summary>
   <summary xml:lang="gl">Doca para as masas</summary>
   <summary xml:lang="id">Dock untuk mengelompokkan</summary>
   <summary xml:lang="it">Area di aggancio per le masse</summary>
   <summary xml:lang="ko">다수의 응용프로그램을 위한 독</summary>
   <summary xml:lang="nl">Dock voor de massa</summary>
   <summary xml:lang="nn">Dokk for massane</summary>
   <summary xml:lang="pl">Dok dla mas</summary>
   <summary xml:lang="pt">Área acoplável para as massas</summary>
   <summary xml:lang="pt-BR">Área acoplável para todos</summary>
   <summary xml:lang="ru">Док в массы</summary>
   <summary xml:lang="sk">Dok pre masy</summary>
   <summary xml:lang="sv">Dockningsfönster för alla</summary>
   <summary xml:lang="uk">Панель для усіх</summary>
   <summary xml:lang="x-test">xxDock for the massesxx</summary>
   <summary xml:lang="zh-CN">给大众使用的停靠栏</summary>
   <summary xml:lang="zh-TW">給大眾使用的 Dock</summary>
   <description>
     <p>Latte is a dock based on plasma frameworks that provides an elegant and intuitive experience for your tasks and plasmoids. It animates its contents by using parabolic zoom effect and tries to be there only when it is needed.</p>
     <p xml:lang="ar">«لاتيه» هو رصيف مبنيّ على أُطر عمل «بلازما» حيث يقدّم تجربة أنيقة وبدهيّة لمهامك والبلازمويد لديك. يعمل الرّصيف على إنشاء حركة للمحتويات باستخدام تأثير تقريب القطع المكافئ، ويحاول أن يكون بمتناول يديك عند حاجتك إليه فقط.</p>
     <p xml:lang="ca">El Latte és un acoblador basat en els Frameworks del Plasma que proporciona una experiència elegant i intuïtiva per a les vostres tasques i els plasmoides. Anima els seus continguts usant un efecte de zoom parabòlic i intenta mostrar-se només quan cal.</p>
     <p xml:lang="ca-valencia">El Latte és un acoblador basat en els Frameworks del Plasma que proporciona una experiència elegant i intuïtiva per a les vostres tasques i els plasmoides. Anima els seus continguts usant un efecte de zoom parabòlic i intenta mostrar-se només quan cal.</p>
     <p xml:lang="da">Latte er en dok som er baseret på plasma-frameworks som giver en elegant og intuitiv oplevelse til dine opgaver og plasmoids. Den animerer dens indhold med parabolsk zoom og prøver på kun at være der når der er brug for det.</p>
     <p xml:lang="de">Latte-Dock ist ein auf Plasma-Framework-Technologie basierendes Dock für  Anwendungen und Plasmoide, das ein elegantes und intuitives Nutzererlebnis bietet.Seine Inhalte werden mithilfe parabolischer Zoom-Effekte animiert. Latte versucht, immer zur Stelle zu sein, wenn es benötigt wird.</p>
     <p xml:lang="el">Το Latte είναι ένας πίνακας εφαρμογών βασισμένος στις βιβλιοθήκες plasma που εστιάζει στην καλαισθησία και παρέχει ένα όμορφο περιβάλλον για τις εργασίες και τα γραφικά συστατικά σας. Χρησιμοποιεί το παραβολικό εφέ έτσι ώστε να απεικονίσει τα περιεχόμενα του και προσπαθεί να είναι εκεί μόνο όταν το χρειάζεστε.</p>
     <p xml:lang="en-GB">Latte is a dock based on plasma frameworks that provides an elegant and intuitive experience for your tasks and plasmoids. It animates its contents by using parabolic zoom effect and tries to be there only when it is needed.</p>
     <p xml:lang="es">Latte es un dock basado en la infraestructura plasma que proporciona una experiencia intuitiva y elegante para sus tareas y plasmoides. Anima sus contenidos usando un efecto de zoom parabólico e intenta estar presente solo cuando se le necesita.</p>
     <p xml:lang="eu">Plasma frameworks-en oinarritutako kaia da Latte, bizipen eder eta intuitiboa hornitzen duena zure ataza eta aplikaziotxoentzat. Honek bere edukiak animatzen ditu zoom parabolikoaren efektua erabiliz eta bertan behar denean bakarrik egoten saiatzen da.</p>
     <p xml:lang="fi">Latte on Plasma Frameworksiin perustuva telakka, joka tarjoaa tyylikkään ja intuitiivisen tehtävä- ja sovelmakäyttöliittymän. Se animoi sisältönsä parabolisella lähennystehosteella ja yrittää pysyä poissa, kunnes sitä tarvitaan.</p>
     <p xml:lang="gl">Latte é unha doca construída coas infraestruturas de Plasma que fornece unha experiencia elegante e intuitiva para as súas tarefas e plasmoides. Anima o seu contido usando o efecto de ampliación parabólico e intenta estar aí só cando se necesita.</p>
     <p xml:lang="id">Latte adalah dock berdasarkan kerangka kerja plasma yang memberikan pengalaman yang elegan dan intuitif untuk tugas dan plasmoid kamu. Ini menganimasikan konten dengan menggunakan efek zoom parabola dan mencoba untuk berada di sana hanya ketika diperlukan.</p>
     <p xml:lang="it">Latte è un'area di aggancio basata su plasma frameworks. Offre ai tuoi processi e ai tuoi plasmoidi un'esperienza elegante ed intuitiva, animando il loro contenuto con un effetto zoom parabolico e facendosi trovare solo quando necessario.</p>
     <p xml:lang="ko">Latte는 Plasma 프레임워크 기반의 독으로 작업 및 plasmoids에 대한 우아하고 직관적인 경험을 제공합니다. 상직적인 확대/축소 효과를 사용하여 내용을 애니메이션화하고 필요할 때만 사용할 수 있습니다.</p>
     <p xml:lang="nl">Latte is een dock gebaseerd op plasma frameworks die een elegante en intuïtieve ervaring voor uw taken en plasmoids is. Het animeert zijn inhoud door een parabolisch zoomeffect te gebruiken en probeert er alleen te zijn wanneer nodig.</p>
     <p xml:lang="nn">Latte er ein dokk basert på Plasma-rammeverket og som gjev elegant og intuitiv tilgang til program/oppgåver og skjermelement. Innhaldet vert animerte med parabolske forstørringseffektar og programmet prøver å ikkje vera i vegen når det ikkje trengst.</p>
     <p xml:lang="pl">Latte jest dokiem opartym na szkieletach plazmy, który zapewnia przyjemne i intuicyjne odczucia w pracy z zadaniami i plazmoidami. Animuje swoją zawartośc przy użyciu efektu przybliżenia parabolicznego i próbuje być widocznym tylko wtedy, gdy jest potrzebny.</p>
     <p xml:lang="pt">O Latte é uma área acoplável baseada nas plataformas do Plasma que oferece uma experiência elegante e intuitiva para as suas tarefas e plasmóides. Ele anima o seu conteúdo, usando um efeito de ampliação parabólico e tenta estar apenas onde for necessário.</p>
     <p xml:lang="pt-BR">O Latte é uma área acoplável baseada nos frameworks do Plasma que oferece uma experiência elegante e intuitiva para as suas tarefas e plasmoides. Ele anima o seu conteúdo, usando um efeito de zoom parabólico e tenta estar apenas onde for necessário.</p>
     <p xml:lang="ru">Latte — это док-панель, основанная на KDE Frameworks, которая обеспечивает элегантный и интуитивно понятный интерфейс для задач и виджетов Plasma. Для анимация содержимого используется эффект параболического увеличения. Панель пытается быть видима только тогда, когда это необходимо.</p>
     <p xml:lang="sk">Latte je dok založený na frameworkoch plasma, ktorý poskytuje elegantné a intuitívne rozhranie pre vaše úlohy a plazmoidy. Animuje svoj obsah použitím parabolického efektu priblíženia a snaží sa by tam len vtedy, keď je to treba.</p>
     <p xml:lang="sv">Latte är ett dockningsfönster baserat på Plasma ramverk som erbjuder en elegant och intuitiv upplevelse för aktiviteter och Plasmoider. Det animerar innehållet genom att använda en paraboleffekt för zoomning, och försöker bara vara där när det behövs.</p>
     <p xml:lang="uk">Латте — панель на основі бібліотек Плазми, яка забезпечує елегантний і інтуїтивно зрозумілий доступ до ваших завдань та плазмоїдів. Вміст панелі анімується за допомогою ефекту параболічного збільшення і показується лише тоді, коли це потрібно.</p>
     <p xml:lang="x-test">xxLatte is a dock based on plasma frameworks that provides an elegant and intuitive experience for your tasks and plasmoids. It animates its contents by using parabolic zoom effect and tries to be there only when it is needed.xx</p>
     <p xml:lang="zh-CN">Latte 是一个基于 plasma 框架的停靠栏，它为您的任务及 plasmoid 提供了优雅直观的体验。它为它的内容赋予抛物线缩放动画效果，并尽可能仅在它被需要时出现。</p>
     <p xml:lang="zh-TW">Latte 是一個基於 Plasma 框架並提供您的工作與 plasmoid 優雅與直觀體驗的 dock。它使用拋物線縮放效果來讓您的內容動畫化，並試著只在您需要它時出現。</p>
     <p> "Art In Coffee" </p>
     <p xml:lang="ar">”الفنّ في القهوة“</p>
     <p xml:lang="ca">"Art al cafè"</p>
     <p xml:lang="ca-valencia">"Art al cafè"</p>
     <p xml:lang="da">"Kunst i kaffe"</p>
     <p xml:lang="de">„Art In Coffee“</p>
     <p xml:lang="el">"Τέχνη στον Καφέ"</p>
     <p xml:lang="en-GB">"Art In Coffee"</p>
     <p xml:lang="es">"El arte en el café"</p>
     <p xml:lang="eu">"Artea kafean"</p>
     <p xml:lang="fi">”Taidetta kahvissa”</p>
     <p xml:lang="gl">«Arte en café».</p>
     <p xml:lang="id">"Art In Coffee"</p>
     <p xml:lang="it">«Art In Coffee»</p>
     <p xml:lang="ko">"커피 안의 예술"</p>
     <p xml:lang="nl">"Kunst in koffie"</p>
     <p xml:lang="nn">«Kunst i kaffi»</p>
     <p xml:lang="pl">"Sztuka w Kawie"</p>
     <p xml:lang="pt">"Art In Coffee"</p>
     <p xml:lang="pt-BR">"Arte no café"</p>
     <p xml:lang="ru">«Искусство в кофе»</p>
     <p xml:lang="sk">"Umenie v káve"</p>
     <p xml:lang="sv">"Konst i kaffe"</p>
     <p xml:lang="uk">«Мистецтво кави»</p>
     <p xml:lang="x-test">xx"Art In Coffee"xx</p>
     <p xml:lang="zh-CN">“咖啡中的艺术”</p>
     <p xml:lang="zh-TW">「咖啡中的藝術」</p>
   </description>
   <categories>
     <category>Utility</category>
     <category>KDE</category>
   </categories>
   <url type="homepage">@WEBSITE@</url>
   <url type="bugtracker">@BUG_ADDRESS@</url>
   <url type="faq">@FAQS@</url>
   <developer_name>Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
+  <developer_name xml:lang="ast">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="ca">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="ca-valencia">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="cs">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="de">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="el">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="en-GB">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="es">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="eu">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="fi">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="gl">Michail Vourlakos e Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="id">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="it">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="ko">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="nl">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="nn">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="pl">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="pt">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="pt-BR">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="ru">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="sk">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="sv">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="uk">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="x-test">xxMichail Vourlakos, Johan Smith Agudelo Rodriguezxx</developer_name>
   <developer_name xml:lang="zh-CN">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <developer_name xml:lang="zh-TW">Michail Vourlakos, Johan Smith Agudelo Rodriguez</developer_name>
   <icon type="stock">latte-dock</icon>
   <project_license>GPL-2.0-or-later</project_license>
   <metadata_license>CC0-1.0</metadata_license>
   <screenshots>
     <screenshot type="default">
       <image type="source">https://cdn.kde.org/screenshots/latte-dock/latte-dock_regular.png</image>
     </screenshot>
     <screenshot>
       <image type="source">https://cdn.kde.org/screenshots/latte-dock/latte-dock_badges.png</image>
     </screenshot>
     <screenshot>
       <image type="source">https://cdn.kde.org/screenshots/latte-dock/latte-dock_settings.png</image>
     </screenshot>
     <screenshot>
       <image type="source">https://cdn.kde.org/screenshots/latte-dock/latte-dock_settings2.png</image>
     </screenshot>
     <screenshot>
       <image type="source">https://cdn.kde.org/screenshots/latte-dock/latte-dock_toppanel.png</image>
     </screenshot>
   </screenshots>
   <project_group>KDE</project_group>
   <provides>
     <binary>latte-dock</binary>
     <library>liblatte2plugin.so</library>
   </provides>
   <releases>
 ​    <release version="0.6.0" date="2017-04-02"/>
 ​    <release version="0.6.1" date="2017-05-05"/>
 ​    <release version="0.6.2" date="2017-05-09"/>
 ​    <release version="0.7.0" date="2017-08-11"/>
 ​    <release version="0.7.1" date="2017-08-31"/>
 ​  </releases>
 </component>
diff --git a/app/org.kde.latte-dock.desktop.cmake b/app/org.kde.latte-dock.desktop.cmake
index 3f6847d5..116209c0 100644
--- a/app/org.kde.latte-dock.desktop.cmake
+++ b/app/org.kde.latte-dock.desktop.cmake
@@ -1,94 +1,95 @@
 [Desktop Entry]
 Name=Latte
+Name[ast]=Latte
 Name[ca]=Latte
 Name[ca@valencia]=Latte
 Name[cs]=Latte
 Name[da]=Latte
 Name[de]=Latte
 Name[el]=Latte
 Name[en_GB]=Latte
 Name[es]=Latte
 Name[eu]=Latte
 Name[fi]=Latte
 Name[gl]=Latte
 Name[it]=Latte
 Name[ko]=Latte
 Name[nl]=Latte
 Name[nn]=Latte
 Name[pl]=Latte
 Name[pt]=Latte
 Name[pt_BR]=Latte
 Name[ru]=Latte
 Name[sv]=Latte
 Name[uk]=Латте
 Name[x-test]=xxLattexx
 Name[zh_CN]=Latte
 Name[zh_TW]=Latte
 Comment=Dock for the masses
 Comment[ca]=Acoblador per a les masses
 Comment[ca@valencia]=Acoblador per a les masses
 Comment[cs]=Dok pro masy
 Comment[da]=Dok til masserene
 Comment[de]=Dock für die Massen
 Comment[el]=Πίνακες για όλον τον κόσμο
 Comment[en_GB]=Dock for the masses
 Comment[es]=Un dock para las masas
 Comment[eu]=Jendartearen kaia
 Comment[fi]=Telakka massoille
 Comment[gl]=Doca para as masas.
 Comment[it]=Area di aggancio per le masse
 Comment[ko]=다수의 응용프로그램을 위한 독
 Comment[nl]=Dock voor de massa
 Comment[nn]=Dokk for massane
 Comment[pl]=Dok dla mas
 Comment[pt]=Área acoplável para as massas
 Comment[pt_BR]=Área acoplável para todos
 Comment[ru]=Док для всех
 Comment[sv]=Dockningsfönster för alla
 Comment[uk]=Панель для усіх
 Comment[x-test]=xxDock for the massesxx
 Comment[zh_CN]=给大众使用的停靠栏
 Comment[zh_TW]=給大眾使用的 Dock
 GenericName=Dock
 GenericName[ca]=Acobla
 GenericName[ca@valencia]=Acobla
 GenericName[cs]=Dok
 GenericName[da]=Dok
 GenericName[de]=Dock
 GenericName[el]=Πίνακας
 GenericName[en_GB]=Dock
 GenericName[es]=Dock
 GenericName[eu]=Kaia
 GenericName[fi]=Telakka
 GenericName[gl]=Doca
 GenericName[it]=Aggancio
 GenericName[ko]=독
 GenericName[nl]=Dock
 GenericName[nn]=Dokk
 GenericName[pl]=Dok
 GenericName[pt]=Área Acoplável
 GenericName[pt_BR]=Área acoplável
 GenericName[ru]=Док
 GenericName[sk]=Dok
 GenericName[sv]=Dockningsfönster
 GenericName[uk]=Панель
 GenericName[x-test]=xxDockxx
 GenericName[zh_CN]=停靠栏
 GenericName[zh_TW]=Dock
 Icon=latte-dock
 Categories=Utility;X-SuSE-DesktopUtility;
 Exec=latte-dock %u
 InitialPreference=1
 StartupNotify=false
 Terminal=false
 Type=Application
 StartupWMClass=latte-dock
 X-DBUS-ServiceName=org.kde.lattedock
 X-DBUS-StartupType=unique
 X-KDE-PluginInfo-Author=@AUTHOR@
 X-KDE-PluginInfo-Email=@EMAIL@
 X-KDE-PluginInfo-Version=@VERSION@
 X-KDE-PluginInfo-Website=@WEBSITE@
 X-KDE-StartupNotify=false
 X-KDE-SubstituteUID=false
 
diff --git a/app/view/positioner.cpp b/app/view/positioner.cpp
index 420318bf..11d29a93 100644
--- a/app/view/positioner.cpp
+++ b/app/view/positioner.cpp
@@ -1,659 +1,668 @@
 /*
 *  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());
+            m_trackedWindowId = m_view->winId();
+            m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
+
+            connect(m_view, &Latte::View::forcedShown, this, [&]() {
+                m_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
+                m_trackedWindowId = m_view->winId();
+                m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
+            });
         } 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);
+                if (m_trackedWindowId.isNull()) {
+                    m_trackedWindowId = m_corona->wm()->winIdFor("latte-dock", m_view->geometry());
+                    m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
                 }
             });
         }
 
+        /////
+
         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_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
 
     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...";
 
     //! 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/positioner.h b/app/view/positioner.h
index 84d8c7ee..2fd6e03a 100644
--- a/app/view/positioner.h
+++ b/app/view/positioner.h
@@ -1,134 +1,134 @@
 /*
 *  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/>.
 */
 
 #ifndef POSITIONER_H
 #define POSITIONER_H
 
 //local
 #include "../wm/windowinfowrap.h"
 
 // Qt
 #include <QObject>
 #include <QPointer>
 #include <QScreen>
 #include <QTimer>
 
 // Plasma
 #include <Plasma/Containment>
 
 namespace Plasma {
 class Types;
 }
 
 namespace Latte {
 class Corona;
 class View;
 }
 
 namespace Latte {
 namespace ViewPart {
 
 class Positioner: public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(int currentScreenId READ currentScreenId NOTIFY currentScreenChanged)
     Q_PROPERTY(QString currentScreenName READ currentScreenName NOTIFY currentScreenChanged)
 
 public:
     Positioner(Latte::View *parent);
     virtual ~Positioner();
 
     int currentScreenId() const;
     QString currentScreenName() const;
 
     bool inLocationChangeAnimation();
     void setScreenToFollow(QScreen *scr, bool updateScreenId = true);
 
     void reconsiderScreen();
 
 public slots:
     Q_INVOKABLE void hideDockDuringLocationChange(int goToLocation);
     Q_INVOKABLE void hideDockDuringMovingToLayout(QString layoutName);
 
     Q_INVOKABLE bool setCurrentScreen(const QString id);
 
     void syncGeometry();
 
 signals:
     void currentScreenChanged();
     void edgeChanged();
     void screenGeometryChanged();
     void windowSizeChanged();
 
     //! these two signals are used from config ui and containment ui
     //! in order to orchestrate an animated hiding/showing of dock
     //! during changing location
     void hideDockDuringLocationChangeStarted();
     void hideDockDuringLocationChangeFinished();
     void hideDockDuringScreenChangeStarted();
     void hideDockDuringScreenChangeFinished();
     void hideDockDuringMovingToLayoutStarted();
     void hideDockDuringMovingToLayoutFinished();
     void onHideWindowsForSlidingOut();
     void showDockAfterLocationChangeFinished();
     void showDockAfterScreenChangeFinished();
     void showDockAfterMovingToLayoutFinished();
 
 private slots:
     void screenChanged(QScreen *screen);
     void validateDockGeometry();
 
 private:
     void init();
     void initSignalingForLocationChangeSliding();
     void resizeWindow(QRect availableScreenRect = QRect());
 
     void updateFormFactor();
     void updatePosition(QRect availableScreenRect = QRect());
 
     QRect maximumNormalGeometry();
 
 private:
     bool m_inDelete{false};
 
     //! it is used in order to enforce X11 to never miss window geometry
     QRect m_validGeometry;
 
     QPointer<Latte::View> m_view;
     QPointer<Latte::Corona> m_corona;
 
     QString m_screenToFollowId;
     QPointer<QScreen> m_screenToFollow;
     QTimer m_screenSyncTimer;
 
     QTimer m_validateGeometryTimer;
 
     //!used at sliding out/in animation
     QString m_moveToLayout;
     Plasma::Types::Location m_goToLocation{Plasma::Types::Floating};
     QScreen *m_goToScreen{nullptr};
 
-    Latte::WindowSystem::WindowId m_waylandWindowId;
+    Latte::WindowSystem::WindowId m_trackedWindowId;
 };
 
 }
 }
 
 #endif
diff --git a/app/view/screenedgeghostwindow.cpp b/app/view/screenedgeghostwindow.cpp
index dfe9dc22..1dbc6e34 100644
--- a/app/view/screenedgeghostwindow.cpp
+++ b/app/view/screenedgeghostwindow.cpp
@@ -1,318 +1,325 @@
 /*
 *  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()) {
                 show();
+                emit forcedShown();
                 //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()) {
                 show();
+                emit forcedShown();
                 //qDebug() << "Ghost Edge:: Enforce reshow from timer 2...";
             } else {
                 //qDebug() << "Ghost Edge:: No needed reshow from timer 2...";
             }
         });
+
+        connectionsHack << connect(this, &ScreenEdgeGhostWindow::forcedShown, this, [&]() {
+            m_corona->wm()->unregisterIgnoredWindow(m_trackedWindowId);
+            m_trackedWindowId = winId();
+            m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
+        });
     }
 
     setupWaylandIntegration();
 
     if (KWindowSystem::isPlatformX11()) {
-        m_corona->wm()->registerIgnoredWindow(winId());
+        m_trackedWindowId = winId();
+        m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
     } 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);
+            if (m_trackedWindowId.isNull()) {
+                m_trackedWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
+                m_corona->wm()->registerIgnoredWindow(m_trackedWindowId);
             }
         });
     }
 
     setScreen(m_latteView->screen());
     show();
     updateGeometry();
     hideWithMask();
 }
 
 ScreenEdgeGhostWindow::~ScreenEdgeGhostWindow()
 {
     m_inDelete = true;
 
-    m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
+    m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_trackedWindowId);
 
     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()
 {
     QRect newGeometry;
-    int thickness;
+    int thickness{2};
+
     if (KWindowSystem::compositingActive()) {
-        thickness == 6;
-    } else {
-        thickness == 2;
-    };
+        thickness = 6;
+    }
 
     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/screenedgeghostwindow.h b/app/view/screenedgeghostwindow.h
index 80ff4fc6..3907a347 100644
--- a/app/view/screenedgeghostwindow.h
+++ b/app/view/screenedgeghostwindow.h
@@ -1,125 +1,126 @@
 /*
 *  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/>.
 */
 
 #ifndef SCREENEDGEGHOSTWINDOW_H
 #define SCREENEDGEGHOSTWINDOW_H
 
 // local
 #include "../lattecorona.h"
 #include "../wm/windowinfowrap.h"
 
 // Qt
 #include <QObject>
 #include <QQuickView>
 #include <QTimer>
 
 namespace KWayland {
 namespace Client {
 class PlasmaShellSurface;
 }
 }
 
 namespace Latte {
 class Corona;
 class View;
 }
 
 namespace Latte {
 namespace ViewPart {
 
 //! What is the importance of this class?
 //!
 //! Plasma is activating the screen edges for the main panel window
 //! unfortunately this isn't possible for the Latte case.
 //! When a window is hidden at an edge it becomes NOT visible
 //! unfortunately that means that all the animations are
 //! stopped (Qt behaviour) and that creates confusion to the user after the window
 //! reappears because various animations are played (adding-removing tasks/launchers)
 //! that aren't relevant any more.
 //!
 //! In order to workaround the above behaviour Latte is using a
 //! fake window to communicate with KWin and the MAIN Latte::View window
 //! continues to use only mask technique to hide
 //!
 //! KDE BUGS: https://bugs.kde.org/show_bug.cgi?id=382219
 //!           https://bugs.kde.org/show_bug.cgi?id=392464
 
 class ScreenEdgeGhostWindow : public QQuickView
 {
     Q_OBJECT
 
 public:
     ScreenEdgeGhostWindow(Latte::View *view);
     ~ScreenEdgeGhostWindow() override;
 
     bool containsMouse() const;
 
     int location();
 
     void hideWithMask();
     void showWithMask();
 
     Latte::View *parentView();
 
     KWayland::Client::PlasmaShellSurface *surface();
 
 signals:
     void containsMouseChanged(bool contains);
     void dragEntered();
+    void forcedShown(); //[workaround] forced shown to avoid a KWin issue that hides windows when activities are stopped
 
 protected:
     bool event(QEvent *ev) override;
 
 private slots:
     void startGeometryTimer();
     void updateGeometry();
     void fixGeometry();
 
 private:
     void setContainsMouse(bool contains);
     void setupWaylandIntegration();
 
 private:
     bool m_delayedContainsMouse{false};
     bool m_containsMouse{false};
     bool m_inDelete{false};
     QRect m_calculatedGeometry;
 
     QTimer m_delayedMouseTimer;
     QTimer m_fixGeometryTimer;
 
     //! HACK: Timers in order to handle KWin faulty
     //! behavior that hides Views when closing Activities
     //! with no actual reason
     QTimer m_visibleHackTimer1;
     QTimer m_visibleHackTimer2;
     //! Connections for the KWin visibility hack
     QList<QMetaObject::Connection> connectionsHack;
 
     Latte::View *m_latteView{nullptr};
 
     QPointer<Latte::Corona> m_corona;
 
-    Latte::WindowSystem::WindowId m_waylandWindowId;
+    Latte::WindowSystem::WindowId m_trackedWindowId;
     KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
 };
 
 }
 }
 #endif
diff --git a/app/view/view.cpp b/app/view/view.cpp
index cf4f56aa..4e31f5b7 100644
--- a/app/view/view.cpp
+++ b/app/view/view.cpp
@@ -1,1315 +1,1318 @@
 /*
 *  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 "view.h"
 
 // local
 #include "contextmenu.h"
 #include "effects.h"
 #include "positioner.h"
 #include "visibilitymanager.h"
 #include "settings/primaryconfigview.h"
 #include "settings/secondaryconfigview.h"
 #include "../indicator/factory.h"
 #include "../lattecorona.h"
 #include "../layout/genericlayout.h"
 #include "../layouts/manager.h"
 #include "../plasma/extended/theme.h"
 #include "../screenpool.h"
 #include "../settings/universalsettings.h"
 #include "../shortcuts/globalshortcuts.h"
 #include "../shortcuts/shortcutstracker.h"
 #include "../../liblatte2/extras.h"
 
 // Qt
 #include <QAction>
 #include <QMouseEvent>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QQmlProperty>
 #include <QQuickItem>
 #include <QMenu>
 
 // KDe
 #include <KActionCollection>
 #include <KActivities/Consumer>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Containment>
 #include <Plasma/ContainmentActions>
 #include <PlasmaQuick/AppletQuickItem>
 
 namespace Latte {
 
 //! both alwaysVisible and byPassWM are passed through corona because
 //! during the view window creation containment hasn't been set, but these variables
 //! are needed in order for window flags to be set correctly
 View::View(Plasma::Corona *corona, QScreen *targetScreen, bool byPassWM)
     : PlasmaQuick::ContainmentView(corona),
       m_contextMenu(new ViewPart::ContextMenu(this)),
       m_effects(new ViewPart::Effects(this))
 {      
     //! needs to be created after Effects because it catches some of its signals
     //! and avoid a crash from View::winId() at the same time
     m_positioner = new ViewPart::Positioner(this);
 
     setTitle(corona->kPackage().metadata().name());
     setIcon(qGuiApp->windowIcon());
     setResizeMode(QuickViewSharedEngine::SizeRootObjectToView);
     setColor(QColor(Qt::transparent));
+    setDefaultAlphaBuffer(true);
     setClearBeforeRendering(true);
 
     const auto flags = Qt::FramelessWindowHint
             | Qt::WindowStaysOnTopHint
             | Qt::NoDropShadowWindowHint
             | Qt::WindowDoesNotAcceptFocus;
 
     if (byPassWM) {
         setFlags(flags | Qt::BypassWindowManagerHint);
     } else {
         setFlags(flags);
     }
 
     if (targetScreen)
         m_positioner->setScreenToFollow(targetScreen);
     else
         m_positioner->setScreenToFollow(qGuiApp->primaryScreen());
 
     connect(this, &View::containmentChanged
             , this, [ &, byPassWM]() {
         qDebug() << "dock view c++ containment changed 1...";
 
         if (!this->containment())
             return;
 
         qDebug() << "dock view c++ containment changed 2...";
 
         //! First load default values from file
         restoreConfig();
 
         //! Afterwards override that values in case during creation something different is needed
         setByPassWM(byPassWM);
 
         //! Check the screen assigned to this dock
         reconsiderScreen();
 
         //! needs to be created before visibility creation because visibility uses it
         if (!m_windowsTracker) {
             m_windowsTracker = new ViewPart::WindowsTracker(this);
             emit windowsTrackerChanged();
         }
 
         if (!m_visibility) {
             m_visibility = new ViewPart::VisibilityManager(this);
 
             connect(m_visibility, &ViewPart::VisibilityManager::isHiddenChanged, this, [&]() {
                 if (m_visibility->isHidden()) {
                     deactivateApplets();
                 }
             });
 
             emit visibilityChanged();
         }
 
         if (!m_indicator) {
             m_indicator = new ViewPart::Indicator(this);
             emit indicatorChanged();
         }
 
         connect(this->containment(), SIGNAL(statusChanged(Plasma::Types::ItemStatus)), SLOT(statusChanged(Plasma::Types::ItemStatus)));
     }, Qt::DirectConnection);
 
     m_corona = qobject_cast<Latte::Corona *>(this->corona());
 
     if (m_corona) {
         connect(m_corona, &Latte::Corona::viewLocationChanged, this, &View::dockLocationChanged);
     }
 }
 
 View::~View()
 {
     m_inDelete = true;
 
     //! clear Layout connections
     m_visibleHackTimer1.stop();
     m_visibleHackTimer2.stop();
     for (auto &c : connectionsLayout) {
         disconnect(c);
     }
 
     //! unload indicators
     if (m_indicator) {
         m_indicator->unloadIndicators();
     }
 
     disconnect(m_corona, &Latte::Corona::availableScreenRectChangedFrom, this, &View::availableScreenRectChangedFrom);
     disconnect(containment(), SIGNAL(statusChanged(Plasma::Types::ItemStatus)), this, SLOT(statusChanged(Plasma::Types::ItemStatus)));
 
     qDebug() << "dock view deleting...";
     rootContext()->setContextProperty(QStringLiteral("dock"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("layoutsManager"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("themeExtended"), nullptr);
     rootContext()->setContextProperty(QStringLiteral("universalSettings"), nullptr);
 
     //! this disconnect does not free up connections correctly when
     //! latteView is deleted. A crash for this example is the following:
     //! switch to Alternative Session and disable compositing,
     //! the signal creating the crash was probably from deleted
     //! windows.
     //! this->disconnect();
 
     if (m_configView) {
         m_configView->deleteLater();
     }
 
     if (m_contextMenu) {
         delete m_contextMenu;
     }
 
     //needs to be deleted before Effects because it catches some of its signals
     if (m_positioner) {
         delete m_positioner;
     }
 
     if (m_effects) {
         delete m_effects;
     }
 
     if (m_indicator) {
         delete m_indicator;
     }
 
     if (m_visibility) {
         delete m_visibility;
     }
 
     if (m_windowsTracker) {
         delete m_windowsTracker;
     }
 }
 
 void View::init()
 {
     connect(this, &QQuickWindow::xChanged, this, &View::xChanged);
     connect(this, &QQuickWindow::xChanged, this, &View::updateAbsoluteGeometry);
     connect(this, &QQuickWindow::yChanged, this, &View::yChanged);
     connect(this, &QQuickWindow::yChanged, this, &View::updateAbsoluteGeometry);
     connect(this, &QQuickWindow::widthChanged, this, &View::widthChanged);
     connect(this, &QQuickWindow::widthChanged, this, &View::updateAbsoluteGeometry);
     connect(this, &QQuickWindow::heightChanged, this, &View::heightChanged);
     connect(this, &QQuickWindow::heightChanged, this, &View::updateAbsoluteGeometry);
 
     connect(m_corona, &Latte::Corona::availableScreenRectChangedFrom, this, &View::availableScreenRectChangedFrom);
 
     connect(this, &View::byPassWMChanged, this, &View::saveConfig);
     connect(this, &View::isPreferredForShortcutsChanged, this, &View::saveConfig);
     connect(this, &View::onPrimaryChanged, this, &View::saveConfig);
     connect(this, &View::typeChanged, this, &View::saveConfig);
 
     connect(this, &View::normalThicknessChanged, this, [&]() {
         emit m_corona->availableScreenRectChangedFrom(this);
     });
 
     connect(m_effects, &ViewPart::Effects::innerShadowChanged, this, [&]() {
         emit m_corona->availableScreenRectChangedFrom(this);
     });
     connect(m_positioner, &ViewPart::Positioner::onHideWindowsForSlidingOut, this, &View::hideWindowsForSlidingOut);
     connect(m_positioner, &ViewPart::Positioner::screenGeometryChanged, this, &View::screenGeometryChanged);
     connect(m_positioner, &ViewPart::Positioner::windowSizeChanged, this, [&]() {
         emit m_corona->availableScreenRectChangedFrom(this);
     });
 
     connect(m_contextMenu, &ViewPart::ContextMenu::menuChanged, this, &View::contextMenuIsShownChanged);
 
     connect(m_corona->indicatorFactory(), &Latte::Indicator::Factory::pluginsUpdated, this, &View::reloadSource);
     //! View sends this signal in order to avoid crashes from ViewPart::Indicator when the view is recreated
     connect(m_corona->indicatorFactory(), &Latte::Indicator::Factory::customPluginsChanged, this, &View::customPluginsChanged);
     connect(m_corona, &Latte::Corona::availableScreenRectChanged, this, &View::availableScreenRectChangedForViewParts);
 
     ///!!!!!
     rootContext()->setContextProperty(QStringLiteral("latteView"), this);
 
     if (m_corona) {
         rootContext()->setContextProperty(QStringLiteral("layoutsManager"), m_corona->layoutsManager());
         rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), m_corona->globalShortcuts()->shortcutsTracker());
         rootContext()->setContextProperty(QStringLiteral("themeExtended"), m_corona->themeExtended());
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), m_corona->universalSettings());
     }
 
     setSource(corona()->kPackage().filePath("lattedockui"));
     m_positioner->syncGeometry();
 
     qDebug() << "SOURCE:" << source();
 }
 
 void View::reloadSource()
 {
     if (m_layout && containment()) {
         if (settingsWindowIsShown()) {
             m_configView->deleteLater();
         }
 
         engine()->clearComponentCache();
         m_layout->recreateView(containment(), settingsWindowIsShown());
     }
 }
 
 
 bool View::inDelete() const
 {
     return m_inDelete;
 }
 
 void View::disconnectSensitiveSignals()
 {
     disconnect(m_corona, &Latte::Corona::availableScreenRectChangedFrom, this, &View::availableScreenRectChangedFrom);
     setLayout(nullptr);
 
     if (m_windowsTracker) {
       //  m_windowsTracker->setEnabled(false);
     }
 }
 
 void View::availableScreenRectChangedFrom(View *origin)
 {
     if (m_inDelete || origin == this)
         return;
 
     if (formFactor() == Plasma::Types::Vertical) {
         m_positioner->syncGeometry();
     }
 
 }
 
 void View::setupWaylandIntegration()
 {
     if (m_shellSurface)
         return;
 
     if (Latte::Corona *c = qobject_cast<Latte::Corona *>(corona())) {
         using namespace KWayland::Client;
         PlasmaShell *interface {c->waylandCoronaInterface()};
 
         if (!interface)
             return;
 
         Surface *s{Surface::fromWindow(this)};
 
         if (!s)
             return;
 
         m_shellSurface = interface->createSurface(s, this);
         qDebug() << "WAYLAND dock window surface was created...";
 
         m_shellSurface->setSkipTaskbar(true);
         m_shellSurface->setRole(PlasmaShellSurface::Role::Panel);
         m_shellSurface->setPanelBehavior(PlasmaShellSurface::PanelBehavior::WindowsGoBelow);
     }
 }
 
 KWayland::Client::PlasmaShellSurface *View::surface()
 {
     return m_shellSurface;
 }
 
 //! the main function which decides if this dock is at the
 //! correct screen
 void View::reconsiderScreen()
 {
     m_positioner->reconsiderScreen();
 }
 
 void View::copyView()
 {
     m_layout->copyView(containment());
 }
 
 void View::removeView()
 {
     if (m_layout && m_layout->viewsCount() > 1) {
         QAction *removeAct = this->containment()->actions()->action(QStringLiteral("remove"));
 
         if (removeAct) {
             removeAct->trigger();
         }
     }
 }
 
 bool View::settingsWindowIsShown()
 {
     auto configView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
     return (configView != nullptr);
 }
 
 void View::showSettingsWindow()
 {
     if (!settingsWindowIsShown()) {
         emit m_visibility->mustBeShown();
         showConfigurationInterface(containment());
         applyActivitiesToWindows();
     }
 }
 
 PlasmaQuick::ConfigView *View::configView()
 {
     return m_configView;
 }
 
 void View::showConfigurationInterface(Plasma::Applet *applet)
 {
     if (!applet || !applet->containment())
         return;
 
     Plasma::Containment *c = qobject_cast<Plasma::Containment *>(applet);
 
     if (m_configView && c && c->isContainment() && c == this->containment()) {
         if (m_configView->isVisible()) {
             m_configView->hide();
         } else {
             m_configView->show();
         }
 
         return;
     } else if (m_configView) {
         if (m_configView->applet() == applet) {
             m_configView->show();
 
             if (KWindowSystem::isPlatformX11()) {
                 m_configView->requestActivate();
             }
             return;
         } else {
             m_configView->hide();
         }
     }
 
     bool delayConfigView = false;
 
     if (c && containment() && c->isContainment() && c->id() == this->containment()->id()) {
         m_configView = new ViewPart::PrimaryConfigView(c, this);
         delayConfigView = true;
     } else {
         m_configView = new PlasmaQuick::ConfigView(applet);
     }
 
     m_configView.data()->init();
 
     if (!delayConfigView) {
         m_configView->show();
     } else {
         //add a timer for showing the configuration window the first time it is
         //created in order to give the containment's layouts the time to
         //calculate the window's height
         QTimer::singleShot(150, [this]() {
             if (m_configView) {
                 m_configView->show();
             }
         });
     }
 }
 
 QRect View::localGeometry() const
 {
     return m_localGeometry;
 }
 
 void View::setLocalGeometry(const QRect &geometry)
 {
     if (m_localGeometry == geometry) {
         return;
     }
 
     m_localGeometry = geometry;
     emit localGeometryChanged();
     updateAbsoluteGeometry();
 }
 
 void View::updateAbsoluteGeometry(bool bypassChecks)
 {
     //! there was a -1 in height and width here. The reason of this
     //! if I remember correctly was related to multi-screen but I cant
     //! remember exactly the reason, something related to right edge in
     //! multi screen environment. BUT this was breaking the entire AlwaysVisible
     //! experience with struts. Removing them in order to restore correct
     //! behavior and keeping this comment in order to check for
     //! multi-screen breakage
     QRect absGeometry {x() + m_localGeometry.x(), y() + m_localGeometry.y()
                 , m_localGeometry.width(), m_localGeometry.height()};
 
     if (m_absoluteGeometry == absGeometry && !bypassChecks) {
         return;
     }
 
     if (m_absoluteGeometry != absGeometry) {
         m_absoluteGeometry = absGeometry;
         emit absoluteGeometryChanged(m_absoluteGeometry);
     }
 
     //! this is needed in order to update correctly the screenGeometries
     if (visibility() && corona() && visibility()->mode() == Types::AlwaysVisible) {
         //! main use of BYPASSCKECKS is from Positioner when the view changes screens
         emit m_corona->availableScreenRectChangedFrom(this);
         emit m_corona->availableScreenRegionChangedFrom(this);
     }
 }
 
 void View::statusChanged(Plasma::Types::ItemStatus status)
 {
     if (containment()) {
         if (containment()->status() >= Plasma::Types::NeedsAttentionStatus &&
                 containment()->status() != Plasma::Types::HiddenStatus) {
             setBlockHiding(true);
         } else if (!containment()->isUserConfiguring()){
             setBlockHiding(false);
         }
     }
 }
 
 Types::ViewType View::type() const
 {
     return m_type;
 }
 
 void View::setType(Types::ViewType type)
 {
     if (m_type == type) {
         return;
     }
 
     m_type = type;
     emit typeChanged();
 }
 
 bool View::alternativesIsShown() const
 {
     return m_alternativesIsShown;
 }
 
 void View::setAlternativesIsShown(bool show)
 {
     if (m_alternativesIsShown == show) {
         return;
     }
 
     m_alternativesIsShown = show;
 
     setBlockHiding(show);
     emit alternativesIsShownChanged();
 }
 
 bool View::containsDrag() const
 {
     return m_containsDrag;
 }
 
 void View::setContainsDrag(bool contains)
 {
     if (m_containsDrag == contains) {
         return;
     }
 
     m_containsDrag = contains;
     emit containsDragChanged();
 }
 
 bool View::containsMouse() const
 {
     return m_containsMouse;
 }
 
 bool View::contextMenuIsShown() const
 {
     if (!m_contextMenu) {
         return false;
     }
 
     return m_contextMenu->menu();
 }
 
 int View::currentThickness() const
 {
     if (formFactor() == Plasma::Types::Vertical) {
         return m_effects->mask().isNull() ? width() : m_effects->mask().width() - m_effects->innerShadow();
     } else {
         return m_effects->mask().isNull() ? height() : m_effects->mask().height() - m_effects->innerShadow();
     }
 }
 
 int View::normalThickness() const
 {
     return m_normalThickness;
 }
 
 void View::setNormalThickness(int thickness)
 {
     if (m_normalThickness == thickness) {
         return;
     }
 
     m_normalThickness = thickness;
     emit normalThicknessChanged();
 }
 
 bool View::byPassWM() const
 {
     return m_byPassWM;
 }
 
 void View::setByPassWM(bool bypass)
 {
     if (m_byPassWM == bypass) {
         return;
     }
 
     m_byPassWM = bypass;
     emit byPassWMChanged();
 }
 
 bool View::behaveAsPlasmaPanel() const
 {
     return m_behaveAsPlasmaPanel;
 }
 
 void View::setBehaveAsPlasmaPanel(bool behavior)
 {
     if (m_behaveAsPlasmaPanel == behavior) {
         return;
     }
 
     m_behaveAsPlasmaPanel = behavior;
 
     emit behaveAsPlasmaPanelChanged();
 }
 
 bool View::inEditMode() const
 {
     return m_inEditMode;
 }
 
 void View::setInEditMode(bool edit)
 {
     if (m_inEditMode == edit) {
         return;
     }
 
     m_inEditMode = edit;
 
     emit inEditModeChanged();
 }
 
 bool View::isPreferredForShortcuts() const
 {
     return m_isPreferredForShortcuts;
 }
 
 void View::setIsPreferredForShortcuts(bool preferred)
 {
     if (m_isPreferredForShortcuts == preferred) {
         return;
     }
 
     m_isPreferredForShortcuts = preferred;
 
     emit isPreferredForShortcutsChanged();
 
     if (m_isPreferredForShortcuts && m_layout) {
         emit m_layout->preferredViewForShortcutsChanged(this);
     }
 }
 
 bool View::latteTasksArePresent() const
 {
     return m_latteTasksArePresent;
 }
 
 void View::setLatteTasksArePresent(bool present)
 {
     if (m_latteTasksArePresent == present) {
         return;
     }
 
     m_latteTasksArePresent = present;
     emit latteTasksArePresentChanged();
 }
 
 void View::preferredViewForShortcutsChangedSlot(Latte::View *view)
 {
     if (view != this) {
         setIsPreferredForShortcuts(false);
     }
 }
 
 bool View::onPrimary() const
 {
     return m_onPrimary;
 }
 
 void View::setOnPrimary(bool flag)
 {
     if (m_onPrimary == flag) {
         return;
     }
 
     m_onPrimary = flag;
     emit onPrimaryChanged();
 }
 
 float View::maxLength() const
 {
     return m_maxLength;
 }
 
 void View::setMaxLength(float length)
 {
     if (m_maxLength == length) {
         return;
     }
 
     m_maxLength = length;
     emit maxLengthChanged();
 }
 
 int View::editThickness() const
 {
     return m_editThickness;
 }
 
 void View::setEditThickness(int thickness)
 {
     if (m_editThickness == thickness) {
         return;
     }
 
     m_editThickness = thickness;
 
     emit editThicknessChanged();
 }
 
 int View::maxThickness() const
 {
     return m_maxThickness;
 }
 
 void View::setMaxThickness(int thickness)
 {
     if (m_maxThickness == thickness)
         return;
 
     m_maxThickness = thickness;
     emit maxThicknessChanged();
 }
 
 int View::alignment() const
 {
     return m_alignment;
 }
 
 void View::setAlignment(int alignment)
 {
     Types::Alignment align = static_cast<Types::Alignment>(alignment);
 
     if (m_alignment == alignment) {
         return;
     }
 
     m_alignment = align;
     emit alignmentChanged();
 }
 
 QRect View::absoluteGeometry() const
 {
     return m_absoluteGeometry;
 }
 
 QRect View::screenGeometry() const
 {
     if (this->screen()) {
         QRect geom = this->screen()->geometry();
         return geom;
     }
 
     return QRect();
 }
 
 int View::offset() const
 {
     return m_offset;
 }
 
 void View::setOffset(int offset)
 {
     if (m_offset == offset) {
         return;
     }
 
     m_offset = offset;
     emit offsetChanged();
 }
 
 int View::fontPixelSize() const
 {
     return m_fontPixelSize;
 }
 
 void View::setFontPixelSize(int size)
 {
     if (m_fontPixelSize == size) {
         return;
     }
 
     m_fontPixelSize = size;
 
     emit fontPixelSizeChanged();
 }
 
 bool View::isOnAllActivities() const
 {
     return m_activities.isEmpty() || m_activities[0] == "0";
 }
 
 bool View::isOnActivity(const QString &activity) const
 {
     return isOnAllActivities() || m_activities.contains(activity);
 }
 
 QStringList View::activities() const
 {
     return m_activities;
 }
 
 void View::applyActivitiesToWindows()
 {
     if (m_visibility && m_layout) {
         m_windowsTracker->setWindowOnActivities(*this, m_activities);
 
         if (m_configView) {
             m_windowsTracker->setWindowOnActivities(*m_configView, m_activities);
 
             auto configView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
             if (configView && configView->secondaryWindow()) {
                 m_windowsTracker->setWindowOnActivities(*configView->secondaryWindow(), m_activities);
             }
         }
 
         if (m_visibility->supportsKWinEdges()) {
             m_visibility->applyActivitiesToHiddenWindows(m_activities);
         }
     }
 }
 
 Layout::GenericLayout *View::layout() const
 {
     return m_layout;
 }
 
 void View::setLayout(Layout::GenericLayout *layout)
 {
     if (m_layout == layout) {
         return;
     }
 
     // clear mode
     for (auto &c : connectionsLayout) {
         disconnect(c);
     }
 
     m_layout = layout;
 
     if (m_layout) {
         connectionsLayout << connect(containment(), &Plasma::Applet::destroyedChanged, m_layout, &Layout::GenericLayout::destroyedChanged);
         connectionsLayout << connect(containment(), &Plasma::Applet::locationChanged, m_corona, &Latte::Corona::viewLocationChanged);
         connectionsLayout << connect(containment(), &Plasma::Containment::appletAlternativesRequested, m_corona, &Latte::Corona::showAlternativesForApplet, Qt::QueuedConnection);
 
         if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             connectionsLayout << connect(containment(), &Plasma::Containment::appletCreated, m_layout, &Layout::GenericLayout::appletCreated);
         }
 
         connectionsLayout << connect(m_positioner, &Latte::ViewPart::Positioner::edgeChanged, m_layout, &Layout::GenericLayout::viewEdgeChanged);
 
         //! Sometimes the activity isnt completely ready, by adding a delay
         //! we try to catch up
         QTimer::singleShot(100, [this]() {
             if (m_layout && m_visibility) {
                 m_activities = m_layout->appliedActivities();
                 qDebug() << "DOCK VIEW FROM LAYOUT ::: " << m_layout->name() << " - activities: " << m_activities;
                 applyActivitiesToWindows();
                 emit activitiesChanged();
             }
         });
 
         connectionsLayout << connect(m_layout, &Layout::GenericLayout::preferredViewForShortcutsChanged, this, &View::preferredViewForShortcutsChangedSlot);
         connectionsLayout << connect(m_layout, &Layout::GenericLayout::lastConfigViewForChanged, this, &View::configViewCreatedFor);
 
         Latte::Corona *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
 
         if (latteCorona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             connectionsLayout << connect(latteCorona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged, this, [&]() {
                 if (m_layout && m_visibility) {
                     m_activities = m_layout->appliedActivities();
                     qDebug() << "DOCK VIEW FROM LAYOUT (runningActivitiesChanged) ::: " << m_layout->name()
                              << " - activities: " << m_activities;
                     applyActivitiesToWindows();
                     emit activitiesChanged();
                 }
             });
 
             connectionsLayout << connect(m_layout, &Layout::GenericLayout::activitiesChanged, this, [&]() {
                 if (m_layout) {
                     m_activities = m_layout->appliedActivities();
                     applyActivitiesToWindows();
                     emit activitiesChanged();
                 }
             });
 
             connectionsLayout << connect(latteCorona->layoutsManager(), &Layouts::Manager::layoutsChanged, this, [&]() {
                 if (m_layout) {
                     m_activities = m_layout->appliedActivities();
                     applyActivitiesToWindows();
                     emit activitiesChanged();
                 }
             });
 
             //! BEGIN OF KWIN HACK
             //! IMPORTANT ::: Fixing KWin Faulty Behavior that KWin hides ALL Views when an Activity stops
             //! with no reason!!
 
             m_visibleHackTimer1.setInterval(400);
             m_visibleHackTimer2.setInterval(2500);
             m_visibleHackTimer1.setSingleShot(true);
             m_visibleHackTimer2.setSingleShot(true);
 
             connectionsLayout << connect(this, &QWindow::visibleChanged, this, [&]() {
                 if (m_layout && !inDelete() & !isVisible()) {
                     m_visibleHackTimer1.start();
                     m_visibleHackTimer2.start();
                 }
             });
 
             connectionsLayout << connect(&m_visibleHackTimer1, &QTimer::timeout, this, [&]() {
                 if (m_layout && !inDelete() & !isVisible()) {
                     show();
                     applyActivitiesToWindows();
                     //qDebug() << "View:: Enforce reshow from timer 1...";
                     emit activitiesChanged();
+                    emit forcedShown();
                 } else {
                     //qDebug() << "View:: No needed reshow from timer 1...";
                 }
             });
 
             connectionsLayout << connect(&m_visibleHackTimer2, &QTimer::timeout, this, [&]() {
                 if (m_layout && !inDelete() && !isVisible()) {
                     show();
                     applyActivitiesToWindows();
                     //qDebug() << "View:: Enforce reshow from timer 2...";
                     emit activitiesChanged();
+                    emit forcedShown();
                 } else {
                     //qDebug() << "View:: No needed reshow from timer 2...";
                 }
             });
 
             //! END OF KWIN HACK
         }
 
         emit layoutChanged();
     } else {
         m_activities.clear();
     }
 }
 
 void View::moveToLayout(QString layoutName)
 {
     if (!m_layout) {
         return;
     }
 
     QList<Plasma::Containment *> containments = m_layout->unassignFromLayout(this);
 
     Latte::Corona *latteCorona = qobject_cast<Latte::Corona *>(this->corona());
 
     if (latteCorona && containments.size() > 0) {
         Layout::GenericLayout *newLayout = latteCorona->layoutsManager()->synchronizer()->layout(layoutName);
 
         if (newLayout) {
             newLayout->assignToLayout(this, containments);
         }
     }
 }
 
 void View::setBlockHiding(bool block)
 {
     if (!block) {
         auto *configView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
         if (m_alternativesIsShown || (configView && configView->sticker() && configView->isVisible())) {
             return;
         }
 
         if (m_visibility) {
             m_visibility->setBlockHiding(false);
         }
     } else {
         if (m_visibility) {
             m_visibility->setBlockHiding(true);
         }
     }
 }
 
 void View::configViewCreatedFor(Latte::View *view)
 {
     if (view!=this && m_configView) {
         //! for each layout only one dock should show its configuration windows
         //! otherwise we could reach a point that because a settings window
         //! is below another Latte View its options are not reachable
         auto configDialog = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
         if (configDialog) {
             configDialog->hideConfigWindow();
         }
     }
 }
 
 void View::hideWindowsForSlidingOut()
 {
     setBlockHiding(false);
 
     if (m_configView) {
         auto configDialog = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
         if (configDialog) {
             configDialog->hideConfigWindow();
         }
     }
 }
 
 //! remove latte tasks plasmoid
 void View::removeTasksPlasmoid()
 {
     if (!tasksPresent() || !containment()) {
         return;
     }
 
     for (const Plasma::Applet *applet : containment()->applets()) {
         KPluginMetaData meta = applet->kPackage().metadata();
 
         if (meta.pluginId() == "org.kde.latte.plasmoid") {
             QAction *closeApplet = applet->actions()->action(QStringLiteral("remove"));
 
             if (closeApplet) {
                 closeApplet->trigger();
                 //! remove only the first found
                 return;
             }
         }
     }
 }
 
 //! check if the tasks plasmoid exist in the dock
 bool View::tasksPresent()
 {
     if (!this->containment()) {
         return false;
     }
 
     for (const Plasma::Applet *applet : this->containment()->applets()) {
         const auto &provides = KPluginMetaData::readStringList(applet->pluginMetaData().rawData(), QStringLiteral("X-Plasma-Provides"));
 
         if (provides.contains(QLatin1String("org.kde.plasma.multitasking"))) {
             return true;
         }
     }
 
     return false;
 }
 
 //!check if the plasmoid with _name_ exists in the midedata
 bool View::mimeContainsPlasmoid(QMimeData *mimeData, QString name)
 {
     if (!mimeData) {
         return false;
     }
 
     if (mimeData->hasFormat(QStringLiteral("text/x-plasmoidservicename"))) {
         QString data = mimeData->data(QStringLiteral("text/x-plasmoidservicename"));
         const QStringList appletNames = data.split('\n', QString::SkipEmptyParts);
 
         for (const QString &appletName : appletNames) {
             if (appletName == name)
                 return true;
         }
     }
 
     return false;
 }
 
 ViewPart::Effects *View::effects() const
 {
     return m_effects;
 }
 
 ViewPart::Indicator *View::indicator() const
 {
     return m_indicator;
 }
 
 ViewPart::Positioner *View::positioner() const
 {
     return m_positioner;
 }
 
 ViewPart::VisibilityManager *View::visibility() const
 {
     return m_visibility;
 }
 
 ViewPart::WindowsTracker *View::windowsTracker() const
 {
     return m_windowsTracker;
 }
 
 bool View::event(QEvent *e)
 {   
     if (!m_inDelete) {
         emit eventTriggered(e);
 
         switch (e->type()) {
         case QEvent::Enter:
             m_containsMouse = true;
 
             if (m_configView) {
                 ViewPart::PrimaryConfigView *primaryConfigView = qobject_cast<ViewPart::PrimaryConfigView *>(m_configView);
 
                 if (primaryConfigView) {
                     if (primaryConfigView->secondaryWindow()) {
                         ViewPart::SecondaryConfigView *secConfigView = qobject_cast<ViewPart::SecondaryConfigView *>(primaryConfigView->secondaryWindow());
                         if (secConfigView) {
                             secConfigView->requestActivate();
                         }
                     }
 
                     primaryConfigView->requestActivate();
                 }
             }
             break;
 
         case QEvent::Leave:
             m_containsMouse = false;
             setContainsDrag(false);
             engine()->trimComponentCache();
             break;
 
         case QEvent::DragEnter:
             setContainsDrag(true);
             break;
 
         case QEvent::DragLeave:
         case QEvent::Drop:
             setContainsDrag(false);
             break;
 
         case QEvent::MouseButtonPress:
             if (auto mouseEvent = dynamic_cast<QMouseEvent *>(e)) {
                 emit mousePressed(mouseEvent->pos(), mouseEvent->button());
             }
             break;
         case QEvent::MouseButtonRelease:
             if (auto mouseEvent = dynamic_cast<QMouseEvent *>(e)) {
                 emit mouseReleased(mouseEvent->pos(), mouseEvent->button());
             }
             break;
        /* case QEvent::DragMove:
             qDebug() << "DRAG MOVING>>>>>>";
             break;*/
         case QEvent::PlatformSurface:
             if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
                 switch (pe->surfaceEventType()) {
                 case QPlatformSurfaceEvent::SurfaceCreated:
                     setupWaylandIntegration();
 
                     if (m_shellSurface) {
                         m_positioner->syncGeometry();
                         m_effects->updateShadows();
                     }
 
                     break;
 
                 case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                     if (m_shellSurface) {
                         delete m_shellSurface;
                         m_shellSurface = nullptr;
                         qDebug() << "WAYLAND dock window surface was deleted...";
                         m_effects->clearShadows();
                     }
 
                     break;
                 }
             }
 
             break;
 
         case QEvent::Show:
             m_corona->wm()->setViewExtraFlags(*this);
             break;
 
         default:
             break;
         }
     }
 
     return ContainmentView::event(e);
 }
 
 void View::deactivateApplets()
 {
     if (!containment()) {
         return;
     }
 
     for (const auto applet : containment()->applets()) {
         PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
         if (ai) {
             ai->setExpanded(false);
         }
     }
 }
 
 void View::toggleAppletExpanded(const int id)
 {
     if (!containment()) {
         return;
     }
 
     for (const auto applet : containment()->applets()) {
         if (applet->id() == id) {
             PlasmaQuick::AppletQuickItem *ai = applet->property("_plasma_graphicObject").value<PlasmaQuick::AppletQuickItem *>();
 
             if (ai) {
                 if (!ai->isActivationTogglesExpanded()) {
                     ai->setActivationTogglesExpanded(true);
                 }
 
                 emit applet->activated();
             }
         }
     }
 }
 
 QVariantList View::containmentActions()
 {
     QVariantList actions;
     /*if (containment()->corona()->immutability() != Plasma::Types::Mutable) {
         return actions;
     }*/
     //FIXME: the trigger string it should be better to be supported this way
     //const QString trigger = Plasma::ContainmentActions::eventToString(event);
     const QString trigger = "RightButton;NoModifier";
     Plasma::ContainmentActions *plugin = this->containment()->containmentActions().value(trigger);
 
     if (!plugin) {
         return actions;
     }
 
     if (plugin->containment() != this->containment()) {
         plugin->setContainment(this->containment());
         // now configure it
         KConfigGroup cfg(this->containment()->corona()->config(), "ActionPlugins");
         cfg = KConfigGroup(&cfg, QString::number(this->containment()->containmentType()));
         KConfigGroup pluginConfig = KConfigGroup(&cfg, trigger);
         plugin->restore(pluginConfig);
     }
 
     for (QAction *ac : plugin->contextualActions()) {
         actions << QVariant::fromValue<QAction *>(ac);
     }
 
     return actions;
 }
 
 void View::disableGrabItemBehavior()
 {
     setMouseGrabEnabled(false);
 }
 
 void View::restoreGrabItemBehavior()
 {
     if (mouseGrabberItem()) {
         mouseGrabberItem()->ungrabMouse();
     }
 }
 
 bool View::isHighestPriorityView() {
     if (m_layout) {
         return this == m_layout->highestPriorityView();
     }
 
     return false;
 }
 
 //!BEGIN overriding context menus behavior
 void View::mousePressEvent(QMouseEvent *event)
 {
     bool result = m_contextMenu->mousePressEvent(event);
     emit contextMenuIsShownChanged();
 
     if (result) {
         PlasmaQuick::ContainmentView::mousePressEvent(event);
     }
 }
 //!END overriding context menus behavior
 
 //!BEGIN configuration functions
 void View::saveConfig()
 {
     if (!this->containment())
         return;
 
     auto config = this->containment()->config();
     config.writeEntry("onPrimary", onPrimary());
     config.writeEntry("byPassWM", byPassWM());
     config.writeEntry("isPreferredForShortcuts", isPreferredForShortcuts());
     config.writeEntry("viewType", (int)m_type);
     config.sync();
 }
 
 void View::restoreConfig()
 {
     if (!this->containment())
         return;
 
     auto config = this->containment()->config();
     m_onPrimary = config.readEntry("onPrimary", true);
     m_byPassWM = config.readEntry("byPassWM", false);
     m_isPreferredForShortcuts = config.readEntry("isPreferredForShortcuts", false);
 
     //! Send changed signals at the end in order to be sure that saveConfig
     //! wont rewrite default/invalid values
     emit onPrimaryChanged();
     emit byPassWMChanged();
 }
 //!END configuration functions
 
 }
 //!END namespace
diff --git a/app/view/view.h b/app/view/view.h
index 78aab38e..1ab23b30 100644
--- a/app/view/view.h
+++ b/app/view/view.h
@@ -1,352 +1,353 @@
 /*
 *  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 VIEW_H
 #define VIEW_H
 
 // local
 #include "effects.h"
 #include "positioner.h"
 #include "visibilitymanager.h"
 #include "indicator/indicator.h"
 #include "settings/primaryconfigview.h"
 #include "windowstracker/windowstracker.h"
 #include "../shortcuts/globalshortcuts.h"
 #include "../layout/genericlayout.h"
 #include "../plasma/quick/containmentview.h"
 #include "../plasma/quick/configview.h"
 #include "../../liblatte2/types.h"
 
 // C++
 #include <array>
 
 // Qt
 #include <QQuickView>
 #include <QMenu>
 #include <QMimeData>
 #include <QScreen>
 #include <QPointer>
 #include <QTimer>
 
 namespace Plasma {
 class Types;
 class Corona;
 class Containment;
 }
 
 namespace KWayland {
 namespace Client {
 class PlasmaShellSurface;
 }
 }
 
 namespace Latte {
 class Corona;
 class GenericLayout;
 
 namespace ViewPart {
 class ContextMenu;
 }
 }
 
 namespace Latte {
 
 class View : public PlasmaQuick::ContainmentView
 {
     Q_OBJECT
 
     Q_PROPERTY(Latte::Types::ViewType type READ type WRITE setType NOTIFY typeChanged)
 
     Q_PROPERTY(bool alternativesIsShown READ alternativesIsShown NOTIFY alternativesIsShownChanged)
     Q_PROPERTY(bool behaveAsPlasmaPanel READ behaveAsPlasmaPanel WRITE setBehaveAsPlasmaPanel NOTIFY behaveAsPlasmaPanelChanged)
     Q_PROPERTY(bool byPassWM READ byPassWM WRITE setByPassWM NOTIFY byPassWMChanged)
     Q_PROPERTY(bool containsDrag READ containsDrag NOTIFY containsDragChanged)
     Q_PROPERTY(bool contextMenuIsShown READ contextMenuIsShown NOTIFY contextMenuIsShownChanged)
     //! Because Latte uses animations, changing to edit mode it may be different than
     //! when the isUserConfiguring changes value
     Q_PROPERTY(bool inEditMode READ inEditMode WRITE setInEditMode NOTIFY inEditModeChanged)
     Q_PROPERTY(bool isPreferredForShortcuts READ isPreferredForShortcuts WRITE setIsPreferredForShortcuts NOTIFY isPreferredForShortcutsChanged)
     Q_PROPERTY(bool latteTasksArePresent READ latteTasksArePresent WRITE setLatteTasksArePresent NOTIFY latteTasksArePresentChanged)
     Q_PROPERTY(bool onPrimary READ onPrimary WRITE setOnPrimary NOTIFY onPrimaryChanged)
 
     Q_PROPERTY(int alignment READ alignment WRITE setAlignment NOTIFY alignmentChanged)
     Q_PROPERTY(int fontPixelSize READ fontPixelSize WRITE setFontPixelSize NOTIFY fontPixelSizeChanged)
     Q_PROPERTY(int x READ x NOTIFY xChanged)
     Q_PROPERTY(int y READ y NOTIFY yChanged)
     Q_PROPERTY(int width READ width NOTIFY widthChanged)
     Q_PROPERTY(int height READ height NOTIFY heightChanged)
     Q_PROPERTY(int editThickness READ editThickness WRITE setEditThickness NOTIFY editThicknessChanged)
     Q_PROPERTY(int maxThickness READ maxThickness WRITE setMaxThickness NOTIFY maxThicknessChanged)
     Q_PROPERTY(int normalThickness READ normalThickness WRITE setNormalThickness NOTIFY normalThicknessChanged)
     Q_PROPERTY(int offset READ offset WRITE setOffset NOTIFY offsetChanged)
 
     Q_PROPERTY(float maxLength READ maxLength WRITE setMaxLength NOTIFY maxLengthChanged)
 
     Q_PROPERTY(Latte::Layout::GenericLayout *layout READ layout WRITE setLayout NOTIFY layoutChanged)
     Q_PROPERTY(Latte::ViewPart::Effects *effects READ effects NOTIFY effectsChanged)
     Q_PROPERTY(Latte::ViewPart::Indicator *indicator READ indicator NOTIFY indicatorChanged)
     Q_PROPERTY(Latte::ViewPart::Positioner *positioner READ positioner NOTIFY positionerChanged)
     Q_PROPERTY(Latte::ViewPart::VisibilityManager *visibility READ visibility NOTIFY visibilityChanged)
     Q_PROPERTY(Latte::ViewPart::WindowsTracker *windowsTracker READ windowsTracker NOTIFY windowsTrackerChanged)
 
     Q_PROPERTY(QRect absoluteGeometry READ absoluteGeometry NOTIFY absoluteGeometryChanged)
     Q_PROPERTY(QRect localGeometry READ localGeometry WRITE setLocalGeometry NOTIFY localGeometryChanged)
     Q_PROPERTY(QRect screenGeometry READ screenGeometry NOTIFY screenGeometryChanged)
 
 public:
     View(Plasma::Corona *corona, QScreen *targetScreen = nullptr, bool byPassWM = false);
     virtual ~View();
 
     void init();
 
     Types::ViewType type() const;
     void setType(Types::ViewType type);
 
     bool alternativesIsShown() const;
     void setAlternativesIsShown(bool show);
 
     bool inDelete() const;
 
     bool onPrimary() const;
     void setOnPrimary(bool flag);
 
     int currentThickness() const;
 
     bool behaveAsPlasmaPanel() const;
     void setBehaveAsPlasmaPanel(bool behavior);
 
     bool containsDrag() const;
     bool containsMouse() const;
 
     bool contextMenuIsShown() const;
 
     bool byPassWM() const;
     void setByPassWM(bool bypass);
 
     bool inEditMode() const;
     void setInEditMode(bool edit);
 
     bool isPreferredForShortcuts() const;
     void setIsPreferredForShortcuts(bool preferred);
 
     bool latteTasksArePresent() const;
     void setLatteTasksArePresent(bool present);
 
     float maxLength() const;
     void setMaxLength(float length);
 
     int fontPixelSize() const;
     void setFontPixelSize(int size);
 
     int editThickness() const;
     void setEditThickness(int thickness);
 
     int maxThickness() const;
     void setMaxThickness(int thickness);
 
     int normalThickness() const;
     void setNormalThickness(int thickness);
 
     int offset() const;
     void setOffset(int offset);
 
     int alignment() const;
     void setAlignment(int alignment);
 
     QRect absoluteGeometry() const;
     QRect screenGeometry() const;
 
     QRect localGeometry() const;
     void setLocalGeometry(const QRect &geometry);
 
     bool isOnActivity(const QString &activity) const;
     bool isOnAllActivities() const;
     QStringList activities() const;
 
     bool settingsWindowIsShown();
     void showSettingsWindow();
 
     PlasmaQuick::ConfigView *configView();
 
     ViewPart::Effects *effects() const;
     ViewPart::Indicator *indicator() const;
     ViewPart::Positioner *positioner() const;
     ViewPart::VisibilityManager *visibility() const;
     ViewPart::WindowsTracker *windowsTracker() const;
 
     Layout::GenericLayout *layout() const;
     void setLayout(Layout::GenericLayout *layout);
 
     KWayland::Client::PlasmaShellSurface *surface();
 
     void reconsiderScreen();
 
     //! these are signals that create crashes, such a example is the availableScreenRectChanged from corona
     //! when its containment is destroyed
     void disconnectSensitiveSignals();
 
 public slots:
     Q_INVOKABLE void copyView();
     Q_INVOKABLE void removeView();
 
     Q_INVOKABLE QVariantList containmentActions();
 
     Q_INVOKABLE void deactivateApplets();
     Q_INVOKABLE void moveToLayout(QString layoutName);
     Q_INVOKABLE void removeTasksPlasmoid();
     Q_INVOKABLE void setBlockHiding(bool block);
     Q_INVOKABLE void toggleAppletExpanded(const int id);
 
     Q_INVOKABLE bool mimeContainsPlasmoid(QMimeData *mimeData, QString name);
     Q_INVOKABLE bool tasksPresent();
 
     void updateAbsoluteGeometry(bool bypassChecks = false);
 
     Q_INVOKABLE void disableGrabItemBehavior();
     Q_INVOKABLE void restoreGrabItemBehavior();
 
     Q_INVOKABLE bool isHighestPriorityView();
 
 protected slots:
     void showConfigurationInterface(Plasma::Applet *applet) override;
 
 protected:
     bool event(QEvent *ev) override;
     void mousePressEvent(QMouseEvent *event) override;
 
 signals:
     void eventTriggered(QEvent *ev);
     void mousePressed(const QPoint pos, const int button);
     void mouseReleased(const QPoint pos, const int button);
 
     void activitiesChanged();
     void alternativesIsShownChanged();
     void alignmentChanged();
     void behaveAsPlasmaPanelChanged();
     void byPassWMChanged();
     void configWindowGeometryChanged(); // is called from config windows
     void containsDragChanged();
     void contextMenuIsShownChanged();
     void dockLocationChanged();
     void editThicknessChanged();
     void effectsChanged();
     void fontPixelSizeChanged();
+    void forcedShown(); //[workaround] forced shown to avoid a KWin issue that hides windows when closing activities
     void widthChanged();
     void heightChanged();
     void inEditModeChanged();
     void indicatorChanged();
     void isPreferredForShortcutsChanged();
     void latteTasksArePresentChanged();
     void layoutChanged();
     void localGeometryChanged();
     void maxLengthChanged();
     void maxThicknessChanged();
     void normalThicknessChanged();
     void offsetChanged();
     void onPrimaryChanged();
     void positionerChanged();
     void screenGeometryChanged();
     void typeChanged();
     void visibilityChanged();
     void windowsTrackerChanged();
     void xChanged();
     void yChanged();
 
     void absoluteGeometryChanged(const QRect &geometry);
 
     //! pass on signals to children in order to avoid crashes when View is recreated or destroyed
     void availableScreenRectChangedForViewParts();
     void customPluginsChanged();
 
 private slots:
     void availableScreenRectChangedFrom(View *origin);
     void configViewCreatedFor(Latte::View *view);
     void hideWindowsForSlidingOut();
     void preferredViewForShortcutsChangedSlot(Latte::View *view);
     void reloadSource();
     void statusChanged(Plasma::Types::ItemStatus);
 
     void restoreConfig();
     void saveConfig();
 
 private:
     void applyActivitiesToWindows();
     void initSignalingForLocationChangeSliding();
     void setupWaylandIntegration();
     void updateAppletContainsMethod();
 
     void setContainsDrag(bool contains);
 
 private:
     Plasma::Containment *containmentById(uint id);
 
     bool m_alternativesIsShown{false};
     bool m_behaveAsPlasmaPanel{false};
     bool m_byPassWM{true};
     bool m_containsDrag{false};
     bool m_containsMouse{false};
     bool m_inDelete{false};
     bool m_inEditMode{false};
     bool m_isPreferredForShortcuts{false};
     bool m_latteTasksArePresent{false};
     bool m_onPrimary{true};
 
     int m_fontPixelSize{ -1};
     int m_editThickness{24};
     int m_maxThickness{24};
     int m_normalThickness{24};
     int m_offset{0};
     float m_maxLength{1};
 
     Types::Alignment m_alignment{Types::Center};
     Types::ViewType m_type{Types::DockView};
 
     QRect m_localGeometry;
     QRect m_absoluteGeometry;
 
     QStringList m_activities;
 
     //! HACK: Timers in order to handle KWin faulty
     //! behavior that hides Views when closing Activities
     //! with no actual reason
     QTimer m_visibleHackTimer1;
     QTimer m_visibleHackTimer2;
 
     Layout::GenericLayout *m_layout{nullptr};
     QPointer<PlasmaQuick::ConfigView> m_configView;
 
     QPointer<ViewPart::ContextMenu> m_contextMenu;
     QPointer<ViewPart::Effects> m_effects;
     QPointer<ViewPart::Indicator> m_indicator;
     QPointer<ViewPart::Positioner> m_positioner;
     QPointer<ViewPart::VisibilityManager> m_visibility;
     QPointer<ViewPart::WindowsTracker> m_windowsTracker;
 
     //! Connections to release and bound for the assigned layout
     QList<QMetaObject::Connection> connectionsLayout;
 
     QPointer<Latte::Corona> m_corona;
 
     KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
 };
 
 }
 
 #endif
diff --git a/app/view/visibilitymanager.cpp b/app/view/visibilitymanager.cpp
index 7af00d6c..7e9b41b6 100644
--- a/app/view/visibilitymanager.cpp
+++ b/app/view/visibilitymanager.cpp
@@ -1,770 +1,771 @@
 /*
 *  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 "visibilitymanager.h"
 
 // local
 #include "positioner.h"
 #include "screenedgeghostwindow.h"
 #include "view.h"
 #include "windowstracker/currentscreentracker.h"
 #include "../lattecorona.h"
 #include "../screenpool.h"
 #include "../layouts/manager.h"
 #include "../wm/abstractwindowinterface.h"
 #include "../../liblatte2/extras.h"
 
 // Qt
 #include <QDebug>
 
 // KDE
 #include <KWindowSystem>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 
 namespace Latte {
 namespace ViewPart {
 
 //! BEGIN: VisiblityManager implementation
 
 VisibilityManager::VisibilityManager(PlasmaQuick::ContainmentView *view)
     : QObject(view)
 {
     qDebug() << "VisibilityManager creating...";
 
     m_latteView = qobject_cast<Latte::View *>(view);
     m_corona = qobject_cast<Latte::Corona *>(view->corona());
     m_wm = m_corona->wm();
 
     connect(this, &VisibilityManager::slideInFinished, this, &VisibilityManager::updateHiddenState);
     connect(this, &VisibilityManager::slideOutFinished, this, &VisibilityManager::updateHiddenState);
 
+    connect(this, &VisibilityManager::enableKWinEdgesChanged, this, &VisibilityManager::updateKWinEdgesSupport);
+    connect(this, &VisibilityManager::modeChanged, this, &VisibilityManager::updateKWinEdgesSupport);
+
     if (m_latteView) {
         connect(m_latteView, &Latte::View::eventTriggered, this, &VisibilityManager::viewEventManager);
         connect(m_latteView, &Latte::View::byPassWMChanged, this, &VisibilityManager::updateKWinEdgesSupport);
 
         connect(m_latteView, &Latte::View::absoluteGeometryChanged, this, [&]() {
             if (m_mode == Types::AlwaysVisible && m_latteView->screen()) {
                 updateStrutsBasedOnLayoutsAndActivities();
             }
         });
 
         connect(m_latteView->windowsTracker(), &WindowsTracker::activeWindowDraggingStarted,
                 this, &VisibilityManager::activeWindowDraggingStarted);
     }
 
     if (m_corona) {
         connect(this, &VisibilityManager::modeChanged, this, [&]() {
             emit m_corona->availableScreenRectChangedFrom(m_latteView);
         });
     }
 
     m_timerStartUp.setInterval(5000);
     m_timerStartUp.setSingleShot(true);
     m_timerShow.setSingleShot(true);
     m_timerHide.setSingleShot(true);
 
     connect(&m_timerShow, &QTimer::timeout, this, [&]() {
         if (m_isHidden) {
             //   qDebug() << "must be shown";
             emit mustBeShown();
         }
     });
     connect(&m_timerHide, &QTimer::timeout, this, [&]() {
         if (!m_blockHiding && !m_isHidden && !m_dragEnter) {
             //   qDebug() << "must be hide";
             emit mustBeHide();
         }
     });
 
     restoreConfig();
 }
 
 VisibilityManager::~VisibilityManager()
 {
     qDebug() << "VisibilityManager deleting...";
     m_wm->removeViewStruts(*m_latteView);
 
     if (m_edgeGhostWindow) {
         m_edgeGhostWindow->deleteLater();
     }
 }
 
 Types::Visibility VisibilityManager::mode() const
 {
     return m_mode;
 }
 
 void VisibilityManager::setMode(Latte::Types::Visibility mode)
 {
     if (m_mode == mode)
         return;
 
     Q_ASSERT_X(mode != Types::None, staticMetaObject.className(), "set visibility to Types::None");
 
     // clear mode
     for (auto &c : m_connections) {
         disconnect(c);
     }
 
     int base{0};
 
     m_publishedStruts = QRect();
 
     if (m_mode == Types::AlwaysVisible) {
         //! remove struts for old always visible mode
         m_wm->removeViewStruts(*m_latteView);
     }
 
     m_timerShow.stop();
     m_timerHide.stop();
     m_mode = mode;
 
     if (mode != Types::AlwaysVisible && mode != Types::WindowsGoBelow) {
         //set wayland visibility mode
         if (m_latteView->surface()) {
             m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::WindowsGoBelow);
         }
 
         m_connections[0] = connect(m_wm, &WindowSystem::AbstractWindowInterface::currentDesktopChanged, this, [&] {
             if (m_raiseOnDesktopChange) {
                 raiseViewTemporarily();
             }
         });
         m_connections[1] = connect(m_wm, &WindowSystem::AbstractWindowInterface::currentActivityChanged, this, [&]() {
             if (m_raiseOnActivityChange) {
                 raiseViewTemporarily();
             } else {
                 updateHiddenState();
             }
         });
 
         base = 2;
     } else {
         //set wayland visibility mode
         if (m_latteView->surface()) {
             m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::AutoHide);
         }
     }
 
     switch (m_mode) {
     case Types::AlwaysVisible: {
         if (m_latteView->containment() && m_latteView->screen()) {
             updateStrutsBasedOnLayoutsAndActivities();
         }
 
 
         m_connections[base] = connect(m_corona->layoutsManager(),  &Layouts::Manager::currentLayoutNameChanged, this, [&]() {
             if (m_corona && m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
                 updateStrutsBasedOnLayoutsAndActivities(true);
             }
         });
 
         m_connections[base+1] = connect(m_latteView, &Latte::View::activitiesChanged, this, [&]() {
             if (m_corona && m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
                 updateStrutsBasedOnLayoutsAndActivities(true);
             }
         });
 
         raiseView(true);
         break;
     }
 
     case Types::AutoHide: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged, this, [&]() {
             raiseView(m_containsMouse);
         });
 
         raiseView(m_containsMouse);
         break;
     }
 
     case Types::DodgeActive: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged
                                       , this, &VisibilityManager::dodgeActive);
         m_connections[base+1] = connect(m_latteView->windowsTracker()->currentScreen(), &TrackerPart::CurrentScreenTracker::activeWindowTouchingChanged
                                         , this, &VisibilityManager::dodgeActive);
 
         dodgeActive();
         break;
     }
 
     case Types::DodgeMaximized: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged
                                       , this, &VisibilityManager::dodgeMaximized);
         m_connections[base+1] = connect(m_latteView->windowsTracker()->currentScreen(), &TrackerPart::CurrentScreenTracker::activeWindowMaximizedChanged
                                         , this, &VisibilityManager::dodgeMaximized);
 
         dodgeMaximized();
         break;
     }
 
     case Types::DodgeAllWindows: {
         m_connections[base] = connect(this, &VisibilityManager::containsMouseChanged
                                       , this, &VisibilityManager::dodgeAllWindows);
 
         m_connections[base+1] = connect(m_latteView->windowsTracker()->currentScreen(), &TrackerPart::CurrentScreenTracker::existsWindowTouchingChanged
                                         , this, &VisibilityManager::dodgeAllWindows);
 
         dodgeAllWindows();
         break;
     }
 
     case Types::WindowsGoBelow:
         break;
 
     default:
         break;
     }
 
     m_latteView->containment()->config().writeEntry("visibility", static_cast<int>(m_mode));
 
     updateKWinEdgesSupport();
 
     emit modeChanged();
 }
 
 void VisibilityManager::updateStrutsBasedOnLayoutsAndActivities(bool forceUpdate)
 {
     bool multipleLayoutsAndCurrent = (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts
                                       && m_latteView->layout() && !m_latteView->positioner()->inLocationChangeAnimation()
                                       && m_latteView->layout()->isCurrent());
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout || multipleLayoutsAndCurrent) {
         QRect computedStruts = acceptableStruts();
         if (m_publishedStruts != computedStruts || forceUpdate) {
             //! Force update is needed when very important events happen in DE and there is a chance
             //! that previously even though struts where sent the DE did not accept them.
             //! Such a case is when STOPPING an Activity and windows faulty become invisible even
             //! though they should not. In such case setting struts when the windows are hidden
             //! the struts do not take any effect
             m_publishedStruts = computedStruts;
             m_wm->setViewStruts(*m_latteView, m_publishedStruts, m_latteView->location());
         }
     } else {
         m_publishedStruts = QRect();
         m_wm->removeViewStruts(*m_latteView);
     }
 }
 
 QRect VisibilityManager::acceptableStruts()
 {
     QRect calcs;
 
     switch (m_latteView->location()) {
         case Plasma::Types::TopEdge: {
             calcs = QRect(m_latteView->x(), m_latteView->y(), m_latteView->width(), m_latteView->normalThickness());
             break;
         }
 
         case Plasma::Types::BottomEdge: {
             int y = m_latteView->y() + m_latteView->height() - m_latteView->normalThickness();
             calcs = QRect(m_latteView->x(), y, m_latteView->width(), m_latteView->normalThickness());
             break;
         }
 
         case Plasma::Types::LeftEdge: {
             calcs = QRect(m_latteView->x(), m_latteView->y(), m_latteView->normalThickness(), m_latteView->height());
             break;
         }
 
         case Plasma::Types::RightEdge: {
             int x = m_latteView->x() + m_latteView->width() - m_latteView->normalThickness();
             calcs = QRect(x, m_latteView->y(), m_latteView->normalThickness(), m_latteView->height());
             break;
         }
     }
 
     return calcs;
 }
 
 bool VisibilityManager::raiseOnDesktop() const
 {
     return m_raiseOnDesktopChange;
 }
 
 void VisibilityManager::setRaiseOnDesktop(bool enable)
 {
     if (enable == m_raiseOnDesktopChange)
         return;
 
     m_raiseOnDesktopChange = enable;
     emit raiseOnDesktopChanged();
 }
 
 bool VisibilityManager::raiseOnActivity() const
 {
     return m_raiseOnActivityChange;
 }
 
 void VisibilityManager::setRaiseOnActivity(bool enable)
 {
     if (enable == m_raiseOnActivityChange)
         return;
 
     m_raiseOnActivityChange = enable;
     emit raiseOnActivityChanged();
 }
 
 bool VisibilityManager::isHidden() const
 {
     return m_isHidden;
 }
 
 void VisibilityManager::setIsHidden(bool isHidden)
 {
     if (m_isHidden == isHidden)
         return;
 
     if (m_blockHiding && isHidden) {
         qWarning() << "isHidden property is blocked, ignoring update";
         return;
     }
 
     m_isHidden = isHidden;
 
     updateGhostWindowState();
 
     emit isHiddenChanged();
 }
 
 bool VisibilityManager::blockHiding() const
 {
     return m_blockHiding;
 }
 
 void VisibilityManager::setBlockHiding(bool blockHiding)
 {
     if (m_blockHiding == blockHiding) {
         return;
     }
 
     m_blockHiding = blockHiding;
     // qDebug() << "blockHiding:" << blockHiding;
 
     if (m_blockHiding) {
         m_timerHide.stop();
 
         if (m_isHidden) {
             emit mustBeShown();
         }
     } else {
         updateHiddenState();
     }
 
     emit blockHidingChanged();
 }
 
 int VisibilityManager::timerShow() const
 {
     return m_timerShow.interval();
 }
 
 void VisibilityManager::setTimerShow(int msec)
 {
     m_timerShow.setInterval(msec);
     emit timerShowChanged();
 }
 
 int VisibilityManager::timerHide() const
 {
     return m_timerHide.interval();
 }
 
 void VisibilityManager::setTimerHide(int msec)
 {
     m_timerHide.setInterval(msec);
     emit timerHideChanged();
 }
 
 bool VisibilityManager::supportsKWinEdges() const
 {
     return (m_edgeGhostWindow != nullptr);
 }
 
 void VisibilityManager::updateGhostWindowState()
 {
     if (supportsKWinEdges()) {
         bool inCurrentLayout = (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout ||
                                 (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts
                                  && m_latteView->layout() && !m_latteView->positioner()->inLocationChangeAnimation()
-                                 && m_latteView->layout()->name() == m_corona->layoutsManager()->currentLayoutName()));
+                                 && m_latteView->layout()->isCurrent()));
 
         if (inCurrentLayout) {
             m_wm->setEdgeStateFor(m_edgeGhostWindow, m_isHidden);
         } else {
             m_wm->setEdgeStateFor(m_edgeGhostWindow, false);
         }
     }
 }
 
 void VisibilityManager::hide()
 {
     if (KWindowSystem::isPlatformX11()) {
         m_latteView->hide();
     }
 }
 
 void VisibilityManager::show()
 {
     if (KWindowSystem::isPlatformX11()) {
         m_latteView->show();
     }
 }
 
 
 void VisibilityManager::raiseView(bool raise)
 {
     if (m_blockHiding)
         return;
 
     if (raise) {
         m_timerHide.stop();
 
         if (!m_timerShow.isActive()) {
             m_timerShow.start();
         }
     } else if (!m_dragEnter) {
         m_timerShow.stop();
 
         if (m_hideNow) {
             m_hideNow = false;
             emit mustBeHide();
         } else if (!m_timerHide.isActive()) {
             m_timerHide.start();
         }
     }
 }
 
 void VisibilityManager::raiseViewTemporarily()
 {
     if (m_raiseTemporarily)
         return;
 
     m_raiseTemporarily = true;
     m_timerHide.stop();
     m_timerShow.stop();
 
     if (m_isHidden)
         emit mustBeShown();
 
     QTimer::singleShot(qBound(1800, 2 * m_timerHide.interval(), 3000), this, [&]() {
         m_raiseTemporarily = false;
         m_hideNow = true;
         updateHiddenState();
     });
 }
 
 void VisibilityManager::updateHiddenState()
 {
     if (m_dragEnter)
         return;
 
     switch (m_mode) {
     case Types::AutoHide:
         raiseView(m_containsMouse);
         break;
 
     case Types::DodgeActive:
         dodgeActive();
         break;
 
     case Types::DodgeMaximized:
         dodgeMaximized();
         break;
 
     case Types::DodgeAllWindows:
         dodgeAllWindows();
         break;
 
     default:
         break;
     }
 }
 
 void VisibilityManager::applyActivitiesToHiddenWindows(const QStringList &activities)
 {
     if (m_edgeGhostWindow) {
         m_wm->setWindowOnActivities(*m_edgeGhostWindow, activities);
     }
 }
 
 void VisibilityManager::activeWindowDraggingStarted()
 {
     setContainsMouse(false);
     updateHiddenState();
 }
 
 void VisibilityManager::dodgeActive()
 {
     if (m_raiseTemporarily)
         return;
 
     //!don't send false raiseView signal when containing mouse
     if (m_containsMouse) {
         raiseView(true);
         return;
     }
 
     raiseView(!m_latteView->windowsTracker()->currentScreen()->activeWindowTouching());
 }
 
 void VisibilityManager::dodgeMaximized()
 {
     if (m_raiseTemporarily)
         return;
 
     //!don't send false raiseView signal when containing mouse
     if (m_containsMouse) {
         raiseView(true);
         return;
     }
 
     raiseView(!m_latteView->windowsTracker()->currentScreen()->activeWindowMaximized());
 }
 
 void VisibilityManager::dodgeAllWindows()
 {
     if (m_raiseTemporarily)
         return;
 
     if (m_containsMouse) {
         raiseView(true);
     }
 
     bool windowIntersects{m_latteView->windowsTracker()->currentScreen()->activeWindowTouching() || m_latteView->windowsTracker()->currentScreen()->existsWindowTouching()};
 
     raiseView(!windowIntersects);
 }
 
 void VisibilityManager::saveConfig()
 {
     if (!m_latteView->containment())
         return;
 
     auto config = m_latteView->containment()->config();
 
     config.writeEntry("enableKWinEdges", m_enableKWinEdgesFromUser);
     config.writeEntry("timerShow", m_timerShow.interval());
     config.writeEntry("timerHide", m_timerHide.interval());
     config.writeEntry("raiseOnDesktopChange", m_raiseOnDesktopChange);
     config.writeEntry("raiseOnActivityChange", m_raiseOnActivityChange);
 
     m_latteView->containment()->configNeedsSaving();
 }
 
 void VisibilityManager::restoreConfig()
 {
     if (!m_latteView || !m_latteView->containment()){
         return;
     }
 
     auto config = m_latteView->containment()->config();
     m_timerShow.setInterval(config.readEntry("timerShow", 0));
     m_timerHide.setInterval(config.readEntry("timerHide", 700));
     emit timerShowChanged();
     emit timerHideChanged();
 
     m_enableKWinEdgesFromUser = config.readEntry("enableKWinEdges", true);
     emit enableKWinEdgesChanged();
 
     setRaiseOnDesktop(config.readEntry("raiseOnDesktopChange", false));
     setRaiseOnActivity(config.readEntry("raiseOnActivityChange", false));
 
     auto storedMode = static_cast<Types::Visibility>(m_latteView->containment()->config().readEntry("visibility", static_cast<int>(Types::DodgeActive)));
 
     if (storedMode == Types::AlwaysVisible) {
         qDebug() << "Loading visibility mode: Always Visible , on startup...";
         setMode(Types::AlwaysVisible);
     } else {
         connect(&m_timerStartUp, &QTimer::timeout, this, [&]() {
             if (!m_latteView || !m_latteView->containment()) {
                 return;
             }
 
             auto fMode = static_cast<Types::Visibility>(m_latteView->containment()->config().readEntry("visibility", static_cast<int>(Types::DodgeActive)));
             qDebug() << "Loading visibility mode:" << fMode << " on startup...";
             setMode(fMode);
         });
         connect(m_latteView->containment(), &Plasma::Containment::userConfiguringChanged
                 , this, [&](bool configuring) {
             if (configuring && m_timerStartUp.isActive())
                 m_timerStartUp.start(100);
         });
 
         m_timerStartUp.start();
     }
 
     connect(m_latteView->containment(), &Plasma::Containment::userConfiguringChanged
             , this, [&](bool configuring) {
         if (!configuring) {
             saveConfig();
         }
     });
 }
 
 bool VisibilityManager::containsMouse() const
 {
     return m_containsMouse;
 }
 
 void VisibilityManager::setContainsMouse(bool contains)
 {
     if (m_containsMouse == contains) {
         return;
     }
 
     m_containsMouse = contains;
     emit containsMouseChanged();
 
     if (contains && m_mode != Types::AlwaysVisible) {
         raiseView(true);
     }
 }
 
 void VisibilityManager::viewEventManager(QEvent *ev)
 {
     switch (ev->type()) {
     case QEvent::Enter:
         setContainsMouse(true);
         break;
 
     case QEvent::Leave:
         m_dragEnter = false;
         setContainsMouse(false);
         break;
 
     case QEvent::DragEnter:
         m_dragEnter = true;
 
         if (m_isHidden) {
             emit mustBeShown();
         }
 
         break;
 
     case QEvent::DragLeave:
     case QEvent::Drop:
         m_dragEnter = false;
         updateHiddenState();
         break;
 
     default:
         break;
     }
 }
 
 //! KWin Edges Support functions
 bool VisibilityManager::enableKWinEdges() const
 {
     return m_enableKWinEdgesFromUser;
 }
 
 void VisibilityManager::setEnableKWinEdges(bool enable)
 {
     if (m_enableKWinEdgesFromUser == enable) {
         return;
     }
 
     m_enableKWinEdgesFromUser = enable;
 
     emit enableKWinEdgesChanged();
-
-    updateKWinEdgesSupport();
 }
 
 void VisibilityManager::updateKWinEdgesSupport()
 {
     if ((m_mode == Types::AutoHide
             || m_mode == Types::DodgeActive
             || m_mode == Types::DodgeAllWindows
             || m_mode == Types::DodgeMaximized)
             && (!m_latteView->byPassWM()) ) {
         if (m_enableKWinEdgesFromUser) {
             createEdgeGhostWindow();
         } else if (!m_enableKWinEdgesFromUser) {
             deleteEdgeGhostWindow();
         }
     } else if (m_mode == Types::AlwaysVisible
                || m_mode == Types::WindowsGoBelow) {
         deleteEdgeGhostWindow();
     }
 }
 
 void VisibilityManager::createEdgeGhostWindow()
 {
     if (!m_edgeGhostWindow) {
         m_edgeGhostWindow = new ScreenEdgeGhostWindow(m_latteView);
 
         m_wm->setViewExtraFlags(*m_edgeGhostWindow);
 
         connect(m_edgeGhostWindow, &ScreenEdgeGhostWindow::containsMouseChanged, this, [ = ](bool contains) {
             if (contains) {
                 raiseView(true);
             } else {
                 m_timerShow.stop();
                 updateGhostWindowState();
             }
         });
 
         connect(m_edgeGhostWindow, &ScreenEdgeGhostWindow::dragEntered, this, [&]() {
             if (m_isHidden) {
                 emit mustBeShown();
             }
         });
 
         m_connectionsKWinEdges[0] = connect(m_wm, &WindowSystem::AbstractWindowInterface::currentActivityChanged,
                                             this, [&]() {
             bool inCurrentLayout = (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout ||
                                     (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts
                                      && m_latteView->layout() && !m_latteView->positioner()->inLocationChangeAnimation()
-                                     && m_latteView->layout()->name() == m_corona->layoutsManager()->currentLayoutName()));
+                                     && m_latteView->layout()->isCurrent()));
 
             if (m_edgeGhostWindow) {
                 if (inCurrentLayout) {
                     m_wm->setEdgeStateFor(m_edgeGhostWindow, m_isHidden);
                 } else {
                     m_wm->setEdgeStateFor(m_edgeGhostWindow, false);
                 }
             }
         });
 
         emit supportsKWinEdgesChanged();
     }
 }
 
 void VisibilityManager::deleteEdgeGhostWindow()
 {
     if (m_edgeGhostWindow) {
         m_edgeGhostWindow->deleteLater();
         m_edgeGhostWindow = nullptr;
 
         for (auto &c : m_connectionsKWinEdges) {
             disconnect(c);
         }
 
         emit supportsKWinEdgesChanged();
     }
 }
 
 //! END: VisibilityManager implementation
 
 }
 }
diff --git a/app/wm/abstractwindowinterface.cpp b/app/wm/abstractwindowinterface.cpp
index ce6ab212..11c0b9b1 100644
--- a/app/wm/abstractwindowinterface.cpp
+++ b/app/wm/abstractwindowinterface.cpp
@@ -1,184 +1,187 @@
 /*
 *  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 "abstractwindowinterface.h"
 
 // local
 #include "tracker/schemes.h"
 #include "tracker/trackerwindows.h"
 #include "../lattecorona.h"
 
+// Qt
+#include <QDebug>
+
 // KDE
 #include <KActivities/Controller>
 
 namespace Latte {
 namespace WindowSystem {
 
 AbstractWindowInterface::AbstractWindowInterface(QObject *parent)
     : QObject(parent)
 {
     m_activities = new KActivities::Consumer(this);
     m_currentActivity = m_activities->currentActivity();
 
     m_corona = qobject_cast<Latte::Corona *>(parent);
     m_windowsTracker = new Tracker::Windows(this);
     m_schemesTracker = new Tracker::Schemes(this);
 
     rulesConfig = KSharedConfig::openConfig(QStringLiteral("taskmanagerrulesrc"));
 
     m_windowWaitingTimer.setInterval(150);
     m_windowWaitingTimer.setSingleShot(true);
 
     connect(&m_windowWaitingTimer, &QTimer::timeout, this, [&]() {
         WindowId wid = m_windowChangedWaiting;
         m_windowChangedWaiting = QVariant();
         emit windowChanged(wid);
     });
 
    // connect(this, &AbstractWindowInterface::windowChanged, this, [&](WindowId wid) {
    //     qDebug() << "WINDOW CHANGED ::: " << wid;
    // });
 
     connect(m_activities.data(), &KActivities::Consumer::currentActivityChanged, this, [&](const QString &id) {
         m_currentActivity = id;
         emit currentActivityChanged();
     });
 
 }
 
 AbstractWindowInterface::~AbstractWindowInterface()
 {
     m_windowWaitingTimer.stop();
 
     m_schemesTracker->deleteLater();
     m_windowsTracker->deleteLater();
 }
 
 QString AbstractWindowInterface::currentDesktop() const
 {
     return m_currentDesktop;
 }
 
 QString AbstractWindowInterface::currentActivity() const
 {
     return m_currentActivity;
 }
 
 Latte::Corona *AbstractWindowInterface::corona()
 {
     return m_corona;
 }
 
 Tracker::Schemes *AbstractWindowInterface::schemesTracker()
 {
     return m_schemesTracker;
 }
 
 Tracker::Windows *AbstractWindowInterface::windowsTracker() const
 {
     return m_windowsTracker;
 }
 
 //! Register Latte Ignored Windows in order to NOT be tracked
 void AbstractWindowInterface::registerIgnoredWindow(WindowId wid)
 {
     if (!wid.isNull() && !m_ignoredWindows.contains(wid)) {
         m_ignoredWindows.append(wid);
         emit windowChanged(wid);
     }
 }
 
 void AbstractWindowInterface::unregisterIgnoredWindow(WindowId wid)
 {
     if (m_ignoredWindows.contains(wid)) {
         m_ignoredWindows.removeAll(wid);
         emit windowRemoved(wid);
     }
 }
 
 
 //! Activities switching
 void AbstractWindowInterface::switchToNextActivity()
 {
     QStringList runningActivities = m_activities->activities(KActivities::Info::State::Running);
     if (runningActivities.count() <= 1) {
         return;
     }
 
     int curPos = runningActivities.indexOf(m_currentActivity);
     int nextPos = curPos + 1;
 
     if (curPos == runningActivities.count() -1) {
         nextPos = 0;
     }
 
     KActivities::Controller activitiesController;
     activitiesController.setCurrentActivity(runningActivities.at(nextPos));
 }
 
 void AbstractWindowInterface::switchToPreviousActivity()
 {
     QStringList runningActivities = m_activities->activities(KActivities::Info::State::Running);
     if (runningActivities.count() <= 1) {
         return;
     }
 
     int curPos = runningActivities.indexOf(m_currentActivity);
     int nextPos = curPos - 1;
 
     if (curPos == 0) {
         nextPos = runningActivities.count() - 1;
     }
 
     KActivities::Controller activitiesController;
     activitiesController.setCurrentActivity(runningActivities.at(nextPos));
 }
 
 //! Delay window changed trigerring
 void AbstractWindowInterface::considerWindowChanged(WindowId wid)
 {
     //! Consider if the windowChanged signal should be sent DIRECTLY or WAIT
 
     if (m_windowChangedWaiting == wid && m_windowWaitingTimer.isActive()) {
         //! window should be sent later
         m_windowWaitingTimer.start();
         return;
     }
 
     if (m_windowChangedWaiting != wid && !m_windowWaitingTimer.isActive()) {
         //! window should be sent later
         m_windowChangedWaiting = wid;
         m_windowWaitingTimer.start();
     }
 
     if (m_windowChangedWaiting != wid && m_windowWaitingTimer.isActive()) {
         m_windowWaitingTimer.stop();
         //! sent previous waiting window
         emit windowChanged(m_windowChangedWaiting);
 
         //! retrigger waiting for the upcoming window
         m_windowChangedWaiting = wid;
         m_windowWaitingTimer.start();
     }
 }
 
 }
 }
 
diff --git a/app/wm/tracker/trackerwindows.cpp b/app/wm/tracker/trackerwindows.cpp
index 34d19bf1..efed57c9 100644
--- a/app/wm/tracker/trackerwindows.cpp
+++ b/app/wm/tracker/trackerwindows.cpp
@@ -1,913 +1,915 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "trackerwindows.h"
 
 // local
 #include "lastactivewindow.h"
 #include "schemes.h"
 #include "trackedlayoutinfo.h"
 #include "trackedviewinfo.h"
 #include "../abstractwindowinterface.h"
 #include "../schemecolors.h"
 #include "../../lattecorona.h"
 #include "../../layout/genericlayout.h"
 #include "../../layouts/manager.h"
 #include "../../view/view.h"
 #include "../../view/positioner.h"
 #include "../../../liblatte2/types.h"
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 Windows::Windows(AbstractWindowInterface *parent)
     : QObject(parent)
 {
     m_wm = parent;
 
     init();
 }
 
 Windows::~Windows()
 {
     //! clear all the m_views tracking information
     for (QHash<Latte::View *, TrackedViewInfo *>::iterator i=m_views.begin(); i!=m_views.end(); ++i) {
         i.value()->deleteLater();
         m_views[i.key()] = nullptr;
     }
 
     m_views.clear();
 
     //! clear all the m_layouts tracking layouts
     for (QHash<Latte::Layout::GenericLayout *, TrackedLayoutInfo *>::iterator i=m_layouts.begin(); i!=m_layouts.end(); ++i) {
         i.value()->deleteLater();
         m_layouts[i.key()] = nullptr;
     }
 
     m_layouts.clear();
 }
 
 void Windows::init()
 {
     connect(m_wm->corona(), &Plasma::Corona::availableScreenRectChanged, this, &Windows::updateAvailableScreenGeometries);
 
     connect(m_wm, &AbstractWindowInterface::windowChanged, this, [&](WindowId wid) {
         m_windows[wid] = m_wm->requestInfo(wid);
         updateAllHints();
 
         emit windowChanged(wid);
     });
 
     connect(m_wm, &AbstractWindowInterface::windowRemoved, this, [&](WindowId wid) {
         m_windows.remove(wid);
         updateAllHints();
 
         emit windowRemoved(wid);
     });
 
     connect(m_wm, &AbstractWindowInterface::windowAdded, this, [&](WindowId wid) {
         if (!m_windows.contains(wid)) {
             m_windows.insert(wid, m_wm->requestInfo(wid));
         }
         updateAllHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::activeWindowChanged, this, [&](WindowId wid) {
         //! for some reason this is needed in order to update properly activeness values
         //! when the active window changes the previous active windows should be also updated
         for (const auto view : m_views.keys()) {
             WindowId lastWinId = m_views[view]->lastActiveWindow()->winId();
             if ((lastWinId) != wid && m_windows.contains(lastWinId)) {
                 m_windows[lastWinId] = m_wm->requestInfo(lastWinId);
             }
         }
 
         m_windows[wid] = m_wm->requestInfo(wid);
         updateAllHints();
 
         emit activeWindowChanged(wid);
     });
 
     connect(m_wm, &AbstractWindowInterface::currentDesktopChanged, this, [&] {
         updateAllHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::currentActivityChanged, this, [&] {
         if (m_wm->corona()->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             //! this is needed in MultipleLayouts because there is a chance that multiple
             //! layouts are providing different available screen geometries in different Activities
             updateAvailableScreenGeometries();
         }
 
         updateAllHints();
     });
 }
 
 void Windows::initLayoutHints(Latte::Layout::GenericLayout *layout)
 {
     if (!m_layouts.contains(layout)) {
         return;
     }
 
     setActiveWindowMaximized(layout, false);
     setExistsWindowActive(layout, false);
     setExistsWindowMaximized(layout, false);
     setActiveWindowScheme(layout, nullptr);
 }
 
 void Windows::initViewHints(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return;
     }
 
     setActiveWindowMaximized(view, false);
     setActiveWindowTouching(view, false);
     setExistsWindowActive(view, false);
     setExistsWindowTouching(view, false);
     setExistsWindowMaximized(view, false);
     setActiveWindowScheme(view, nullptr);
     setTouchingWindowScheme(view, nullptr);
 }
 
 AbstractWindowInterface *Windows::wm()
 {
     return m_wm;
 }
 
 
 void Windows::addView(Latte::View *view)
 {
     if (m_views.contains(view)) {
         return;
     }
 
     m_views[view] = new TrackedViewInfo(this, view);
 
     updateAvailableScreenGeometries();
 
     //! Consider Layouts
     addRelevantLayout(view);
 
     connect(view, &Latte::View::layoutChanged, this, [&, view]() {
         addRelevantLayout(view);
     });
 
     updateAllHints();
 
     emit informationAnnounced(view);
 }
 
 void Windows::removeView(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return;
     }
 
     m_views[view]->deleteLater();
     m_views.remove(view);
 
     updateRelevantLayouts();
 }
 
 void Windows::addRelevantLayout(Latte::View *view)
 {
     if (view->layout() && !m_layouts.contains(view->layout())) {
         m_layouts[view->layout()] = new TrackedLayoutInfo(this, view->layout());
 
         updateRelevantLayouts();
         updateHints(view->layout());
         emit informationAnnouncedForLayout(view->layout());
     }
 }
 
 void Windows::updateRelevantLayouts()
 {
     QList<Latte::Layout::GenericLayout*> orphanedLayouts;
 
     //! REMOVE Orphaned Relevant layouts that have been removed or they dont contain any Views anymore
     for (QHash<Latte::Layout::GenericLayout *, TrackedLayoutInfo *>::iterator i=m_layouts.begin(); i!=m_layouts.end(); ++i) {
         bool hasView{false};
         for (QHash<Latte::View *, TrackedViewInfo *>::iterator j=m_views.begin(); j!=m_views.end(); ++j) {
             if (j.key() && i.key() && i.key() == j.key()->layout()) {
                 hasView = true;
                 break;
             }
         }
 
         if (!hasView)  {
             if (i.value()) {
                 i.value()->deleteLater();
             }
             orphanedLayouts << i.key();
         }
     }
 
     for(const auto &layout : orphanedLayouts) {
         m_layouts.remove(layout);
     }
 
     //! UPDATE Enabled layout window tracking based on the Views that are requesting windows tracking
     for (QHash<Latte::Layout::GenericLayout *, TrackedLayoutInfo *>::iterator i=m_layouts.begin(); i!=m_layouts.end(); ++i) {
         bool hasViewEnabled{false};
         for (QHash<Latte::View *, TrackedViewInfo *>::iterator j=m_views.begin(); j!=m_views.end(); ++j) {
             if (i.key() == j.key()->layout() && j.value()->enabled()) {
                 hasViewEnabled = true;
                 break;
             }
         }
 
         if (i.value()) {
             i.value()->setEnabled(hasViewEnabled);
 
             if (!hasViewEnabled) {
                 initLayoutHints(i.key());
             }
         }
     }
 }
 
 //! Views Properties And Hints
 
 bool Windows::enabled(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->enabled();
 }
 
 void Windows::setEnabled(Latte::View *view, const bool enabled)
 {
     if (!m_views.contains(view) || m_views[view]->enabled() == enabled) {
         return;
     }
 
     m_views[view]->setEnabled(enabled);
 
     if (enabled) {
         updateHints(view);
     } else {
         initViewHints(view);
     }
 
     updateRelevantLayouts();
 
     emit enabledChanged(view);
 }
 
 bool Windows::activeWindowMaximized(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->activeWindowMaximized();
 }
 
 void Windows::setActiveWindowMaximized(Latte::View *view, bool activeMaximized)
 {
     if (!m_views.contains(view) || m_views[view]->activeWindowMaximized() == activeMaximized) {
         return;
     }
 
     m_views[view]->setActiveWindowMaximized(activeMaximized);
     emit activeWindowMaximizedChanged(view);
 }
 
 bool Windows::activeWindowTouching(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->activeWindowTouching();
 }
 
 void Windows::setActiveWindowTouching(Latte::View *view, bool activeTouching)
 {
     if (!m_views.contains(view) || m_views[view]->activeWindowTouching() == activeTouching) {
         return;
     }
 
     m_views[view]->setActiveWindowTouching(activeTouching);
     emit activeWindowTouchingChanged(view);
 }
 
 bool Windows::existsWindowActive(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->existsWindowActive();
 }
 
 void Windows::setExistsWindowActive(Latte::View *view, bool windowActive)
 {
     if (!m_views.contains(view) || m_views[view]->existsWindowActive() == windowActive) {
         return;
     }
 
     m_views[view]->setExistsWindowActive(windowActive);
     emit existsWindowActiveChanged(view);
 }
 
 bool Windows::existsWindowMaximized(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->existsWindowMaximized();
 }
 
 void Windows::setExistsWindowMaximized(Latte::View *view, bool windowMaximized)
 {
     if (!m_views.contains(view) || m_views[view]->existsWindowMaximized() == windowMaximized) {
         return;
     }
 
     m_views[view]->setExistsWindowMaximized(windowMaximized);
     emit existsWindowMaximizedChanged(view);
 }
 
 bool Windows::existsWindowTouching(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->existsWindowTouching();
 }
 
 void Windows::setExistsWindowTouching(Latte::View *view, bool windowTouching)
 {
     if (!m_views.contains(view) || m_views[view]->existsWindowTouching() == windowTouching) {
         return;
     }
 
     m_views[view]->setExistsWindowTouching(windowTouching);
     emit existsWindowTouchingChanged(view);
 }
 
 SchemeColors *Windows::activeWindowScheme(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return nullptr;
     }
 
     return m_views[view]->activeWindowScheme();
 }
 
 void Windows::setActiveWindowScheme(Latte::View *view, WindowSystem::SchemeColors *scheme)
 {
     if (!m_views.contains(view) || m_views[view]->activeWindowScheme() == scheme) {
         return;
     }
 
     m_views[view]->setActiveWindowScheme(scheme);
     emit activeWindowSchemeChanged(view);
 }
 
 SchemeColors *Windows::touchingWindowScheme(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return nullptr;
     }
 
     return m_views[view]->touchingWindowScheme();
 }
 
 void Windows::setTouchingWindowScheme(Latte::View *view, WindowSystem::SchemeColors *scheme)
 {
     if (!m_views.contains(view) || m_views[view]->touchingWindowScheme() == scheme) {
         return;
     }
 
     m_views[view]->setTouchingWindowScheme(scheme);
     emit touchingWindowSchemeChanged(view);
 }
 
 LastActiveWindow *Windows::lastActiveWindow(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return nullptr;
     }
 
     return m_views[view]->lastActiveWindow();
 }
 
 //! Layouts
 bool Windows::enabled(Latte::Layout::GenericLayout *layout)
 {
     if (!m_layouts.contains(layout)) {
         return false;
     }
 
     return m_layouts[layout]->enabled();
 }
 
 bool Windows::activeWindowMaximized(Latte::Layout::GenericLayout *layout) const
 {
     if (!m_layouts.contains(layout)) {
         return false;
     }
 
     return m_layouts[layout]->activeWindowMaximized();
 }
 
 void Windows::setActiveWindowMaximized(Latte::Layout::GenericLayout *layout, bool activeMaximized)
 {
     if (!m_layouts.contains(layout) || m_layouts[layout]->activeWindowMaximized() == activeMaximized) {
         return;
     }
 
     m_layouts[layout]->setActiveWindowMaximized(activeMaximized);
     emit activeWindowMaximizedChangedForLayout(layout);
 }
 
 bool Windows::existsWindowActive(Latte::Layout::GenericLayout *layout) const
 {
     if (!m_layouts.contains(layout)) {
         return false;
     }
 
     return m_layouts[layout]->existsWindowActive();
 }
 
 void Windows::setExistsWindowActive(Latte::Layout::GenericLayout *layout, bool windowActive)
 {
     if (!m_layouts.contains(layout) || m_layouts[layout]->existsWindowActive() == windowActive) {
         return;
     }
 
     m_layouts[layout]->setExistsWindowActive(windowActive);
     emit existsWindowActiveChangedForLayout(layout);
 }
 
 bool Windows::existsWindowMaximized(Latte::Layout::GenericLayout *layout) const
 {
     if (!m_layouts.contains(layout)) {
         return false;
     }
 
     return m_layouts[layout]->existsWindowMaximized();
 }
 
 void Windows::setExistsWindowMaximized(Latte::Layout::GenericLayout *layout, bool windowMaximized)
 {
     if (!m_layouts.contains(layout) || m_layouts[layout]->existsWindowMaximized() == windowMaximized) {
         return;
     }
 
     m_layouts[layout]->setExistsWindowMaximized(windowMaximized);
     emit existsWindowMaximizedChangedForLayout(layout);
 }
 
 SchemeColors *Windows::activeWindowScheme(Latte::Layout::GenericLayout *layout) const
 {
     if (!m_layouts.contains(layout)) {
         return nullptr;
     }
 
     return m_layouts[layout]->activeWindowScheme();
 }
 
 void Windows::setActiveWindowScheme(Latte::Layout::GenericLayout *layout, WindowSystem::SchemeColors *scheme)
 {
     if (!m_layouts.contains(layout) || m_layouts[layout]->activeWindowScheme() == scheme) {
         return;
     }
 
     m_layouts[layout]->setActiveWindowScheme(scheme);
     emit activeWindowSchemeChangedForLayout(layout);
 }
 
 LastActiveWindow *Windows::lastActiveWindow(Latte::Layout::GenericLayout *layout)
 {
     if (!m_layouts.contains(layout)) {
         return nullptr;
     }
 
     return m_layouts[layout]->lastActiveWindow();
 }
 
 
 //! Windows
 bool Windows::isValidFor(const WindowId &wid) const
 {
     if (!m_windows.contains(wid)) {
         return false;
     }
 
     return m_windows[wid].isValid() && !m_windows[wid].isPlasmaDesktop();
 }
 
 QIcon Windows::iconFor(const WindowId &wid)
 {
     if (!m_windows.contains(wid)) {
         return QIcon();
     }
 
     if (m_windows[wid].icon().isNull()) {
         AppData data = m_wm->appDataFor(wid);
 
         QIcon icon = data.icon;
 
         if (icon.isNull()) {
             icon = m_wm->iconFor(wid);
         }
 
         m_windows[wid].setIcon(icon);
         return icon;
     }
 
     return m_windows[wid].icon();
 }
 
 QString Windows::appNameFor(const WindowId &wid)
 {
     if (!m_windows.contains(wid)) {
         return QString();
     }
 
     if (m_windows[wid].appName().isEmpty()) {
         AppData data = m_wm->appDataFor(wid);
 
         m_windows[wid].setAppName(data.name);
         return data.name;
     }
 
     return m_windows[wid].appName();
 }
 
 WindowInfoWrap Windows::infoFor(const WindowId &wid) const
 {
     if (!m_windows.contains(wid)) {
         return WindowInfoWrap();
     }
 
     return m_windows[wid];
 }
 
 
 
 //! Windows Criteria Functions
 
 bool Windows::inCurrentDesktopActivity(const WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && winfo.isOnDesktop(m_wm->currentDesktop()) && winfo.isOnActivity(m_wm->currentActivity()));
 }
 
 bool Windows::intersects(Latte::View *view, const WindowInfoWrap &winfo)
 {
     return (!winfo.isMinimized() && !winfo.isShaded() && winfo.geometry().intersects(view->absoluteGeometry()));
 }
 
 bool Windows::isActive(const WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && winfo.isActive() && !winfo.isPlasmaDesktop() && !winfo.isMinimized());
 }
 
 bool Windows::isActiveInViewScreen(Latte::View *view, const WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && winfo.isActive() && !winfo.isPlasmaDesktop() &&  !winfo.isMinimized()
             && m_views[view]->availableScreenGeometry().contains(winfo.geometry().center()));
 }
 
 bool Windows::isMaximizedInViewScreen(Latte::View *view, const WindowInfoWrap &winfo)
 {
     auto viewIntersectsMaxVert = [&]() noexcept -> bool {
             return ((winfo.isMaxVert()
                      || (view->screen() && view->screen()->availableSize().height() <= winfo.geometry().height()))
                     && intersects(view, winfo));
 };
 
     auto viewIntersectsMaxHoriz = [&]() noexcept -> bool {
             return ((winfo.isMaxHoriz()
                      || (view->screen() && view->screen()->availableSize().width() <= winfo.geometry().width()))
                     && intersects(view, winfo));
 };
 
     //! updated implementation to identify the screen that the maximized window is present
     //! in order to avoid: https://bugs.kde.org/show_bug.cgi?id=397700
     return (winfo.isValid() && !winfo.isPlasmaDesktop() && !winfo.isMinimized()
             && (winfo.isMaximized() || viewIntersectsMaxVert() || viewIntersectsMaxHoriz())
             && m_views[view]->availableScreenGeometry().contains(winfo.geometry().center()));
 }
 
 bool Windows::isTouchingView(Latte::View *view, const WindowSystem::WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && !winfo.isPlasmaDesktop() && intersects(view, winfo));
 }
 
 bool Windows::isTouchingViewEdge(Latte::View *view, const WindowInfoWrap &winfo)
 {
     if (winfo.isValid() && !winfo.isPlasmaDesktop() &&  !winfo.isMinimized()) {
         bool inViewThicknessEdge{false};
         bool inViewLengthBoundaries{false};
 
         QRect screenGeometry = view->screenGeometry();
 
         bool inCurrentScreen{screenGeometry.contains(winfo.geometry().topLeft()) || screenGeometry.contains(winfo.geometry().bottomRight())};
 
         if (inCurrentScreen) {
             if (view->location() == Plasma::Types::TopEdge) {
                 inViewThicknessEdge = (winfo.geometry().y() == view->absoluteGeometry().bottom() + 1);
             } else if (view->location() == Plasma::Types::BottomEdge) {
                 inViewThicknessEdge = (winfo.geometry().bottom() == view->absoluteGeometry().top() - 1);
             } else if (view->location() == Plasma::Types::LeftEdge) {
                 inViewThicknessEdge = (winfo.geometry().x() == view->absoluteGeometry().right() + 1);
             } else if (view->location() == Plasma::Types::RightEdge) {
                 inViewThicknessEdge = (winfo.geometry().right() == view->absoluteGeometry().left() - 1);
             }
 
             if (view->formFactor() == Plasma::Types::Horizontal) {
                 int yCenter = view->absoluteGeometry().center().y();
 
                 QPoint leftChecker(winfo.geometry().left(), yCenter);
                 QPoint rightChecker(winfo.geometry().right(), yCenter);
 
                 bool fulloverlap = (winfo.geometry().left()<=view->absoluteGeometry().left()) && (winfo.geometry().right()>=view->absoluteGeometry().right());
 
                 inViewLengthBoundaries = fulloverlap || view->absoluteGeometry().contains(leftChecker) || view->absoluteGeometry().contains(rightChecker);
             } else if (view->formFactor() == Plasma::Types::Vertical) {
                 int xCenter = view->absoluteGeometry().center().x();
 
                 QPoint topChecker(xCenter, winfo.geometry().top());
                 QPoint bottomChecker(xCenter, winfo.geometry().bottom());
 
                 bool fulloverlap = (winfo.geometry().top()<=view->absoluteGeometry().top()) && (winfo.geometry().bottom()>=view->absoluteGeometry().bottom());
 
                 inViewLengthBoundaries = fulloverlap || view->absoluteGeometry().contains(topChecker) || view->absoluteGeometry().contains(bottomChecker);
             }
         }
 
         return (inViewThicknessEdge && inViewLengthBoundaries);
     }
 
     return false;
 }
 
 void Windows::cleanupFaultyWindows()
 {
     for (const auto &key : m_windows.keys()) {
         auto winfo = m_windows[key];
 
         //! garbage windows removing
         if (winfo.geometry() == QRect(0, 0, 0, 0)) {
             //qDebug() << "Faulty Geometry ::: " << winfo.wid();
             m_windows.remove(key);
         }
     }
 }
 
 
 void Windows::updateAvailableScreenGeometries()
 {
     for (const auto view : m_views.keys()) {
         if (m_views[view]->enabled()) {
             int currentScrId = view->positioner()->currentScreenId();
             QRect tempAvailableScreenGeometry = m_wm->corona()->availableScreenRectWithCriteria(currentScrId, {Types::AlwaysVisible}, {});
 
             if (tempAvailableScreenGeometry != m_views[view]->availableScreenGeometry()) {
                 m_views[view]->setAvailableScreenGeometry(tempAvailableScreenGeometry);
 
                 updateHints(view);
             }
         }
     }
 }
 
 void Windows::setPlasmaDesktop(WindowId wid)
 {
     if (!m_windows.contains(wid)) {
         return;
     }
 
     if (!m_windows[wid].isPlasmaDesktop()) {
         m_windows[wid].setIsPlasmaDesktop(true);
         qDebug() << " plasmashell updated...";
         updateAllHints();
     }
 }
 
 void Windows::updateAllHints()
 {
     for (const auto view : m_views.keys()) {
         updateHints(view);
     }
 
     for (const auto layout : m_layouts.keys()) {
         updateHints(layout);
     }
 }
 
 void Windows::updateHints(Latte::View *view)
 {
     if (!m_views.contains(view) || !m_views[view]->enabled() || !m_views[view]->isTrackingCurrentActivity()) {
         return;
     }
 
     bool foundActive{false};
     bool foundActiveInCurScreen{false};
     bool foundActiveTouchInCurScreen{false};
     bool foundTouchInCurScreen{false};
     bool foundMaximizedInCurScreen{false};
 
     //! the notification window is not sending a remove signal and creates windows of geometry (0x0 0,0),
     //! maybe a garbage collector here is a good idea!!!
     bool existsFaultyWindow{false};
 
     WindowId maxWinId;
     WindowId activeWinId;
     WindowId touchWinId;
     WindowId activeTouchWinId;
 
     for (const auto &winfo : m_windows) {
         if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo)) {
             continue;
         }
 
         if (isActive(winfo)) {
             foundActive = true;
         }
 
         if (isActiveInViewScreen(view, winfo)) {
             foundActiveInCurScreen = true;
             activeWinId = winfo.wid();
         }
 
         if (isTouchingViewEdge(view, winfo) || isTouchingView(view, winfo)) {
             if (winfo.isActive()) {
+                //qDebug() << " ACTIVE-TOUCH :: " << winfo.wid() << " _ " << winfo.appName() << " _ " << winfo.geometry() << " _ " << winfo.display();
                 foundActiveTouchInCurScreen = true;
                 activeTouchWinId = winfo.wid();
 
                 if (isMaximizedInViewScreen(view, winfo)) {
                     //! active maximized windows have higher priority than the rest maximized windows
                     foundMaximizedInCurScreen = true;
                     maxWinId = winfo.wid();
                 }
             } else {
+                //qDebug() << " TOUCH :: " << winfo.wid() << " _ " << winfo.appName() << " _ " << winfo.geometry() << " _ " << winfo.display();
                 foundTouchInCurScreen = true;
                 touchWinId = winfo.wid();
             }
 
             if (!foundMaximizedInCurScreen && isMaximizedInViewScreen(view, winfo)) {
                 foundMaximizedInCurScreen = true;
                 maxWinId = winfo.wid();
             }
         }
 
         if (!existsFaultyWindow && winfo.geometry() == QRect(0, 0, 0, 0)) {
             existsFaultyWindow = true;
         }
 
         //qDebug() << "window geometry ::: " << winfo.geometry();
     }
 
     if (existsFaultyWindow) {
         cleanupFaultyWindows();
     }
 
     //! HACK: KWin Effects such as ShowDesktop have no way to be identified and as such
     //! create issues with identifying properly touching and maximized windows. BUT when
     //! they are enabled then NO ACTIVE window is found. This is a way to identify these
     //! effects trigerring and disable the touch flags.
     //! BUG: 404483
     //! Disabled because it has fault identifications, e.g. when a window is maximized and
     //! Latte or Plasma are showing their View settings
     //foundMaximizedInCurScreen = foundMaximizedInCurScreen && foundActive;
     //foundTouchInCurScreen = foundTouchInCurScreen && foundActive;
 
     //! assign flags
     setExistsWindowActive(view, foundActiveInCurScreen);
     setActiveWindowTouching(view, foundActiveTouchInCurScreen);
     setActiveWindowMaximized(view, (maxWinId.toInt()>0 && (maxWinId == activeTouchWinId)));
     setExistsWindowMaximized(view, foundMaximizedInCurScreen);
     setExistsWindowTouching(view, (foundTouchInCurScreen || foundActiveTouchInCurScreen));
 
     //! update color schemes for active and touching windows
     setActiveWindowScheme(view, (foundActiveInCurScreen ? m_wm->schemesTracker()->schemeForWindow(activeWinId) : nullptr));
 
     if (foundActiveTouchInCurScreen) {
         setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(activeTouchWinId));
     } else if (foundMaximizedInCurScreen) {
         setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(maxWinId));
     } else if (foundTouchInCurScreen) {
         setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(touchWinId));
     } else {
         setTouchingWindowScheme(view, nullptr);
     }
 
     //! update LastActiveWindow
     if (foundActiveInCurScreen) {
         m_views[view]->setActiveWindow(activeWinId);
     }
 
     //! Debug
     //qDebug() << "TRACKING | SCREEN: " << view->positioner()->currentScreenId() << " , EDGE:" << view->location() << " , ENABLED:" << enabled(view);
     //qDebug() << "TRACKING | activeWindowTouching: " << foundActiveTouchInCurScreen << " ,activeWindowMaximized: " << activeWindowMaximized(view);
     //qDebug() << "TRACKING | existsWindowActive: " << foundActiveInCurScreen << " , existsWindowMaximized:" << existsWindowMaximized(view)
     //         << " , existsWindowTouching:"<<existsWindowTouching(view);
 }
 
 void Windows::updateHints(Latte::Layout::GenericLayout *layout) {
     if (!m_layouts.contains(layout) || !m_layouts[layout]->enabled() || !m_layouts[layout]->isTrackingCurrentActivity()) {
         return;
     }
 
     bool foundActive{false};
     bool foundActiveMaximized{false};
     bool foundMaximized{false};
 
     //! the notification window is not sending a remove signal and creates windows of geometry (0x0 0,0),
     //! maybe a garbage collector here is a good idea!!!
     bool existsFaultyWindow{false};
 
     WindowId activeWinId;
     WindowId maxWinId;
 
     for (const auto &winfo : m_windows) {
         if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo)) {
             continue;
         }
 
         if (isActive(winfo)) {
             foundActive = true;
             activeWinId = winfo.wid();
 
             if (winfo.isMaximized() && !winfo.isMinimized()) {
                 foundActiveMaximized = true;
                 maxWinId = winfo.wid();
             }
         }
 
         if (!foundActiveMaximized && winfo.isMaximized() && !winfo.isMinimized()) {
             foundMaximized = true;
             maxWinId = winfo.wid();
         }
 
         if (!existsFaultyWindow && winfo.geometry() == QRect(0, 0, 0, 0)) {
             existsFaultyWindow = true;
         }
 
         //qDebug() << "window geometry ::: " << winfo.geometry();
     }
 
     if (existsFaultyWindow) {
         cleanupFaultyWindows();
     }
 
     //! HACK: KWin Effects such as ShowDesktop have no way to be identified and as such
     //! create issues with identifying properly touching and maximized windows. BUT when
     //! they are enabled then NO ACTIVE window is found. This is a way to identify these
     //! effects trigerring and disable the touch flags.
     //! BUG: 404483
     //! Disabled because it has fault identifications, e.g. when a window is maximized and
     //! Latte or Plasma are showing their View settings
     //foundMaximizedInCurScreen = foundMaximizedInCurScreen && foundActive;
     //foundTouchInCurScreen = foundTouchInCurScreen && foundActive;
 
     //! assign flags
     setExistsWindowActive(layout, foundActive);
     setActiveWindowMaximized(layout, foundActiveMaximized);
     setExistsWindowMaximized(layout, foundActiveMaximized || foundMaximized);
 
     //! update color schemes for active and touching windows
     setActiveWindowScheme(layout, (foundActive ? m_wm->schemesTracker()->schemeForWindow(activeWinId) : nullptr));
 
     //! update LastActiveWindow
     if (foundActive) {
         m_layouts[layout]->setActiveWindow(activeWinId);
     }
 
     //! Debug
     //qDebug() << "TRACKING | SCREEN: " << view->positioner()->currentScreenId() << " , EDGE:" << view->location() << " , ENABLED:" << enabled(view);
     //qDebug() << "TRACKING | activeWindowTouching: " << foundActiveTouchInCurScreen << " ,activeWindowMaximized: " << activeWindowMaximized(view);
     //qDebug() << "TRACKING | existsWindowActive: " << foundActiveInCurScreen << " , existsWindowMaximized:" << existsWindowMaximized(view)
     //         << " , existsWindowTouching:"<<existsWindowTouching(view);
 }
 
 }
 }
 }
diff --git a/containment/metadata.desktop.cmake b/containment/metadata.desktop.cmake
index f9ea871d..6fd09156 100644
--- a/containment/metadata.desktop.cmake
+++ b/containment/metadata.desktop.cmake
@@ -1,67 +1,68 @@
 [Desktop Entry]
 Encoding=UTF-8
 Name=Latte
+Name[ast]=Latte
 Name[ca]=Latte
 Name[ca@valencia]=Latte
 Name[cs]=Latte
 Name[da]=Latte
 Name[de]=Latte
 Name[el]=Latte
 Name[en_GB]=Latte
 Name[es]=Latte
 Name[eu]=Latte
 Name[fi]=Latte
 Name[gl]=Latte
 Name[it]=Latte
 Name[ko]=Latte
 Name[nl]=Latte
 Name[nn]=Latte
 Name[pl]=Latte
 Name[pt]=Latte
 Name[pt_BR]=Latte
 Name[ru]=Latte
 Name[sv]=Latte
 Name[uk]=Латте
 Name[x-test]=xxLattexx
 Name[zh_CN]=Latte
 Name[zh_TW]=Latte
 Comment=Containment provided for the Latte Dock
 Comment[ca]=Intèrpret d'ordres proporcionat pel Latte Dock
 Comment[ca@valencia]=Intèrpret d'ordres proporcionat pel Latte Dock
 Comment[da]=Beholder til Latte-dokken
 Comment[de]=Containment für Latte-Dock
 Comment[el]=Περιέκτης της εφαρμογής Latte
 Comment[en_GB]=Containment provided for the Latte Dock
 Comment[es]=Contención proporcionada para Latte Dock
 Comment[eu]=Konfinamendua hornitu da Latte Dockentzako
 Comment[fi]=Latte-telakalla tarjottu sisällytys
 Comment[gl]=Contedor fornecido para a doca Latte.
 Comment[it]=Contenitore fornito per Latte Dock
 Comment[ko]=Latte 독을 위해 제공된 컨테이너
 Comment[nl]=Container geleverd voor de Latte Dock
 Comment[nn]=Behaldar for Latte-dokk
 Comment[pl]=Pojemnik dla doku Latte
 Comment[pt]=Contentor oferecido para a área acoplável do Latte
 Comment[pt_BR]=Contêiner fornecido pelo Latte Dock
 Comment[ru]=Контейнер Latte Dock
 Comment[sv]=Omgivning tillhandahållen för Latte dockningsfönster
 Comment[uk]=Контейнер панелі Латте
 Comment[x-test]=xxContainment provided for the Latte Dockxx
 Comment[zh_CN]=用于 Latte 停靠栏的容器
 Comment[zh_TW]=提供 Latte Dock 使用的容器
 
 Type=Service
 NoDisplay=true
 
 X-KDE-PluginInfo-Author=@AUTHOR@
 X-KDE-PluginInfo-Email=@EMAIL@
 X-KDE-PluginInfo-Name=org.kde.latte.containment
 X-KDE-PluginInfo-Version=@VERSION@
 X-KDE-PluginInfo-Website=@WEBSITE@
 X-KDE-PluginInfo-Category=X-KDE-PluginInfo-Depends=
 X-KDE-PluginInfo-License=GPL
 X-KDE-PluginInfo-EnabledByDefault=true
 X-KDE-ServiceTypes=Plasma/Applet,Plasma/Containment
 X-Plasma-API=declarativeappletscript
 X-Plasma-MainScript=ui/main.qml
 X-Plasma-ContainmentType=Panel
diff --git a/containment/package/metadata.desktop b/containment/package/metadata.desktop
index f44883ee..a0f310ba 100644
--- a/containment/package/metadata.desktop
+++ b/containment/package/metadata.desktop
@@ -1,67 +1,68 @@
 [Desktop Entry]
 Encoding=UTF-8
 Name=Latte
+Name[ast]=Latte
 Name[ca]=Latte
 Name[ca@valencia]=Latte
 Name[cs]=Latte
 Name[da]=Latte
 Name[de]=Latte
 Name[el]=Latte
 Name[en_GB]=Latte
 Name[es]=Latte
 Name[eu]=Latte
 Name[fi]=Latte
 Name[gl]=Latte
 Name[it]=Latte
 Name[ko]=Latte
 Name[nl]=Latte
 Name[nn]=Latte
 Name[pl]=Latte
 Name[pt]=Latte
 Name[pt_BR]=Latte
 Name[ru]=Latte
 Name[sv]=Latte
 Name[uk]=Латте
 Name[x-test]=xxLattexx
 Name[zh_CN]=Latte
 Name[zh_TW]=Latte
 Comment=Containment provided for the Latte Dock
 Comment[ca]=Intèrpret d'ordres proporcionat pel Latte Dock
 Comment[ca@valencia]=Intèrpret d'ordres proporcionat pel Latte Dock
 Comment[da]=Beholder til Latte-dokken
 Comment[de]=Containment für Latte-Dock
 Comment[el]=Περιέκτης της εφαρμογής Latte
 Comment[en_GB]=Containment provided for the Latte Dock
 Comment[es]=Contención proporcionada para Latte Dock
 Comment[eu]=Konfinamendua hornitu da Latte Dockentzako
 Comment[fi]=Latte-telakalla tarjottu sisällytys
 Comment[gl]=Contedor fornecido para a doca Latte.
 Comment[it]=Contenitore fornito per Latte Dock
 Comment[ko]=Latte 독을 위해 제공된 컨테이너
 Comment[nl]=Container geleverd voor de Latte Dock
 Comment[nn]=Behaldar for Latte-dokk
 Comment[pl]=Pojemnik dla doku Latte
 Comment[pt]=Contentor oferecido para a área acoplável do Latte
 Comment[pt_BR]=Contêiner fornecido pelo Latte Dock
 Comment[ru]=Контейнер Latte Dock
 Comment[sv]=Omgivning tillhandahållen för Latte dockningsfönster
 Comment[uk]=Контейнер панелі Латте
 Comment[x-test]=xxContainment provided for the Latte Dockxx
 Comment[zh_CN]=用于 Latte 停靠栏的容器
 Comment[zh_TW]=提供 Latte Dock 使用的容器
 
 Type=Service
 NoDisplay=true
 
 X-KDE-PluginInfo-Author=Michail Vourlakos, Smith Ar
 X-KDE-PluginInfo-Email=mvourlakos@gmail.com, audoban@openmailbox.org
 X-KDE-PluginInfo-Name=org.kde.latte.containment
 X-KDE-PluginInfo-Version=0.8.96
 X-KDE-PluginInfo-Website=https://github.com/psifidotos/Latte-Dock
 X-KDE-PluginInfo-Category=X-KDE-PluginInfo-Depends=
 X-KDE-PluginInfo-License=GPL
 X-KDE-PluginInfo-EnabledByDefault=true
 X-KDE-ServiceTypes=Plasma/Applet,Plasma/Containment
 X-Plasma-API=declarativeappletscript
 X-Plasma-MainScript=ui/main.qml
 X-Plasma-ContainmentType=Panel
diff --git a/indicators/default/metadata.desktop b/indicators/default/metadata.desktop
index cc4d4a2c..92eb8d47 100644
--- a/indicators/default/metadata.desktop
+++ b/indicators/default/metadata.desktop
@@ -1,63 +1,64 @@
 [Desktop Entry]
 Name=Latte
+Name[ast]=Latte
 Name[ca]=Latte
 Name[ca@valencia]=Latte
 Name[cs]=Latte
 Name[da]=Latte
 Name[de]=Latte
 Name[el]=Latte
 Name[en_GB]=Latte
 Name[es]=Latte
 Name[eu]=Latte
 Name[fi]=Latte
 Name[gl]=Latte
 Name[it]=Latte
 Name[ko]=Latte
 Name[nl]=Latte
 Name[nn]=Latte
 Name[pl]=Latte
 Name[pt]=Latte
 Name[pt_BR]=Latte
 Name[ru]=Latte
 Name[sv]=Latte
 Name[uk]=Латте
 Name[x-test]=xxLattexx
 Name[zh_CN]=Latte
 Name[zh_TW]=Latte
 Comment=Latte default indicator
 Comment[ca]=Indicador predeterminat del Latte
 Comment[ca@valencia]=Indicador predeterminat del Latte
 Comment[en_GB]=Latte default indicator
 Comment[es]=Indicador por omisión de Latte
 Comment[fi]=Latte-oletusilmaisin
 Comment[gl]=Indicador predeterminado de Latte
 Comment[it]=Indicatore predefinito di Latte
 Comment[ko]=Latte 기본 표시기
 Comment[nl]=Standaard indicator van Latte
 Comment[pl]=Domyślny wskaźnik Latte
 Comment[pt]=Indicador predefinido do Latte
 Comment[pt_BR]=Indicador padrão do Latte
 Comment[ru]=Индикатор Latte умолчанию
 Comment[sv]=Latte standardindikator
 Comment[uk]=Типовий індикатор Латте
 Comment[x-test]=xxLatte default indicatorxx
 Comment[zh_TW]=Latte 預設指示器
 
 Encoding=UTF-8
 Type=Service
 Icon=latte-dock
 X-Plasma-API=declarativeappletscript
 X-KDE-ServiceTypes=Latte/Indicator
 
 X-Latte-MainScript=ui/main.qml
 X-Latte-ConfigUi=config/config.qml
 X-Latte-ConfigXml=config/main.xml
 
 X-KDE-PluginInfo-Author=Michail Vourlakos
 X-KDE-PluginInfo-Email=mvourlakos@gmail.com
 X-KDE-PluginInfo-Name=org.kde.latte.default
 X-KDE-PluginInfo-Version=0.1
 X-KDE-PluginInfo-Category=Latte Indicator
 X-KDE-PluginInfo-License=GPL v2+
 X-KDE-PluginInfo-EnabledByDefault=true