diff --git a/app/view/screenedgeghostwindow.cpp b/app/view/screenedgeghostwindow.cpp
index 1d2d3023..60f23e02 100644
--- a/app/view/screenedgeghostwindow.cpp
+++ b/app/view/screenedgeghostwindow.cpp
@@ -1,243 +1,258 @@
 /*
 *  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"
 #include "../lattecorona.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)
 {
     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);
 
     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::absGeometryChanged, 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()) {
         connect(this, &QWindow::visibleChanged, this, [&]() {
             //! IMPORTANT!!! ::: This fixes a bug when closing an Activity all views from all Activities are
             //!  disappearing! With this they reappear!!!
             if (m_latteView && m_latteView->managedLayout()) {
                 if (!isVisible()) {
                     QTimer::singleShot(100, [this]() {
                         if (!m_inDelete && m_latteView && m_latteView->managedLayout() && !isVisible()) {
                             setVisible(true);
                         }
                     });
 
                     QTimer::singleShot(1500, [this]() {
                         if (!m_inDelete && m_latteView && m_latteView->managedLayout() && !isVisible()) {
                             setVisible(true);
                         }
                     });
                 } else {
                     //! For some reason when the window is hidden in the edge under X11 afterwards
                     //! is losing its window flags
                     if (!m_inDelete) {
                         KWindowSystem::setType(winId(), NET::Dock);
                         KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
                         KWindowSystem::setOnAllDesktops(winId(), true);
                     }
                 }
             }
         });
     }
 
     setupWaylandIntegration();
 
     setScreen(m_latteView->screen());
     setVisible(true);
     updateGeometry();
     hideWithMask();
 }
 
 ScreenEdgeGhostWindow::~ScreenEdgeGhostWindow()
 {
     m_inDelete = true;
     m_latteView = nullptr;
 
     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{1};
+    int thickness{2};
 
     if (m_latteView->location() == Plasma::Types::BottomEdge) {
         newGeometry.setX(m_latteView->absGeometry().left());
         newGeometry.setY(m_latteView->screenGeometry().bottom() - thickness);
     } else if (m_latteView->location() == Plasma::Types::TopEdge) {
         newGeometry.setX(m_latteView->absGeometry().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->absGeometry().top());
     } else if (m_latteView->location() == Plasma::Types::RightEdge) {
         newGeometry.setX(m_latteView->screenGeometry().right() - thickness);
         newGeometry.setY(m_latteView->absGeometry().top());
     }
 
     if (m_latteView->formFactor() == Plasma::Types::Horizontal) {
         newGeometry.setWidth(qMin(m_latteView->absGeometry().width(), m_latteView->screenGeometry().width() - 1));
         newGeometry.setHeight(thickness + 1);
     } else {
         newGeometry.setWidth(thickness + 1);
         newGeometry.setHeight(qMin(m_latteView->absGeometry().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 (Latte::Corona *c = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona())) {
         using namespace KWayland::Client;
 
         PlasmaShell *interface = c->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::Enter || e->type() == QEvent::DragEnter) {
-        emit containsMouseChanged(true);
+        setContainsMouse(true);
     } else if (e->type() == QEvent::Leave || e->type() == QEvent::DragLeave) {
-        emit containsMouseChanged(false);
+        setContainsMouse(false);
     }
 
     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 a27a0777..76df91a7 100644
--- a/app/view/screenedgeghostwindow.h
+++ b/app/view/screenedgeghostwindow.h
@@ -1,102 +1,106 @@
 /*
 *  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
 
 // Qt
 #include <QObject>
 #include <QQuickView>
 #include <QTimer>
 
 namespace KWayland {
 namespace Client {
 class PlasmaShellSurface;
 }
 }
 
 namespace Latte {
 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);
 
 protected:
     bool event(QEvent *ev) override;
 
 private slots:
     void startGeometryTimer();
     void updateGeometry();
     void fixGeometry();
 
 private:
+    void setContainsMouse(bool contains);
     void setupWaylandIntegration();
 
 private:
+    bool m_containsMouse{false};
     bool m_inDelete{false};
     QRect m_calculatedGeometry;
 
     QTimer m_fixGeometryTimer;
 
     Latte::View *m_latteView{nullptr};
 
     KWayland::Client::PlasmaShellSurface *m_shellSurface{nullptr};
 };
 
 }
 }
 #endif
diff --git a/app/view/visibilitymanager.cpp b/app/view/visibilitymanager.cpp
index de91eb9d..3a1f8aa6 100644
--- a/app/view/visibilitymanager.cpp
+++ b/app/view/visibilitymanager.cpp
@@ -1,765 +1,773 @@
 /*
 *  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 "../lattecorona.h"
 #include "../layoutmanager.h"
 #include "../screenpool.h"
 #include "../wm/windowinfowrap.h"
 #include "../../liblatte2/extras.h"
 
 // Qt
 #include <QDebug>
 
 // KDE
 #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());
     wm = m_corona->wm();
 
     if (m_latteView) {
         connect(m_latteView, &Latte::View::absGeometryChanged, this, &VisibilityManager::setViewGeometry);
         connect(m_latteView, &Latte::View::eventTriggered, this, &VisibilityManager::viewEventManager);
     }
 
     if (m_corona) {
         connect(this, &VisibilityManager::modeChanged, m_corona, &Plasma::Corona::availableScreenRectChanged);
     }
 
     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 && !dragEnter) {
             //   qDebug() << "must be hide";
             emit mustBeHide();
         }
     });
     wm->setViewExtraFlags(*m_latteView);
     wm->addView(m_latteView->winId());
 
     restoreConfig();
 }
 
 VisibilityManager::~VisibilityManager()
 {
     qDebug() << "VisibilityManager deleting...";
     wm->removeViewStruts(*m_latteView);
     wm->removeView(m_latteView->winId());
 
     if (edgeGhostWindow) {
         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(m_mode != Types::None, staticMetaObject.className(), "set visibility to Types::None");
 
     // clear mode
     for (auto &c : connections) {
         disconnect(c);
     }
 
     if (m_mode == Types::AlwaysVisible) {
         wm->removeViewStruts(*m_latteView);
     } else {
         connections[3] = connect(wm, &WindowSystem::currentDesktopChanged
         , this, [&] {
             if (raiseOnDesktopChange)
                 raiseViewTemporarily();
         });
         connections[4] = connect(wm, &WindowSystem::currentActivityChanged
         , this, [&]() {
             if (raiseOnActivityChange)
                 raiseViewTemporarily();
             else
                 updateHiddenState();
         });
     }
 
     m_timerShow.stop();
     m_timerHide.stop();
     m_mode = mode;
 
     switch (m_mode) {
         case Types::AlwaysVisible: {
             //set wayland visibility mode
             if (m_latteView->surface()) {
                 m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::WindowsGoBelow);
             }
 
             if (m_latteView->containment() && !m_latteView->inEditMode() && m_latteView->screen()) {
                 updateStrutsBasedOnLayoutsAndActivities();
             }
 
             connections[0] = connect(m_latteView->containment(), &Plasma::Containment::locationChanged
             , this, [&]() {
                 if (m_latteView->inEditMode())
                     wm->removeViewStruts(*m_latteView);
             });
             connections[1] = connect(m_latteView, &Latte::View::inEditModeChanged
             , this, [&]() {
                 if (!m_latteView->inEditMode() && !m_latteView->positioner()->inLocationChangeAnimation() && m_latteView->screen())
                     wm->setViewStruts(*m_latteView, m_viewGeometry, m_latteView->containment()->location());
             });
 
             if (m_corona && m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts) {
                 connections[2] = connect(m_corona->activitiesConsumer(), &KActivities::Consumer::currentActivityChanged, this, [&]() {
                     updateStrutsBasedOnLayoutsAndActivities();
                 });
 
                 connections[3] = connect(m_latteView, &Latte::View::activitiesChanged, this, [&]() {
                     updateStrutsBasedOnLayoutsAndActivities();
                 });
             }
 
             raiseView(true);
         }
         break;
 
         case Types::AutoHide: {
             //set wayland visibility mode
             if (m_latteView->surface()) {
                 m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::AutoHide);
             }
 
             raiseView(m_containsMouse);
         }
         break;
 
         case Types::DodgeActive: {
             //set wayland visibility mode
             if (m_latteView->surface()) {
                 m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::AutoHide);
             }
 
             connections[0] = connect(wm, &WindowSystem::activeWindowChanged
                                      , this, &VisibilityManager::dodgeActive);
             connections[1] = connect(wm, &WindowSystem::windowChanged
                                      , this, &VisibilityManager::dodgeActive);
             dodgeActive(wm->activeWindow());
         }
         break;
 
         case Types::DodgeMaximized: {
             //set wayland visibility mode
             if (m_latteView->surface()) {
                 m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::AutoHide);
             }
 
             connections[0] = connect(wm, &WindowSystem::activeWindowChanged
                                      , this, &VisibilityManager::dodgeMaximized);
             connections[1] = connect(wm, &WindowSystem::windowChanged
                                      , this, &VisibilityManager::dodgeMaximized);
             dodgeMaximized(wm->activeWindow());
         }
         break;
 
         case Types::DodgeAllWindows: {
             //set wayland visibility mode
             if (m_latteView->surface()) {
                 m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::AutoHide);
             }
 
             connections[0] = connect(this, &VisibilityManager::containsMouseChanged
                                      , this, &VisibilityManager::dodgeAllWindows);
 
             connections[1] = connect(m_latteView->windowsTracker(), &WindowsTracker::existsWindowTouchingChanged
                                      , this, &VisibilityManager::dodgeAllWindows);
         }
         break;
 
         case Types::WindowsGoBelow:
 
             //set wayland visibility mode
             if (m_latteView->surface()) {
                 m_latteView->surface()->setPanelBehavior(KWayland::Client::PlasmaShellSurface::PanelBehavior::WindowsGoBelow);
             }
 
             break;
 
         default:
             break;
     }
 
     m_latteView->containment()->config().writeEntry("visibility", static_cast<int>(m_mode));
 
     updateKWinEdgesSupport();
 
     emit modeChanged();
 }
 
 void VisibilityManager::updateStrutsBasedOnLayoutsAndActivities()
 {
     bool multipleLayoutsAndCurrent = (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts
                                       && m_latteView->managedLayout() && !m_latteView->positioner()->inLocationChangeAnimation()
                                       && m_latteView->managedLayout()->name() == m_corona->layoutManager()->currentLayoutName());
 
     if (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout || multipleLayoutsAndCurrent) {
         wm->setViewStruts(*m_latteView, m_viewGeometry, m_latteView->location());
     } else {
         wm->removeViewStruts(*m_latteView);
     }
 }
 
 bool VisibilityManager::raiseOnDesktop() const
 {
     return raiseOnDesktopChange;
 }
 
 void VisibilityManager::setRaiseOnDesktop(bool enable)
 {
     if (enable == raiseOnDesktopChange)
         return;
 
     raiseOnDesktopChange = enable;
     emit raiseOnDesktopChanged();
 }
 
 bool VisibilityManager::raiseOnActivity() const
 {
     return raiseOnActivityChange;
 }
 
 void VisibilityManager::setRaiseOnActivity(bool enable)
 {
     if (enable == raiseOnActivityChange)
         return;
 
     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;
 
-    if (supportsKWinEdges()) {
-        bool inCurrentLayout = (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout ||
-                                (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts
-                                 && m_latteView->managedLayout() && !m_latteView->positioner()->inLocationChangeAnimation()
-                                 && m_latteView->managedLayout()->name() == m_corona->layoutManager()->currentLayoutName()));
-
-        if (inCurrentLayout) {
-            wm->setEdgeStateFor(edgeGhostWindow, m_isHidden);
-        } else {
-            wm->setEdgeStateFor(edgeGhostWindow, false);
-        }
-    }
+    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 (edgeGhostWindow != nullptr);
 }
 
+void VisibilityManager::updateGhostWindowState()
+{
+    if (supportsKWinEdges()) {
+        bool inCurrentLayout = (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout ||
+                                (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts
+                                 && m_latteView->managedLayout() && !m_latteView->positioner()->inLocationChangeAnimation()
+                                 && m_latteView->managedLayout()->name() == m_corona->layoutManager()->currentLayoutName()));
+
+        if (inCurrentLayout) {
+            wm->setEdgeStateFor(edgeGhostWindow, m_isHidden);
+        } else {
+            wm->setEdgeStateFor(edgeGhostWindow, false);
+        }
+    }
+}
+
 void VisibilityManager::raiseView(bool raise)
 {
     if (m_blockHiding)
         return;
 
     if (raise) {
         m_timerHide.stop();
 
         if (!m_timerShow.isActive()) {
             m_timerShow.start();
         }
     } else if (!dragEnter) {
         m_timerShow.stop();
 
         if (hideNow) {
             hideNow = false;
             emit mustBeHide();
         } else if (!m_timerHide.isActive()) {
             m_timerHide.start();
         }
     }
 }
 
 void VisibilityManager::raiseViewTemporarily()
 {
     if (raiseTemporarily)
         return;
 
     raiseTemporarily = true;
     m_timerHide.stop();
     m_timerShow.stop();
 
     if (m_isHidden)
         emit mustBeShown();
 
     QTimer::singleShot(qBound(1800, 2 * m_timerHide.interval(), 3000), this, [&]() {
         raiseTemporarily = false;
         hideNow = true;
         updateHiddenState();
     });
 }
 
 void VisibilityManager::updateHiddenState()
 {
     if (dragEnter)
         return;
 
     switch (m_mode) {
         case Types::AutoHide:
             raiseView(m_containsMouse);
             break;
 
         case Types::DodgeActive:
             dodgeActive(wm->activeWindow());
             break;
 
         case Types::DodgeMaximized:
             dodgeMaximized(wm->activeWindow());
             break;
 
         case Types::DodgeAllWindows:
             dodgeAllWindows();
             break;
 
         default:
             break;
     }
 }
 
 void VisibilityManager::setViewGeometry(const QRect &geometry)
 {
     if (!m_latteView->containment())
         return;
 
     m_viewGeometry = geometry;
 
     if (m_mode == Types::AlwaysVisible && !m_latteView->inEditMode() && m_latteView->screen()) {
         updateStrutsBasedOnLayoutsAndActivities();
     }
 }
 
 void VisibilityManager::applyActivitiesToHiddenWindows(const QStringList &activities)
 {
     if (edgeGhostWindow) {
         wm->setWindowOnActivities(*edgeGhostWindow, activities);
     }
 }
 
 void VisibilityManager::activeWindowDraggingStarted()
 {
     setContainsMouse(false);
     updateHiddenState();
 }
 
 void VisibilityManager::dodgeActive(WindowId wid)
 {
     if (raiseTemporarily)
         return;
 
     //!don't send false raiseView signal when containing mouse
     if (m_containsMouse) {
         raiseView(true);
         return;
     }
 
     auto winfo = wm->requestInfo(wid);
 
     if (!winfo.isValid() || !winfo.isActive()) {
         winfo = wm->requestInfo(wm->activeWindow());
 
         if (!winfo.isValid()) {
             //! very rare case that window manager doesn't have any active window at all
             raiseView(true);
             return;
         }
     }
 
     //! don't send false raiseView signal when containing mouse, // Johan comment
     //! I don't know why that wasn't winfo.wid() //active window, but just wid//the window that made the call
     if (wm->isOnCurrentDesktop(winfo.wid()) && wm->isOnCurrentActivity(winfo.wid())) {
         bool overlaps{intersects(winfo)};
         raiseView(!overlaps);
     }
 }
 
 void VisibilityManager::dodgeMaximized(WindowId wid)
 {
     if (raiseTemporarily)
         return;
 
     //!don't send false raiseView signal when containing mouse
     if (m_containsMouse) {
         raiseView(true);
         return;
     }
 
     auto winfo = wm->requestInfo(wid);
 
     if (!winfo.isValid() || !winfo.isActive()) {
         winfo = wm->requestInfo(wm->activeWindow());
 
         if (!winfo.isValid()) {
             //! very rare case that window manager doesn't have any active window at all
             raiseView(true);
             return;
         }
     }
 
     auto intersectsMaxVert = [&]() noexcept -> bool {
         return ((winfo.isMaxVert()
                  || (m_latteView->screen() && m_latteView->screen()->availableSize().height() <= winfo.geometry().height()))
                 && intersects(winfo));
     };
 
     auto intersectsMaxHoriz = [&]() noexcept -> bool {
         return ((winfo.isMaxHoriz()
                  || (m_latteView->screen() && m_latteView->screen()->availableSize().width() <= winfo.geometry().width()))
                 && intersects(winfo));
     };
 
     //! don't send false raiseView signal when containing mouse, // Johan comment
     //! I don't know why that wasn't winfo.wid() //active window, but just wid//the window that made the call
     if (wm->isOnCurrentDesktop(winfo.wid()) && wm->isOnCurrentActivity(winfo.wid())) {
         bool overlapsMaximized{m_latteView->formFactor() == Plasma::Types::Vertical ? intersectsMaxHoriz() : intersectsMaxVert()};
         raiseView(!overlapsMaximized);
     }
 }
 
 void VisibilityManager::dodgeAllWindows()
 {
     if (raiseTemporarily)
         return;
 
     if (m_containsMouse) {
         raiseView(true);
     }
 
     bool windowIntersects{m_latteView->windowsTracker()->activeWindowTouching() || m_latteView->windowsTracker()->existsWindowTouching()};
 
     raiseView(!windowIntersects);
 }
 
 bool VisibilityManager::intersects(const WindowInfoWrap &winfo)
 {
     return (!winfo.isMinimized()
             && wm->isOnCurrentDesktop(winfo.wid())
             && wm->isOnCurrentActivity(winfo.wid())
             && winfo.geometry().intersects(m_viewGeometry)
             && !winfo.isShaded());
 }
 
 void VisibilityManager::saveConfig()
 {
     if (!m_latteView->containment())
         return;
 
     auto config = m_latteView->containment()->config();
 
     config.writeEntry("enableKWinEdges", enableKWinEdgesFromUser);
     config.writeEntry("timerShow", m_timerShow.interval());
     config.writeEntry("timerHide", m_timerHide.interval());
     config.writeEntry("raiseOnDesktopChange", raiseOnDesktopChange);
     config.writeEntry("raiseOnActivityChange", 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();
 
     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, [&]() {
             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:
             setContainsMouse(false);
             updateHiddenState();
 
             break;
 
         case QEvent::DragEnter:
             dragEnter = true;
 
             if (m_isHidden)
                 emit mustBeShown();
 
             break;
 
         case QEvent::DragLeave:
         case QEvent::Drop:
             dragEnter = false;
             updateHiddenState();
             break;
 
         case QEvent::Show:
             wm->setViewExtraFlags(*m_latteView);
             break;
 
         default:
             break;
     }
 }
 
 //! KWin Edges Support functions
 bool VisibilityManager::enableKWinEdges() const
 {
     return enableKWinEdgesFromUser;
 }
 
 void VisibilityManager::setEnableKWinEdges(bool enable)
 {
     if (enableKWinEdgesFromUser == enable) {
         return;
     }
 
     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) {
         if (enableKWinEdgesFromUser) {
             createEdgeGhostWindow();
         } else if (!enableKWinEdgesFromUser) {
             deleteEdgeGhostWindow();
         }
     } else if (m_mode == Types::AlwaysVisible
                || m_mode == Types::WindowsGoBelow) {
         deleteEdgeGhostWindow();
     }
 }
 
 void VisibilityManager::createEdgeGhostWindow()
 {
     if (!edgeGhostWindow) {
         edgeGhostWindow = new ScreenEdgeGhostWindow(m_latteView);
 
         wm->setViewExtraFlags(*edgeGhostWindow);
 
         connect(edgeGhostWindow, &ScreenEdgeGhostWindow::containsMouseChanged, this, [ = ](bool contains) {
             if (contains) {
-                emit mustBeShown();
+                raiseView(true);
+            } else {
+                m_timerShow.stop();
+                updateGhostWindowState();
             }
         });
 
         connectionsKWinEdges[0] = connect(wm, &WindowSystem::currentActivityChanged,
         this, [&]() {
             bool inCurrentLayout = (m_corona->layoutManager()->memoryUsage() == Types::SingleLayout ||
                                     (m_corona->layoutManager()->memoryUsage() == Types::MultipleLayouts
                                      && m_latteView->managedLayout() && !m_latteView->positioner()->inLocationChangeAnimation()
                                      && m_latteView->managedLayout()->name() == m_corona->layoutManager()->currentLayoutName()));
 
             if (edgeGhostWindow) {
                 if (inCurrentLayout) {
                     wm->setEdgeStateFor(edgeGhostWindow, m_isHidden);
                 } else {
                     wm->setEdgeStateFor(edgeGhostWindow, false);
                 }
             }
         });
 
         emit supportsKWinEdgesChanged();
     }
 }
 
 void VisibilityManager::deleteEdgeGhostWindow()
 {
     if (edgeGhostWindow) {
         edgeGhostWindow->deleteLater();
         edgeGhostWindow = nullptr;
 
         for (auto &c : connectionsKWinEdges) {
             disconnect(c);
         }
 
         emit supportsKWinEdgesChanged();
     }
 }
 
 //! END: VisibilityManager implementation
 
 }
 }
diff --git a/app/view/visibilitymanager.h b/app/view/visibilitymanager.h
index d2bba331..35a4c834 100644
--- a/app/view/visibilitymanager.h
+++ b/app/view/visibilitymanager.h
@@ -1,183 +1,184 @@
 /*
 *  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 VISIBILITYMANAGER_H
 #define VISIBILITYMANAGER_H
 
 // local
 #include "../plasma/quick/containmentview.h"
 #include "../schemecolors.h"
 #include "../wm/abstractwindowinterface.h"
 #include "../wm/windowinfowrap.h"
 #include "../../liblatte2/types.h"
 
 // Qt
 #include <QObject>
 #include <QTimer>
 
 // Plasma
 #include <Plasma/Containment>
 
 namespace Latte {
 class Corona;
 class View;
 namespace ViewPart {
 class ScreenEdgeGhostWindow;
 }
 }
 
 namespace Latte {
 namespace ViewPart {
 
 class VisibilityManager : public QObject
 {
     Q_OBJECT
 
     Q_PROPERTY(Latte::Types::Visibility mode READ mode WRITE setMode NOTIFY modeChanged)
     Q_PROPERTY(bool raiseOnDesktop READ raiseOnDesktop WRITE setRaiseOnDesktop NOTIFY raiseOnDesktopChanged)
     Q_PROPERTY(bool raiseOnActivity READ raiseOnActivity WRITE setRaiseOnActivity NOTIFY raiseOnActivityChanged)
     Q_PROPERTY(bool isHidden READ isHidden WRITE setIsHidden NOTIFY isHiddenChanged)
     Q_PROPERTY(bool blockHiding READ blockHiding WRITE setBlockHiding NOTIFY blockHidingChanged)
     Q_PROPERTY(bool containsMouse READ containsMouse NOTIFY containsMouseChanged)
 
     //! KWin Edges Support Options
     Q_PROPERTY(bool enableKWinEdges READ enableKWinEdges WRITE setEnableKWinEdges NOTIFY enableKWinEdgesChanged)
     Q_PROPERTY(bool supportsKWinEdges READ supportsKWinEdges NOTIFY supportsKWinEdgesChanged)
 
     Q_PROPERTY(int timerShow READ timerShow WRITE setTimerShow NOTIFY timerShowChanged)
     Q_PROPERTY(int timerHide READ timerHide WRITE setTimerHide NOTIFY timerHideChanged)
 
 public:
     explicit VisibilityManager(PlasmaQuick::ContainmentView *view);
     virtual ~VisibilityManager();
 
     Latte::Types::Visibility mode() const;
     void setMode(Latte::Types::Visibility mode);
 
     void applyActivitiesToHiddenWindows(const QStringList &activities);
 
     bool raiseOnDesktop() const;
     void setRaiseOnDesktop(bool enable);
 
     bool raiseOnActivity() const;
     void setRaiseOnActivity(bool enable);
 
     bool isHidden() const;
     void setIsHidden(bool isHidden);
 
     bool blockHiding() const;
     void setBlockHiding(bool blockHiding);
 
     bool containsMouse() const;
 
     int timerShow() const;
     void setTimerShow(int msec);
 
     int timerHide() const;
     void setTimerHide(int msec);
 
     bool intersects(const WindowInfoWrap &winfo);
 
     //! KWin Edges Support functions
     bool enableKWinEdges() const;
     void setEnableKWinEdges(bool enable);
 
     bool supportsKWinEdges() const;
 
     //! called for windowTracker to reset values
     void activeWindowDraggingStarted();
 
 signals:
     void mustBeShown();
     void mustBeHide();
 
     void modeChanged();
     void raiseOnDesktopChanged();
     void raiseOnActivityChanged();
     void isHiddenChanged();
     void blockHidingChanged();
     void containsMouseChanged();
     void timerShowChanged();
     void timerHideChanged();
 
     //! KWin Edges Support signals
     void enableKWinEdgesChanged();
     void supportsKWinEdgesChanged();
 
 private slots:
     void saveConfig();
     void restoreConfig();
 
 private:
     void setContainsMouse(bool contains);
 
     void raiseView(bool raise);
     void raiseViewTemporarily();
     void updateHiddenState();
 
 
     //! KWin Edges Support functions
     void createEdgeGhostWindow();
     void deleteEdgeGhostWindow();
     void updateKWinEdgesSupport();
+    void updateGhostWindowState();
 
     void setViewGeometry(const QRect &rect);
 
     void windowAdded(WindowId id);
     void dodgeActive(WindowId id);
     void dodgeMaximized(WindowId id);
 
     void updateStrutsBasedOnLayoutsAndActivities();
     void viewEventManager(QEvent *ev);
 
 private slots:
     void dodgeAllWindows();
 
 private:
     AbstractWindowInterface *wm;
     Types::Visibility m_mode{Types::None};
     std::array<QMetaObject::Connection, 5> connections;
 
     QTimer m_timerShow;
     QTimer m_timerHide;
     QTimer m_timerStartUp;
     QRect m_viewGeometry;
     bool m_isHidden{false};
     bool dragEnter{false};
     bool m_blockHiding{false};
     bool m_containsMouse{false};
     bool raiseTemporarily{false};
     bool raiseOnDesktopChange{false};
     bool raiseOnActivityChange{false};
     bool hideNow{false};
 
     //! KWin Edges
     bool enableKWinEdgesFromUser{true};
     std::array<QMetaObject::Connection, 1> connectionsKWinEdges;
     ScreenEdgeGhostWindow *edgeGhostWindow{nullptr};
 
     Latte::Corona *m_corona{nullptr};
     Latte::View *m_latteView{nullptr};
 
 };
 
 }
 }
 #endif // VISIBILITYMANAGER_H