diff --git a/app/lattecorona.cpp b/app/lattecorona.cpp
index 58d0b993..f0c88505 100644
--- a/app/lattecorona.cpp
+++ b/app/lattecorona.cpp
@@ -1,1081 +1,1081 @@
 /*
 *  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 "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/windows.h"
+#include "wm/tracker/trackerwindows.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(QApplication::desktop(), &QDesktopWidget::screenCountChanged, this, &Corona::screenCountChanged);
 
         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);
     }
 }
 
 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
 {
     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(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
 {
     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 = 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()));
 }
 
 void Corona::primaryOutputChanged()
 {
     m_viewsScreenSyncTimer.start();
 }
 
 void Corona::screenRemoved(QScreen *screen)
 {
     Q_ASSERT(screen);
 }
 
 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;
         }
     }
 
     Latte::CentralLayout *currentLayout = m_layoutsManager->currentLayout();
     Latte::View *view = currentLayout->viewForContainment(containment);
 
     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::CentralLayout *currentLayout = m_layoutsManager->currentLayout();
     Latte::View *latteView = currentLayout->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)
 {
     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
 {
     qmlRegisterType<QScreen>();
     qmlRegisterType<Latte::View>();
     qmlRegisterType<Latte::WindowSystem::SchemeColors>();
     qmlRegisterType<Latte::WindowSystem::Tracker::LastActiveWindow>();
 }
 
 }
diff --git a/app/view/windowstracker.cpp b/app/view/windowstracker.cpp
index 785673a2..26e988c6 100644
--- a/app/view/windowstracker.cpp
+++ b/app/view/windowstracker.cpp
@@ -1,169 +1,169 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "windowstracker.h"
 
 // local
 #include "positioner.h"
 #include "view.h"
 #include "../lattecorona.h"
 #include "../layouts/manager.h"
 #include "../wm/schemecolors.h"
-#include "../wm/tracker/windows.h"
 #include "../wm/tracker/lastactivewindow.h"
+#include "../wm/tracker/trackerwindows.h"
 #include "../../liblatte2/types.h"
 
 namespace Latte {
 namespace ViewPart {
 
 WindowsTracker::WindowsTracker(Latte::View *parent)
     : QObject(parent),
       m_latteView(parent)
 {
     qDebug() << "WindowsTracker creating...";
 
     m_corona = qobject_cast<Latte::Corona *>(m_latteView->corona());
     m_wm = m_corona->wm();
 
     init();
     m_wm->windowsTracker()->addView(m_latteView);
 
 
     connect(lastActiveWindow(), &WindowSystem::Tracker::LastActiveWindow::draggingStarted,
             this, &WindowsTracker::activeWindowDraggingStarted);
 
     emit lastActiveWindowChanged();
 }
 
 WindowsTracker::~WindowsTracker()
 {
     qDebug() << "WindowsTracker removing...";
     m_wm->windowsTracker()->removeView(m_latteView);
 }
 
 void  WindowsTracker::init()
 {
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::enabledChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit enabledChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::activeWindowMaximizedChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit activeWindowMaximizedChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::activeWindowTouchingChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit activeWindowTouchingChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::existsWindowActiveChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit existsWindowActiveChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::existsWindowMaximizedChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit existsWindowMaximizedChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::existsWindowTouchingChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit existsWindowTouchingChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::activeWindowSchemeChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit activeWindowSchemeChanged();
         }
     });
 
     connect(m_wm->windowsTracker(), &WindowSystem::Tracker::Windows::touchingWindowSchemeChanged, this, [&](const Latte::View *view) {
         if (m_latteView == view) {
             emit touchingWindowSchemeChanged();
         }
     });
 }
 
 bool WindowsTracker::activeWindowMaximized() const
 {
     return m_wm->windowsTracker()->activeWindowMaximized(m_latteView);
 }
 
 bool WindowsTracker::activeWindowTouching() const
 {
     return m_wm->windowsTracker()->activeWindowTouching(m_latteView);
 }
 
 bool WindowsTracker::existsWindowActive() const
 {
     return m_wm->windowsTracker()->existsWindowActive(m_latteView);
 }
 
 bool WindowsTracker::existsWindowMaximized() const
 {
     return m_wm->windowsTracker()->existsWindowMaximized(m_latteView);
 }
 
 bool WindowsTracker::existsWindowTouching() const
 {
     return m_wm->windowsTracker()->existsWindowTouching(m_latteView);
 }
 
 WindowSystem::SchemeColors *WindowsTracker::activeWindowScheme() const
 {
     return m_wm->windowsTracker()->activeWindowScheme(m_latteView);
 }
 
 WindowSystem::SchemeColors *WindowsTracker::touchingWindowScheme() const
 {
     return m_wm->windowsTracker()->touchingWindowScheme(m_latteView);
 }
 
 bool WindowsTracker::enabled() const
 {
     return m_wm->windowsTracker()->enabled(m_latteView);
 }
 
 void WindowsTracker::setEnabled(bool active)
 {
     m_wm->windowsTracker()->setEnabled(m_latteView, active);
 }
 
 WindowSystem::Tracker::LastActiveWindow *WindowsTracker::lastActiveWindow()
 {
     return m_wm->windowsTracker()->lastActiveWindow(m_latteView);
 }
 
 
 //! Window Functions
 void WindowsTracker::setWindowOnActivities(QWindow &window, const QStringList &activities)
 {
     m_wm->setWindowOnActivities(window, activities);
 }
 
 }
 }
diff --git a/app/wm/abstractwindowinterface.cpp b/app/wm/abstractwindowinterface.cpp
index 57807028..2b08cfcf 100644
--- a/app/wm/abstractwindowinterface.cpp
+++ b/app/wm/abstractwindowinterface.cpp
@@ -1,107 +1,107 @@
 /*
 *  Copyright 2016  Smith AR <audoban@openmailbox.org>
 *                  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "abstractwindowinterface.h"
 
 // local
 #include "tracker/schemes.h"
-#include "tracker/windows.h"
+#include "tracker/trackerwindows.h"
 #include "../lattecorona.h"
 
 
 namespace Latte {
 namespace WindowSystem {
 
 AbstractWindowInterface::AbstractWindowInterface(QObject *parent)
     : QObject(parent)
 {
     m_corona = qobject_cast<Latte::Corona *>(parent);
     m_windowsTracker = new Tracker::Windows(this);
     m_schemesTracker = new Tracker::Schemes(this);
 
     rulesConfig = KSharedConfig::openConfig(QStringLiteral("taskmanagerrulesrc"));
 
     m_windowWaitingTimer.setInterval(150);
     m_windowWaitingTimer.setSingleShot(true);
 
     connect(&m_windowWaitingTimer, &QTimer::timeout, this, [&]() {
         WindowId wid = m_windowChangedWaiting;
         m_windowChangedWaiting = QVariant();
         emit windowChanged(wid);
     });
 
     connect(this, &AbstractWindowInterface::windowChanged, this, [&](WindowId wid) {
         qDebug() << "WINDOW CHANGED ::: " << wid;
     });
 }
 
 AbstractWindowInterface::~AbstractWindowInterface()
 {
     m_windowWaitingTimer.stop();
 
     m_schemesTracker->deleteLater();
     m_windowsTracker->deleteLater();
 }
 
 Latte::Corona *AbstractWindowInterface::corona()
 {
     return m_corona;
 }
 
 Tracker::Schemes *AbstractWindowInterface::schemesTracker()
 {
     return m_schemesTracker;
 }
 
 Tracker::Windows *AbstractWindowInterface::windowsTracker() const
 {
     return m_windowsTracker;
 }
 
 void AbstractWindowInterface::considerWindowChanged(WindowId wid)
 {
     //! Consider if the windowChanged signal should be sent DIRECTLY or WAIT
 
     if (m_windowChangedWaiting == wid && m_windowWaitingTimer.isActive()) {
         //! window should be sent later
         m_windowWaitingTimer.start();
         return;
     }
 
     if (m_windowChangedWaiting != wid && !m_windowWaitingTimer.isActive()) {
         //! window should be sent later
         m_windowChangedWaiting = wid;
         m_windowWaitingTimer.start();
     }
 
     if (m_windowChangedWaiting != wid && m_windowWaitingTimer.isActive()) {
         m_windowWaitingTimer.stop();
         //! sent previous waiting window
         emit (m_windowChangedWaiting);
 
         //! retrigger waiting for the upcoming window
         m_windowChangedWaiting = wid;
         m_windowWaitingTimer.start();
     }
 }
 
 }
 }
 
diff --git a/app/wm/abstractwindowinterface.h b/app/wm/abstractwindowinterface.h
index f94e3503..803c0288 100644
--- a/app/wm/abstractwindowinterface.h
+++ b/app/wm/abstractwindowinterface.h
@@ -1,154 +1,154 @@
 /*
 *  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 ABSTRACTWINDOWINTERFACE_H
 #define ABSTRACTWINDOWINTERFACE_H
 
 // local
 #include "schemecolors.h"
 #include "tasktools.h"
 #include "windowinfowrap.h"
-#include "tracker/windows.h"
+#include "tracker/trackerwindows.h"
 #include "../liblatte2/types.h"
 #include "../liblatte2/extras.h"
 
 // C++
 #include <unordered_map>
 #include <list>
 
 // Qt
 #include <QObject>
 #include <QWindow>
 #include <QDialog>
 #include <QMap>
 #include <QRect>
 #include <QPoint>
 #include <QPointer>
 #include <QScreen>
 #include <QTimer>
 
 // KDE
 #include <KSharedConfig>
 #include <KActivities/Consumer>
 
 // Plasma
 #include <Plasma>
 
 namespace Latte {
 class Corona;
 namespace WindowSystem {
 namespace Tracker {
 class Schemes;
 class Windows;
 }
 }
 }
 
 namespace Latte {
 namespace WindowSystem {
 
 class AbstractWindowInterface : public QObject
 {
     Q_OBJECT
 
 public:
     enum class Slide
     {
         None,
         Top,
         Left,
         Bottom,
         Right,
     };
 
     explicit AbstractWindowInterface(QObject *parent = nullptr);
     virtual ~AbstractWindowInterface();
 
     virtual void setViewExtraFlags(QWindow &view) = 0;
     virtual void setViewStruts(QWindow &view, const QRect &rect
                                , Plasma::Types::Location location) = 0;
     virtual void setWindowOnActivities(QWindow &window, const QStringList &activities) = 0;
 
     virtual void removeViewStruts(QWindow &view) const = 0;
 
     virtual WindowId activeWindow() const = 0;
     virtual WindowInfoWrap requestInfo(WindowId wid) const = 0;
     virtual WindowInfoWrap requestInfoActive() const = 0;
     virtual bool isOnCurrentDesktop(WindowId wid) const = 0;
     virtual bool isOnCurrentActivity(WindowId wid) const = 0;
 
     virtual void setKeepAbove(const QDialog &dialog, bool above = true) const = 0;
     virtual void skipTaskBar(const QDialog &dialog) const = 0;
     virtual void slideWindow(QWindow &view, Slide location) const = 0;
     virtual void enableBlurBehind(QWindow &view) const = 0;
     virtual void setEdgeStateFor(QWindow *view, bool active) const = 0;
 
     virtual void releaseMouseEventFor(WindowId wid) const = 0;
 
     virtual void requestActivate(WindowId wid) const = 0;
     virtual void requestClose(WindowId wid) const = 0;
     virtual void requestMoveWindow(WindowId wid, QPoint from) const = 0;
     virtual void requestToggleIsOnAllDesktops(WindowId wid) const = 0;
     virtual void requestToggleKeepAbove(WindowId wid) const = 0;
     virtual void requestToggleMinimized(WindowId wid) const = 0;
     virtual void requestToggleMaximized(WindowId wid) const = 0;
 
     virtual bool windowCanBeDragged(WindowId wid) const = 0;
 
     virtual QIcon iconFor(WindowId wid) const = 0;
     virtual WindowId winIdFor(QString appId, QRect geometry) const = 0;
     virtual AppData appDataFor(WindowId wid) const = 0;
 
     Latte::Corona *corona();
     Tracker::Schemes *schemesTracker();
     Tracker::Windows *windowsTracker() const;
 
 signals:
     void activeWindowChanged(WindowId wid);
     void windowChanged(WindowId winfo);
     void windowAdded(WindowId wid);
     void windowRemoved(WindowId wid);
     void currentDesktopChanged();
     void currentActivityChanged();
 
 protected:
     QPointer<KActivities::Consumer> m_activities;
 
     //! Sending too fast plenty of signals for the same window
     //! has no reason and can create HIGH CPU usage. This Timer
     //! can delay the batch sending of signals for the same window
     WindowId m_windowChangedWaiting;
     QTimer m_windowWaitingTimer;
 
     //! Plasma taskmanager rules ile
     KSharedConfig::Ptr rulesConfig;
 
     void considerWindowChanged(WindowId wid);
 
 private:
     Latte::Corona *m_corona;
     Tracker::Schemes *m_schemesTracker;
     Tracker::Windows *m_windowsTracker;
 };
 
 }
 }
 
 #endif // ABSTRACTWINDOWINTERFACE_H
diff --git a/app/wm/tracker/CMakeLists.txt b/app/wm/tracker/CMakeLists.txt
index 685ec0e5..6baf2923 100644
--- a/app/wm/tracker/CMakeLists.txt
+++ b/app/wm/tracker/CMakeLists.txt
@@ -1,9 +1,9 @@
 set(lattedock-app_SRCS
     ${lattedock-app_SRCS}   
     ${CMAKE_CURRENT_SOURCE_DIR}/lastactivewindow.cpp
-    ${CMAKE_CURRENT_SOURCE_DIR}/windows.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/schemes.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/trackedgeneralinfo.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/trackedviewinfo.cpp
+    ${CMAKE_CURRENT_SOURCE_DIR}/trackerwindows.cpp
     PARENT_SCOPE
 )
diff --git a/app/wm/tracker/lastactivewindow.cpp b/app/wm/tracker/lastactivewindow.cpp
index da35f859..c63982e7 100644
--- a/app/wm/tracker/lastactivewindow.cpp
+++ b/app/wm/tracker/lastactivewindow.cpp
@@ -1,326 +1,326 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "lastactivewindow.h"
 
 // local
 #include "trackedgeneralinfo.h"
-#include "windows.h"
+#include "trackerwindows.h"
 #include "../abstractwindowinterface.h"
 #include "../tasktools.h"
 #include "../../view/view.h"
 #include "../../view/visibilitymanager.h"
 
 // Qt
 #include <QDebug>
 #include <QPoint>
 #include <QTimer>
 
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 LastActiveWindow::LastActiveWindow(TrackedGeneralInfo *trackedInfo)
     : QObject(trackedInfo),
       m_trackedInfo(trackedInfo),
       m_windowsTracker(trackedInfo->wm()->windowsTracker()),
       m_wm(trackedInfo->wm())
 {
 }
 
 LastActiveWindow::~LastActiveWindow()
 {
 }
 
 bool LastActiveWindow::isActive() const
 {
     return m_isActive;
 }
 
 void LastActiveWindow::setActive(bool active)
 {
     if (m_isActive == active) {
         return;
     }
 
     m_isActive = active;
     emit isActiveChanged();
 }
 
 bool LastActiveWindow::isMinimized() const
 {
     return m_isMinimized;
 }
 
 void LastActiveWindow::setIsMinimized(bool minimized)
 {
     if (m_isMinimized == minimized) {
         return;
     }
 
     m_isMinimized = minimized;
     emit isMinimizedChanged();
 }
 
 bool LastActiveWindow::isMaximized() const
 {
     return m_isMaximized;
 }
 
 void LastActiveWindow::setIsMaximized(bool maximized)
 {
     if (m_isMaximized == maximized) {
         return;
     }
 
     m_isMaximized = maximized;
     emit isMaximizedChanged();
 }
 
 bool LastActiveWindow::isFullScreen() const
 {
     return m_isFullScreen;
 }
 
 void LastActiveWindow::setIsFullScreen(bool fullscreen)
 {
     if (m_isFullScreen == fullscreen) {
         return;
     }
 
     m_isFullScreen = fullscreen;
     emit isFullScreenChanged();
 }
 
 bool LastActiveWindow::isKeepAbove() const
 {
     return m_isKeepAbove;
 }
 
 void LastActiveWindow::setIsKeepAbove(bool above)
 {
     if (m_isKeepAbove == above) {
         return;
     }
 
     m_isKeepAbove = above;
     emit isKeepAboveChanged();
 }
 
 bool LastActiveWindow::isOnAllDesktops() const
 {
     return m_isOnAllDesktops;
 }
 
 void LastActiveWindow::setIsOnAllDesktops(bool all)
 {
     if (m_isOnAllDesktops == all) {
         return;
     }
 
     m_isOnAllDesktops = all;
     emit isOnAllDesktopsChanged();
 }
 
 bool LastActiveWindow::isShaded() const
 {
     return m_isShaded;
 }
 
 void LastActiveWindow::setIsShaded(bool shaded)
 {
     if (m_isShaded == shaded) {
         return;
     }
 
     m_isShaded = shaded;
     emit isShadedChanged();
 }
 
 bool LastActiveWindow::hasSkipTaskbar() const
 {
     return m_hasSkipTaskbar;
 }
 
 void LastActiveWindow::setHasSkipTaskbar(bool skip)
 {
     if (m_hasSkipTaskbar == skip) {
         return;
     }
 
     m_hasSkipTaskbar = skip;
     emit hasSkipTaskbarChanged();
 }
 
 QRect LastActiveWindow::geometry() const
 {
     return m_geometry;
 }
 
 void LastActiveWindow::setGeometry(QRect geometry)
 {
     if (m_geometry == geometry) {
         return;
     }
 
     m_geometry = geometry;
     emit geometryChanged();
 }
 
 QString LastActiveWindow::appName() const
 {
     return m_appName;
 }
 
 void LastActiveWindow::setAppName(QString appName)
 {
     if (m_appName == appName) {
         return;
     }
 
     m_appName = appName;
     emit appNameChanged();
 }
 
 QString LastActiveWindow::display() const
 {
     return m_display;
 }
 
 void LastActiveWindow::setDisplay(QString display)
 {
     if (m_display == display) {
         return;
     }
 
     m_display = display;
     emit displayChanged();
 }
 
 QIcon LastActiveWindow::icon() const
 {
     return m_icon;
 }
 
 void LastActiveWindow::setIcon(QIcon icon)
 {
     m_icon = icon;
     emit iconChanged();
 }
 
 QVariant LastActiveWindow::winId() const
 {
     return m_winId;
 }
 
 void LastActiveWindow::setWinId(QVariant winId)
 {
     if (m_winId == winId) {
         return;
     }
 
     m_winId = winId;
     emit winIdChanged();
 }
 
 void LastActiveWindow::setInformation(const WindowInfoWrap &info)
 {
     setWinId(info.wid());
 
     setActive(info.isActive());
     setIsMinimized(info.isMinimized());
     setIsMaximized(info.isMaxVert() || info.isMaxHoriz());
     setIsOnAllDesktops(info.isOnAllDesktops());
 
     setAppName(info.appName());
     setDisplay(info.display());
     setGeometry(info.geometry());
     setIsKeepAbove(info.isKeepAbove());
 
     if (info.appName().isEmpty()) {
         setAppName(m_windowsTracker->appNameFor(info.wid()));
     } else {
         setAppName(info.appName());
     }
 
     if (info.icon().isNull()) {
         setIcon(m_windowsTracker->iconFor(info.wid()));
     } else {
         setIcon(info.icon());
     }
 
 }
 
 //! FUNCTIONALITY
 
 
 void LastActiveWindow::requestActivate()
 {
     m_wm->requestActivate(m_winId);
 }
 
 void LastActiveWindow::requestClose()
 {
     m_wm->requestClose(m_winId);
 }
 
 void LastActiveWindow::requestMove(int localX, int localY)
 {
     QPoint globalPoint{m_trackedInfo->view()->x() + localX, m_trackedInfo->view()->y() + localY};
 
     m_wm->requestMoveWindow(m_winId, globalPoint);
 
     //! This timer is needed because otherwise the mouse position
     //! in the dragged window changes to TopLeft corner
     QTimer::singleShot(250, this, [&]() {
         m_wm->releaseMouseEventFor(m_trackedInfo->view()->winId());
     });
 
     emit draggingStarted();
 }
 
 void LastActiveWindow::requestToggleIsOnAllDesktops()
 {
     m_wm->requestToggleIsOnAllDesktops(m_winId);
 }
 
 void LastActiveWindow::requestToggleKeepAbove()
 {
     m_wm->requestToggleKeepAbove(m_winId);
 }
 
 void LastActiveWindow::requestToggleMinimized()
 {
     m_wm->requestToggleMinimized(m_winId);
 }
 
 void LastActiveWindow::requestToggleMaximized()
 {
     m_wm->requestToggleMaximized(m_winId);
 }
 
 bool LastActiveWindow::canBeDragged()
 {
     return m_wm->windowCanBeDragged(m_winId);
 }
 
 }
 }
 }
diff --git a/app/wm/tracker/trackedgeneralinfo.cpp b/app/wm/tracker/trackedgeneralinfo.cpp
index 3963566b..2c150538 100644
--- a/app/wm/tracker/trackedgeneralinfo.cpp
+++ b/app/wm/tracker/trackedgeneralinfo.cpp
@@ -1,140 +1,140 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "trackedgeneralinfo.h"
 
 //local
-#include "windows.h"
+#include "trackerwindows.h"
 #include "../schemecolors.h"
 #include "../../view/view.h"
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 
 TrackedGeneralInfo::TrackedGeneralInfo(Tracker::Windows *tracker, Latte::View *view)
     : QObject(tracker) ,
       m_wm(tracker->wm()),
       m_view(view)
 {
     m_lastActiveWindow = new LastActiveWindow(this);
 
     emit lastActiveWindowChanged();
 }
 
 TrackedGeneralInfo::~TrackedGeneralInfo()
 {
     if (m_lastActiveWindow) {
         auto law = m_lastActiveWindow;
         m_lastActiveWindow = nullptr;
         emit lastActiveWindowChanged();
 
         law->deleteLater();
     }
 }
 
 bool TrackedGeneralInfo::enabled() const
 {
     return m_enabled;
 }
 
 void TrackedGeneralInfo::setEnabled(bool enabled)
 {
     if (m_enabled == enabled) {
         return;
     }
 
     m_enabled = enabled;
 }
 
 bool TrackedGeneralInfo::activeWindowMaximized() const
 {
     return m_activeWindowMaximized;
 }
 
 void TrackedGeneralInfo::setActiveWindowMaximized(bool activeMaximized)
 {
     if (m_activeWindowMaximized == activeMaximized) {
         return;
     }
 
     m_activeWindowMaximized = activeMaximized;
 }
 
 bool TrackedGeneralInfo::existsWindowActive() const
 {
     return m_existsWindowActive;
 }
 
 void TrackedGeneralInfo::setExistsWindowActive(bool exists)
 {
     if (m_existsWindowActive == exists) {
         return;
     }
 
     m_existsWindowActive = exists;
 }
 
 bool TrackedGeneralInfo::existsWindowMaximized() const
 {
     return m_existsWindowMaximized;
 }
 
 void TrackedGeneralInfo::setExistsWindowMaximized(bool maximized)
 {
     if (m_existsWindowMaximized == maximized) {
         return;
     }
 
     m_existsWindowMaximized = maximized;
 }
 
 LastActiveWindow *TrackedGeneralInfo::lastActiveWindow() const
 {
     return m_lastActiveWindow;
 }
 
 SchemeColors *TrackedGeneralInfo::activeWindowScheme() const
 {
     return m_activeWindowScheme;
 }
 
 void TrackedGeneralInfo::setActiveWindowScheme(SchemeColors *scheme)
 {
     if (m_activeWindowScheme == scheme) {
         return;
     }
 
     m_activeWindowScheme = scheme;
 }
 
 Latte::View *TrackedGeneralInfo::view()
 {
     return m_view;
 }
 
 AbstractWindowInterface *TrackedGeneralInfo::wm()
 {
     return m_wm;
 }
 
 }
 }
 }
diff --git a/app/wm/tracker/trackedviewinfo.cpp b/app/wm/tracker/trackedviewinfo.cpp
index d3b146ce..b8c61304 100644
--- a/app/wm/tracker/trackedviewinfo.cpp
+++ b/app/wm/tracker/trackedviewinfo.cpp
@@ -1,100 +1,100 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "trackedviewinfo.h"
 
 //local
-#include "windows.h"
+#include "trackerwindows.h"
 #include "../schemecolors.h"
 #include "../../view/view.h"
 
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 
 TrackedViewInfo::TrackedViewInfo(Tracker::Windows *tracker, Latte::View *view)
     : TrackedGeneralInfo(tracker, view)
 {
 }
 
 TrackedViewInfo::~TrackedViewInfo()
 {
 }
 
 bool TrackedViewInfo::activeWindowTouching() const
 {
     return m_activeWindowTouching;
 }
 
 void TrackedViewInfo::setActiveWindowTouching(bool touching)
 {
     if (m_activeWindowTouching == touching) {
         return;
     }
 
     m_activeWindowTouching = touching;
 }
 
 bool TrackedViewInfo::existsWindowTouching() const
 {
     return m_existsWindowTouching;
 }
 
 void TrackedViewInfo::setExistsWindowTouching(bool touching)
 {
     if (m_existsWindowTouching == touching) {
         return;
     }
 
     m_existsWindowTouching = touching;
 }
 
 QRect TrackedViewInfo::availableScreenGeometry() const
 {
     return m_availableScreenGeometry;
 }
 
 void TrackedViewInfo::setAvailableScreenGeometry(QRect geometry)
 {
     if (m_availableScreenGeometry == geometry) {
         return;
     }
 
     m_availableScreenGeometry = geometry;
 }
 
 SchemeColors *TrackedViewInfo::touchingWindowScheme() const
 {
     return m_touchingWindowScheme;
 }
 
 void TrackedViewInfo::setTouchingWindowScheme(SchemeColors *scheme)
 {
     if (m_touchingWindowScheme == scheme) {
         return;
     }
 
     m_touchingWindowScheme = scheme;
 }
 
 }
 }
 }
diff --git a/app/wm/tracker/windows.cpp b/app/wm/tracker/trackerwindows.cpp
similarity index 99%
rename from app/wm/tracker/windows.cpp
rename to app/wm/tracker/trackerwindows.cpp
index 6b28c52c..1d5384eb 100644
--- a/app/wm/tracker/windows.cpp
+++ b/app/wm/tracker/trackerwindows.cpp
@@ -1,610 +1,610 @@
 /*
 *  Copyright 2019  Michail Vourlakos <mvourlakos@gmail.com>
 *
 *  This file is part of Latte-Dock
 *
 *  Latte-Dock is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU General Public License as
 *  published by the Free Software Foundation; either version 2 of
 *  the License, or (at your option) any later version.
 *
 *  Latte-Dock is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#include "windows.h"
+#include "trackerwindows.h"
 
 // local
 #include "lastactivewindow.h"
 #include "schemes.h"
 #include "trackedviewinfo.h"
 #include "../abstractwindowinterface.h"
 #include "../schemecolors.h"
 #include "../../lattecorona.h"
 #include "../../layouts/manager.h"
 #include "../../view/view.h"
 #include "../../view/positioner.h"
 #include "../../../liblatte2/types.h"
 
 namespace Latte {
 namespace WindowSystem {
 namespace Tracker {
 
 Windows::Windows(AbstractWindowInterface *parent)
     : QObject(parent)
 {
     m_wm = parent;
 
     init();
 }
 
 Windows::~Windows()
 {
     //! clear all the m_views tracking information
     for (QHash<Latte::View *, TrackedViewInfo *>::iterator i=m_views.begin(); i!=m_views.end(); ++i) {
         i.value()->deleteLater();
         m_views[i.key()] = nullptr;
     }
 
     m_views.clear();
 }
 
 void Windows::init()
 {
     connect(m_wm->corona(), &Plasma::Corona::availableScreenRectChanged, this, &Windows::updateAvailableScreenGeometries);
 
     connect(m_wm, &AbstractWindowInterface::windowChanged, this, [&](WindowId wid) {
         m_windows[wid] = m_wm->requestInfo(wid);
 
         for (const auto view : m_views.keys()) {
             WindowId lastWinId = m_views[view]->lastActiveWindow()->winId();
             if (lastWinId == wid) {
                 m_views[view]->lastActiveWindow()->setInformation(m_windows[lastWinId]);
             }
         }
 
         updateViewsHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::windowRemoved, this, [&](WindowId wid) {
         m_windows.remove(wid);
         updateViewsHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::windowAdded, this, [&](WindowId wid) {
         if (!m_windows.contains(wid)) {
             m_windows.insert(wid, m_wm->requestInfo(wid));
         }
         updateViewsHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::activeWindowChanged, this, [&](WindowId wid) {
         for (const auto view : m_views.keys()) {
             WindowId lastWinId = m_views[view]->lastActiveWindow()->winId();
             if (m_windows.contains(lastWinId)) {
                 m_windows[lastWinId] = m_wm->requestInfo(lastWinId);
                 m_views[view]->lastActiveWindow()->setInformation(m_windows[lastWinId]);
             }
         }
 
         m_windows[wid] = m_wm->requestInfo(wid);
         updateViewsHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::currentDesktopChanged, this, [&] {
         updateViewsHints();
     });
 
     connect(m_wm, &AbstractWindowInterface::currentActivityChanged, this, [&] {
         if (m_wm->corona()->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             //! this is needed in MultipleLayouts because there is a chance that multiple
             //! layouts are providing different available screen geometries in different Activities
             updateAvailableScreenGeometries();
         }
 
         updateViewsHints();
     });
 }
 
 void Windows::initViewHints(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return;
     }
 
     setActiveWindowMaximized(view, false);
     setActiveWindowTouching(view, false);
     setExistsWindowActive(view, false);
     setExistsWindowTouching(view, false);
     setExistsWindowMaximized(view, false);
     setActiveWindowScheme(view, nullptr);
     setTouchingWindowScheme(view, nullptr);
 }
 
 AbstractWindowInterface *Windows::wm()
 {
     return m_wm;
 }
 
 
 void Windows::addView(Latte::View *view)
 {
     if (m_views.contains(view)) {
         return;
     }
 
     m_views[view] = new TrackedViewInfo(this, view);
 
     updateAvailableScreenGeometries();
     updateHints(view);
 }
 
 void Windows::removeView(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return;
     }
 
     m_views[view]->deleteLater();
     m_views.remove(view);
 }
 
 //! Views Properties And Hints
 
 bool Windows::enabled(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->enabled();
 }
 
 void Windows::setEnabled(Latte::View *view, const bool enabled)
 {
     if (!m_views.contains(view) || m_views[view]->enabled() == enabled) {
         return;
     }
 
     m_views[view]->setEnabled(enabled);
 
     if (enabled) {
         updateHints(view);
     } else {
         initViewHints(view);
     }
 
     emit enabledChanged(view);
 }
 
 bool Windows::activeWindowMaximized(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->activeWindowMaximized();
 }
 
 void Windows::setActiveWindowMaximized(Latte::View *view, bool activeMaximized)
 {
     if (!m_views.contains(view) || m_views[view]->activeWindowMaximized() == activeMaximized) {
         return;
     }
 
     m_views[view]->setActiveWindowMaximized(activeMaximized);
     emit activeWindowMaximizedChanged(view);
 }
 
 bool Windows::activeWindowTouching(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->activeWindowTouching();
 }
 
 void Windows::setActiveWindowTouching(Latte::View *view, bool activeTouching)
 {
     if (!m_views.contains(view) || m_views[view]->activeWindowTouching() == activeTouching) {
         return;
     }
 
     m_views[view]->setActiveWindowTouching(activeTouching);
     emit activeWindowTouchingChanged(view);
 }
 
 bool Windows::existsWindowActive(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->existsWindowActive();
 }
 
 void Windows::setExistsWindowActive(Latte::View *view, bool windowActive)
 {
     if (!m_views.contains(view) || m_views[view]->existsWindowActive() == windowActive) {
         return;
     }
 
     m_views[view]->setExistsWindowActive(windowActive);
     emit existsWindowActiveChanged(view);
 }
 
 bool Windows::existsWindowMaximized(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->existsWindowMaximized();
 }
 
 void Windows::setExistsWindowMaximized(Latte::View *view, bool windowMaximized)
 {
     if (!m_views.contains(view) || m_views[view]->existsWindowMaximized() == windowMaximized) {
         return;
     }
 
     m_views[view]->setExistsWindowMaximized(windowMaximized);
     emit existsWindowMaximizedChanged(view);
 }
 
 bool Windows::existsWindowTouching(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return false;
     }
 
     return m_views[view]->existsWindowTouching();
 }
 
 void Windows::setExistsWindowTouching(Latte::View *view, bool windowTouching)
 {
     if (!m_views.contains(view) || m_views[view]->existsWindowTouching() == windowTouching) {
         return;
     }
 
     m_views[view]->setExistsWindowTouching(windowTouching);
     emit existsWindowTouchingChanged(view);
 }
 
 SchemeColors *Windows::activeWindowScheme(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return nullptr;
     }
 
     return m_views[view]->activeWindowScheme();
 }
 
 void Windows::setActiveWindowScheme(Latte::View *view, WindowSystem::SchemeColors *scheme)
 {
     if (!m_views.contains(view) || m_views[view]->activeWindowScheme() == scheme) {
         return;
     }
 
     m_views[view]->setActiveWindowScheme(scheme);
     emit activeWindowSchemeChanged(view);
 }
 
 SchemeColors *Windows::touchingWindowScheme(Latte::View *view) const
 {
     if (!m_views.contains(view)) {
         return nullptr;
     }
 
     return m_views[view]->touchingWindowScheme();
 }
 
 void Windows::setTouchingWindowScheme(Latte::View *view, WindowSystem::SchemeColors *scheme)
 {
     if (!m_views.contains(view) || m_views[view]->touchingWindowScheme() == scheme) {
         return;
     }
 
     m_views[view]->setTouchingWindowScheme(scheme);
     emit touchingWindowSchemeChanged(view);
 }
 
 LastActiveWindow *Windows::lastActiveWindow(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return nullptr;
     }
 
     return m_views[view]->lastActiveWindow();
 }
 
 bool Windows::isValidFor(WindowId wid) const
 {
     if (!m_windows.contains(wid)) {
         return false;
     }
 
     return m_windows[wid].isValid() && !m_windows[wid].isPlasmaDesktop();
 }
 
 QIcon Windows::iconFor(WindowId wid)
 {
     if (!m_windows.contains(wid)) {
         return QIcon();
     }
 
     if (m_windows[wid].icon().isNull()) {
         AppData data = m_wm->appDataFor(wid);
 
         QIcon icon = data.icon;
 
         if (icon.isNull()) {
             icon = m_wm->iconFor(wid);
         }
 
         m_windows[wid].setIcon(icon);
         return icon;
     }
 
     return m_windows[wid].icon();
 }
 
 QString Windows::appNameFor(WindowId wid)
 {
     if (!m_windows.contains(wid)) {
         return QString();
     }
 
     if (m_windows[wid].appName().isEmpty()) {
         AppData data = m_wm->appDataFor(wid);
 
         m_windows[wid].setAppName(data.name);
         return data.name;
     }
 
     return m_windows[wid].appName();
 }
 
 //! Windows Criteria Functions
 
 bool Windows::inCurrentDesktopActivity(const WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && m_wm->isOnCurrentDesktop(winfo.wid()) && m_wm->isOnCurrentActivity(winfo.wid()));
 }
 
 bool Windows::intersects(Latte::View *view, const WindowInfoWrap &winfo)
 {
     return (!winfo.isMinimized() && !winfo.isShaded() && winfo.geometry().intersects(view->absoluteGeometry()));
 }
 
 bool Windows::isActive(const WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && winfo.isActive() && !winfo.isPlasmaDesktop() && !winfo.isMinimized());
 }
 
 bool Windows::isActiveInViewScreen(Latte::View *view, const WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && winfo.isActive() && !winfo.isPlasmaDesktop() &&  !winfo.isMinimized()
             && m_views[view]->availableScreenGeometry().contains(winfo.geometry().center()));
 }
 
 bool Windows::isMaximizedInViewScreen(Latte::View *view, const WindowInfoWrap &winfo)
 {
     auto viewIntersectsMaxVert = [&]() noexcept -> bool {
         return ((winfo.isMaxVert()
                  || (view->screen() && view->screen()->availableSize().height() <= winfo.geometry().height()))
                 && intersects(view, winfo));
     };
 
     auto viewIntersectsMaxHoriz = [&]() noexcept -> bool {
         return ((winfo.isMaxHoriz()
                  || (view->screen() && view->screen()->availableSize().width() <= winfo.geometry().width()))
                 && intersects(view, winfo));
     };
 
     //! updated implementation to identify the screen that the maximized window is present
     //! in order to avoid: https://bugs.kde.org/show_bug.cgi?id=397700
     return (winfo.isValid() && !winfo.isPlasmaDesktop() && !winfo.isMinimized()
             && (winfo.isMaximized() || viewIntersectsMaxVert() || viewIntersectsMaxHoriz())
             && m_views[view]->availableScreenGeometry().contains(winfo.geometry().center()));
 }
 
 bool Windows::isTouchingView(Latte::View *view, const WindowSystem::WindowInfoWrap &winfo)
 {
     return (winfo.isValid() && !winfo.isPlasmaDesktop() &&  intersects(view, winfo));
 }
 
 bool Windows::isTouchingViewEdge(Latte::View *view, const WindowInfoWrap &winfo)
 {
     if (winfo.isValid() && !winfo.isPlasmaDesktop() &&  !winfo.isMinimized()) {
         bool touchingViewEdge{false};
 
         QRect screenGeometry = view->screenGeometry();
         QRect availableScreenGeometry = m_views[view]->availableScreenGeometry();
 
         bool inCurrentScreen{screenGeometry.contains(winfo.geometry().topLeft()) || screenGeometry.contains(winfo.geometry().bottomRight())};
 
         if (inCurrentScreen) {
             if (view->location() == Plasma::Types::TopEdge) {
                 touchingViewEdge = (winfo.geometry().y() == availableScreenGeometry.y());
             } else if (view->location() == Plasma::Types::BottomEdge) {
                 touchingViewEdge = (winfo.geometry().bottom() == availableScreenGeometry.bottom());
             } else if (view->location() == Plasma::Types::LeftEdge) {
                 touchingViewEdge = (winfo.geometry().x() == availableScreenGeometry.x());
             } else if (view->location() == Plasma::Types::RightEdge) {
                 touchingViewEdge = (winfo.geometry().right() == availableScreenGeometry.right());
             }
         }
 
         return touchingViewEdge;
     }
 
     return false;
 }
 
 void Windows::cleanupFaultyWindows()
 {
     for (const auto &key : m_windows.keys()) {
         auto winfo = m_windows[key];
 
         //! garbage windows removing
         if (winfo.geometry() == QRect(0, 0, 0, 0)) {
             //qDebug() << "Faulty Geometry ::: " << winfo.wid();
             m_windows.remove(key);
         }
     }
 }
 
 
 void Windows::updateAvailableScreenGeometries()
 {
     for (const auto view : m_views.keys()) {
         if (m_views[view]->enabled()) {
             int currentScrId = view->positioner()->currentScreenId();
             QRect tempAvailableScreenGeometry = m_wm->corona()->availableScreenRectWithCriteria(currentScrId, {Types::AlwaysVisible}, {});
 
             if (tempAvailableScreenGeometry != m_views[view]->availableScreenGeometry()) {
                 m_views[view]->setAvailableScreenGeometry(tempAvailableScreenGeometry);
 
                 updateHints(view);
             }
         }
     }
 }
 
 void Windows::setPlasmaDesktop(WindowId wid)
 {
     if (!m_windows.contains(wid)) {
         return;
     }
 
     if (!m_windows[wid].isPlasmaDesktop()) {
         m_windows[wid].setIsPlasmaDesktop(true);
         qDebug() << " plasmashell updated...";
         updateViewsHints();
     }
 }
 
 void Windows::updateViewsHints()
 {
     for (const auto view : m_views.keys()) {
         if (m_views[view]->enabled()) {
             updateHints(view);
         }
     }
 }
 
 void Windows::updateHints(Latte::View *view)
 {
     if (!m_views.contains(view)) {
         return;
     }
 
     bool foundActive{false};
     bool foundActiveInCurScreen{false};
     bool foundActiveTouchInCurScreen{false};
     bool foundTouchInCurScreen{false};
     bool foundMaximizedInCurScreen{false};
 
     //! the notification window is not sending a remove signal and creates windows of geometry (0x0 0,0),
     //! maybe a garbage collector here is a good idea!!!
     bool existsFaultyWindow{false};
 
     WindowId maxWinId;
     WindowId activeWinId;
     WindowId touchWinId;
     WindowId activeTouchWinId;
 
     for (const auto &winfo : m_windows) {
         if (winfo.isPlasmaDesktop() || !inCurrentDesktopActivity(winfo)) {
             continue;
         }
 
         if (isActive(winfo)) {
             foundActive = true;
         }
 
         if (isActiveInViewScreen(view, winfo)) {
             m_views[view]->lastActiveWindow()->setInformation(winfo);
             foundActiveInCurScreen = true;
             activeWinId = winfo.wid();
         }
 
         if (isTouchingViewEdge(view, winfo) || isTouchingView(view, winfo)) {
             if (winfo.isActive()) {
                 foundActiveTouchInCurScreen = true;
                 activeTouchWinId = winfo.wid();
 
                 if (isMaximizedInViewScreen(view, winfo)) {
                     //! active maximized windows have higher priority than the rest maximized windows
                     foundMaximizedInCurScreen = true;
                     maxWinId = winfo.wid();
                 }
             } else {
                 foundTouchInCurScreen = true;
                 touchWinId = winfo.wid();
             }
 
             if (!foundMaximizedInCurScreen && isMaximizedInViewScreen(view, winfo)) {
                 foundMaximizedInCurScreen = true;
                 maxWinId = winfo.wid();
             }
         }
 
         if (!existsFaultyWindow && winfo.geometry() == QRect(0, 0, 0, 0)) {
             existsFaultyWindow = true;
         }
 
         //qDebug() << "window geometry ::: " << winfo.geometry();
     }
 
     if (existsFaultyWindow) {
         cleanupFaultyWindows();
     }
 
     //! HACK: KWin Effects such as ShowDesktop have no way to be identified and as such
     //! create issues with identifying properly touching and maximized windows. BUT when
     //! they are enabled then NO ACTIVE window is found. This is a way to identify these
     //! effects trigerring and disable the touch flags.
     //! BUG: 404483
     //! Disabled because it has fault identifications, e.g. when a window is maximized and
     //! Latte or Plasma are showing their View settings
     //foundMaximizedInCurScreen = foundMaximizedInCurScreen && foundActive;
     //foundTouchInCurScreen = foundTouchInCurScreen && foundActive;
 
     //! assign flags
     setExistsWindowActive(view, foundActiveInCurScreen);
     setActiveWindowTouching(view, foundActiveTouchInCurScreen);
     setActiveWindowMaximized(view, (maxWinId.toInt()>0 && (maxWinId == activeTouchWinId)));
     setExistsWindowMaximized(view, foundMaximizedInCurScreen);
     setExistsWindowTouching(view, (foundTouchInCurScreen || foundActiveTouchInCurScreen));
 
     //! update color schemes for active and touching windows
     setActiveWindowScheme(view, (foundActiveInCurScreen ? m_wm->schemesTracker()->schemeForWindow(activeWinId) : nullptr));
 
     if (foundActiveTouchInCurScreen) {
         setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(activeTouchWinId));
     } else if (foundMaximizedInCurScreen) {
         setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(maxWinId));
     } else if (foundTouchInCurScreen) {
         setTouchingWindowScheme(view, m_wm->schemesTracker()->schemeForWindow(touchWinId));
     } else {
         setTouchingWindowScheme(view, nullptr);
     }
 
     //! Debug
     //qDebug() << "TRACKING | SCREEN: " << view->positioner()->currentScreenId() << " , EDGE:" << view->location() << " , ENABLED:" << enabled(view);
     //qDebug() << "TRACKING | activeWindowTouching: " << foundActiveTouchInCurScreen << " ,activeWindowMaximized: " << activeWindowMaximized(view);
     //qDebug() << "TRACKING | existsWindowActive: " << foundActiveInCurScreen << " , existsWindowMaximized:" << existsWindowMaximized(view)
     //         << " , existsWindowTouching:"<<existsWindowTouching(view);
 }
 
 }
 }
 }
diff --git a/app/wm/tracker/windows.h b/app/wm/tracker/trackerwindows.h
similarity index 100%
rename from app/wm/tracker/windows.h
rename to app/wm/tracker/trackerwindows.h
diff --git a/containment/package/contents/ui/DebugWindow.qml b/containment/package/contents/ui/DebugWindow.qml
index ff997014..dd55d0a0 100644
--- a/containment/package/contents/ui/DebugWindow.qml
+++ b/containment/package/contents/ui/DebugWindow.qml
@@ -1,763 +1,780 @@
 /*
 *  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.1
 import QtQuick.Window 2.2
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.extras 2.0 as PlasmaExtras
 
 import org.kde.latte 0.2 as Latte
 
 Window{
     width: mainGrid.width + 10
     height: Math.min(mainGrid.height+10, Screen.height - visibilityManager.thicknessNormalOriginal)
     visible: true
 
     property string space:" :   "
 
     PlasmaExtras.ScrollArea {
         id: scrollArea
 
         anchors.fill: parent
         verticalScrollBarPolicy: Qt.ScrollBarAsNeeded
         horizontalScrollBarPolicy: Qt.ScrollBarAlwaysOff
 
         flickableItem.flickableDirection: Flickable.VerticalFlick
 
         Grid{
             id:mainGrid
             columns: 2
 
             Text{
                 text: "Screen id"+space
             }
 
             Text{
                 text: latteView && latteView.positioner ? latteView.positioner.currentScreenName : "___"
             }
 
             Text{
                 text: "Screen Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.screenGeometry){
                         return latteView.screenGeometry.x+","+latteView.screenGeometry.y+ " "+latteView.screenGeometry.width+"x"+latteView.screenGeometry.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Window Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView) {
                         return  latteView.x + "," + latteView.y + " "+latteView.width+ "x"+latteView.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "On Primary"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.onPrimary)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Contents Width"+space
             }
 
             Text{
                 text: layoutsContainer.contentsWidth
             }
 
             Text{
                 text: "Contents Height"+space
             }
 
             Text{
                 text: layoutsContainer.contentsHeight
             }
 
             Text{
                 text: "Max Length (user)"+space
             }
 
             Text{
                 text: plasmoid.configuration.maxLength +"%"
             }
 
             Text{
                 text: "Max Length (pixels)"+space
             }
 
             Text{
                 text: root.maxLength
             }
 
             Text{
                 text: "Offset (pixels)"+space
             }
 
             Text{
                 text: root.offset
             }
 
             Text{
                 text: "Mask"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.effects && latteView.effects.mask) {
                         return latteView.effects.mask.x +", "+ latteView.effects.mask.y+"  "+latteView.effects.mask.width+"x"+latteView.effects.mask.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Absolute Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.absoluteGeometry) {
                         return latteView.absoluteGeometry.x + ", " + latteView.absoluteGeometry.y + "  " + latteView.absoluteGeometry.width + "x" + latteView.absoluteGeometry.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Local Geometry"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.localGeometry) {
                         return latteView.localGeometry.x + ", " + latteView.localGeometry.y + "  " + latteView.localGeometry.width + "x" + latteView.localGeometry.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "Draw Effects"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.effects && latteView.effects.drawEffects)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Effects Area"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.effects && latteView.effects.rect) {
                         return latteView.effects.rect.x + ", " + latteView.effects.rect.y + "  " +latteView.effects.rect.width + "x" + latteView.effects.rect.height;
                     } else {
                         return "_,_ _x_";
                     }
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Is Hidden (flag)"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.visibility && latteView.visibility.isHidden)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Actions Block Hiding "+space
             }
 
             Text{
                 text: root.actionsBlockHiding
             }
 
             Text{
                 text: "Contains Mouse (flag)"+space
             }
 
             Text{
                 text: {
                     if (latteView && latteView.visibility && latteView.visibility.containsMouse)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Edit Mode"+space
             }
 
             Text{
                 text: {
                     if (root.editMode)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Location"+space
             }
 
             Text{
                 text: {
                     switch(plasmoid.location){
                     case PlasmaCore.Types.LeftEdge:
                         return "Left Edge";
                         break;
                     case PlasmaCore.Types.RightEdge:
                         return "Right Edge";
                         break;
                     case PlasmaCore.Types.TopEdge:
                         return "Top Edge";
                         break;
                     case PlasmaCore.Types.BottomEdge:
                         return "Bottom Edge";
                         break;
                     }
 
                     return " <unknown> : " + plasmoid.location;
                 }
             }
 
             Text{
                 text: "Alignment"+space
             }
 
             Text{
                 text: {
                     switch(plasmoid.configuration.panelPosition){
                     case Latte.Types.Left:
                         return "Left";
                         break;
                     case Latte.Types.Right:
                         return "Right";
                         break;
                     case Latte.Types.Center:
                         return "Center";
                         break;
                     case Latte.Types.Top:
                         return "Top";
                         break;
                     case Latte.Types.Bottom:
                         return "Bottom";
                         break;
                     case Latte.Types.Justify:
                         return "Justify";
                         break;
                     }
 
                     return "<unknown> : " + plasmoid.configuration.panelPosition;
                 }
             }
 
             Text{
                 text: "Visibility"+space
             }
 
             Text{
                 text: {
                     if (!latteView || !latteView.visibility)
                         return "";
 
                     switch(latteView.visibility.mode){
                     case Latte.Types.AlwaysVisible:
                         return "Always Visible";
                         break;
                     case Latte.Types.AutoHide:
                         return "Auto Hide";
                         break;
                     case Latte.Types.DodgeActive:
                         return "Dodge Active";
                         break;
                     case Latte.Types.DodgeMaximized:
                         return "Dodge Maximized";
                         break;
                     case Latte.Types.DodgeAllWindows:
                         return "Dodge All Windows";
                         break;
                     case Latte.Types.None:
                         return "None";
                         break;
                     }
 
                     return "<unknown> : " + latteView.visibility.mode;
                 }
             }
 
             Text{
                 text: "Zoom Factor"+space
             }
 
             Text{
                 text: root.zoomFactor
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Icon Size (current)"+space
             }
 
             Text{
                 text: root.iconSize
             }
 
             Text{
                 text: "Icon Size (user)"+space
             }
 
             Text{
                 text: plasmoid.configuration.iconSize
             }
 
             Text{
                 text: "Icon Size (proportion)"+space
             }
 
             Text{
                 text: root.proportionIconSize
             }
 
             Text{
                 text: "Icon Size (auto decrease), Enabled"+space
             }
 
             Text{
                 text: root.autoDecreaseIconSize
             }
 
             Text{
                 text: "Icon Size (auto decrease)"+space
             }
 
             Text{
                 text: root.automaticIconSizeBasedSize
             }
 
             Text{
                 text: "Length Internal Margin (pixels)"+space
             }
 
             Text{
                 text: root.lengthIntMargin
             }
 
             Text{
                 text: "Length External Margin (pixels)"+space
             }
 
             Text{
                 text: root.lengthExtMargin
             }
 
             Text{
                 text: "Thickness Margin"+space
             }
 
             Text{
                 text: root.thickMargin
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Show Panel Background (user)"+space
             }
 
             Text{
                 text: {
                     if (plasmoid.configuration.useThemePanel)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Force Transparent Panel (auto)"+space
             }
 
             Text{
                 text: {
                     if (root.forceTransparentPanel)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Panel Background Length"+space
             }
 
             Text{
                 text: root.realPanelLength
             }
 
             Text{
                 text: "Panel Background Thickness(user)"+space
             }
 
             Text{
                 text: plasmoid.configuration.panelSize + "%"
             }
 
             Text{
                 text: "Panel Background Thickness(automatic)"+space
             }
 
             Text{
                 text: root.realPanelSize
             }
 
             Text{
                 text: "Panel Transparency"+space
             }
 
             Text{
                 text: root.panelTransparency + "%"
             }
 
             Text{
                 text: "Panel Shadows Active"+space
             }
 
             Text{
                 text: {
                     if (root.panelShadowsActive)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Panel Background Shadow"+space
             }
 
             Text{
                 text: root.panelShadow
             }
 
             Text{
                 text: "Panel Thickness Margin High"+space
             }
 
             Text{
                 text: root.panelThickMarginHigh
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Mask - Normal Thickness"+space
             }
 
             Text{
                 text: visibilityManager.thicknessNormal
             }
 
             Text{
                 text: "Thickness Uses Panel Size"+space
             }
 
             Text{
                 text: visibilityManager.panelIsBiggerFromIconSize
             }
 
             Text{
                 text: "Behave As Plasma Panel"+space
             }
 
             Text{
                 text: {
                     if (root.behaveAsPlasmaPanel)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "Draw Shadows (external)"+space
             }
 
             Text{
                 text: {
                     if (root.drawShadowsExternal)
                         return "Yes";
                     else
                         return "No";
                 }
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Applet Hovered"+space
             }
 
             Text{
                 text: layoutsContainer.hoveredIndex
             }
 
             Text{
                 text: "Task Hovered"+space
             }
 
             Text{
                 text: root.latteAppletHoveredIndex
             }
 
             Text{
                 text: "In Normal State"+space
             }
 
             Text{
                 text: visibilityManager.normalState
             }
 
             Text{
                 text: "Animations Both Axis"+space
             }
 
             Text{
                 text: root.animationsNeedBothAxis
             }
 
             Text{
                 text: "Animations Only Length"+space
             }
 
             Text{
                 text: root.animationsNeedLength
             }
 
             Text{
                 text: "Animations Need Thickness"+space
             }
 
             Text{
                 text: root.animationsNeedThickness
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Start Layout Shown Applets"+space
             }
 
             Text{
                 text: layoutsContainer.startLayout.shownApplets
             }
 
             Text{
                 text: "Start Layout Applets (with fill)"+space
             }
 
             Text{
                 text: layoutsContainer.startLayout.fillApplets
             }
 
             Text{
                 text: "Start Layout Size (no fill applets)"+space
             }
 
             Text{
                 text: layoutsContainer.startLayout.sizeWithNoFillApplets+" px."
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Main Layout Shown Applets"+space
             }
 
             Text{
                 text: layoutsContainer.mainLayout.shownApplets
             }
 
             Text{
                 text: "Main Layout Applets (with fill)"+space
             }
 
             Text{
                 text: layoutsContainer.mainLayout.fillApplets
             }
 
             Text{
                 text: "Main Layout Size (no fill applets)"+space
             }
 
             Text{
                 text: layoutsContainer.mainLayout.sizeWithNoFillApplets+" px."
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "End Layout Shown Applets"+space
             }
 
             Text{
                 text: layoutsContainer.endLayout.shownApplets
             }
 
             Text{
                 text: "End Layout Applets (with fill)"+space
             }
 
             Text{
                 text: layoutsContainer.endLayout.fillApplets
             }
 
             Text{
                 text: "End Layout Size (no fill applets)"+space
             }
 
             Text{
                 text: layoutsContainer.endLayout.sizeWithNoFillApplets+" px."
             }
 
             Text{
                 text: "   -----------   "
             }
 
             Text{
                 text: " -----------   "
             }
 
             Text{
                 text: "Applets need Windows Tracking"+space
             }
 
             Text{
                 text: root.appletsNeedWindowsTracking
             }
+
+            Text{
+                text: "Last Active Window (id)"+space
+            }
+
+            Text{
+                text: latteView && latteView.windowsTracker ? latteView.windowsTracker.lastActiveWindow.winId : ""
+            }
+
+            Text{
+                text: "Last Active Window (title)"+space
+            }
+
+            Text{
+                text: latteView && latteView.windowsTracker ? latteView.windowsTracker.lastActiveWindow.display : ""
+                elide: Text.ElideRight
+            }
         }
 
     }
 }