diff --git a/app/lattecorona.cpp b/app/lattecorona.cpp
index 380abb7f..da53014d 100644
--- a/app/lattecorona.cpp
+++ b/app/lattecorona.cpp
@@ -1,1130 +1,1137 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmaibox.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 "lattecorona.h"
 
 // local
 #include "alternativeshelper.h"
 #include "lattedockadaptor.h"
 #include "screenpool.h"
 #include "indicator/factory.h"
 #include "layout/centrallayout.h"
 #include "layout/genericlayout.h"
 #include "layout/sharedlayout.h"
 #include "layouts/importer.h"
 #include "layouts/manager.h"
 #include "layouts/synchronizer.h"
 #include "layouts/launcherssignals.h"
 #include "shortcuts/globalshortcuts.h"
 #include "package/lattepackage.h"
 #include "plasma/extended/screenpool.h"
 #include "plasma/extended/theme.h"
 #include "settings/universalsettings.h"
 #include "view/view.h"
 #include "view/windowstracker/windowstracker.h"
 #include "view/windowstracker/allscreenstracker.h"
 #include "view/windowstracker/currentscreentracker.h"
 #include "wm/abstractwindowinterface.h"
 #include "wm/schemecolors.h"
 #include "wm/waylandinterface.h"
 #include "wm/xwindowinterface.h"
 #include "wm/tracker/lastactivewindow.h"
 #include "wm/tracker/schemes.h"
 #include "wm/tracker/windowstracker.h"
 
 // Qt
 #include <QAction>
 #include <QApplication>
 #include <QScreen>
 #include <QDBusConnection>
 #include <QDebug>
 #include <QDesktopWidget>
 #include <QFile>
 #include <QFontDatabase>
 #include <QQmlContext>
 
 // Plasma
 #include <Plasma>
 #include <Plasma/Corona>
 #include <Plasma/Containment>
 #include <PlasmaQuick/ConfigView>
 
 // KDE
 #include <KActionCollection>
 #include <KPluginMetaData>
 #include <KGlobalAccel>
 #include <KLocalizedString>
 #include <KPackage/Package>
 #include <KPackage/PackageLoader>
 #include <KAboutData>
 #include <KActivities/Consumer>
 #include <KDeclarative/QmlObjectSharedEngine>
 #include <KWindowSystem>
 #include <KWayland/Client/connection_thread.h>
 #include <KWayland/Client/registry.h>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/plasmawindowmanagement.h>
 
 namespace Latte {
 
 Corona::Corona(bool defaultLayoutOnStartup, QString layoutNameOnStartUp, int userSetMemoryUsage, QObject *parent)
     : Plasma::Corona(parent),
       m_defaultLayoutOnStartup(defaultLayoutOnStartup),
       m_userSetMemoryUsage(userSetMemoryUsage),
       m_layoutNameOnStartUp(layoutNameOnStartUp),
       m_activityConsumer(new KActivities::Consumer(this)),
       m_screenPool(new ScreenPool(KSharedConfig::openConfig(), this)),
       m_indicatorFactory(new Indicator::Factory(this)),
       m_universalSettings(new UniversalSettings(KSharedConfig::openConfig(), this)),
       m_globalShortcuts(new GlobalShortcuts(this)),
       m_plasmaScreenPool(new PlasmaExtended::ScreenPool(this)),
       m_themeExtended(new PlasmaExtended::Theme(KSharedConfig::openConfig(), this)),
-      m_layoutsManager(new Layouts::Manager(this))
+      m_layoutsManager(new Layouts::Manager(this)),
+      m_dialogShadows(new PanelShadows(this, QStringLiteral("dialogs/background")))
 {
     //! create the window manager
 
     if (KWindowSystem::isPlatformWayland()) {
         m_wm = new WindowSystem::WaylandInterface(this);
     } else {
         m_wm = new WindowSystem::XWindowInterface(this);
     }
 
     setupWaylandIntegration();
 
     KPackage::Package package(new Latte::Package(this));
 
     m_screenPool->load();
 
     if (!package.isValid()) {
         qWarning() << staticMetaObject.className()
                    << "the package" << package.metadata().rawData() << "is invalid!";
         return;
     } else {
         qDebug() << staticMetaObject.className()
                  << "the package" << package.metadata().rawData() << "is valid!";
     }
 
     setKPackage(package);
     //! universal settings / extendedtheme must be loaded after the package has been set
     m_universalSettings->load();
     m_themeExtended->load();
 
     qmlRegisterTypes();
 
     if (m_activityConsumer && (m_activityConsumer->serviceStatus() == KActivities::Consumer::Running)) {
         load();
     }
 
     connect(m_activityConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
 
     m_viewsScreenSyncTimer.setSingleShot(true);
     m_viewsScreenSyncTimer.setInterval(m_universalSettings->screenTrackerInterval());
     connect(&m_viewsScreenSyncTimer, &QTimer::timeout, this, &Corona::syncLatteViewsToScreens);
     connect(m_universalSettings, &UniversalSettings::screenTrackerIntervalChanged, this, [this]() {
         m_viewsScreenSyncTimer.setInterval(m_universalSettings->screenTrackerInterval());
     });
 
     //! initialize the background tracer for broadcasted backgrounds
     m_backgroundTracer = new KDeclarative::QmlObjectSharedEngine(this);
     m_backgroundTracer->setInitializationDelayed(true);
     m_backgroundTracer->setSource(kPackage().filePath("backgroundTracer"));
     m_backgroundTracer->completeInitialization();
 
     //! Dbus adaptor initialization
     new LatteDockAdaptor(this);
     QDBusConnection dbus = QDBusConnection::sessionBus();
     dbus.registerObject(QStringLiteral("/Latte"), this);
 }
 
 Corona::~Corona()
 {
     //! BEGIN: Give the time to slide-out views when closing
     m_layoutsManager->synchronizer()->hideAllViews();
 
     //! Don't delay the destruction under wayland in any case
     //! because it creates a crash with kwin effects
     //! https://bugs.kde.org/show_bug.cgi?id=392890
     if (!KWindowSystem::isPlatformWayland()) {
         QTimer::singleShot(400, [this]() {
             m_quitTimedEnded = true;
         });
 
         while (!m_quitTimedEnded) {
             QGuiApplication::processEvents(QEventLoop::AllEvents, 50);
         }
     }
 
     //! END: slide-out views when closing
 
     m_viewsScreenSyncTimer.stop();
 
     if (m_layoutsManager->memoryUsage() == Types::SingleLayout) {
         cleanConfig();
     }
 
     qDebug() << "Latte Corona - unload: containments ...";
 
     m_layoutsManager->unload();
 
     m_wm->deleteLater();
+    m_dialogShadows->deleteLater();
     m_globalShortcuts->deleteLater();
     m_layoutsManager->deleteLater();
     m_screenPool->deleteLater();
     m_universalSettings->deleteLater();
     m_plasmaScreenPool->deleteLater();
     m_backgroundTracer->deleteLater();
     m_themeExtended->deleteLater();
     m_indicatorFactory->deleteLater();
 
     disconnect(m_activityConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
     delete m_activityConsumer;
 
     qDebug() << "Latte Corona - deleted...";
 }
 
 void Corona::load()
 {
     if (m_activityConsumer && (m_activityConsumer->serviceStatus() == KActivities::Consumer::Running) && m_activitiesStarting) {
         m_activitiesStarting = false;
 
         disconnect(m_activityConsumer, &KActivities::Consumer::serviceStatusChanged, this, &Corona::load);
 
         m_layoutsManager->load();
 
         connect(this, &Corona::availableScreenRectChangedFrom, this, &Plasma::Corona::availableScreenRectChanged);
         connect(this, &Corona::availableScreenRegionChangedFrom, this, &Plasma::Corona::availableScreenRegionChanged);
 
         connect(qGuiApp, &QGuiApplication::primaryScreenChanged, this, &Corona::primaryOutputChanged, Qt::UniqueConnection);
 
         connect(m_screenPool, &ScreenPool::primaryPoolChanged, this, &Corona::screenCountChanged);
 
         QString assignedLayout = m_layoutsManager->synchronizer()->shouldSwitchToLayout(m_activityConsumer->currentActivity());
 
         QString loadLayoutName = "";
 
         if (!m_defaultLayoutOnStartup && m_layoutNameOnStartUp.isEmpty()) {
             if (!assignedLayout.isEmpty() && assignedLayout != m_universalSettings->currentLayoutName()) {
                 loadLayoutName = assignedLayout;
             } else {
                 loadLayoutName = m_universalSettings->currentLayoutName();
             }
 
             if (!m_layoutsManager->synchronizer()->layoutExists(loadLayoutName)) {
                 loadLayoutName = m_layoutsManager->defaultLayoutName();
                 m_layoutsManager->importDefaultLayout(false);
             }
         } else if (m_defaultLayoutOnStartup) {
             loadLayoutName = m_layoutsManager->importer()->uniqueLayoutName(m_layoutsManager->defaultLayoutName());
             m_layoutsManager->importDefaultLayout(true);
         } else {
             loadLayoutName = m_layoutNameOnStartUp;
         }
 
         if (m_userSetMemoryUsage != -1 && !KWindowSystem::isPlatformWayland()) {
             Types::LayoutsMemoryUsage usage = static_cast<Types::LayoutsMemoryUsage>(m_userSetMemoryUsage);
 
             m_universalSettings->setLayoutsMemoryUsage(usage);
         }
 
         if (KWindowSystem::isPlatformWayland()) {
             m_universalSettings->setLayoutsMemoryUsage(Types::SingleLayout);
         }
 
         m_layoutsManager->loadLayoutOnStartup(loadLayoutName);
 
 
         //! load screens signals such screenGeometryChanged in order to support
         //! plasmoid.screenGeometry properly
         for (QScreen *screen : qGuiApp->screens()) {
             addOutput(screen);
         }
 
         connect(qGuiApp, &QGuiApplication::screenAdded, this, &Corona::addOutput, Qt::UniqueConnection);
         connect(qGuiApp, &QGuiApplication::screenRemoved, this, &Corona::screenRemoved, Qt::UniqueConnection);
     }
 }
 
 void Corona::unload()
 {
     qDebug() << "unload: removing containments...";
 
     while (!containments().isEmpty()) {
         //deleting a containment will remove it from the list due to QObject::destroyed connect in Corona
         //this form doesn't crash, while qDeleteAll(containments()) does
         delete containments().first();
     }
 }
 
 void Corona::setupWaylandIntegration()
 {
     if (!KWindowSystem::isPlatformWayland()) {
         return;
     }
 
     using namespace KWayland::Client;
 
     auto connection = ConnectionThread::fromApplication(this);
 
     if (!connection) {
         return;
     }
 
     Registry *registry{new Registry(this)};
     registry->create(connection);
 
     connect(registry, &Registry::plasmaShellAnnounced, this
             , [this, registry](quint32 name, quint32 version) {
         m_waylandCorona = registry->createPlasmaShell(name, version, this);
     });
 
     QObject::connect(registry, &KWayland::Client::Registry::plasmaWindowManagementAnnounced,
                      [this, registry](quint32 name, quint32 version) {
         KWayland::Client::PlasmaWindowManagement *pwm = registry->createPlasmaWindowManagement(name, version, this);
 
         WindowSystem::WaylandInterface *wI = qobject_cast<WindowSystem::WaylandInterface *>(m_wm);
 
         if (wI) {
             wI->initWindowManagement(pwm);
         }
     });
 
 #if KF5_VERSION_MINOR >= 52
     QObject::connect(registry, &KWayland::Client::Registry::plasmaVirtualDesktopManagementAnnounced,
                      [this, registry] (quint32 name, quint32 version) {
         KWayland::Client::PlasmaVirtualDesktopManagement *vdm = registry->createPlasmaVirtualDesktopManagement(name, version, this);
 
         WindowSystem::WaylandInterface *wI = qobject_cast<WindowSystem::WaylandInterface *>(m_wm);
 
         if (wI) {
             wI->initVirtualDesktopManagement(vdm);
         }
     });
 #endif
 
     registry->setup();
     connection->roundtrip();
 }
 
 KActivities::Consumer *Corona::activityConsumer() const
 {
     return m_activityConsumer;
 }
 
 KWayland::Client::PlasmaShell *Corona::waylandCoronaInterface() const
 {
     return m_waylandCorona;
 }
 
 void Corona::cleanConfig()
 {
     auto containmentsEntries = config()->group("Containments");
     bool changed = false;
 
     for(const auto &cId : containmentsEntries.groupList()) {
         if (!containmentExists(cId.toUInt())) {
             //cleanup obsolete containments
             containmentsEntries.group(cId).deleteGroup();
             changed = true;
             qDebug() << "obsolete containment configuration deleted:" << cId;
         } else {
             //cleanup obsolete applets of running containments
             auto appletsEntries = containmentsEntries.group(cId).group("Applets");
 
             for(const auto &appletId : appletsEntries.groupList()) {
                 if (!appletExists(cId.toUInt(), appletId.toUInt())) {
                     appletsEntries.group(appletId).deleteGroup();
                     changed = true;
                     qDebug() << "obsolete applet configuration deleted:" << appletId;
                 }
             }
         }
     }
 
     if (changed) {
         config()->sync();
         qDebug() << "configuration file cleaned...";
     }
 }
 
 bool Corona::containmentExists(uint id) const
 {
     for(const auto containment : containments()) {
         if (id == containment->id()) {
             return true;
         }
     }
 
     return false;
 }
 
 bool Corona::appletExists(uint containmentId, uint appletId) const
 {
     Plasma::Containment *containment = nullptr;
 
     for(const auto cont : containments()) {
         if (containmentId == cont->id()) {
             containment = cont;
             break;
         }
     }
 
     if (!containment) {
         return false;
     }
 
     for(const auto applet : containment->applets()) {
         if (applet->id() == appletId) {
             return true;
         }
     }
 
     return false;
 }
 
 KActivities::Consumer *Corona::activitiesConsumer() const
 {
     return m_activityConsumer;
 }
 
+PanelShadows *Corona::dialogShadows() const
+{
+    return m_dialogShadows;
+}
+
 GlobalShortcuts *Corona::globalShortcuts() const
 {
     return m_globalShortcuts;
 }
 
 ScreenPool *Corona::screenPool() const
 {
     return m_screenPool;
 }
 
 UniversalSettings *Corona::universalSettings() const
 {
     return m_universalSettings;
 }
 
 WindowSystem::AbstractWindowInterface *Corona::wm() const
 {
     return m_wm;
 }
 
 Indicator::Factory *Corona::indicatorFactory() const
 {
     return m_indicatorFactory;
 }
 
 Layouts::Manager *Corona::layoutsManager() const
 {
     return m_layoutsManager;
 }
 
 PlasmaExtended::ScreenPool *Corona::plasmaScreenPool() const
 {
     return m_plasmaScreenPool;
 }
 
 PlasmaExtended::Theme *Corona::themeExtended() const
 {
     return m_themeExtended;
 }
 
 int Corona::numScreens() const
 {
     return qGuiApp->screens().count();
 }
 
 QRect Corona::screenGeometry(int id) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     QString screenName;
 
     if (m_screenPool->hasId(id)) {
         screenName = m_screenPool->connector(id);
     }
 
     for(const auto scr : screens) {
         if (scr->name() == screenName) {
             screen = scr;
             break;
         }
     }
 
     return screen->geometry();
 }
 
 QRegion Corona::availableScreenRegion(int id) const
 {
     return availableScreenRegionWithCriteria(id);
 }
 
 QRegion Corona::availableScreenRegionWithCriteria(int id, QString forLayout, bool includeExternalPanels) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     QString screenName;
 
     if (m_screenPool->hasId(id)) {
         screenName = m_screenPool->connector(id);
     }
 
     for(auto scr : screens) {
         if (scr->name() == screenName) {
             screen = scr;
             break;
         }
     }
 
     if (!screen) {
         return QRegion();
     }
 
     QList<Latte::View *> views;
 
     if (forLayout.isEmpty()) {
         Latte::CentralLayout *currentLayout = m_layoutsManager->currentLayout();
         views = currentLayout->latteViews();
     } else {
         Layout::GenericLayout *generic = m_layoutsManager->synchronizer()->centralLayout(forLayout);
 
         if (!generic) {
             //! Identify best active layout to be used for metrics calculations.
             //! Active layouts are always take into account their shared layouts for their metrics
             SharedLayout *sharedLayout = m_layoutsManager->synchronizer()->sharedLayout(forLayout);
 
             if (sharedLayout) {
                 generic = sharedLayout->currentCentralLayout();
             }
         }
 
         if (!generic) {
             generic = m_layoutsManager->currentLayout();
         }
 
         views = generic->latteViews();
     }
 
     QRegion available = includeExternalPanels ? screen->availableGeometry() : screen->geometry();
 
     for (const auto *view : views) {
         if (view && view->containment() && view->screen() == screen
                 && view->visibility() && (view->visibility()->mode() != Latte::Types::AutoHide)) {
             int realThickness = view->normalThickness();
 
             // Usually availableScreenRect is used by the desktop,
             // but Latte don't have desktop, then here just
             // need calculate available space for top and bottom location,
             // because the left and right are those who dodge others views
             switch (view->location()) {
             case Plasma::Types::TopEdge:
                 if (view->behaveAsPlasmaPanel()) {
                     available -= view->geometry();
                 } else {
                     QRect realGeometry;
                     int realWidth = view->maxLength() * view->width();
 
                     switch (view->alignment()) {
                     case Latte::Types::Left:
                         realGeometry = QRect(view->x(), view->y(),
                                              realWidth, realThickness);
                         break;
 
                     case Latte::Types::Center:
                     case Latte::Types::Justify:
                         realGeometry = QRect(qMax(view->geometry().x(), view->geometry().center().x() - realWidth / 2), view->y(),
                                              realWidth, realThickness);
                         break;
 
                     case Latte::Types::Right:
                         realGeometry = QRect(view->geometry().right() - realWidth + 1, view->y(),
                                              realWidth, realThickness);
                         break;
                     }
 
                     available -= realGeometry;
                 }
 
                 break;
 
             case Plasma::Types::BottomEdge:
                 if (view->behaveAsPlasmaPanel()) {
                     available -= view->geometry();
                 } else {
                     QRect realGeometry;
                     int realWidth = view->maxLength() * view->width();
                     int realY = view->geometry().bottom() - realThickness + 1;
 
                     switch (view->alignment()) {
                     case Latte::Types::Left:
                         realGeometry = QRect(view->x(), realY,
                                              realWidth, realThickness);
                         break;
 
                     case Latte::Types::Center:
                     case Latte::Types::Justify:
                         realGeometry = QRect(qMax(view->geometry().x(), view->geometry().center().x() - realWidth / 2),
                                              realY, realWidth, realThickness);
                         break;
 
                     case Latte::Types::Right:
                         realGeometry = QRect(view->geometry().right() - realWidth + 1, realY,
                                              realWidth, realThickness);
                         break;
                     }
 
                     available -= realGeometry;
                 }
 
                 break;
 
             default:
                 //! bypass clang warnings
                 break;
             }
         }
     }
 
     /*qDebug() << "::::: FREE AREAS :::::";
 
     for (int i = 0; i < available.rectCount(); ++i) {
         qDebug() << available.rects().at(i);
     }
 
     qDebug() << "::::: END OF FREE AREAS :::::";*/
 
     return available;
 }
 
 QRect Corona::availableScreenRect(int id) const
 {
     return availableScreenRectWithCriteria(id);
 }
 
 QRect Corona::availableScreenRectWithCriteria(int id, QList<Types::Visibility> modes, QList<Plasma::Types::Location> edges, bool includeExternalPanels) const
 {
     const auto screens = qGuiApp->screens();
     const QScreen *screen{qGuiApp->primaryScreen()};
 
     if (m_screenPool->hasId(id)) {
         QString scrName = m_screenPool->connector(id);
 
         for(const auto scr : screens) {
             if (scr->name() == scrName) {
                 screen = scr;
                 break;
             }
         }
     }
 
     if (!screen) {
         return {};
     }
 
     bool allModes = modes.isEmpty();
 
     bool allEdges = edges.isEmpty();
 
     auto available = includeExternalPanels ? screen->availableGeometry() : screen->geometry();
 
     Latte::CentralLayout *currentLayout = m_layoutsManager->currentLayout();
     QList<Latte::View *> views;
 
     if (currentLayout) {
         views = currentLayout->latteViews();
     }
 
     for (const auto *view : views) {
         if (view && view->containment() && view->screen() == screen
                 && ((allEdges || edges.contains(view->location()))
                     && (allModes || (view->visibility() && modes.contains(view->visibility()->mode()))))) {
 
             // Usually availableScreenRect is used by the desktop,
             // but Latte don't have desktop, then here just
             // need calculate available space for top and bottom location,
             // because the left and right are those who dodge others docks
             switch (view->location()) {
             case Plasma::Types::TopEdge:
                 available.setTop(view->y() + view->normalThickness());
                 break;
 
             case Plasma::Types::BottomEdge:
                 available.setBottom(view->y() + view->height() - view->normalThickness());
                 break;
 
             case Plasma::Types::LeftEdge:
                 available.setLeft(view->x() + view->normalThickness());
                 break;
 
             case Plasma::Types::RightEdge:
                 available.setRight(view->x() + view->width() - view->normalThickness());
                 break;
 
             default:
                 //! bypass clang warnings
                 break;
             }
         }
     }
 
     return available;
 }
 
 void Corona::addOutput(QScreen *screen)
 {
     Q_ASSERT(screen);
 
     int id = m_screenPool->id(screen->name());
 
     if (id == -1) {
         int newId = m_screenPool->firstAvailableId();
         m_screenPool->insertScreenMapping(newId, screen->name());
     }
 
     connect(screen, &QScreen::geometryChanged, this, [ = ]() {
         const int id = m_screenPool->id(screen->name());
 
         if (id >= 0) {
             emit screenGeometryChanged(id);
             emit availableScreenRegionChanged();
             emit availableScreenRectChanged();
         }
     });
 
     emit availableScreenRectChanged();
     emit screenAdded(m_screenPool->id(screen->name()));
 
     screenCountChanged();
 }
 
 void Corona::primaryOutputChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 void Corona::screenRemoved(QScreen *screen)
 {
     screenCountChanged();
 }
 
 void Corona::screenCountChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 //! the central functions that updates loading/unloading latteviews
 //! concerning screen changed (for multi-screen setups mainly)
 void Corona::syncLatteViewsToScreens()
 {
     m_layoutsManager->synchronizer()->syncLatteViewsToScreens();
 }
 
 int Corona::primaryScreenId() const
 {
     return m_screenPool->id(qGuiApp->primaryScreen()->name());
 }
 
 void Corona::closeApplication()
 {
     //! this code must be called asynchronously because it is called
     //! also from qml (Settings window).
     QTimer::singleShot(300, [this]() {
         m_layoutsManager->hideLatteSettingsDialog();
         m_layoutsManager->synchronizer()->hideAllViews();
     });
 
     //! give the time for the views to hide themselves
     QTimer::singleShot(800, [this]() {
         qGuiApp->quit();
     });
 }
 
 void Corona::aboutApplication()
 {
     if (aboutDialog) {
         aboutDialog->hide();
         aboutDialog->deleteLater();
     }
 
     aboutDialog = new KAboutApplicationDialog(KAboutData::applicationData());
     connect(aboutDialog.data(), &QDialog::finished, aboutDialog.data(), &QObject::deleteLater);
     m_wm->skipTaskBar(*aboutDialog);
     m_wm->setKeepAbove(*aboutDialog, true);
 
     aboutDialog->show();
 }
 
 int Corona::screenForContainment(const Plasma::Containment *containment) const
 {
     //FIXME: indexOf is not a proper way to support multi-screen
     // as for environment to environment the indexes change
     // also there is the following issue triggered
     // from latteView adaptToScreen()
     //
     // in a multi-screen environment that
     // primary screen is not set to 0 it was
     // created an endless showing loop at
     // startup (catch-up race) between
     // screen:0 and primaryScreen
 
     //case in which this containment is child of an applet, hello systray :)
 
     if (Plasma::Applet *parentApplet = qobject_cast<Plasma::Applet *>(containment->parent())) {
         if (Plasma::Containment *cont = parentApplet->containment()) {
             return screenForContainment(cont);
         } else {
             return -1;
         }
     }
 
     Plasma::Containment *c = const_cast<Plasma::Containment *>(containment);
     Latte::View *view =  m_layoutsManager->synchronizer()->viewForContainment(c);
 
     if (view && view->screen()) {
         return m_screenPool->id(view->screen()->name());
     }
 
     //Failed? fallback on lastScreen()
     //lastScreen() is the correct screen for panels
     //It is also correct for desktops *that have the correct activity()*
     //a containment with lastScreen() == 0 but another activity,
     //won't be associated to a screen
     //     qDebug() << "ShellCorona screenForContainment: " << containment << " Last screen is " << containment->lastScreen();
 
     for (auto screen : qGuiApp->screens()) {
         // containment->lastScreen() == m_screenPool->id(screen->name()) to check if the lastScreen refers to a screen that exists/it's known
         if (containment->lastScreen() == m_screenPool->id(screen->name()) &&
                 (containment->activity() == m_activityConsumer->currentActivity() ||
                  containment->containmentType() == Plasma::Types::PanelContainment || containment->containmentType() == Plasma::Types::CustomPanelContainment)) {
             return containment->lastScreen();
         }
     }
 
     return -1;
 }
 
 void Corona::showAlternativesForApplet(Plasma::Applet *applet)
 {
     const QString alternativesQML = kPackage().filePath("appletalternativesui");
 
     if (alternativesQML.isEmpty()) {
         return;
     }
 
     Latte::View *latteView =  m_layoutsManager->synchronizer()->viewForContainment(applet->containment());
 
     KDeclarative::QmlObjectSharedEngine *qmlObj{nullptr};
 
     if (latteView) {
         latteView->setAlternativesIsShown(true);
         qmlObj = new KDeclarative::QmlObjectSharedEngine(latteView);
     } else {
         qmlObj = new KDeclarative::QmlObjectSharedEngine(this);
     }
 
     qmlObj->setInitializationDelayed(true);
     qmlObj->setSource(QUrl::fromLocalFile(alternativesQML));
 
     AlternativesHelper *helper = new AlternativesHelper(applet, qmlObj);
     qmlObj->rootContext()->setContextProperty(QStringLiteral("alternativesHelper"), helper);
 
     m_alternativesObjects << qmlObj;
     qmlObj->completeInitialization();
 
     //! Alternative dialog signals
     connect(helper, &QObject::destroyed, this, [latteView]() {
         latteView->setAlternativesIsShown(false);
     });
 
     connect(qmlObj->rootObject(), SIGNAL(visibleChanged(bool)),
             this, SLOT(alternativesVisibilityChanged(bool)));
 
     connect(applet, &Plasma::Applet::destroyedChanged, this, [this, qmlObj](bool destroyed) {
         if (!destroyed) {
             return;
         }
 
         QMutableListIterator<KDeclarative::QmlObjectSharedEngine *> it(m_alternativesObjects);
 
         while (it.hasNext()) {
             KDeclarative::QmlObjectSharedEngine *obj = it.next();
 
             if (obj == qmlObj) {
                 it.remove();
                 obj->deleteLater();
             }
         }
     });
 }
 
 void Corona::alternativesVisibilityChanged(bool visible)
 {
     if (visible) {
         return;
     }
 
     QObject *root = sender();
 
     QMutableListIterator<KDeclarative::QmlObjectSharedEngine *> it(m_alternativesObjects);
 
     while (it.hasNext()) {
         KDeclarative::QmlObjectSharedEngine *obj = it.next();
 
         if (obj->rootObject() == root) {
             it.remove();
             obj->deleteLater();
         }
     }
 }
 
 void Corona::addViewForLayout(QString layoutName)
 {
     qDebug() << "loading default layout";
     //! Setting mutable for create a containment
     setImmutability(Plasma::Types::Mutable);
     QVariantList args;
     auto defaultContainment = createContainmentDelayed("org.kde.latte.containment", args);
     defaultContainment->setContainmentType(Plasma::Types::PanelContainment);
     defaultContainment->init();
 
     if (!defaultContainment || !defaultContainment->kPackage().isValid()) {
         qWarning() << "the requested containment plugin can not be located or loaded";
         return;
     }
 
     auto config = defaultContainment->config();
     defaultContainment->restore(config);
 
     using Plasma::Types;
     QList<Types::Location> edges{Types::BottomEdge, Types::LeftEdge,
                 Types::TopEdge, Types::RightEdge};
 
     Layout::GenericLayout *currentLayout = m_layoutsManager->synchronizer()->layout(layoutName);
 
     if (currentLayout) {
         edges = currentLayout->freeEdges(defaultContainment->screen());
     }
 
     if ((edges.count() > 0)) {
         defaultContainment->setLocation(edges.at(0));
     } else {
         defaultContainment->setLocation(Plasma::Types::BottomEdge);
     }
 
     if (m_layoutsManager->memoryUsage() == Latte::Types::MultipleLayouts) {
         config.writeEntry("layoutId", layoutName);
     }
 
     defaultContainment->updateConstraints(Plasma::Types::StartupCompletedConstraint);
 
     defaultContainment->save(config);
     requestConfigSync();
 
     defaultContainment->flushPendingConstraintsEvents();
     emit containmentAdded(defaultContainment);
     emit containmentCreated(defaultContainment);
 
     defaultContainment->createApplet(QStringLiteral("org.kde.latte.plasmoid"));
     defaultContainment->createApplet(QStringLiteral("org.kde.plasma.analogclock"));
 }
 
 void Corona::loadDefaultLayout()
 {
     addViewForLayout(m_layoutsManager->currentLayoutName());
 }
 
 QStringList Corona::containmentsIds()
 {
     QStringList ids;
 
     for(const auto containment : containments()) {
         ids << QString::number(containment->id());
     }
 
     return ids;
 }
 
 QStringList Corona::appletsIds()
 {
     QStringList ids;
 
     for(const auto containment : containments()) {
         auto applets = containment->config().group("Applets");
         ids << applets.groupList();
     }
 
     return ids;
 }
 
 //! Activate launcher menu through dbus interface
 void Corona::activateLauncherMenu()
 {
     m_globalShortcuts->activateLauncherMenu();
 }
 
 void Corona::windowColorScheme(QString windowIdAndScheme)
 {
     int firstSlash = windowIdAndScheme.indexOf("-");
     QString windowIdStr = windowIdAndScheme.mid(0, firstSlash);
     QString schemeStr = windowIdAndScheme.mid(firstSlash + 1);
 
     if (KWindowSystem::isPlatformWayland()) {
         QTimer::singleShot(200, [this, schemeStr]() {
             //! [Wayland Case] - give the time to be informed correctly for the active window id
             //! otherwise the active window id may not be the same with the one trigerred
             //! the color scheme dbus signal
             QString windowIdStr = m_wm->activeWindow().toString();
             m_wm->schemesTracker()->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr);
         });
     } else {
         m_wm->schemesTracker()->setColorSchemeForWindow(windowIdStr.toUInt(), schemeStr);
     }
 }
 
 //! update badge for specific view item
 void Corona::updateDockItemBadge(QString identifier, QString value)
 {
     m_globalShortcuts->updateViewItemBadge(identifier, value);
 }
 
 
 void Corona::switchToLayout(QString layout)
 {
     if ((layout.startsWith("file:/") || layout.startsWith("/")) && layout.endsWith(".layout.latte")) {
         //! Import and load runtime a layout through dbus interface
         //! It can be used from external programs that want to update runtime
         //! the Latte shown layout
         QString layoutPath = layout;
 
         //! cleanup layout path
         if (layoutPath.startsWith("file:///")) {
             layoutPath = layout.remove("file://");
         } else if (layoutPath.startsWith("file://")) {
             layoutPath = layout.remove("file:/");
         }
 
         //! check out layoutpath existence
         if (QFileInfo(layoutPath).exists()) {
             qDebug() << " Layout is going to be imported and loaded from file :: " << layoutPath;
 
             QString importedLayout = m_layoutsManager->importer()->importLayoutHelper(layoutPath);
 
             if (importedLayout.isEmpty()) {
                 qDebug() << i18n("The layout cannot be imported from file :: ") << layoutPath;
             } else {
                 m_layoutsManager->synchronizer()->loadLayouts();
                 m_layoutsManager->switchToLayout(importedLayout);
             }
         } else {
             qDebug() << " Layout from missing file can not be imported and loaded :: " << layoutPath;
         }
     } else {
         m_layoutsManager->switchToLayout(layout);
     }
 }
 
 void Corona::showSettingsWindow(int page)
 {
     Types::LatteConfigPage p = Types::LayoutPage;
 
     if (page >= Types::LayoutPage && page <= Types::PreferencesPage) {
         p = static_cast<Types::LatteConfigPage>(page);
     }
 
     m_layoutsManager->showLatteSettingsDialog(p);
 }
 
 void Corona::setContextMenuView(int id)
 {
     //! set context menu view id
     m_contextMenuViewId = id;
 }
 
 QStringList Corona::contextMenuData()
 {
     QStringList data;
     Types::ViewType viewType{Types::DockView};
 
     Latte::CentralLayout *currentLayout = m_layoutsManager->currentLayout();
 
     if (currentLayout) {
         viewType = currentLayout->latteViewType(m_contextMenuViewId);
     }
 
     data << QString::number((int)m_layoutsManager->memoryUsage());
     data << m_layoutsManager->currentLayoutName();
     data << QString::number((int)viewType);
 
     for(const auto &layoutName : m_layoutsManager->menuLayouts()) {
         if (m_layoutsManager->synchronizer()->centralLayout(layoutName)) {
             data << QString("1," + layoutName);
         } else {
             data << QString("0," + layoutName);
         }
     }
 
     //! reset context menu view id
     m_contextMenuViewId = -1;
     return data;
 }
 
 void Corona::setBackgroundFromBroadcast(QString activity, QString screenName, QString filename)
 {
     if (filename.startsWith("file://")) {
         filename = filename.remove(0,7);
     }
 
     QMetaObject::invokeMethod(m_backgroundTracer->rootObject(),
                               "setBackgroundFromBroadcast",
                               Q_ARG(QVariant, activity),
                               Q_ARG(QVariant, screenName),
                               Q_ARG(QVariant, filename));
 }
 
 void Corona::setBroadcastedBackgroundsEnabled(QString activity, QString screenName, bool enabled)
 {
     QMetaObject::invokeMethod(m_backgroundTracer->rootObject(),
                               "setBroadcastedBackgroundsEnabled",
                               Q_ARG(QVariant, activity),
                               Q_ARG(QVariant, screenName),
                               Q_ARG(QVariant, enabled));
 }
 
 inline void Corona::qmlRegisterTypes() const
 {
 #if QT_VERSION < QT_VERSION_CHECK(5, 14, 0)
     qmlRegisterType<QScreen>();
     qmlRegisterType<Latte::View>();
     qmlRegisterType<Latte::ViewPart::WindowsTracker>();
     qmlRegisterType<Latte::ViewPart::TrackerPart::CurrentScreenTracker>();
     qmlRegisterType<Latte::ViewPart::TrackerPart::AllScreensTracker>();
     qmlRegisterType<Latte::WindowSystem::SchemeColors>();
     qmlRegisterType<Latte::WindowSystem::Tracker::LastActiveWindow>();
 #else
     qmlRegisterAnonymousType<QScreen>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::View>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::ViewPart::WindowsTracker>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::ViewPart::TrackerPart::CurrentScreenTracker>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::ViewPart::TrackerPart::AllScreensTracker>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::WindowSystem::SchemeColors>("latte-dock", 1);
     qmlRegisterAnonymousType<Latte::WindowSystem::Tracker::LastActiveWindow>("latte-dock", 1);
 #endif
 }
 
 }
diff --git a/app/lattecorona.h b/app/lattecorona.h
index c9317b99..44f03655 100644
--- a/app/lattecorona.h
+++ b/app/lattecorona.h
@@ -1,232 +1,237 @@
 /*
 *  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 LATTECORONA_H
 #define LATTECORONA_H
 
 // local
 #include "plasma/quick/configview.h"
 #include "layout/storage.h"
+#include "view/panelshadows_p.h"
 #include "../liblatte2/types.h"
 
 // Qt
 #include <QObject>
 #include <QTimer>
 
 // Plasma
 #include <Plasma/Corona>
 
 // KDE
 #include <KAboutApplicationDialog>
 
 namespace KDeclarative {
 class QmlObjectSharedEngine;
 }
 
 namespace Plasma {
 class Corona;
 class Containment;
 class Types;
 }
 
 namespace PlasmaQuick {
 class ConfigView;
 }
 
 namespace KActivities {
 class Consumer;
 }
 
 namespace KWayland {
 namespace Client {
 class PlasmaShell;
 }
 }
 
 namespace Latte {
 class ScreenPool;
 class GlobalShortcuts;
 class UniversalSettings;
 class View;
 namespace Indicator{
 class Factory;
 }
 namespace Layout{
 class GenericLayout;
 class Storage;
 }
 namespace Layouts{
 class LaunchersSignals;
 class Manager;
 }
 namespace PlasmaExtended{
 class ScreenPool;
 class Theme;
 }
 namespace WindowSystem{
 class AbstractWindowInterface;
 }
 }
 
 namespace Latte {
 
 class Corona : public Plasma::Corona
 {
     Q_OBJECT
     Q_CLASSINFO("D-Bus Interface", "org.kde.LatteDock")
 
 public:
     Corona(bool defaultLayoutOnStartup = false,
                QString layoutNameOnStartUp = QString(),
                int userSetMemoryUsage = -1,
                QObject *parent = nullptr);
     virtual ~Corona();
 
     int numScreens() const override;
     QRect screenGeometry(int id) const override;
     QRegion availableScreenRegion(int id) const override;
     QRect availableScreenRect(int id) const override;
 
     //! This is a very generic function in order to return the availableScreenRect of specific screen
     //! by calculating only the user specified visibility modes and edges. Empty QLists for both
     //! arguments mean that all choices are accepted in calculations. includeExternalPanels means that
     //! external panels should be considered in the calculations
     QRect availableScreenRectWithCriteria(int id,
                                           QList<Types::Visibility> modes = QList<Types::Visibility>(),
                                           QList<Plasma::Types::Location> edges = QList<Plasma::Types::Location>(),
                                           bool includeExternalPanels = false) const;
 
     QRegion availableScreenRegionWithCriteria(int id,
                                               QString forLayout = QString(),
                                               bool includeExternalPanels = false) const;
 
     int screenForContainment(const Plasma::Containment *containment) const override;
 
     void closeApplication();
 
     KActivities::Consumer *activityConsumer() const;
     KWayland::Client::PlasmaShell *waylandCoronaInterface() const;
 
     KActivities::Consumer *activitiesConsumer() const;
     GlobalShortcuts *globalShortcuts() const;
     ScreenPool *screenPool() const;
     UniversalSettings *universalSettings() const;
     Layouts::Manager *layoutsManager() const;   
 
     Indicator::Factory *indicatorFactory() const;
 
     PlasmaExtended::ScreenPool *plasmaScreenPool() const;
     PlasmaExtended::Theme *themeExtended() const;
 
     WindowSystem::AbstractWindowInterface *wm() const;
 
+    PanelShadows *dialogShadows() const;
+
     //! these functions are used from context menu through containmentactions
     void switchToLayout(QString layout);
     void showSettingsWindow(int page);
     void setContextMenuView(int id);
     QStringList contextMenuData();
 
 public slots:
     void aboutApplication();
     void addViewForLayout(QString layoutName);
     void activateLauncherMenu();
     void loadDefaultLayout() override;
     void setBackgroundFromBroadcast(QString activity, QString screenName, QString filename);
     void setBroadcastedBackgroundsEnabled(QString activity, QString screenName, bool enabled);
     void showAlternativesForApplet(Plasma::Applet *applet);
     //! values are separated with a "-" character
     void windowColorScheme(QString windowIdAndScheme);
     void updateDockItemBadge(QString identifier, QString value);
 
     void unload();
 
 signals:
     void configurationShown(PlasmaQuick::ConfigView *configView);
     void viewLocationChanged();
     void raiseViewsTemporaryChanged();
     void availableScreenRectChangedFrom(Latte::View *origin);
     void availableScreenRegionChangedFrom(Latte::View *origin);
 
 private slots:
     void alternativesVisibilityChanged(bool visible);
     void load();
 
     void addOutput(QScreen *screen);
     void primaryOutputChanged();
     void screenRemoved(QScreen *screen);
     void screenCountChanged();
     void syncLatteViewsToScreens();
 
 private:
     void cleanConfig();
     void qmlRegisterTypes() const;
     void setupWaylandIntegration();
 
     bool appletExists(uint containmentId, uint appletId) const;
     bool containmentExists(uint id) const;
 
     int primaryScreenId() const;
 
     QStringList containmentsIds();
     QStringList appletsIds();
 
     bool m_activitiesStarting{true};
     bool m_defaultLayoutOnStartup{false}; //! this is used to enforce loading the default layout on startup
     bool m_quitTimedEnded{false}; //! this is used on destructor in order to delay it and slide-out the views
 
     //!it can be used on startup to change memory usage from command line
     int m_userSetMemoryUsage{ -1};
 
     int m_contextMenuViewId{-1};
 
     QString m_layoutNameOnStartUp;
 
     QList<KDeclarative::QmlObjectSharedEngine *> m_alternativesObjects;
 
     KDeclarative::QmlObjectSharedEngine *m_backgroundTracer;
 
     QTimer m_viewsScreenSyncTimer;
 
     KActivities::Consumer *m_activityConsumer;
     QPointer<KAboutApplicationDialog> aboutDialog;
 
     ScreenPool *m_screenPool{nullptr};
     UniversalSettings *m_universalSettings{nullptr};
     GlobalShortcuts *m_globalShortcuts{nullptr};
 
     Indicator::Factory *m_indicatorFactory{nullptr};
     Layouts::Manager *m_layoutsManager{nullptr};
 
     PlasmaExtended::ScreenPool *m_plasmaScreenPool{nullptr};
     PlasmaExtended::Theme *m_themeExtended{nullptr};
 
     WindowSystem::AbstractWindowInterface *m_wm{nullptr};
 
+    PanelShadows *m_dialogShadows{nullptr};
+
     KWayland::Client::PlasmaShell *m_waylandCorona{nullptr};
 
     friend class GlobalShortcuts;
     friend class Layout::Storage;
     friend class Layouts::LaunchersSignals;
     friend class Layouts::Manager;
 };
 
 }
 
 #endif // LATTECORONA_H
diff --git a/app/view/settings/primaryconfigview.cpp b/app/view/settings/primaryconfigview.cpp
index 822020b2..c836ff5f 100644
--- a/app/view/settings/primaryconfigview.cpp
+++ b/app/view/settings/primaryconfigview.cpp
@@ -1,727 +1,729 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "primaryconfigview.h"
 
 // local
 #include <config-latte.h>
 #include "secondaryconfigview.h"
 #include "../effects.h"
 #include "../panelshadows_p.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../layouts/manager.h"
 #include "../../layout/genericlayout.h"
 #include "../../settings/universalsettings.h"
 #include "../../shortcuts/globalshortcuts.h"
 #include "../../shortcuts/shortcutstracker.h"
 #include "../../wm/abstractwindowinterface.h"
 
 // Qt
 #include <QQuickItem>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedContext>
 #include <KDeclarative/KDeclarative>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Package>
 
 namespace Latte {
 namespace ViewPart {
 
 PrimaryConfigView::PrimaryConfigView(Plasma::Containment *containment, Latte::View *view, QWindow *parent)
     : PlasmaQuick::ConfigView(containment, parent),
       m_latteView(view)
 {
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona());
 
     setupWaylandIntegration();
 
     if (KWindowSystem::isPlatformX11()) {
         m_corona->wm()->registerIgnoredWindow(winId());
     } else {
         connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
             if (m_waylandWindowId.isNull()) {
                 m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
                 m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
             }
         });
     }
 
     setScreen(m_latteView->screen());
 
     if (containment) {
         setIcon(qGuiApp->windowIcon());
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(100);
 
     connect(this, &PrimaryConfigView::availableScreenGeometryChanged, this, &PrimaryConfigView::syncGeometry);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::saveConfig);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::updateShowInlineProperties);
     connect(this, &PrimaryConfigView::complexityChanged, this, &PrimaryConfigView::syncGeometry);
 
     connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() {
         setScreen(m_latteView->screen());
         setFlags(wFlags());
 
         if (KWindowSystem::isPlatformX11()) {
 #if KF5_VERSION_MINOR >= 45
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager | NET::SkipSwitcher);
 #else
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
 #endif
 
             KWindowSystem::setOnAllDesktops(winId(), true);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &PrimaryConfigView::syncGeometry);
     connections << connect(containment, &Plasma::Containment::immutabilityChanged, this, &PrimaryConfigView::immutabilityChanged);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 
     if (m_corona) {
         connections << connect(m_corona, &Latte::Corona::raiseViewsTemporaryChanged, this, &PrimaryConfigView::raiseDocksTemporaryChanged);
         connections << connect(m_corona, &Latte::Corona::availableScreenRectChangedFrom, this, &PrimaryConfigView::updateAvailableScreenGeometry);
     }
 
     if (m_latteView->layout()) {
         emit m_latteView->layout()->setLastConfigViewFor(m_latteView);
     }
 }
 
 PrimaryConfigView::~PrimaryConfigView()
 {
     qDebug() << "ConfigView deleting ...";
 
+    m_corona->dialogShadows()->removeWindow(this);
+
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     deleteSecondaryWindow();
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 }
 
 void PrimaryConfigView::init()
 {
     qDebug() << "dock config view : initialization started...";
     m_originalByPassWM = m_latteView->byPassWM();
     m_originalMode = m_latteView->visibility()->mode();
 
     loadConfig();
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
-    PanelShadows::self()->addWindow(this);
+    m_corona->dialogShadows()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), m_corona->globalShortcuts()->shortcutsTracker());
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
 
     if (m_corona) {
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), m_corona->universalSettings());
         rootContext()->setContextProperty(QStringLiteral("layoutsManager"), m_corona->layoutsManager());
     }
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedockconfigurationui";
 
     updateEnabledBorders();
     updateAvailableScreenGeometry();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     qDebug() << "dock config view : initialization ended...";
 }
 
 inline Qt::WindowFlags PrimaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint /*| Qt::WindowStaysOnTopHint*/) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QQuickView *PrimaryConfigView::secondaryWindow()
 {
     return m_secConfigView;
 }
 
 void PrimaryConfigView::createSecondaryWindow()
 {
     if (m_secConfigView) {
         return;
     }
 
     m_secConfigView = new SecondaryConfigView(m_latteView, this);
     m_secConfigView->init();
 }
 
 void PrimaryConfigView::deleteSecondaryWindow()
 {
     if (m_secConfigView) {
         auto secWindow = m_secConfigView;
         m_secConfigView = nullptr;
         secWindow->deleteLater();
 
         if (KWindowSystem::isPlatformX11()) {
             //! this is needed in order for subtracked mask of secondary window to
             //! be released properly when changing for Advanced to Basic mode.
             //! Under wayland this is not needed because masks do not break any visuals.
             m_latteView->effects()->updateMask();
         }
     }
 }
 
 void PrimaryConfigView::updateAvailableScreenGeometry(View *origin)
 {    
     int currentScrId = m_latteView->positioner()->currentScreenId();
     m_availableScreenGeometry = m_corona->availableScreenRectWithCriteria(currentScrId, {}, {}, true);
 
     emit availableScreenGeometryChanged();
 }
 
 QRect PrimaryConfigView::availableScreenGeometry() const
 {
     return m_availableScreenGeometry;
 }
 
 QRect PrimaryConfigView::geometryWhenVisible() const
 {
     return m_geometryWhenVisible;
 }
 
 void PrimaryConfigView::requestActivate()
 {
     if (KWindowSystem::isPlatformWayland() && m_shellSurface) {
         if (m_waylandWindowId.isNull()) {
             m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
         }
 
         m_corona->wm()->requestActivate(m_waylandWindowId);
     } else {
         QQuickView::requestActivate();
     }
 }
 
 void PrimaryConfigView::syncGeometry()
 {
     if (!m_latteView || !m_latteView->layout() || !m_latteView->containment() || !rootObject()) {
         return;
     }
 
     const QSize size(rootObject()->width(), rootObject()->height());
     setMaximumSize(size);
     setMinimumSize(size);
     resize(size);
 
     const auto location = m_latteView->containment()->location();
     const auto scrGeometry = m_latteView->screenGeometry();
     const auto availGeometry = m_availableScreenGeometry;
 
     int clearThickness = m_latteView->editThickness();
 
     QPoint position{0, 0};
 
     int xPos{0};
     int yPos{0};
 
     switch (m_latteView->formFactor()) {
     case Plasma::Types::Horizontal: {
         if (m_complexity == Latte::Types::ExpertSettings) {
             if (qApp->isLeftToRight()) {
                 xPos = availGeometry.x() + availGeometry.width() - size.width();
             } else {
                 xPos = availGeometry.x();
             }
         } else {
             xPos = scrGeometry.center().x() - size.width() / 2;
         }
 
         if (location == Plasma::Types::TopEdge) {
             yPos = scrGeometry.y() + clearThickness;
         } else if (location == Plasma::Types::BottomEdge) {
             yPos = scrGeometry.y() + scrGeometry.height() - clearThickness - size.height();
         }
     }
         break;
 
     case Plasma::Types::Vertical: {
         if (location == Plasma::Types::LeftEdge) {
             xPos = scrGeometry.x() + clearThickness;
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         } else if (location == Plasma::Types::RightEdge) {
             xPos = scrGeometry.x() + scrGeometry.width() - clearThickness - size.width();
             yPos =  availGeometry.y() + (availGeometry.height() - size.height())/2;
         }
     }
         break;
 
     default:
         qWarning() << "no sync geometry, wrong formFactor";
         break;
     }
 
     position = {xPos, yPos};
 
     updateEnabledBorders();
 
     m_geometryWhenVisible = QRect(position.x(), position.y(), size.width(), size.height());
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 
     updateShowInlineProperties();
 
     emit m_latteView->configWindowGeometryChanged();
 }
 
 void PrimaryConfigView::syncSlideEffect()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto slideLocation = WindowSystem::AbstractWindowInterface::Slide::None;
 
     switch (m_latteView->containment()->location()) {
     case Plasma::Types::TopEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Top;
         break;
 
     case Plasma::Types::RightEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Right;
         break;
 
     case Plasma::Types::BottomEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Bottom;
         break;
 
     case Plasma::Types::LeftEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Left;
         break;
 
     default:
         qDebug() << staticMetaObject.className() << "wrong location";
         break;
     }
 
     m_corona->wm()->slideWindow(*this, slideLocation);
 }
 
 void PrimaryConfigView::showEvent(QShowEvent *ev)
 {
     QQuickWindow::showEvent(ev);
 
     if (!m_latteView) {
         return;
     }
 
     m_corona->wm()->setViewExtraFlags(*this);
     setFlags(wFlags());
 
     m_corona->wm()->enableBlurBehind(*this);
 
     syncGeometry();
     syncSlideEffect();
 
     if (m_latteView && m_latteView->containment())
         m_latteView->containment()->setUserConfiguring(true);
 
     m_screenSyncTimer.start();
     QTimer::singleShot(400, this, &PrimaryConfigView::syncGeometry);
 
     emit showSignal();
 }
 
 void PrimaryConfigView::hideEvent(QHideEvent *ev)
 {
     if (!m_latteView) {
         deleteLater();
         //QQuickWindow::hideEvent(ev);
         return;
     }
 
     if (m_latteView->containment()) {
         m_latteView->containment()->setUserConfiguring(false);
     }
 
     // QQuickWindow::hideEvent(ev);
 
     const auto mode = m_latteView->visibility()->mode();
 
     if ((mode == Types::AlwaysVisible || mode == Types::WindowsGoBelow)
             && !(m_originalMode == Types::AlwaysVisible || m_originalMode == Types::WindowsGoBelow)) {
         //! mode changed to AlwaysVisible OR WindowsGoBelow FROM Dodge mode
         if (m_originalByPassWM) {
             //! if original by pass is active
             m_latteView->layout()->recreateView(m_latteView->containment());
         }
     } else if (m_latteView->byPassWM() != m_originalByPassWM) {
         m_latteView->layout()->recreateView(m_latteView->containment());
     }
 
     deleteLater();
 }
 
 void PrimaryConfigView::focusOutEvent(QFocusEvent *ev)
 {
     Q_UNUSED(ev);
 
     const auto *focusWindow = qGuiApp->focusWindow();
 
     if (!m_latteView
             || (focusWindow && (focusWindow->flags().testFlag(Qt::Popup)
                                 || focusWindow->flags().testFlag(Qt::ToolTip)))
             || m_latteView->alternativesIsShown()) {
         return;
     }
 
     if (!m_blockFocusLost && !m_latteView->containsMouse()
             && (!m_secConfigView || (m_secConfigView && !m_secConfigView->isActive()))) {
         hideConfigWindow();
     }
 }
 
 void PrimaryConfigView::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland primary settings surface was created...";
 
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setSkipTaskbar(true);
 #if KF5_VERSION_MINOR >= 47
         m_shellSurface->setSkipSwitcher(true);
 #endif
 
         syncGeometry();
     }
 }
 
 bool PrimaryConfigView::event(QEvent *e)
 {
     if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
 
                 if (m_shellSurface) {
                     break;
                 }
 
                 setupWaylandIntegration();
                 break;
 
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 if (m_shellSurface) {
                     delete m_shellSurface;
                     m_shellSurface = nullptr;
                     qDebug() << "WAYLAND config window surface was deleted...";
                 }
 
                 break;
             }
         }
     }
 
     return PlasmaQuick::ConfigView::event(e);
 }
 
 
 void PrimaryConfigView::immutabilityChanged(Plasma::Types::ImmutabilityType type)
 {
     if (type != Plasma::Types::Mutable && isVisible())
         hideConfigWindow();
 }
 
 bool PrimaryConfigView::sticker() const
 {
     return m_blockFocusLost;
 }
 
 void PrimaryConfigView::setSticker(bool blockFocusLost)
 {
     if (m_blockFocusLost == blockFocusLost)
         return;
 
     m_blockFocusLost = blockFocusLost;
 }
 
 bool PrimaryConfigView::showInlineProperties() const
 {
     return m_showInlineProperties;
 }
 void PrimaryConfigView::setShowInlineProperties(bool show)
 {
     if (m_showInlineProperties == show) {
         return;
     }
 
     m_showInlineProperties = show;
     emit showInlinePropertiesChanged();
 }
 
 void PrimaryConfigView::updateShowInlineProperties()
 {
     if (!m_latteView) {
         return;
     }
 
     bool showSecWindow{false};
     bool complexityApprovedSecWindow{false};
 
 
     if (m_complexity != Latte::Types::BasicSettings
             && !(m_complexity == Latte::Types::ExpertSettings && m_latteView->formFactor() == Plasma::Types::Vertical)) {
         showSecWindow = true;
         complexityApprovedSecWindow = true;
     }
 
     //! consider screen geometry for showing or not the secondary window
     if (!geometryWhenVisible().isNull()) {
         createSecondaryWindow();
 
         if (m_secConfigView->geometryWhenVisible().intersects(geometryWhenVisible())) {
             showSecWindow = false;
         } else if (complexityApprovedSecWindow) {
             showSecWindow = true;
         }
     }
 
     if (showSecWindow) {
         if (!m_secConfigView) {
             createSecondaryWindow();
         }
 
         QTimer::singleShot(150, m_secConfigView, SLOT(show()));
         setShowInlineProperties(false);
     } else {
         deleteSecondaryWindow();
         setShowInlineProperties(true);
     }
 
     // qDebug() << " showSecWindow:" << showSecWindow << " _ " << " inline:"<< !showSecWindow;
 }
 
 int PrimaryConfigView::complexity() const
 {
     return (int)m_complexity;
 }
 
 void PrimaryConfigView::setComplexity(int complexity)
 {
     if ((int)m_complexity == complexity) {
         return;
     }
 
     m_complexity = static_cast<Latte::Types::SettingsComplexity>(complexity);
 
     emit complexityChanged();
 }
 
 void PrimaryConfigView::hideConfigWindow()
 {
     if (m_shellSurface) {
         //!NOTE: Avoid crash in wayland environment with qt5.9
         close();
     } else {
         hide();
     }
 }
 
 void PrimaryConfigView::updateLaunchersForGroup(int groupInt)
 {
     Types::LaunchersGroup group = (Types::LaunchersGroup)groupInt;
 
     //! when the layout/global launchers list is empty then the current dock launchers are used for them
     //! as a start point
     if (m_corona &&  m_latteView->layout()) {
         if ((group == Types::LayoutLaunchers && m_latteView->layout()->launchers().isEmpty())
                 || (group == Types::GlobalLaunchers && m_corona->universalSettings()->launchers().isEmpty())) {
 
             Plasma::Containment *c = m_latteView->containment();
 
             const auto &applets = c->applets();
 
             for (auto *applet : applets) {
                 KPluginMetaData meta = applet->kPackage().metadata();
 
                 if (meta.pluginId() == "org.kde.latte.plasmoid") {
                     if (QQuickItem *appletInterface = applet->property("_plasma_graphicObject").value<QQuickItem *>()) {
                         const auto &childItems = appletInterface->childItems();
 
                         if (childItems.isEmpty()) {
                             continue;
                         }
 
                         for (QQuickItem *item : childItems) {
                             if (auto *metaObject = item->metaObject()) {
                                 // not using QMetaObject::invokeMethod to avoid warnings when calling
                                 // this on applets that don't have it or other child items since this
                                 // is pretty much trial and error.
                                 // Also, "var" arguments are treated as QVariant in QMetaObject
 
                                 int methodIndex = metaObject->indexOfMethod("getLauncherList()");
 
                                 if (methodIndex == -1) {
                                     continue;
                                 }
 
                                 QMetaMethod method = metaObject->method(methodIndex);
 
                                 QVariant launchers;
 
                                 if (method.invoke(item, Q_RETURN_ARG(QVariant, launchers))) {
                                     if (group == Types::LayoutLaunchers) {
                                         m_latteView->layout()->setLaunchers(launchers.toStringList());
                                     } else if (group == Types::GlobalLaunchers) {
                                         m_corona->universalSettings()->setLaunchers(launchers.toStringList());
                                     }
                                 }
                             }
                         }
                     }
                 }
             }
         }
     }
 
 }
 
 //!BEGIN borders
 Plasma::FrameSvg::EnabledBorders PrimaryConfigView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void PrimaryConfigView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::BottomBorder : ~Plasma::FrameSvg::TopBorder;
         break;
 
     case Plasma::Types::LeftEdge:
         borders &= ~Plasma::FrameSvg::LeftBorder;
         break;
 
     case Plasma::Types::RightEdge:
         borders &= ~Plasma::FrameSvg::RightBorder;
         break;
 
     case Plasma::Types::BottomEdge:
         borders &= m_inReverse ? ~Plasma::FrameSvg::TopBorder : ~Plasma::FrameSvg::BottomBorder;
         break;
 
     default:
         break;
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
 
-        PanelShadows::self()->addWindow(this, m_enabledBorders);
+        m_corona->dialogShadows()->addWindow(this, m_enabledBorders);
 
         emit enabledBordersChanged();
     }
 }
 //!END borders
 
 //!BEGIN configuration
 void PrimaryConfigView::loadConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
     auto config = m_latteView->containment()->config();
     int complexity = config.readEntry("settingsComplexity", (int)Latte::Types::BasicSettings);
     setComplexity(static_cast<Latte::Types::SettingsComplexity>(complexity));
 }
 
 void PrimaryConfigView::saveConfig()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto config = m_latteView->containment()->config();
     config.writeEntry("settingsComplexity", (int)m_complexity);
     config.sync();
 }
 //!END configuration
 
 }
 }
 
diff --git a/app/view/settings/secondaryconfigview.cpp b/app/view/settings/secondaryconfigview.cpp
index a74c23cf..f7987667 100644
--- a/app/view/settings/secondaryconfigview.cpp
+++ b/app/view/settings/secondaryconfigview.cpp
@@ -1,451 +1,453 @@
 /*
 *  Copyright 2018  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "secondaryconfigview.h"
 
 // local
 #include <config-latte.h>
 #include "primaryconfigview.h"
 #include "../panelshadows_p.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../wm/abstractwindowinterface.h"
 
 // Qt
 #include <QQuickItem>
 #include <QQmlContext>
 #include <QQmlEngine>
 #include <QScreen>
 
 // KDE
 #include <KLocalizedContext>
 #include <KDeclarative/KDeclarative>
 #include <KWayland/Client/plasmashell.h>
 #include <KWayland/Client/surface.h>
 #include <KWindowSystem>
 
 // Plasma
 #include <Plasma/Package>
 
 namespace Latte {
 namespace ViewPart {
 
 SecondaryConfigView::SecondaryConfigView(Latte::View *view, QWindow *parent)
     : QQuickView(nullptr),
       m_latteView(view)
 {
     m_parent = qobject_cast<PrimaryConfigView *>(parent);
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->containment()->corona());
 
     setupWaylandIntegration();
 
     if (KWindowSystem::isPlatformX11()) {
         m_corona->wm()->registerIgnoredWindow(winId());
     } else {
         connect(m_corona->wm(), &WindowSystem::AbstractWindowInterface::latteWindowAdded, this, [&]() {
             if (m_waylandWindowId.isNull()) {
                 m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
                 m_corona->wm()->registerIgnoredWindow(m_waylandWindowId);
             }
         });
     }
 
     setResizeMode(QQuickView::SizeViewToRootObject);
     setScreen(m_latteView->screen());
 
     if (m_latteView && m_latteView->containment()) {
         setIcon(qGuiApp->windowIcon());
     }
 
     m_screenSyncTimer.setSingleShot(true);
     m_screenSyncTimer.setInterval(100);
 
     connections << connect(m_parent, &PrimaryConfigView::availableScreenGeometryChanged, this, &SecondaryConfigView::syncGeometry);
 
     connections << connect(&m_screenSyncTimer, &QTimer::timeout, this, [this]() {
         setScreen(m_latteView->screen());
         setFlags(wFlags());
 
         if (KWindowSystem::isPlatformX11()) {
 #if KF5_VERSION_MINOR >= 45
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager | NET::SkipSwitcher);
 #else
             KWindowSystem::setState(winId(), NET::SkipTaskbar | NET::SkipPager);
 #endif
 
             KWindowSystem::setOnAllDesktops(winId(), true);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &SecondaryConfigView::syncGeometry);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 }
 
 SecondaryConfigView::~SecondaryConfigView()
 {
     qDebug() << "SecDockConfigView deleting ...";
 
+    m_corona->dialogShadows()->removeWindow(this);
+
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 }
 
 void SecondaryConfigView::init()
 {
     qDebug() << "dock secondary config view : initialization started...";
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
-    PanelShadows::self()->addWindow(this);
+    m_corona->dialogShadows()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
     rootContext()->setContextProperty(QStringLiteral("plasmoid"), m_latteView->containment()->property("_plasma_graphicObject").value<QObject *>());
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedocksecondaryconfigurationui";
 
     updateEnabledBorders();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     if (m_parent && KWindowSystem::isPlatformX11()) {
         m_parent->requestActivate();
     }
 
     qDebug() << "dock secondary config view : initialization ended...";
 }
 
 inline Qt::WindowFlags SecondaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint /*| Qt::WindowStaysOnTopHint*/) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QRect SecondaryConfigView::geometryWhenVisible() const
 {
     return m_geometryWhenVisible;
 }
 
 void SecondaryConfigView::requestActivate()
 {
     if (KWindowSystem::isPlatformWayland() && m_shellSurface) {
         if (m_waylandWindowId.isNull()) {
             m_waylandWindowId = m_corona->wm()->winIdFor("latte-dock", geometry());
         }
 
         m_corona->wm()->requestActivate(m_waylandWindowId);
     } else {
         QQuickView::requestActivate();
     }
 }
 
 void SecondaryConfigView::syncGeometry()
 {
     if (!m_latteView || !m_latteView->layout() || !m_latteView->containment() || !m_parent || !rootObject()) {
         return;
     }
 
     const QSize size(rootObject()->width(), rootObject()->height());
     setMaximumSize(size);
     setMinimumSize(size);
     resize(size);
 
     const auto location = m_latteView->containment()->location();
     const auto scrGeometry = m_latteView->screenGeometry();
     const auto availGeometry = m_parent->availableScreenGeometry();
 
     int clearThickness = m_latteView->editThickness();
 
     int secondaryConfigSpacing = 2 * m_latteView->fontPixelSize();
 
     QPoint position{0, 0};
 
     int xPos{0};
     int yPos{0};
 
     switch (m_latteView->containment()->formFactor()) {
     case Plasma::Types::Horizontal: {
         if (qApp->isLeftToRight()) {
             xPos = availGeometry.x() + secondaryConfigSpacing;
         } else {
             xPos = availGeometry.x() + availGeometry.width() - size.width() - secondaryConfigSpacing;
         }
 
         if (location == Plasma::Types::TopEdge) {
             yPos = scrGeometry.y() + clearThickness;
         } else if (location == Plasma::Types::BottomEdge) {
             yPos = scrGeometry.y() + scrGeometry.height() - clearThickness - size.height();
         }
     }
         break;
 
     case Plasma::Types::Vertical: {
         yPos = availGeometry.y() + secondaryConfigSpacing;
 
         if (location == Plasma::Types::LeftEdge) {
             xPos = scrGeometry.x() + clearThickness;
         } else if (location == Plasma::Types::RightEdge) {
             xPos = scrGeometry.x() + scrGeometry.width() - clearThickness - size.width();
         }
     }
         break;
 
     default:
         qWarning() << "no sync geometry, wrong formFactor";
         break;
     }
 
     position = {xPos, yPos};
 
     updateEnabledBorders();
 
     m_geometryWhenVisible = QRect(position.x(), position.y(), size.width(), size.height());
 
     setPosition(position);
 
     if (m_shellSurface) {
         m_shellSurface->setPosition(position);
     }
 
     //! after placement request to activate the main config window in order to avoid
     //! rare cases of closing settings window from secondaryConfigView->focusOutEvent
     if (m_parent && KWindowSystem::isPlatformX11()) {
         m_parent->requestActivate();
     }
 }
 
 void SecondaryConfigView::syncSlideEffect()
 {
     if (!m_latteView || !m_latteView->containment()) {
         return;
     }
 
     auto slideLocation = WindowSystem::AbstractWindowInterface::Slide::None;
 
     switch (m_latteView->containment()->location()) {
     case Plasma::Types::TopEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Top;
         break;
 
     case Plasma::Types::RightEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Right;
         break;
 
     case Plasma::Types::BottomEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Bottom;
         break;
 
     case Plasma::Types::LeftEdge:
         slideLocation = WindowSystem::AbstractWindowInterface::Slide::Left;
         break;
 
     default:
         qDebug() << staticMetaObject.className() << "wrong location";
         break;
     }
 
     m_corona->wm()->slideWindow(*this, slideLocation);
 }
 
 void SecondaryConfigView::showEvent(QShowEvent *ev)
 {
     QQuickWindow::showEvent(ev);
 
     if (!m_latteView) {
         return;
     }
 
     m_corona->wm()->setViewExtraFlags(*this);
     setFlags(wFlags());
 
     m_corona->wm()->enableBlurBehind(*this);
 
     syncGeometry();
     syncSlideEffect();
 
     m_screenSyncTimer.start();
     QTimer::singleShot(400, this, &SecondaryConfigView::syncGeometry);
 
     emit showSignal();
 }
 
 void SecondaryConfigView::focusOutEvent(QFocusEvent *ev)
 {
     Q_UNUSED(ev);
 
     const auto *focusWindow = qGuiApp->focusWindow();
 
     if ((focusWindow && (focusWindow->flags().testFlag(Qt::Popup)
                          || focusWindow->flags().testFlag(Qt::ToolTip)))
             || m_latteView->alternativesIsShown()) {
         return;
     }
 
     const auto parent = qobject_cast<PrimaryConfigView *>(m_parent);
 
     if (!m_latteView->containsMouse() && parent && !parent->sticker() && !parent->isActive()) {
         parent->hideConfigWindow();
     }
 }
 
 void SecondaryConfigView::setupWaylandIntegration()
 {
     if (m_shellSurface || !KWindowSystem::isPlatformWayland() || !m_latteView || !m_latteView->containment()) {
         // already setup
         return;
     }
 
     if (m_corona) {
         using namespace KWayland::Client;
         PlasmaShell *interface = m_corona->waylandCoronaInterface();
 
         if (!interface) {
             return;
         }
 
         Surface *s = Surface::fromWindow(this);
 
         if (!s) {
             return;
         }
 
         qDebug() << "wayland secondary settings surface was created...";
 
         m_shellSurface = interface->createSurface(s, this);
         m_shellSurface->setSkipTaskbar(true);
 #if KF5_VERSION_MINOR >= 47
         m_shellSurface->setSkipSwitcher(true);
 #endif
 
         syncGeometry();
     }
 }
 
 bool SecondaryConfigView::event(QEvent *e)
 {
     if (e->type() == QEvent::PlatformSurface) {
         if (auto pe = dynamic_cast<QPlatformSurfaceEvent *>(e)) {
             switch (pe->surfaceEventType()) {
             case QPlatformSurfaceEvent::SurfaceCreated:
 
                 if (m_shellSurface) {
                     break;
                 }
 
                 setupWaylandIntegration();
                 break;
 
             case QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed:
                 if (m_shellSurface) {
                     delete m_shellSurface;
                     m_shellSurface = nullptr;
                     qDebug() << "WAYLAND secondary config window surface was deleted...";
                 }
 
                 break;
             }
         }
     }
 
     return QQuickView::event(e);
 }
 
 void SecondaryConfigView::hideConfigWindow()
 {
     if (m_shellSurface) {
         //!NOTE: Avoid crash in wayland environment with qt5.9
         close();
     } else {
         hide();
     }
 }
 
 //!BEGIN borders
 Plasma::FrameSvg::EnabledBorders SecondaryConfigView::enabledBorders() const
 {
     return m_enabledBorders;
 }
 
 void SecondaryConfigView::updateEnabledBorders()
 {
     if (!this->screen()) {
         return;
     }
 
     Plasma::FrameSvg::EnabledBorders borders = Plasma::FrameSvg::AllBorders;
 
     switch (m_latteView->location()) {
     case Plasma::Types::TopEdge:
         borders &= ~Plasma::FrameSvg::TopBorder;
         break;
 
     case Plasma::Types::LeftEdge:
         borders &= ~Plasma::FrameSvg::LeftBorder;
         break;
 
     case Plasma::Types::RightEdge:
         borders &= ~Plasma::FrameSvg::RightBorder;
         break;
 
     case Plasma::Types::BottomEdge:
         borders &=  ~Plasma::FrameSvg::BottomBorder;
         break;
 
     default:
         break;
     }
 
     if (m_enabledBorders != borders) {
         m_enabledBorders = borders;
 
-        PanelShadows::self()->addWindow(this, m_enabledBorders);
+        m_corona->dialogShadows()->addWindow(this, m_enabledBorders);
 
         emit enabledBordersChanged();
     }
 }
 
 //!END borders
 
 }
 }
 
diff --git a/shell/package/contents/configuration/LatteDockConfiguration.qml b/shell/package/contents/configuration/LatteDockConfiguration.qml
index 1a1e6f4b..4cc7aee6 100644
--- a/shell/package/contents/configuration/LatteDockConfiguration.qml
+++ b/shell/package/contents/configuration/LatteDockConfiguration.qml
@@ -1,700 +1,700 @@
 /*
 *  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/>.
 */
 
 import QtQuick 2.7
 import QtQuick.Controls 1.4
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 import QtQuick.Window 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.components 3.0 as PlasmaComponents3
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import QtQuick.Controls.Styles.Plasma 2.0 as Styles
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.kquickcontrolsaddons 2.0 as KQuickControlAddons
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "pages" as Pages
 import "../controls" as LatteExtraControls
 
 FocusScope {
     id: dialog
 
     readonly property bool basicLevel: viewConfig.complexity === Latte.Types.BasicSettings
     readonly property bool advancedLevel: viewConfig.complexity === Latte.Types.AdvancedSettings
     readonly property bool expertLevel: viewConfig.complexity === Latte.Types.ExpertSettings
 
     readonly property bool highLevel: advancedLevel || expertLevel
 
     readonly property bool inConfigureAppletsMode: plasmoid.configuration.inConfigureAppletsMode || !Latte.WindowSystem.compositingActive
 
     //! max size based on screen resolution
     //!    TODO: if we can access availableScreenGeometry.height this can be improved, currently
     //!    we use 100px. or 50px. in order to give space for othe views to be shown and to have also
     //!    some space around the settings window
     property int maxHeight: plasmoid.formFactor === PlasmaCore.Types.Horizontal ?
                                 viewConfig.availableScreenGeometry.height - (latteView.editThickness - latteView.normalThickness) - 16 :
                                 viewConfig.availableScreenGeometry.height - 2 * units.largeSpacing
     property int maxWidth: 0.6 * latteView.screenGeometry.width
 
     //! propose size based on font size
     property int proposedWidth: 0.82 * proposedHeight + units.smallSpacing * 2
     property int proposedHeight: 36 * theme.mSize(theme.defaultFont).height
 
     //! chosen size to be applied, if the user has set or not a different scale for the settings window
     property int chosenWidth: userScaleWidth !== 1 ? userScaleWidth * proposedWidth : proposedWidth
     property int chosenHeight: userScaleHeight !== 1 ? userScaleHeight * heightLevel * proposedHeight : heightLevel * proposedHeight
 
     readonly property int optionsWidth: appliedWidth - units.smallSpacing * 10
 
     //! user set scales based on its preference, e.g. 96% of the proposed size
     property real userScaleWidth: 1
     property real userScaleHeight: 1
 
     readonly property real heightLevel: (dialog.expertLevel ? 100 : 1)
 
     onHeightChanged: viewConfig.syncGeometry();
 
     //! applied size in order to not be out of boundaries
     //! width can be between 200px - maxWidth
     //! height can be between 400px - maxHeight
     property int appliedWidth: Math.min(maxWidth, Math.max(200, chosenWidth))
     property int appliedHeight: Math.min(maxHeight, Math.max(400, chosenHeight))
 
     width: appliedWidth
     height: appliedHeight
 
     Layout.minimumWidth: width
     Layout.minimumHeight: height
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft
     LayoutMirroring.childrenInherit: true
 
     readonly property bool viewIsPanel: latteView.type === Latte.Types.PanelView
 
     property bool panelIsVertical: plasmoid.formFactor === PlasmaCore.Types.Vertical
     property int subGroupSpacing: units.largeSpacing + units.smallSpacing * 1.5
 
     property color bC: theme.backgroundColor
     property color transparentBackgroundColor: Qt.rgba(bC.r, bC.g, bC.b, 0.7)
 
     onHighLevelChanged: {
         //! switch to appearancePage when effectsPage becomes hidden because
         //! advancedLevel was disabled by the user
         if (!highLevel && tabGroup.currentTab === effectsPage) {
             tabGroup.currentTab = appearancePage;
             tabBar.currentTab = appearanceTabBtn;
         }
     }
 
     Component.onCompleted: {
         updateScales();
     }
 
     Connections {
         target: latteView.positioner
         onCurrentScreenNameChanged: dialog.updateScales();
     }
 
     function updateScales() {
         userScaleWidth = universalSettings.screenWidthScale(latteView.positioner.currentScreenName);
         userScaleHeight = universalSettings.screenHeightScale(latteView.positioner.currentScreenName);
     }
 
     PlasmaCore.FrameSvgItem{
         anchors.fill: parent
-        imagePath: "widgets/panel-background"
+        imagePath: "dialogs/background"
         enabledBorders: viewConfig.enabledBorders
     }
 
     MouseArea{
         id: backgroundMouseArea
         anchors.fill: parent
         hoverEnabled: true
 
         property bool blockWheel: false
         property bool updatingWidthScale: false
         property bool updatingHeightScale: false
         property bool wheelTriggeredOnce: false
         property real scaleStep: 0.04
 
         onWheel: {
             var metaModifier = (wheel.modifiers & Qt.MetaModifier);
             var ctrlModifier = (wheel.modifiers & Qt.ControlModifier);
 
             if (blockWheel || !(metaModifier || ctrlModifier)){
                 return;
             }
 
             updatingWidthScale = metaModifier || (dialog.expertLevel && ctrlModifier);
             updatingHeightScale = !dialog.expertLevel && ctrlModifier;
 
             blockWheel = true;
             wheelTriggeredOnce = true;
             scrollDelayer.start();
 
             var angle = wheel.angleDelta.y / 8;
 
             //positive direction
             if (angle > 12) {
                 var scales;
                 if (updatingWidthScale) {
                     userScaleWidth = userScaleWidth + scaleStep;
                 }
 
                 if (updatingHeightScale) {
                     userScaleHeight = userScaleHeight + scaleStep;
                 }
 
                 universalSettings.setScreenScales(latteView.positioner.currentScreenName, userScaleWidth, userScaleHeight);
                 viewConfig.syncGeometry();
                 //negative direction
             } else if (angle < -12) {
                 if (updatingWidthScale) {
                     userScaleWidth = userScaleWidth - scaleStep;
                 }
 
                 if (updatingHeightScale) {
                     userScaleHeight = userScaleHeight - scaleStep;
                 }
                 universalSettings.setScreenScales(latteView.positioner.currentScreenName, userScaleWidth, userScaleHeight);
                 viewConfig.syncGeometry();
             }
         }
     }
 
     PlasmaComponents.Button {
         id: backgroundMouseAreaTooltip
         anchors.fill: parent
         opacity: 0
         tooltip: i18n("You can use Ctrl/Meta + Scroll Wheel to alter the window size")
 
         onHoveredChanged: {
             if (!hovered) {
                 backgroundMouseArea.wheelTriggeredOnce = false;
             }
         }
     }
 
     PlasmaComponents.Label{
         anchors.top: parent.top
         anchors.horizontalCenter: parent.horizontalCenter
         text: backgroundMouseArea.updatingWidthScale ?
                   i18nc("view settings width scale","Width scale at %0%").arg(userScaleWidth * 100) :
                   i18nc("view settings height scale","Height scale at %0%").arg(userScaleHeight * 100)
         visible: backgroundMouseAreaTooltip.hovered && backgroundMouseArea.wheelTriggeredOnce
     }
 
     //! A timer is needed in order to handle also touchpads that probably
     //! send too many signals very fast. This way the signals per sec are limited.
     //! The user needs to have a steady normal scroll in order to not
     //! notice a annoying delay
     Timer{
         id: scrollDelayer
         interval: 75
         onTriggered: backgroundMouseArea.blockWheel = false;
     }
 
     ColumnLayout {
         id: content
 
         Layout.minimumWidth: width
         Layout.minimumHeight: calculatedHeight
         Layout.preferredWidth: width
         Layout.preferredHeight: calculatedHeight
         width: (dialog.appliedWidth - units.smallSpacing * 2)
 
         anchors.horizontalCenter: parent.horizontalCenter
         anchors.top: parent.top
         spacing: units.smallSpacing
 
         property int calculatedHeight: header.height + headerSpacer.height+ tabBar.height + pagesBackground.height + actionButtons.height + spacing * 3
 
         Keys.onPressed: {
             if (event.key === Qt.Key_Escape) {
                 viewConfig.hideConfigWindow();
             }
         }
 
         Component.onCompleted: forceActiveFocus();
 
         RowLayout {
             id: header
             Layout.fillWidth: true
 
             spacing: 0
 
             Item {
                 Layout.alignment: Qt.AlignLeft | Qt.AlignTop
                 Layout.fillWidth: false
                 Layout.topMargin: units.smallSpacing
                 Layout.preferredWidth: width
                 Layout.preferredHeight: height
 
                 width: Qt.application.layoutDirection !== Qt.RightToLeft ? logo.width + latteTxt.width + units.smallSpacing : logo.width + units.smallSpacing
                 height: logo.height
 
                 Latte.IconItem {
                     id: logo
 
                     width: Math.round(1.4 * latteTxtMetrics.font.pixelSize)
                     height: width
 
                     smooth: true
                     source: "latte-dock"
                     // animated: true
                     usesPlasmaTheme: false
                     active: aboutArea.hovered
                 }
 
                 PlasmaComponents.Label {
                     id: latteTxtMetrics
                     text: i18n("Latte")
                     width: 0
                     font.pointSize: 2 * theme.defaultFont.pointSize
                     visible: false
                 }
 
                 PlasmaCore.SvgItem{
                     id: latteTxt
 
                     width: 2.2 * height
                     height: 0.4 * latteTxtMetrics.font.pixelSize
 
                     visible: Qt.application.layoutDirection !== Qt.RightToLeft
 
                     anchors.left: logo.right
                     anchors.verticalCenter: logo.verticalCenter
 
                     svg: PlasmaCore.Svg{
                         imagePath: universalSettings.trademarkIconPath()
                     }
                 }
 
                 PlasmaComponents.Button{
                     id: aboutArea
                     //! Used as tooltip
                     anchors.fill: parent
                     opacity: 0
                     tooltip: i18n("Open Latte settings window")
                     onPressedChanged: {
                         if (pressed) {
                             layoutsManager.showLatteSettingsDialog(Latte.Types.PreferencesPage)
                         }
                     }
                 }
 
                 Rectangle {
                     anchors.top: parent.bottom
                     anchors.horizontalCenter: parent.horizontalCenter
                     anchors.topMargin: 2
                     width: parent.width + 4
                     height: 2
                     color: theme.highlightColor
                     visible: aboutArea.hovered
                 }
             }
 
             Item{
                 id: headerSpacer
                 Layout.minimumHeight: complexitySettings.height + 2*units.smallSpacing
             }
 
             ColumnLayout {
                 PlasmaComponents.ToolButton {
                     id: pinButton
 
                     Layout.fillWidth: false
                     Layout.fillHeight: false
                     Layout.preferredWidth: width
                     Layout.preferredHeight: height
                     Layout.alignment: Qt.AlignRight | Qt.AlignVCenter
                     Layout.bottomMargin: units.smallSpacing
                     //!avoid editMode box shadow
                     Layout.topMargin: units.smallSpacing * 2
                     Layout.rightMargin: units.smallSpacing
 
                     iconSource: "window-pin"
                     checkable: true
 
                     width: Math.round(units.gridUnit * 1.25)
                     height: width
 
                     property bool inStartup: true
 
                     onClicked: {
                         plasmoid.configuration.configurationSticker = checked
                         viewConfig.setSticker(checked)
                     }
 
                     Component.onCompleted: {
                         checked = plasmoid.configuration.configurationSticker
                         viewConfig.setSticker(plasmoid.configuration.configurationSticker)
                     }
                 }
 
                 RowLayout {
                     id: complexitySettings
                     Layout.fillWidth: true
                     Layout.rightMargin: units.smallSpacing * 2
                     Layout.alignment: Qt.AlignRight | Qt.AlignTop
 
                     PlasmaComponents.Label {
                         Layout.fillWidth: true
                         Layout.alignment: Qt.AlignRight
                     }
 
                     PlasmaComponents.Label {
                         id: complexityLbl
                         Layout.alignment: Qt.AlignRight
                       //  opacity: dialog.basicLevel ? basicOpacity : 1
 
                         //! TODO: the term here is not accurate because the expert settings mode
                         //! is used currently. In the future this term will be rethought if
                         //! it must remain or be changed
                         text: i18nc("advanced settings", "Advanced")
 
                         readonly property real textColorBrightness: colorBrightness(theme.textColor)
                         readonly property real basicOpacity: textColorBrightness > 127 ? 0.7 : 0.3
 
                         color: {
                             if (dialog.basicLevel) {
                                 return textColorBrightness > 127 ? Qt.darker(theme.textColor, 1.4) : Qt.lighter(theme.textColor, 2.8);
                             }
 
                             return theme.textColor;
                         }
 
                         function colorBrightness(color) {
                             return colorBrightnessFromRGB(color.r * 255, color.g * 255, color.b * 255);
                         }
 
                         // formula for brightness according to:
                         // https://www.w3.org/TR/AERT/#color-contrast
                         function colorBrightnessFromRGB(r, g, b) {
                             return (r * 299 + g * 587 + b * 114) / 1000
                         }
 
                         MouseArea {
                             id: complexityMouseArea
                             anchors.fill: parent
                             hoverEnabled: true
                             onClicked: {
                                 complexitySwitch.checked = !complexitySwitch.checked;
                             }
                         }
                     }
 
                     LatteComponents.Switch {
                         id: complexitySwitch
                         checked: (viewConfig.complexity === Latte.Types.ExpertSettings)
 
                         onCheckedChanged: {
                             if (checked) {
                                 viewConfig.complexity = Latte.Types.ExpertSettings;
                             } else {
                                 viewConfig.complexity = Latte.Types.BasicSettings;
                             }
                         }
                     }
                 }
             }
         }
 
         PlasmaComponents.TabBar {
             id: tabBar
             Layout.fillWidth: true
             Layout.maximumWidth: (dialog.appliedWidth - units.smallSpacing * 2)
 
             PlasmaComponents.TabButton {
                 id: behaviorTabBtn
                 text: i18n("Behavior")
                 tab: behaviorPage
             }
             PlasmaComponents.TabButton {
                 id: appearanceTabBtn
                 text: i18n("Appearance")
                 tab: appearancePage
             }
             PlasmaComponents.TabButton {
                 id: effectsTabBtn
                 text: i18n("Effects")
                 tab: effectsPage
                 visible: dialog.highLevel
             }
             PlasmaComponents.TabButton {
                 id: tasksTabBtn
                 text: i18n("Tasks")
                 tab: tasksPage
 
                 visible: latteView.latteTasksArePresent
             }
         }
 
         Rectangle {
             id: pagesBackground
             Layout.fillWidth: true
             Layout.fillHeight: false
             Layout.minimumWidth: dialog.appliedWidth - units.smallSpacing * 4
             Layout.minimumHeight: height
             Layout.maximumHeight: height
 
             width: dialog.appliedWidth - units.smallSpacing * 3
             height: availableFreeHeight + units.smallSpacing * 4
 
             color: transparentBackgroundColor
             border.width: 1
             border.color: theme.backgroundColor
 
             //fix the height binding loop when showing the configuration window
             property int availableFreeHeight: dialog.appliedHeight - header.height - headerSpacer.height - tabBar.height - actionButtons.height - 2 * units.smallSpacing
 
             PlasmaExtras.ScrollArea {
                 id: scrollArea
 
                 anchors.fill: parent
                 verticalScrollBarPolicy: Qt.ScrollBarAsNeeded
                 horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
 
                 flickableItem.flickableDirection: Flickable.VerticalFlick
 
                 PlasmaComponents.TabGroup {
                     id: tabGroup
 
                     width: currentTab.Layout.maximumWidth
                     height: currentTab.Layout.maximumHeight
 
                     Pages.BehaviorConfig {
                         id: behaviorPage
                     }
 
                     Pages.AppearanceConfig {
                         id: appearancePage
                     }
 
                     Pages.EffectsConfig {
                         id: effectsPage
                     }
 
                     Pages.TasksConfig {
                         id: tasksPage
                     }
                 }
             }
         }
 
         RowLayout {
             id: actionButtons
             Layout.fillWidth: true
             Layout.alignment: Qt.AlignHCenter | Qt.AlignBottom
 
             spacing: units.largeSpacing
 
             Connections{
                 target: latteView.layout
                 onViewsCountChanged: actionButtons.updateEnabled();
             }
 
             function updateEnabled() {
                 var screenFreeEdges = latteView.layout.qmlFreeEdges(latteView.positioner.currentScreenId);
                 actionsComboBtn.buttonEnabled = screenFreeEdges.length > 0;
                 if (actionsModel.count > 0) {
                     actionsModel.get(0).enabled = actionsComboBtn.buttonEnabled;
                 }
                 removeView.enabled = latteView.layout.viewsCount>1 /*&& !(latteView.layout.viewsWithTasks()===1 && latteView.tasksPresent())*/
             }
 
             LatteComponents.ComboBoxButton {
                 id: actionsComboBtn
                 Layout.fillWidth: true
                 implicitWidth: removeView.implicitWidth
                 implicitHeight: removeView.implicitHeight
 
                 buttonEnabled: true
                 buttonText: i18n("New Dock")
                 buttonIconSource: "list-add"
                 buttonToolTip: i18n("Add a new dock")
 
                 comboBoxEnabled: true
                 comboBoxBlankSpaceForEmptyIcons: true
                 comboBoxPopUpAlignRight: Qt.application.layoutDirection === Qt.RightToLeft
                 comboBoxEnabledRole: "enabled"
                 comboBoxTextRole: "name"
                 comboBoxIconRole: "icon"
                 comboBoxMinimumPopUpWidth: actionsModel.count > 1 ? dialog.width / 2 : 150
 
                 property var centralLayoutsNames: []
                 property var sharedLayoutsNames: []
 
                 Component.onCompleted: {
                     comboBox.model = actionsModel;
                     actionButtons.updateEnabled();
                 }
 
                 ListModel {
                     id: actionsModel
                 }
 
                 Connections{
                     target: actionsComboBtn.comboBox
 
                     Component.onCompleted:{
                         actionsComboBtn.addModel();
                         actionButtons.updateEnabled();
                     }
 
                     onActivated: {
                         if (index==0) {
                             latteView.copyView();
                         } else if (index>=1) {
                             var layouts = actionsComboBtn.sharedLayoutsNames.concat(actionsComboBtn.centralLayoutsNames);
 
                             latteView.positioner.hideDockDuringMovingToLayout(layouts[index-1]);
                         }
 
                         actionsComboBtn.comboBox.currentIndex = -1;
                     }
 
                     onEnabledChanged: {
                         if (enabled) {
                             actionsComboBtn.addModel();
                         } else {
                             actionsComboBtn.emptyModel();
                         }
                     }
                 }
 
                 Connections{
                     target: actionsComboBtn.button
 
                     onClicked: latteView.layout.addNewView();
                 }
 
                 Connections{
                     target: latteView
                     onTypeChanged: actionsComboBtn.updateCopyText()
                 }
 
                 function addModel() {
                     actionsModel.clear();
 
                     var copy = {actionId: 'copy:', enabled: true, name: '', icon: 'edit-copy'};
                     actionsModel.append(copy);
 
                     updateCopyText();
 
                     var tempCentralLayouts = layoutsManager.centralLayoutsNames();
                     var tempSharedLayouts = layoutsManager.sharedLayoutsNames();
 
                     if (tempSharedLayouts.length > 0) {
                         var curIndex = tempSharedLayouts.indexOf(latteView.layout.name);
                         if (curIndex >=0) {
                             tempSharedLayouts.splice(curIndex,1);
                         }
 
                         sharedLayoutsNames = tempSharedLayouts;
                         var icon = "document-share";
 
                         for(var i=0; i<sharedLayoutsNames.length; ++i) {
                             var layout = {actionId: 'move:', enabled: true, name: i18n("Move to: %0").arg(sharedLayoutsNames[i]), icon: icon};
                             actionsModel.append(layout);
                         }
                     }
 
 
                     if (tempCentralLayouts.length > 0) {
                         var curIndex = tempCentralLayouts.indexOf(latteView.layout.name);
                         if (curIndex >=0) {
                             tempCentralLayouts.splice(curIndex,1);
                         }
 
                         centralLayoutsNames = tempCentralLayouts;
                         var iconArrow = Qt.application.layoutDirection === Qt.RightToLeft ? 'arrow-left' : 'arrow-right';
 
                         for(var i=0; i<centralLayoutsNames.length; ++i) {
                             var layout = {actionId: 'move:', enabled: true, name: i18n("Move to: %0").arg(centralLayoutsNames[i]), icon: iconArrow};
                             actionsModel.append(layout);
                         }
                     }
 
                     actionsComboBtn.comboBox.currentIndex = -1;
                 }
 
                 function emptyModel() {
                     actionsModel.clear();
                     var copy = {actionId: 'copy:', enabled: true, name: '', icon: 'edit-copy'};
                     actionsModel.append(copy);
                     updateCopyText();
                     actionsComboBtn.comboBox.currentIndex = -1;
                 }
 
                 function updateCopyText() {
                     var copyText = latteView.type === Latte.Types.DockView ? i18n("Copy Dock") : i18n("Copy Panel")
                     actionsModel.get(0).name = copyText;
                 }
             }
 
             PlasmaComponents.Button {
                 id: removeView
                 Layout.fillWidth: true
 
                 text: i18n("Remove")
                 iconSource: "delete"
                 opacity: latteView.layout.viewsCount > 1 ? 1 : 0
                 tooltip: i18n("Remove current dock")
 
                 onClicked: latteView.removeView()
             }
 
             PlasmaComponents.Button {
                 id: closeButton
                 Layout.fillWidth: true
 
                 text: i18n("Close")
                 iconSource: "dialog-close"
                 tooltip: i18n("Close settings window")
 
                 onClicked: viewConfig.hideConfigWindow();
             }
         }
     }
 
     //! HACK FOR X11 environments
     //! show an inner shadow similar to Latte::View editShadow in order to
     //! not break the visual user experience
     LatteExtraControls.InnerShadow{
         width: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? dialog.width + 2*shadowSize : shadowSize
         height: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? shadowSize : dialog.height + 2*shadowSize
 
         shadowSize: latteView.effects.editShadow
         shadowOpacity: Math.max(0.35, maxOpacity)
         shadowDirection: plasmoid.location
 
         visible: !Latte.WindowSystem.isPlatformWayland && Latte.WindowSystem.compositingActive && latteView.effects.settingsMaskSubtracted
 
         readonly property real maxOpacity: Latte.WindowSystem.compositingActive && !plasmoid.configuration.inConfigureAppletsMode ?
                                                plasmoid.configuration.editBackgroundOpacity : 1
     }
 }
diff --git a/shell/package/contents/configuration/LatteDockSecondaryConfiguration.qml b/shell/package/contents/configuration/LatteDockSecondaryConfiguration.qml
index 30c7282d..f8b0c2ea 100644
--- a/shell/package/contents/configuration/LatteDockSecondaryConfiguration.qml
+++ b/shell/package/contents/configuration/LatteDockSecondaryConfiguration.qml
@@ -1,88 +1,88 @@
 /*
 *  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/>.
 */
 
 import QtQuick 2.7
 import QtQuick.Controls 1.4
 import QtQuick.Layouts 1.3
 import QtGraphicalEffects 1.0
 import QtQuick.Window 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 import QtQuick.Controls.Styles.Plasma 2.0 as Styles
 
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.kquickcontrolsaddons 2.0 as KQuickControlAddons
 
 import org.kde.latte 0.2 as Latte
 
 import "../controls" as LatteExtraControls
 
 FocusScope {
     id: dialog
 
     width: typeSettings.width + units.smallSpacing * 4
     height: typeSettings.height + units.smallSpacing * 4
     Layout.minimumWidth: width
     Layout.minimumHeight: height
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft
     LayoutMirroring.childrenInherit: true
 
     property bool panelIsVertical: plasmoid.formFactor === PlasmaCore.Types.Vertical
 
     PlasmaCore.FrameSvgItem{
         anchors.fill: parent
-        imagePath: "widgets/panel-background"
+        imagePath: "dialogs/background"
         enabledBorders: viewConfig.enabledBorders
     }
 
 
     LatteExtraControls.TypeSelection{
         id: typeSettings
         anchors.centerIn: parent
 
         Component.onCompleted: forceActiveFocus();
 
         Keys.onPressed: {
             if (event.key === Qt.Key_Escape) {
                 viewConfig.hideConfigWindow();
             }
         }
     }
 
     //! HACK FOR X11 environments
     //! show an inner shadow similar to Latte::View editShadow in order to
     //! not break the visual user experience
     LatteExtraControls.InnerShadow{
         width: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? dialog.width + 2*shadowSize : shadowSize
         height: plasmoid.formFactor === PlasmaCore.Types.Horizontal ? shadowSize : dialog.height + 2*shadowSize
 
         shadowSize: latteView.effects.editShadow
         shadowOpacity: Math.max(0.35, maxOpacity)
         shadowDirection: plasmoid.location
 
         visible: !Latte.WindowSystem.isPlatformWayland && Latte.WindowSystem.compositingActive && latteView.effects.settingsMaskSubtracted
 
         readonly property real maxOpacity: Latte.WindowSystem.compositingActive && !plasmoid.configuration.inConfigureAppletsMode ?
                                                plasmoid.configuration.editBackgroundOpacity : 1
     }
 }