diff --git a/app/view/effects.cpp b/app/view/effects.cpp
index 4b2786c6..c66f2297 100644
--- a/app/view/effects.cpp
+++ b/app/view/effects.cpp
@@ -1,506 +1,507 @@
 /*
 *  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 "effects.h"
 
 // local
 #include "panelshadows_p.h"
 #include "view.h"
 #include "settings/primaryconfigview.h"
 #include "../../liblatte2/types.h"
 
 // Qt
 #include <QRegion>
 
 // KDE
 #include <KWindowEffects>
 #include <KWindowSystem>
 
 namespace Latte {
 namespace ViewPart {
 
 Effects::Effects(Latte::View *parent)
     : QObject(parent),
       m_view(parent)
 {
     init();
 }
 
 Effects::~Effects()
 {
 }
 
 void Effects::init()
 {
     connect(this, &Effects::backgroundOpacityChanged, this, &Effects::updateEffects);
     connect(this, &Effects::drawEffectsChanged, this, &Effects::updateEffects);
     connect(this, &Effects::rectChanged, this, &Effects::updateEffects);
     connect(this, &Effects::settingsMaskSubtractedChanged, this, &Effects::updateMask);
 
     connect(this, &Effects::drawShadowsChanged, this, [&]() {
         if (m_view->behaveAsPlasmaPanel()) {
             updateEnabledBorders();
         }
     });
 
     connect(m_view, &Latte::View::alignmentChanged, this, &Effects::updateEnabledBorders);
     connect(m_view, &Latte::View::behaveAsPlasmaPanelChanged, this, &Effects::updateEffects);
     connect(m_view, &Latte::View::behaveAsPlasmaPanelChanged, this, &Effects::updateShadows);
     connect(m_view, &Latte::View::configWindowGeometryChanged, this, &Effects::updateMask);
 
     connect(this, SIGNAL(innerShadowChanged()), m_view->corona(), SIGNAL(availableScreenRectChanged()));
 }
 
 bool Effects::animationsBlocked() const
 {
     return m_animationsBlocked;
 }
 
 void Effects::setAnimationsBlocked(bool blocked)
 {
     if (m_animationsBlocked == blocked) {
         return;
     }
 
     m_animationsBlocked = blocked;
     emit animationsBlockedChanged();
 }
 
 bool Effects::drawShadows() const
 {
     return m_drawShadows;
 }
 
 void Effects::setDrawShadows(bool draw)
 {
     if (m_drawShadows == draw) {
         return;
     }
 
     m_drawShadows = draw;
 
     if (m_view->behaveAsPlasmaPanel() && m_drawShadows) {
         PanelShadows::self()->addWindow(m_view, m_enabledBorders);
     } else {
         PanelShadows::self()->removeWindow(m_view);
     }
 
     emit drawShadowsChanged();
 }
 
 bool Effects::drawEffects() const
 {
     return m_drawEffects;
 }
 
 void Effects::setDrawEffects(bool draw)
 {
     if (m_drawEffects == draw) {
         return;
     }
 
     m_drawEffects = draw;
 
     emit drawEffectsChanged();
 }
 
 bool Effects::forceDrawCenteredBorders() const
 {
     return m_forceDrawCenteredBorders;
 }
 
 void Effects::setForceDrawCenteredBorders(bool draw)
 {
     if (m_forceDrawCenteredBorders == draw) {
         return;
     }
 
     m_forceDrawCenteredBorders = draw;
 }
 
 int Effects::backgroundOpacity() const
 {
     return m_backgroundOpacity;
 }
 
 void Effects::setBackgroundOpacity(int opacity)
 {
     if (m_backgroundOpacity == opacity) {
         return;
     }
 
     m_backgroundOpacity = opacity;
     emit backgroundOpacityChanged();
 }
 
 int Effects::editShadow() const
 {
     return m_editShadow;
 }
 
 void Effects::setEditShadow(int shadow)
 {
     if (m_editShadow == shadow) {
         return;
     }
 
     m_editShadow = shadow;
     emit editShadowChanged();
 }
 
 int Effects::innerShadow() const
 {
     return m_innerShadow;
 }
 
 void Effects::setInnerShadow(int shadow)
 {
     if (m_innerShadow == shadow)
         return;
 
     m_innerShadow = shadow;
 
     emit innerShadowChanged();
 }
 
 bool Effects::settingsMaskSubtracted() const
 {
     return m_settingsMaskSubtracted;
 }
 
 void Effects::setSettingsMaskSubtracted(bool enabled)
 {
     if (m_settingsMaskSubtracted == enabled) {
         return;
     }
 
     m_settingsMaskSubtracted = enabled;
+
     emit settingsMaskSubtractedChanged();
 }
 
 QRegion Effects::subtrackedMaskFromWindow(QRegion initialRegion, QQuickView *window)
 {
     QRegion subtractedMask = initialRegion;
 
     int start;
     int length;
 
     if (m_view->formFactor() == Plasma::Types::Horizontal) {
         if (KWindowSystem::isPlatformX11()) {
             start = window->x();
             length = window->width();
         } else {
             start = m_view->x();
             length = m_view->width();
         }
     } else {
         if (KWindowSystem::isPlatformX11()) {
             start = window->y();
             length = window->height();
         } else {
             start = m_view->y();
             length = m_view->height();
         }
     }
 
     if (m_settingsMaskSubtracted && window) {
         QRect windowMask;
         //! we need to subtrack the mask areas that overlap with underlying window
         switch (m_view->location()) {
             case Plasma::Types::TopEdge:
                 windowMask.setTopLeft(QPoint(start - m_view->x(), m_mask.y() + m_mask.height() - m_editShadow));
                 windowMask.setSize(QSize(length, m_editShadow));
                 break;
 
             case Plasma::Types::LeftEdge:
                 windowMask.setTopLeft(QPoint(m_mask.right() + 1 - m_editShadow, start - m_view->y()));
                 windowMask.setSize(QSize(m_editShadow, length));
                 break;
 
             case Plasma::Types::RightEdge:
                 windowMask.setTopLeft(QPoint(m_mask.x(), start - m_view->y()));
                 windowMask.setSize(QSize(m_editShadow, length));
                 break;
 
             case Plasma::Types::BottomEdge:
                 windowMask.setTopLeft(QPoint(start - m_view->x(), m_mask.y()));
                 windowMask.setSize(QSize(length, m_editShadow));
                 break;
 
             default:
                 break;
         }
 
         subtractedMask = subtractedMask.subtracted(windowMask);
     }
 
     return subtractedMask;
 }
 
 QRegion Effects::subtractedMask()
 {
     QRegion subMask = m_mask;
 
     if (m_settingsMaskSubtracted && m_view->configView()) {
         subMask = subtrackedMaskFromWindow(subMask, m_view->configView());
 
         ViewPart::PrimaryConfigView *primaryConfig = qobject_cast<ViewPart::PrimaryConfigView *>(m_view->configView());
 
         if (primaryConfig && m_view->formFactor() == Plasma::Types::Horizontal && primaryConfig->secondaryWindow()) {
             subMask = subtrackedMaskFromWindow(subMask, primaryConfig->secondaryWindow());
         }
     }
 
     return subMask;
 }
 
 QRect Effects::rect() const
 {
     return m_rect;
 }
 
 void Effects::setRect(QRect area)
 {
     if (KWindowSystem::compositingActive()) {
         QRect inWindowRect = area.intersected(QRect(0, 0, m_view->width(), m_view->height()));
 
         if (m_rect == inWindowRect) {
             return;
         }
 
         m_rect = inWindowRect;
     } else {
         if (m_rect == area) {
             return;
         }
 
         m_rect = area;
     }
 
     emit rectChanged();
 }
 
 QRect Effects::mask() const
 {
     return m_mask;
 }
 
 void Effects::setMask(QRect area)
 {
     if (m_mask == area)
         return;
 
     m_mask = area;
     updateMask();
 
     // qDebug() << "dock mask set:" << m_mask;
     emit maskChanged();
 }
 
 void Effects::updateMask()
 {
     if (KWindowSystem::compositingActive()) {
         if (m_view->behaveAsPlasmaPanel()) {
             m_view->setMask(QRect());
         } else {
             m_view->setMask(subtractedMask());
         }
     } else {
         //! this is used when compositing is disabled and provides
         //! the correct way for the mask to be painted in order for
         //! rounded corners to be shown correctly
         //! the enabledBorders check was added because there was cases
         //! that the mask region wasn't calculated correctly after location changes
         if (!m_background || m_background->enabledBorders() != m_enabledBorders) {
             m_background = new Plasma::FrameSvg(this);
         }
 
         if (m_background->imagePath() != "opaque/dialogs/background") {
             m_background->setImagePath(QStringLiteral("opaque/dialogs/background"));
         }
 
         m_background->setEnabledBorders(m_enabledBorders);
         m_background->resizeFrame(m_mask.size());
         QRegion fixedMask = m_background->mask();
         fixedMask.translate(m_mask.x(), m_mask.y());
 
         //! fix for KF5.32 that return empty QRegion's for the mask
         if (fixedMask.isEmpty()) {
             fixedMask = QRegion(m_mask);
         }
 
         m_view->setMask(fixedMask);
     }
 }
 
 void Effects::clearShadows()
 {
     PanelShadows::self()->removeWindow(m_view);
 }
 
 void Effects::updateShadows()
 {
     if (m_view->behaveAsPlasmaPanel() && drawShadows()) {
         PanelShadows::self()->addWindow(m_view, enabledBorders());
     } else {
         PanelShadows::self()->removeWindow(m_view);
     }
 }
 
 void Effects::updateEffects()
 {
     //! Don't apply any effect before the wayland surface is created under wayland
     //! https://bugs.kde.org/show_bug.cgi?id=392890
     if (KWindowSystem::isPlatformWayland() && !m_view->surface()) {
         return;
     }
 
     if (!m_view->behaveAsPlasmaPanel()) {
         if (m_drawEffects && !m_rect.isNull() && !m_rect.isEmpty()) {
             //! this is used when compositing is disabled and provides
             //! the correct way for the mask to be painted in order for
             //! rounded corners to be shown correctly
             if (!m_background) {
                 m_background = new Plasma::FrameSvg(this);
             }
 
             if (m_background->imagePath() != "widgets/panel-background") {
                 m_background->setImagePath(QStringLiteral("widgets/panel-background"));
             }
 
             m_background->setEnabledBorders(m_enabledBorders);
             m_background->resizeFrame(m_rect.size());
             QRegion fixedMask = m_background->mask();
             fixedMask.translate(m_rect.x(), m_rect.y());
 
             //! fix1, for KF5.32 that return empty QRegion's for the mask
             if (fixedMask.isEmpty()) {
                 fixedMask = QRegion(m_rect);
             }
 
             KWindowEffects::enableBlurBehind(m_view->winId(), true, fixedMask);
 
             bool drawBackgroundEffect = m_theme.backgroundContrastEnabled() && (m_backgroundOpacity == 100);
             //based on Breeze Dark theme behavior the enableBackgroundContrast even though it does accept
             //a QRegion it uses only the first rect. The bug was that for Breeze Dark there was a line
             //at the dock bottom that was distinguishing it from other themes
             KWindowEffects::enableBackgroundContrast(m_view->winId(), drawBackgroundEffect,
                     m_theme.backgroundContrast(),
                     m_theme.backgroundIntensity(),
                     m_theme.backgroundSaturation(),
                     fixedMask.boundingRect());
         } else {
             KWindowEffects::enableBlurBehind(m_view->winId(), false);
             KWindowEffects::enableBackgroundContrast(m_view->winId(), false);
         }
     } else if (m_view->behaveAsPlasmaPanel() && m_drawEffects) {
         KWindowEffects::enableBlurBehind(m_view->winId(), true);
 
         bool drawBackgroundEffect = m_theme.backgroundContrastEnabled() && (m_backgroundOpacity == 100);
 
         KWindowEffects::enableBackgroundContrast(m_view->winId(), drawBackgroundEffect,
                 m_theme.backgroundContrast(),
                 m_theme.backgroundIntensity(),
                 m_theme.backgroundSaturation());
     } else {
         KWindowEffects::enableBlurBehind(m_view->winId(), false);
         KWindowEffects::enableBackgroundContrast(m_view->winId(), false);
     }
 }
 
 //!BEGIN draw panel shadows outside the dock window
 Plasma::FrameSvg::EnabledBorders Effects::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void Effects::updateEnabledBorders()
 {
     if (!m_view->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_view->location()) {
         case Plasma::Types::TopEdge:
             borders &= ~Plasma::FrameSvg::TopBorder;
             break;
 
         case Plasma::Types::LeftEdge:
             borders &= ~Plasma::FrameSvg::LeftBorder;
             break;
 
         case Plasma::Types::RightEdge:
             borders &= ~Plasma::FrameSvg::RightBorder;
             break;
 
         case Plasma::Types::BottomEdge:
             borders &= ~Plasma::FrameSvg::BottomBorder;
             break;
 
         default:
             break;
     }
 
     if ((m_view->location() == Plasma::Types::LeftEdge || m_view->location() == Plasma::Types::RightEdge)) {
         if (m_view->maxLength() == 1 && m_view->alignment() == Latte::Types::Justify && !m_forceDrawCenteredBorders) {
             borders &= ~Plasma::FrameSvg::TopBorder;
             borders &= ~Plasma::FrameSvg::BottomBorder;
         }
 
         if (m_view->alignment() == Latte::Types::Top && !m_forceDrawCenteredBorders && m_view->offset() == 0) {
             borders &= ~Plasma::FrameSvg::TopBorder;
         }
 
         if (m_view->alignment() == Latte::Types::Bottom && !m_forceDrawCenteredBorders && m_view->offset() == 0) {
             borders &= ~Plasma::FrameSvg::BottomBorder;
         }
     }
 
     if (m_view->location() == Plasma::Types::TopEdge || m_view->location() == Plasma::Types::BottomEdge) {
         if (m_view->maxLength() == 1 && m_view->alignment() == Latte::Types::Justify) {
             borders &= ~Plasma::FrameSvg::LeftBorder;
             borders &= ~Plasma::FrameSvg::RightBorder;
         }
 
         if (m_view->alignment() == Latte::Types::Left && m_view->offset() == 0) {
             borders &= ~Plasma::FrameSvg::LeftBorder;
         }
 
         if (m_view->alignment() == Latte::Types::Right  && m_view->offset() == 0) {
             borders &= ~Plasma::FrameSvg::RightBorder;
         }
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
         emit enabledBordersChanged();
     }
 
     if (!m_view->behaveAsPlasmaPanel() || !m_drawShadows) {
         PanelShadows::self()->removeWindow(m_view);
     } else {
         PanelShadows::self()->setEnabledBorders(m_view, borders);
     }
 }
 //!END draw panel shadows outside the dock window
 
 }
 }
diff --git a/app/view/effects.h b/app/view/effects.h
index 983924f0..05106693 100644
--- a/app/view/effects.h
+++ b/app/view/effects.h
@@ -1,147 +1,147 @@
 /*
 *  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 EFFECTS_H
 #define EFFECTS_H
 
 // Qt
 #include <QObject>
 #include <QPointer>
 #include <QQuickView>
 #include <QRect>
 
 // Plasma
 #include <Plasma/FrameSvg>
 #include <Plasma/Theme>
 
 namespace Latte {
 class View;
 }
 
 namespace Latte {
 namespace ViewPart {
 
 class Effects: public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool animationsBlocked READ animationsBlocked NOTIFY animationsBlockedChanged)
     Q_PROPERTY(bool drawShadows READ drawShadows WRITE setDrawShadows NOTIFY drawShadowsChanged)
     Q_PROPERTY(bool drawEffects READ drawEffects WRITE setDrawEffects NOTIFY drawEffectsChanged)
     Q_PROPERTY(bool settingsMaskSubtracted READ settingsMaskSubtracted WRITE setSettingsMaskSubtracted NOTIFY settingsMaskSubtractedChanged)
 
     //! thickness shadow size when is drawn inside the window from qml
     Q_PROPERTY(int backgroundOpacity READ backgroundOpacity WRITE setBackgroundOpacity NOTIFY backgroundOpacityChanged)
     Q_PROPERTY(int editShadow READ editShadow WRITE setEditShadow NOTIFY editShadowChanged)
     Q_PROPERTY(int innerShadow READ innerShadow WRITE setInnerShadow NOTIFY innerShadowChanged)
 
     Q_PROPERTY(QRect mask READ mask WRITE setMask NOTIFY maskChanged)
     Q_PROPERTY(QRect rect READ rect WRITE setRect NOTIFY rectChanged)
 
     Q_PROPERTY(Plasma::FrameSvg::EnabledBorders enabledBorders READ enabledBorders NOTIFY enabledBordersChanged)
 
 public:
     Effects(Latte::View *parent);
     virtual ~Effects();
 
     bool animationsBlocked() const;
     void setAnimationsBlocked(bool blocked);
 
     bool drawShadows() const;
     void setDrawShadows(bool draw);
 
     bool drawEffects() const;
     void setDrawEffects(bool draw);
 
     bool forceDrawCenteredBorders() const;
     void setForceDrawCenteredBorders(bool draw);
 
     bool settingsMaskSubtracted() const;
     void setSettingsMaskSubtracted(bool enabled);
 
     int backgroundOpacity() const;
     void setBackgroundOpacity(int opacity);
 
     int editShadow() const;
     void setEditShadow(int shadow);
 
     int innerShadow() const;
     void setInnerShadow(int shadow);
 
     QRect mask() const;
     void setMask(QRect area);
 
     QRect rect() const;
     void setRect(QRect area);
 
     Plasma::FrameSvg::EnabledBorders enabledBorders() const;
 
 public slots:
     void clearShadows();
     void updateShadows();
     void updateEffects();
     void updateEnabledBorders();
+    void updateMask();
 
 signals:
     void animationsBlockedChanged();
     void backgroundOpacityChanged();
     void drawShadowsChanged();
     void drawEffectsChanged();
     void editShadowChanged();
     void enabledBordersChanged();
     void maskChanged();
     void innerShadowChanged();
     void rectChanged();
     void settingsMaskSubtractedChanged();
 
 private slots:
     void init();
-    void updateMask();
 
 private:
     QRegion subtractedMask();
     QRegion subtrackedMaskFromWindow(QRegion initialRegion, QQuickView *window);
 
 private:
     bool m_animationsBlocked{false};
     bool m_drawShadows{true};
     bool m_drawEffects{false};
     bool m_forceDrawCenteredBorders{false};
     bool m_settingsMaskSubtracted{false};
 
     int m_backgroundOpacity{100};
     int m_editShadow{0};
     int m_innerShadow{0};
 
     QRect m_rect;
     QRect m_mask;
 
     QPointer<Latte::View> m_view;
 
     Plasma::Theme m_theme;
     //only for the mask on disabled compositing, not to actually paint
     Plasma::FrameSvg *m_background{nullptr};
 
     //only for the mask, not to actually paint
     Plasma::FrameSvg::EnabledBorders m_enabledBorders{Plasma::FrameSvg::AllBorders};
 };
 
 }
 }
 
 #endif
diff --git a/app/view/settings/primaryconfigview.cpp b/app/view/settings/primaryconfigview.cpp
index 1faf8526..600ae68c 100644
--- a/app/view/settings/primaryconfigview.cpp
+++ b/app/view/settings/primaryconfigview.cpp
@@ -1,716 +1,726 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "primaryconfigview.h"
 
 // local
 #include <config-latte.h>
 #include "secondaryconfigview.h"
+#include "../effects.h"
 #include "../panelshadows_p.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../layoutmanager.h"
 #include "../../layout/activelayout.h"
 #include "../../settings/universalsettings.h"
 #include "../../shortcuts/globalshortcuts.h"
 #include "../../shortcuts/shortcutstracker.h"
 #include "../../wm/abstractwindowinterface.h"
 
 // Qt
 #include <QFontMetrics>
 #include <QQuickItem>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedContext>
 #include <KDeclarative/KDeclarative>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Package>
 
 namespace Latte {
 namespace ViewPart {
 
 PrimaryConfigView::PrimaryConfigView(Plasma::Containment *containment, Latte::View *view, QWindow *parent)
     : PlasmaQuick::ConfigView(containment, parent),
       m_latteView(view)
 {
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona());
 
     setupWaylandIntegration();
 
     setScreen(m_latteView->screen());
 
     if (containment) {
         setIcon(qGuiApp->windowIcon());
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(100);
 
     connect(this, &PrimaryConfigView::availableScreenGeometryChanged, this, &PrimaryConfigView::syncGeometry);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::saveConfig);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::updateShowInlineProperties);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::syncGeometry);
 
     connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() {
         setScreen(m_latteView->screen());
         setFlags(wFlags());
 
         if (KWindowSystem::isPlatformX11()) {
 #if KF5_VERSION_MINOR >= 45
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager | NET::SkipSwitcher);
 #else
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
 #endif
 
             KWindowSystem::setOnAllDesktops(winId(), true);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &PrimaryConfigView::syncGeometry);
     connections << connect(containment, &Plasma::Containment::immutabilityChanged, this, &PrimaryConfigView::immutabilityChanged);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 
     connections << connect(m_corona, &Latte::Corona::availableScreenRectChanged, this, [this]() {
         updateAvailableScreenGeometry();
     });
 
     if (m_corona) {
         connections << connect(m_corona, &Latte::Corona::raiseViewsTemporaryChanged, this, &PrimaryConfigView::raiseDocksTemporaryChanged);
     }
 
     if (m_latteView->managedLayout()) {
         emit m_latteView->managedLayout()->configViewCreated(this);
     }
 }
 
 PrimaryConfigView::~PrimaryConfigView()
 {
     qDebug() << "ConfigView deleting ...";
 
     deleteSecondaryWindow();
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 
     if (m_shellSurface) {
         delete m_shellSurface;
         m_shellSurface = nullptr;
     }
 
 }
 
 void PrimaryConfigView::init()
 {
     qDebug() << "dock config view : initialization started...";
     m_originalByPassWM = m_latteView->byPassWM();
     m_originalMode = m_latteView->visibility()->mode();
 
     loadConfig();
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
     PanelShadows::self()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), m_corona->globalShortcuts()->shortcutsTracker());
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
 
     if (m_corona) {
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), m_corona->universalSettings());
         rootContext()->setContextProperty(QStringLiteral("layoutManager"), m_corona->layoutManager());
     }
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedockconfigurationui";
 
     updateEnabledBorders();
     updateAvailableScreenGeometry();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     qDebug() << "dock config view : initialization ended...";
 }
 
 inline Qt::WindowFlags PrimaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint /*| Qt::WindowStaysOnTopHint*/) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QQuickView *PrimaryConfigView::secondaryWindow()
 {
     return m_secConfigView;
 }
 
 void PrimaryConfigView::createSecondaryWindow()
 {
     if (m_secConfigView) {
         return;
     }
 
     m_secConfigView = new SecondaryConfigView(m_latteView, this);
     m_secConfigView->init();
 }
 
 void PrimaryConfigView::deleteSecondaryWindow()
 {
     if (m_secConfigView) {
-        m_secConfigView->deleteLater();
+        auto secWindow = m_secConfigView;
+        m_secConfigView = nullptr;
+        secWindow->deleteLater();
+
+        if (KWindowSystem::isPlatformX11()) {
+            //! this is needed in order for subtracked mask of secondary window to
+            //! be released properly when changing for Advanced to Basic mode.
+            //! Under wayland this is not needed because masks do not break any visuals.
+            m_latteView->effects()->updateMask();
+        }
     }
 }
 
 void PrimaryConfigView::updateAvailableScreenGeometry()
 {
     int currentScrId = m_latteView->positioner()->currentScreenId();
     m_availableScreenGeometry = m_corona->availableScreenRect(currentScrId);
 
     emit availableScreenGeometryChanged();
 }
 
 QRect PrimaryConfigView::availableScreenGeometry() const
 {
     return m_availableScreenGeometry;
 }
 
 QRect PrimaryConfigView::geometryWhenVisible() const
 {
     return m_geometryWhenVisible;
 }
 
 void PrimaryConfigView::requestActivate()
 {
     if (KWindowSystem::isPlatformWayland() && m_shellSurface) {
         WindowId wid = m_corona->wm()->winIdFor("latte-dock", geometry());
         m_corona->wm()->requestActivate(wid);
     } else {
         QQuickView::requestActivate();
     }
 }
 
 void PrimaryConfigView::syncGeometry()
 {
     if (!m_latteView || !m_latteView->managedLayout() || !m_latteView->containment() || !rootObject()) {
         return;
     }
 
     const QSize size(rootObject()->width(), rootObject()->height());
     setMaximumSize(size);
     setMinimumSize(size);
     resize(size);
 
     const auto location = m_latteView->containment()->location();
     const auto scrGeometry = m_latteView->screenGeometry();
     const auto availGeometry = m_availableScreenGeometry;
 
     int clearThickness = m_latteView->editThickness();
 
     QPoint position{0, 0};
 
     int xPos{0};
     int yPos{0};
 
     switch (m_latteView->formFactor()) {
     case Plasma::Types::Horizontal: {
         if (m_complexity == Latte::Types::ExpertSettings) {
             if (qApp->isLeftToRight()) {
                 xPos = availGeometry.x() + availGeometry.width() - size.width();
             } else {
                 xPos = availGeometry.x();
             }
         } else {
             xPos = scrGeometry.center().x() - size.width() / 2;
         }
 
         if (location == Plasma::Types::TopEdge) {
             yPos = scrGeometry.y() + clearThickness;
         } else if (location == Plasma::Types::BottomEdge) {
             yPos = scrGeometry.y() + scrGeometry.height() - clearThickness - size.height();
         }
     }
         break;
 
     case Plasma::Types::Vertical: {
         if (location == Plasma::Types::LeftEdge) {
             xPos = scrGeometry.x() + clearThickness;
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         } else if (location == Plasma::Types::RightEdge) {
             xPos = scrGeometry.x() + scrGeometry.width() - clearThickness - size.width();
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         }
     }
         break;
 
     default:
         qWarning() << "no sync geometry, wrong formFactor";
         break;
     }
 
     position = {xPos, yPos};
 
     updateEnabledBorders();
 
     m_geometryWhenVisible = QRect(position.x(), position.y(), size.width(), size.height());
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 
     updateShowInlineProperties();
 
     emit m_latteView->configWindowGeometryChanged();
 }
 
 void PrimaryConfigView::syncSlideEffect()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto slideLocation = WindowSystem::Slide::None;
 
     switch (m_latteView->containment()->location()) {
     case Plasma::Types::TopEdge:
         slideLocation = WindowSystem::Slide::Top;
         break;
 
     case Plasma::Types::RightEdge:
         slideLocation = WindowSystem::Slide::Right;
         break;
 
     case Plasma::Types::BottomEdge:
         slideLocation = WindowSystem::Slide::Bottom;
         break;
 
     case Plasma::Types::LeftEdge:
         slideLocation = WindowSystem::Slide::Left;
         break;
 
     default:
         qDebug() << staticMetaObject.className() << "wrong location";
         break;
     }
 
     m_corona->wm()->slideWindow(*this, slideLocation);
 }
 
 void PrimaryConfigView::showEvent(QShowEvent *ev)
 {
     QQuickWindow::showEvent(ev);
 
     if (!m_latteView) {
         return;
     }
 
     m_corona->wm()->setViewExtraFlags(*this);
     setFlags(wFlags());
 
     m_corona->wm()->enableBlurBehind(*this);
 
     syncGeometry();
     syncSlideEffect();
 
     if (m_latteView && m_latteView->containment())
         m_latteView->containment()->setUserConfiguring(true);
 
     m_screenSyncTimer.start();
     QTimer::singleShot(400, this, &PrimaryConfigView::syncGeometry);
 
     emit showSignal();
 }
 
 void PrimaryConfigView::hideEvent(QHideEvent *ev)
 {
     if (!m_latteView) {
         QQuickWindow::hideEvent(ev);
         return;
     }
 
     if (m_latteView->containment())
         m_latteView->containment()->setUserConfiguring(false);
 
     QQuickWindow::hideEvent(ev);
 
     const auto mode = m_latteView->visibility()->mode();
 
     if ((mode == Types::AlwaysVisible || mode == Types::WindowsGoBelow)
             && !(m_originalMode == Types::AlwaysVisible || m_originalMode == Types::WindowsGoBelow)) {
         //! mode changed to AlwaysVisible OR WindowsGoBelow FROM Dodge mode
         if (m_originalByPassWM) {
             //! if original by pass is active
             m_latteView->managedLayout()->recreateView(m_latteView->containment());
         }
     } else if (m_latteView->byPassWM() != m_originalByPassWM) {
         m_latteView->managedLayout()->recreateView(m_latteView->containment());
     }
 
     deleteLater();
 }
 
 void PrimaryConfigView::focusOutEvent(QFocusEvent *ev)
 {
     Q_UNUSED(ev);
 
     const auto *focusWindow = qGuiApp->focusWindow();
 
     if ((focusWindow && (focusWindow->flags().testFlag(Qt::Popup)
                          || focusWindow->flags().testFlag(Qt::ToolTip)))
             || m_latteView->alternativesIsShown()) {
         return;
     }
 
     if (!m_blockFocusLost && !m_latteView->containsMouse()
             && (!m_secConfigView || (m_secConfigView && !m_secConfigView->isActive()))) {
         hideConfigWindow();
     }
 }
 
 void PrimaryConfigView::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland primary settings surface was created...";
 
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setSkipTaskbar(true);
 #if KF5_VERSION_MINOR >= 47
         m_shellSurface->setSkipSwitcher(true);
 #endif
 
         syncGeometry();
     }
 }
 
 bool PrimaryConfigView::event(QEvent *e)
 {
     if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
 
                 if (m_shellSurface) {
                     break;
                 }
 
                 setupWaylandIntegration();
                 break;
 
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 if (m_shellSurface) {
                     delete m_shellSurface;
                     m_shellSurface = nullptr;
                     qDebug() << "WAYLAND config window surface was deleted...";
                     PanelShadows::self()->removeWindow(this);
                 }
 
                 break;
             }
         }
     }
 
     return PlasmaQuick::ConfigView::event(e);
 }
 
 
 void PrimaryConfigView::immutabilityChanged(Plasma::Types::ImmutabilityType type)
 {
     if (type != Plasma::Types::Mutable && isVisible())
         hideConfigWindow();
 }
 
 bool PrimaryConfigView::sticker() const
 {
     return m_blockFocusLost;
 }
 
 void PrimaryConfigView::setSticker(bool blockFocusLost)
 {
     if (m_blockFocusLost == blockFocusLost)
         return;
 
     m_blockFocusLost = blockFocusLost;
 }
 
 bool PrimaryConfigView::showInlineProperties() const
 {
     return m_showInlineProperties;
 }
 void PrimaryConfigView::setShowInlineProperties(bool show)
 {
     if (m_showInlineProperties == show) {
         return;
     }
 
     m_showInlineProperties = show;
     emit showInlinePropertiesChanged();
 }
 
 void PrimaryConfigView::updateShowInlineProperties()
 {
     if (!m_latteView) {
         return;
     }
 
     bool showSecWindow{false};
     bool complexityApprovedSecWindow{false};
 
 
     if (m_complexity != Latte::Types::BasicSettings
             && !(m_complexity == Latte::Types::ExpertSettings && m_latteView->formFactor() == Plasma::Types::Vertical)) {
         showSecWindow = true;
         complexityApprovedSecWindow = true;
     }
 
     //! consider screen geometry for showing or not the secondary window
     if (!geometryWhenVisible().isNull()) {
         createSecondaryWindow();
 
         if (m_secConfigView->geometryWhenVisible().intersects(geometryWhenVisible())) {
             showSecWindow = false;
         } else if (complexityApprovedSecWindow) {
             showSecWindow = true;
         }
     }
 
     if (showSecWindow) {
         if (!m_secConfigView) {
             createSecondaryWindow();
         }
 
         if (!KWindowSystem::isPlatformWayland()) {
             QTimer::singleShot(150, m_secConfigView, SLOT(show()));
         } else {
             QTimer::singleShot(150, [this]() {
                 m_secConfigView->setVisible(true);
             });
         }
 
         setShowInlineProperties(false);
     } else {
         deleteSecondaryWindow();
         setShowInlineProperties(true);
     }
 
     // qDebug() << " showSecWindow:" << showSecWindow << " _ " << " inline:"<< !showSecWindow;
 }
 
 int PrimaryConfigView::complexity() const
 {
     return (int)m_complexity;
 }
 
 void PrimaryConfigView::setComplexity(int complexity)
 {
     if ((int)m_complexity == complexity) {
         return;
     }
 
     m_complexity = static_cast<Latte::Types::SettingsComplexity>(complexity);
 
     emit complexityChanged();
 }
 
 void PrimaryConfigView::hideConfigWindow()
 {
     if (m_shellSurface) {
         //!NOTE: Avoid crash in wayland environment with qt5.9
         close();
     } else {
         hide();
     }
 }
 
 void PrimaryConfigView::updateLaunchersForGroup(int groupInt)
 {
     Types::LaunchersGroup group = (Types::LaunchersGroup)groupInt;
 
     //! when the layout/global launchers list is empty then the current dock launchers are used for them
     //! as a start point
     if (m_corona &&  m_latteView->managedLayout()) {
         if ((group == Types::LayoutLaunchers && m_latteView->managedLayout()->launchers().isEmpty())
                 || (group == Types::GlobalLaunchers && m_corona->universalSettings()->launchers().isEmpty())) {
 
             Plasma::Containment *c = m_latteView->containment();
 
             const auto &applets = c->applets();
 
             for (auto *applet : applets) {
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 if (meta.pluginId() == "org.kde.latte.plasmoid") {
                     if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                         const auto &childItems = appletInterface->childItems();
 
                         if (childItems.isEmpty()) {
                             continue;
                         }
 
                         for (QQuickItem *item : childItems) {
                             if (auto *metaObject = item->metaObject()) {
                                 // not using QMetaObject::invokeMethod to avoid warnings when calling
                                 // this on applets that don't have it or other child items since this
                                 // is pretty much trial and error.
                                 // Also, "var" arguments are treated as QVariant in QMetaObject
 
                                 int methodIndex = metaObject->indexOfMethod("getLauncherList()");
 
                                 if (methodIndex == -1) {
                                     continue;
                                 }
 
                                 QMetaMethod method = metaObject->method(methodIndex);
 
                                 QVariant launchers;
 
                                 if (method.invoke(item, Q_RETURN_ARG(QVariant, launchers))) {
                                     if (group == Types::LayoutLaunchers) {
                                         m_latteView->managedLayout()->setLaunchers(launchers.toStringList());
                                     } else if (group == Types::GlobalLaunchers) {
                                         m_corona->universalSettings()->setLaunchers(launchers.toStringList());
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 
 }
 
 //!BEGIN borders
 Plasma::FrameSvg::EnabledBorders PrimaryConfigView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void PrimaryConfigView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::BottomBorder : ~Plasma::FrameSvg::TopBorder;
         break;
 
     case Plasma::Types::LeftEdge:
         borders &= ~Plasma::FrameSvg::LeftBorder;
         break;
 
     case Plasma::Types::RightEdge:
         borders &= ~Plasma::FrameSvg::RightBorder;
         break;
 
     case Plasma::Types::BottomEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::TopBorder : ~Plasma::FrameSvg::BottomBorder;
         break;
 
     default:
         break;
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
 
         PanelShadows::self()->addWindow(this, m_enabledBorders);
 
         emit enabledBordersChanged();
     }
 }
 //!END borders
 
 //!BEGIN configuration
 void PrimaryConfigView::loadConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
     auto config = m_latteView->containment()->config();
     int complexity = config.readEntry("settingsComplexity", (int)Latte::Types::BasicSettings);
     setComplexity(static_cast<Latte::Types::SettingsComplexity>(complexity));
 }
 
 void PrimaryConfigView::saveConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto config = m_latteView->containment()->config();
     config.writeEntry("settingsComplexity", (int)m_complexity);
     config.sync();
 }
 //!END configuration
 
 }
 }