diff --git a/app/lattecorona.cpp b/app/lattecorona.cpp
index b92c4ff5..ac7f895c 100644
--- a/app/lattecorona.cpp
+++ b/app/lattecorona.cpp
@@ -1,1128 +1,1130 @@
 /*
 *  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))
 {
     //! 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_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;
 }
 
 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) const
+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)
+    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(screen->geometry());
+    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) const
+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)
+    if (!screen) {
         return {};
+    }
 
     bool allModes = modes.isEmpty();
 
     bool allEdges = edges.isEmpty();
 
-    auto available = screen->geometry();
+    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->winId(), 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 eb2fbc35..c9317b99 100644
--- a/app/lattecorona.h
+++ b/app/lattecorona.h
@@ -1,228 +1,232 @@
 /*
 *  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 "../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
+    //! 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>()) const;
+                                          QList<Plasma::Types::Location> edges = QList<Plasma::Types::Location>(),
+                                          bool includeExternalPanels = false) const;
 
-    QRegion availableScreenRegionWithCriteria(int id, QString forLayout = QString()) 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;
 
     //! 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};
 
     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 a6db9733..fae3c51d 100644
--- a/app/view/settings/primaryconfigview.cpp
+++ b/app/view/settings/primaryconfigview.cpp
@@ -1,719 +1,719 @@
 /*
 *  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()) {
             m_corona->wm()->setViewExtraFlags(this, false, Latte::Types::NormalWindow);
         }
 
         syncGeometry();
         syncSlideEffect();
     });
     connections << connect(m_latteView->visibility(), &VisibilityManager::modeChanged, this, &PrimaryConfigView::syncGeometry);
     connections << connect(containment, &Plasma::Containment::immutabilityChanged, this, &PrimaryConfigView::immutabilityChanged);
 
     m_thicknessSyncTimer.setSingleShot(true);
     m_thicknessSyncTimer.setInterval(200);
     connections << connect(&m_thicknessSyncTimer, &QTimer::timeout, this, [this]() {
         syncGeometry();
     });
 
     connections << connect(m_latteView, &Latte::View::normalThicknessChanged, [&]() {
         m_thicknessSyncTimer.start();
     });
 
     connections << connect(m_latteView, &Latte::View::availableScreenRectChangedForViewParts, this, &PrimaryConfigView::updateAvailableScreenGeometry);
 
     if (m_corona) {
         connections << connect(m_corona, &Latte::Corona::raiseViewsTemporaryChanged, this, &PrimaryConfigView::raiseDocksTemporaryChanged);
     }
 
     if (m_latteView->layout()) {
         emit m_latteView->layout()->setLastConfigViewFor(m_latteView);
     }
 }
 
 PrimaryConfigView::~PrimaryConfigView()
 {
     qDebug() << "ConfigView deleting ...";
 
     m_corona->wm()->unregisterIgnoredWindow(KWindowSystem::isPlatformX11() ? winId() : m_waylandWindowId);
 
     deleteSecondaryWindow();
 
     for (const auto &var : connections) {
         QObject::disconnect(var);
     }
 }
 
 void PrimaryConfigView::init()
 {
     qDebug() << "dock config view : initialization started...";
     m_originalByPassWM = m_latteView->byPassWM();
     m_originalMode = m_latteView->visibility()->mode();
 
     loadConfig();
 
     setDefaultAlphaBuffer(true);
     setColor(Qt::transparent);
     PanelShadows::self()->addWindow(this);
     rootContext()->setContextProperty(QStringLiteral("latteView"), m_latteView);
     rootContext()->setContextProperty(QStringLiteral("shortcutsEngine"), m_corona->globalShortcuts()->shortcutsTracker());
     rootContext()->setContextProperty(QStringLiteral("viewConfig"), this);
 
     if (m_corona) {
         rootContext()->setContextProperty(QStringLiteral("universalSettings"), m_corona->universalSettings());
         rootContext()->setContextProperty(QStringLiteral("layoutsManager"), m_corona->layoutsManager());
     }
 
     KDeclarative::KDeclarative kdeclarative;
     kdeclarative.setDeclarativeEngine(engine());
     kdeclarative.setTranslationDomain(QStringLiteral("latte-dock"));
 #if KF5_VERSION_MINOR >= 45
     kdeclarative.setupContext();
     kdeclarative.setupEngine(engine());
 #else
     kdeclarative.setupBindings();
 #endif
 
     QByteArray tempFilePath = "lattedockconfigurationui";
 
     updateEnabledBorders();
     updateAvailableScreenGeometry();
 
     auto source = QUrl::fromLocalFile(m_latteView->containment()->corona()->kPackage().filePath(tempFilePath));
     setSource(source);
     syncGeometry();
     syncSlideEffect();
 
     qDebug() << "dock config view : initialization ended...";
 }
 
 inline Qt::WindowFlags PrimaryConfigView::wFlags() const
 {
     return (flags() | Qt::FramelessWindowHint) & ~Qt::WindowDoesNotAcceptFocus;
 }
 
 QQuickView *PrimaryConfigView::secondaryWindow()
 {
     return m_secConfigView;
 }
 
 void PrimaryConfigView::createSecondaryWindow()
 {
     if (m_secConfigView) {
         return;
     }
 
     m_secConfigView = new SecondaryConfigView(m_latteView, this);
     m_secConfigView->init();
 }
 
 void PrimaryConfigView::deleteSecondaryWindow()
 {
     if (m_secConfigView) {
         auto secWindow = m_secConfigView;
         m_secConfigView = nullptr;
         secWindow->deleteLater();
 
         if (KWindowSystem::isPlatformX11()) {
             //! this is needed in order for subtracked mask of secondary window to
             //! be released properly when changing for Advanced to Basic mode.
             //! Under wayland this is not needed because masks do not break any visuals.
             m_latteView->effects()->updateMask();
         }
     }
 }
 
 void PrimaryConfigView::updateAvailableScreenGeometry()
 {
     int currentScrId = m_latteView->positioner()->currentScreenId();
-    m_availableScreenGeometry = m_corona->availableScreenRect(currentScrId);
+    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;
     }
 
     setFlags(wFlags());
     m_corona->wm()->setViewExtraFlags(this, false, Latte::Types::NormalWindow);
 
     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_corona->wm()->setViewExtraFlags(m_shellSurface, false);
 
         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);
 
         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
 
 }
 }