diff --git a/app/indicator/factory.cpp b/app/indicator/factory.cpp
index ee8eeaa5..e34615a9 100644
--- a/app/indicator/factory.cpp
+++ b/app/indicator/factory.cpp
@@ -1,308 +1,320 @@
 /*
 *  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 "factory.h"
 
 // local
 #include "../layouts/importer.h"
 
 // Qt
 #include <QDebug>
 #include <QDir>
 #include <QDirIterator>
 #include <QMessageBox>
 #include <QProcess>
 #include <QTemporaryDir>
 
 // KDE
 #include <KDirWatch>
 #include <KLocalizedString>
 #include <KNotification>
 #include <KPluginMetaData>
 #include <KArchive/KTar>
 #include <KArchive/KZip>
 #include <KArchive/KArchiveEntry>
 #include <KArchive/KArchiveDirectory>
 #include <KNewStuff3/KNS3/DownloadDialog>
 
 namespace Latte {
 namespace Indicator {
 
 Factory::Factory(QObject *parent)
     : QObject(parent)
 {
     m_parentWidget = new QWidget();
 
     m_watchedPaths = Latte::Layouts::Importer::standardPaths();
 
     for(int i=0; i<m_watchedPaths.count(); ++i) {
         m_watchedPaths[i] = m_watchedPaths[i] + "/latte/indicators";
     }
 
     reload();
 
     //! track paths for changes
     for(const auto &dir : m_watchedPaths) {
         KDirWatch::self()->addDir(dir);
     }
 
     connect(KDirWatch::self(), &KDirWatch::dirty, this, [ & ](const QString & path) {
         if (m_watchedPaths.contains(path)) {
             reload();
         }
     });
 
     qDebug() << m_plugins["org.kde.latte.default"].name();
 }
 
 Factory::~Factory()
 {
     m_parentWidget->deleteLater();
 }
 
 bool Factory::pluginExists(QString id) const
 {
     return m_plugins.contains(id);
 }
 
 int Factory::customPluginsCount()
 {
     return m_customPluginIds.count();
 }
 
 QStringList Factory::customPluginIds()
 {
     return m_customPluginIds;
 }
 
 QStringList Factory::customPluginNames()
 {
     return m_customPluginNames;
 }
 
 QStringList Factory::customLocalPluginIds()
 {
     return m_customLocalPluginIds;
 }
 
 KPluginMetaData Factory::metadata(QString pluginId)
 {
     if (m_plugins.contains(pluginId)) {
         return m_plugins[pluginId];
     }
 
     return KPluginMetaData();
 }
 
 void Factory::reload()
 {
     m_plugins.clear();
+    m_pluginUiPaths.clear();
     m_customPluginIds.clear();
     m_customPluginNames.clear();
     m_customLocalPluginIds.clear();
 
     for(const auto &path : m_watchedPaths) {
         QDir standard(path);
 
         if (standard.exists()) {
             QStringList pluginDirs = standard.entryList(QStringList(),QDir::AllDirs | QDir::NoSymLinks);
 
             for (const auto &pluginDir : pluginDirs) {
                 if (pluginDir != "." && pluginDir != "..") {
                     QString metadataFile = standard.absolutePath() + "/" + pluginDir + "/metadata.desktop";
                     KPluginMetaData metadata = KPluginMetaData::fromDesktopFile(metadataFile);
 
                     if (metadataAreValid(metadata)) {
                         QString uiFile = standard.absolutePath() + "/" + pluginDir + "/package/" + metadata.value("X-Latte-MainScript");
 
                         if (QFileInfo(uiFile).exists() && !m_plugins.contains(metadata.pluginId())) {
                             m_plugins[metadata.pluginId()] = metadata;
 
                             if ((metadata.pluginId() != "org.kde.latte.default")
                                     && (metadata.pluginId() != "org.kde.latte.plasma")) {
                                 m_customPluginIds << metadata.pluginId();
                                 m_customPluginNames << metadata.name();
                             }
 
                             if (standard.absolutePath().startsWith(QDir::homePath())) {
                                 m_customLocalPluginIds << metadata.pluginId();
                             }
 
-                            QString pluginPath = metadata.fileName().remove("metadata.desktop");
+                            m_pluginUiPaths[metadata.pluginId()] = QFileInfo(uiFile).absolutePath();
+
+                            QString pluginPath = metadata.fileName().remove("metadata.desktop");                                                        
                             qDebug() << " Indicator Package Loaded ::: " << metadata.name() << " [" << metadata.pluginId() << "]" << " - [" <<pluginPath<<"]";
+
                             /*qDebug() << " Indicator value ::: " << metadata.pluginId();
                             qDebug() << " Indicator value ::: " << metadata.fileName();
                             qDebug() << " Indicator value ::: " << metadata.value("X-Latte-MainScript");
                             qDebug() << " Indicator value ::: " << metadata.value("X-Latte-ConfigUi");
                             qDebug() << " Indicator value ::: " << metadata.value("X-Latte-ConfigXml");*/
                         }
                     }
                 }
             }
         }
     }
 
     emit customPluginsChanged();
 }
 
 bool Factory::metadataAreValid(KPluginMetaData &metadata)
 {
     return metadata.isValid()
             && metadata.category() == "Latte Indicator"
             && !metadata.value("X-Latte-MainScript").isEmpty();
 }
 
 bool Factory::metadataAreValid(QString &file)
 {
     if (QFileInfo(file).exists()) {
         KPluginMetaData metadata = KPluginMetaData::fromDesktopFile(file);
         return metadata.isValid();
     }
 
     return false;
 }
 
+QString Factory::uiPath(QString pluginName) const
+{
+    if (!m_pluginUiPaths.contains(pluginName)) {
+        return "";
+    }
+
+    return m_pluginUiPaths[pluginName];
+}
 
 Latte::Types::ImportExportState Factory::importIndicatorFile(QString compressedFile)
 {
     auto showNotificationError = []() {
         auto notification = new KNotification("import-fail", KNotification::CloseOnTimeout);
         notification->setText(i18n("Failed to import indicator"));
         notification->sendEvent();
     };
 
     auto showNotificationSucceed = [](QString name, bool updated) {
         auto notification = new KNotification("import-done", KNotification::CloseOnTimeout);
         notification->setText(updated ? i18nc("indicator_name, imported updated","%0 indicator updated successfully").arg(name) :
                                         i18nc("indicator_name, imported success","%0 indicator installed successfully").arg(name));
         notification->sendEvent();
     };
 
     KArchive *archive;
 
     KZip *zipArchive = new KZip(compressedFile);
     zipArchive->open(QIODevice::ReadOnly);
 
     //! if the file isnt a zip archive
     if (!zipArchive->isOpen()) {
         delete zipArchive;
 
         KTar *tarArchive = new KTar(compressedFile, QStringLiteral("application/x-tar"));
         tarArchive->open(QIODevice::ReadOnly);
 
         if (!tarArchive->isOpen()) {
             delete tarArchive;
             showNotificationError();
             return Latte::Types::Failed;
         } else {
             archive = tarArchive;
         }
     } else {
         archive = zipArchive;
     }
 
     QTemporaryDir archiveTempDir;
     archive->directory()->copyTo(archiveTempDir.path());
 
     //metadata file
     QString packagePath = archiveTempDir.path();
     QString metadataFile = archiveTempDir.path() + "/metadata.desktop";
 
     if (!QFileInfo(metadataFile).exists()){
         QDirIterator iter(archiveTempDir.path(), QDir::Dirs | QDir::NoDotAndDotDot);
 
         while(iter.hasNext() ) {
             QString currentPath = iter.next();
 
             QString tempMetadata = currentPath + "/metadata.desktop";
 
             if (QFileInfo(tempMetadata).exists()) {
                 metadataFile = tempMetadata;
                 packagePath = currentPath;
             }
         }
     }
 
     KPluginMetaData metadata = KPluginMetaData::fromDesktopFile(metadataFile);
 
     if (metadataAreValid(metadata)) {
         QStringList standardPaths = Latte::Layouts::Importer::standardPaths();
         QString installPath = standardPaths[0] + "/latte/indicators/" + metadata.pluginId();
 
         bool updated{QDir(installPath).exists()};
 
         if (QDir(installPath).exists()) {
             QDir(installPath).removeRecursively();
         }
 
         QProcess process;
         process.start(QString("mv " +packagePath + " " + installPath));
         process.waitForFinished();
         QString output(process.readAllStandardOutput());
 
         showNotificationSucceed(metadata.name(), updated);
         return Latte::Types::Installed;
     }
 
     showNotificationError();
     return Latte::Types::Failed;
 }
 
 void Factory::removeIndicator(QString id)
 {
     if (m_plugins.contains(id)) {
         QString pluginName = m_plugins[id].name();
 
         auto msg = new QMessageBox(m_parentWidget);
         msg->setIcon(QMessageBox::Warning);
         msg->setWindowTitle(i18n("Remove Indicator"));
         msg->setText(
                     i18n("Do you want to remove <b>%0</b> indicator from your system?").arg(pluginName));
         msg->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
         msg->setDefaultButton(QMessageBox::No);
 
         connect(msg, &QMessageBox::finished, this, [ &, msg, id, pluginName](int result) {
             auto showRemovedSucceed = [](QString name) {
                 auto notification = new KNotification("remove-done", KNotification::CloseOnTimeout);
                 notification->setText(i18nc("indicator_name, removed success","<b>%0</b> indicator removed successfully").arg(name));
                 notification->sendEvent();
             };
 
             if (result == QMessageBox::Yes) {
                 qDebug() << "Trying to remove indicator :: " << id;
                 QProcess process;
                 process.start(QString("kpackagetool5 -r " +id + " -t Latte/Indicator"));
                 process.waitForFinished();
                 showRemovedSucceed(pluginName);
             }
         });
 
         msg->open();
     }
 }
 
 void Factory::downloadIndicator()
 {
     KNS3::DownloadDialog dialog(QStringLiteral("latte-indicators.knsrc"), m_parentWidget);
 
     dialog.exec();
 }
 
 }
 }
diff --git a/app/indicator/factory.h b/app/indicator/factory.h
index fde2f86c..de18c379 100644
--- a/app/indicator/factory.h
+++ b/app/indicator/factory.h
@@ -1,84 +1,87 @@
 /*
 *  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/>.
 */
 
 #ifndef INDICATORFACTORY_H
 #define INDICATORFACTORY_H
 
 // local
 #include "../../liblatte2/types.h"
 
 // Qt
 #include <QHash>
 #include <QObject>
 #include <QWidget>
 
 class KPluginMetaData;
 
 namespace Latte {
 namespace Indicator {
 
 class Factory : public QObject
 {
     Q_OBJECT
 
 public:
     Factory(QObject *parent);
     ~Factory() override;
 
     int customPluginsCount();
     QStringList customPluginIds();
     QStringList customPluginNames();
     QStringList customLocalPluginIds();
 
     KPluginMetaData metadata(QString pluginId);
 
     void downloadIndicator();
     void removeIndicator(QString id);
 
     bool pluginExists(QString id) const;
 
+    QString uiPath(QString pluginName) const;
+
     //! metadata record
     static bool metadataAreValid(KPluginMetaData &metadata);
     //! metadata file
     static bool metadataAreValid(QString &file);
 
     //! imports an indicator compressed file
     static Latte::Types::ImportExportState importIndicatorFile(QString compressedFile);
 signals:
     void customPluginsChanged();
 
 private:
     void reload();
 
 private:
     QHash<QString, KPluginMetaData> m_plugins;
+    QHash<QString, QString> m_pluginUiPaths;
 
     QStringList m_customPluginIds;
     QStringList m_customPluginNames;
     QStringList m_customLocalPluginIds;
 
     QStringList m_watchedPaths;
 
     QWidget *m_parentWidget;
 };
 
 }
 }
 
 #endif
diff --git a/app/view/indicator/indicator.cpp b/app/view/indicator/indicator.cpp
index 1acc1885..adde8110 100644
--- a/app/view/indicator/indicator.cpp
+++ b/app/view/indicator/indicator.cpp
@@ -1,449 +1,454 @@
 /*
 *  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 "indicator.h"
 
 // local
 #include "indicatorinfo.h"
 #include "../view.h"
 #include "../../lattecorona.h"
 #include "../../indicator/factory.h"
 #include "../../../liblatte2/types.h"
 
 // Qt
 #include <QFileDialog>
 
 // KDE
 #include <KLocalizedString>
 #include <KPluginMetaData>
 #include <KDeclarative/ConfigPropertyMap>
 #include <KDeclarative/QmlObjectSharedEngine>
 
 namespace Latte {
 namespace ViewPart {
 
 Indicator::Indicator(Latte::View *parent)
     : QObject(parent),
       m_view(parent),
       m_info(new IndicatorPart::Info(this)),
       m_resources(new IndicatorPart::Resources(this))
 {
     m_corona = qobject_cast<Latte::Corona *>(m_view->corona());
     loadConfig();
 
     connect(this, &Indicator::enabledChanged, this, &Indicator::saveConfig);
     connect(this, &Indicator::enabledForAppletsChanged, this, &Indicator::saveConfig);
     connect(this, &Indicator::paddingChanged, this, &Indicator::saveConfig);
     connect(this, &Indicator::pluginChanged, this, &Indicator::saveConfig);
 
     connect(m_view, &Latte::View::latteTasksArePresentChanged, this, &Indicator::latteTasksArePresentChanged);
 
     connect(m_corona->indicatorFactory(), &Latte::Indicator::Factory::customPluginsChanged, [this]() {
         if (!m_corona->indicatorFactory()->pluginExists(m_type)) {
             setType("org.kde.latte.default");
         }
 
         emit customPluginsChanged();
     });
 
     connect(this, &Indicator::pluginChanged, [this]() {
         if ((m_type != "org.kde.latte.default") && m_type != "org.kde.latte.plasma") {
             setCustomType(m_type);
         }
     });
 
     load(m_type);
 
     loadPlasmaComponent();
 }
 
 Indicator::~Indicator()
 {
     if (m_component) {
         m_component->deleteLater();
     }
 
     if (m_configLoader) {
         m_configLoader->deleteLater();
     }
 
     if (m_configuration) {
         m_configuration->deleteLater();
     }
 
     if (m_info) {
         m_info->deleteLater();
     }
 }
 
 bool Indicator::enabled() const
 {
     return m_enabled;
 }
 
 void Indicator::setEnabled(bool enabled)
 {
     if (m_enabled == enabled) {
         return;
     }
 
     m_enabled = enabled;
     emit enabledChanged();
 }
 
 bool Indicator::enabledForApplets() const
 {
     return m_enabledForApplets;
 }
 
 void Indicator::setEnabledForApplets(bool enabled)
 {
     if (m_enabledForApplets == enabled) {
         return;
     }
 
     m_enabledForApplets = enabled;
     emit enabledForAppletsChanged();
 }
 
 bool Indicator::latteTasksArePresent()
 {
     return m_view->latteTasksArePresent();
 }
 
 bool Indicator::providesConfigUi() const
 {
     return m_providesConfigUi;
 }
 
 void Indicator::setProvidesConfigUi(bool provides)
 {
     if (m_providesConfigUi == provides) {
         return;
     }
 
     m_providesConfigUi = provides;
     emit providesConfigUiChanged();
 }
 
 float Indicator::padding() const
 {
     return m_padding;
 }
 
 void Indicator::setPadding(float padding)
 {
     if (m_padding == padding) {
         return;
     }
 
     m_padding = padding;
     emit paddingChanged();
 }
 
 bool Indicator::pluginIsReady()
 {
     return m_pluginIsReady;
 }
 
 void Indicator::setPluginIsReady(bool ready)
 {
     if (m_pluginIsReady == ready) {
         return;
     }
 
     m_pluginIsReady = ready;
     emit pluginIsReadyChanged();
 }
 
 QString Indicator::type() const
 {
     return m_type;
 }
 
 void Indicator::setType(QString type)
 {
     if (m_type == type) {
         return;
     }
 
     load(type);
 }
 
 QString Indicator::customType() const
 {
     return m_customType;
 }
 
 void Indicator::setCustomType(QString type)
 {
     if (m_customType == type) {
         return;
     }
 
     m_customType = type;
     emit customPluginChanged();
 }
 
 int Indicator::customPluginsCount() const
 {
     return m_corona->indicatorFactory()->customPluginsCount();
 }
 
+QString Indicator::uiPath() const
+{
+    return m_corona->indicatorFactory()->uiPath(m_type);
+}
+
 QStringList Indicator::customPluginIds() const
 {
     return m_corona->indicatorFactory()->customPluginIds();
 }
 
 QStringList Indicator::customPluginNames() const
 {
     return m_corona->indicatorFactory()->customPluginNames();
 }
 
 QStringList Indicator::customLocalPluginIds() const
 {
     return m_corona->indicatorFactory()->customLocalPluginIds();
 }
 
 IndicatorPart::Info *Indicator::info() const
 {
     return m_info;
 }
 
 IndicatorPart::Resources *Indicator::resources() const
 {
     return m_resources;
 }
 
 QQmlComponent *Indicator::component() const
 {
     return m_component;
 }
 
 QQmlComponent *Indicator::plasmaComponent() const
 {
     return m_plasmaComponent;
 }
 
 QObject *Indicator::configuration() const
 {
     return m_configuration;
 }
 
 void Indicator::load(QString type)
 {
     KPluginMetaData metadata = m_corona->indicatorFactory()->metadata(type);
 
     if (metadata.isValid()) {
         bool state{m_enabled};
         //! remove all previous indicators
         setPluginIsReady(false);
 
         m_metadata = metadata;
         m_type = type;
 
         QString path = m_metadata.fileName();
         m_pluginPath = path.remove("metadata.desktop");
 
         updateScheme();
         updateComponent();
 
         emit pluginChanged();
 
         //! create all indicators with the new type
         setPluginIsReady(true);
     } else if (type!="org.kde.latte.default") {
         qDebug() << " Indicator metadata are not valid : " << type;
         setType("org.kde.latte.default");
     }
 }
 
 void Indicator::updateComponent()
 {
     auto prevComponent = m_component;
 
     QString uiPath = m_metadata.value("X-Latte-MainScript");
 
     if (!uiPath.isEmpty()) {
         uiPath = m_pluginPath + "package/" + uiPath;
         m_component = new QQmlComponent(m_view->engine(), uiPath);
     }
 
     if (prevComponent) {
         prevComponent->deleteLater();
     }
 }
 
 void Indicator::loadPlasmaComponent()
 {
     auto prevComponent = m_plasmaComponent;
 
     KPluginMetaData metadata = m_corona->indicatorFactory()->metadata("org.kde.latte.plasma");
     QString uiPath = metadata.value("X-Latte-MainScript");
 
     if (!uiPath.isEmpty()) {
         QString path = metadata.fileName();
         path = path.remove("metadata.desktop");
 
         uiPath = path + "package/" + uiPath;
         m_plasmaComponent = new QQmlComponent(m_view->engine(), uiPath);
     }
 
     if (prevComponent) {
         prevComponent->deleteLater();
     }
 
     emit plasmaComponentChanged();
 }
 
 void Indicator::configUiFor(QString type, QQuickItem *parent)
 {
     if (m_lastCreatedConfigUi) {
         delete m_lastCreatedConfigUi;
         m_lastCreatedConfigUi = nullptr;
     }
     auto prevConfigUi = m_lastCreatedConfigUi;
 
     KPluginMetaData metadata;
 
     if (m_metadata.pluginId() == type) {
         metadata = m_metadata;
     } else {
         metadata = m_corona->indicatorFactory()->metadata(type);
     }
 
     if (metadata.isValid()) {
         QString uiPath = metadata.value("X-Latte-ConfigUi");
 
         if (!uiPath.isEmpty()) {
             m_lastCreatedConfigUi = new KDeclarative::QmlObjectSharedEngine(parent);
             m_lastCreatedConfigUi->setTranslationDomain(QLatin1String("latte_indicator_") + m_metadata.pluginId());
             m_lastCreatedConfigUi->setInitializationDelayed(true);
             uiPath = m_pluginPath + "package/" + uiPath;
             m_lastCreatedConfigUi->setSource(QUrl::fromLocalFile(uiPath));
             m_lastCreatedConfigUi->rootContext()->setContextProperty(QStringLiteral("dialog"), parent);
             m_lastCreatedConfigUi->rootContext()->setContextProperty(QStringLiteral("indicator"), this);
             m_lastCreatedConfigUi->completeInitialization();
 
             QQuickItem *qmlItem = qobject_cast<QQuickItem*>(m_lastCreatedConfigUi->rootObject());
             qmlItem->setParentItem(parent);
 
             setProvidesConfigUi(true);
         } else {
             setProvidesConfigUi(false);
         }
     }
 }
 
 void Indicator::unloadIndicators()
 {
     setPluginIsReady(false);
 }
 
 void Indicator::updateScheme()
 {
     auto prevConfigLoader = m_configLoader;
     auto prevConfiguration = m_configuration;
 
     QString xmlPath = m_metadata.value("X-Latte-ConfigXml");
 
     if (!xmlPath.isEmpty()) {
         QFile file(m_pluginPath + "package/" + xmlPath);
         m_configLoader = new KConfigLoader(m_view->containment()->config().group("Indicator").group(m_metadata.pluginId()), &file);
         m_configuration = new KDeclarative::ConfigPropertyMap(m_configLoader, this);
     } else {
         m_configLoader = nullptr;
         m_configuration = nullptr;
     }
 
     if (prevConfigLoader) {
         prevConfigLoader->deleteLater();
     }
 
     if (prevConfiguration) {
         prevConfiguration->deleteLater();
     }
 }
 
 void Indicator::addIndicator()
 {
     QFileDialog *fileDialog = new QFileDialog(nullptr
                                               , i18nc("add indicator", "Add Indicator")
                                               , QDir::homePath()
                                               , QStringLiteral("indicator.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog->setDefaultSuffix("indicator.latte");
 
     QStringList filters;
     filters << QString(i18nc("add indicator file", "Latte Indicator") + "(*.indicator.latte)");
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished, fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected, this, [&](const QString & file) {
         qDebug() << "Trying to import indicator file ::: " << file;
         m_corona->indicatorFactory()->importIndicatorFile(file);
     });
 
     fileDialog->open();
 }
 
 void Indicator::downloadIndicator()
 {
     //! call asynchronously in order to not crash when view settings window
     //! loses focus and it closes
     QTimer::singleShot(0, [this]() {
         m_corona->indicatorFactory()->downloadIndicator();
     });
 }
 
 void Indicator::removeIndicator(QString pluginId)
 {    //! call asynchronously in order to not crash when view settings window
     //! loses focus and it closes
     QTimer::singleShot(0, [this, pluginId]() {
         m_corona->indicatorFactory()->removeIndicator(pluginId);
     });
 }
 
 void Indicator::loadConfig()
 {
     auto config = m_view->containment()->config().group("Indicator");
     m_customType = config.readEntry("customType", QString());
     m_enabled = config.readEntry("enabled", true);
     m_enabledForApplets = config.readEntry("enabledForApplets", true);
     m_padding = config.readEntry("padding", (float)0.08);
     m_type = config.readEntry("type", "org.kde.latte.default");
 }
 
 void Indicator::saveConfig()
 {
     auto config = m_view->containment()->config().group("Indicator");
     config.writeEntry("customType", m_customType);
     config.writeEntry("enabled", m_enabled);
     config.writeEntry("enabledForApplets", m_enabledForApplets);
     config.writeEntry("padding", m_padding);
     config.writeEntry("type", m_type);
 
     config.sync();
 }
 
 }
 }
diff --git a/app/view/indicator/indicator.h b/app/view/indicator/indicator.h
index d3723ea3..64b9d3ff 100644
--- a/app/view/indicator/indicator.h
+++ b/app/view/indicator/indicator.h
@@ -1,193 +1,195 @@
 /*
 *  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/>.
 */
 
 #ifndef VIEWINDICATOR_H
 #define VIEWINDICATOR_H
 
 // local
 #include "indicatorinfo.h"
 #include "indicatorresources.h"
 
 // Qt
 #include <QObject>
 #include <QPointer>
 #include <QQmlComponent>
 #include <QQmlContext>
 #include <QQuickItem>
 
 // KDE
 #include <KConfigLoader>
 #include <KPluginMetaData>
 
 namespace KDeclarative
 {
 class ConfigPropertyMap;
 class QmlObjectSharedEngine;
 }
 
 namespace Latte {
 class Corona;
 class View;
 }
 
 namespace Latte {
 namespace ViewPart {
 
 class Indicator: public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool enabled READ enabled WRITE setEnabled NOTIFY enabledChanged)
     Q_PROPERTY(bool enabledForApplets READ enabledForApplets WRITE setEnabledForApplets NOTIFY enabledForAppletsChanged)
     Q_PROPERTY(bool latteTasksArePresent READ latteTasksArePresent NOTIFY latteTasksArePresentChanged)
     Q_PROPERTY(bool pluginIsReady READ pluginIsReady NOTIFY pluginIsReadyChanged)
     Q_PROPERTY(bool providesConfigUi READ providesConfigUi NOTIFY providesConfigUiChanged)
 
     Q_PROPERTY(float padding READ padding WRITE setPadding NOTIFY paddingChanged)
 
     Q_PROPERTY(QString type READ type WRITE setType NOTIFY pluginChanged)
     Q_PROPERTY(QString customType READ customType NOTIFY customPluginChanged)
 
     /* Custom plugins */
     Q_PROPERTY(int customPluginsCount READ customPluginsCount NOTIFY customPluginsChanged)
     Q_PROPERTY(QStringList customPluginIds READ customPluginIds NOTIFY customPluginsChanged)
     Q_PROPERTY(QStringList customPluginNames READ customPluginNames NOTIFY customPluginsChanged)
     Q_PROPERTY(QStringList customLocalPluginIds READ customLocalPluginIds NOTIFY customPluginsChanged)
 
     /**
      * Configuration object: each config key will be a writable property of this object. property bindings work.
      */
     Q_PROPERTY(QObject *configuration READ configuration NOTIFY pluginChanged)
 
     Q_PROPERTY(QQmlComponent *component READ component NOTIFY pluginChanged)
     Q_PROPERTY(QQmlComponent *plasmaComponent READ plasmaComponent NOTIFY plasmaComponentChanged)
 
     /**
       * Information provided from the indicator itself
       */
     Q_PROPERTY(Latte::ViewPart::IndicatorPart::Info *info READ info NOTIFY infoChanged)
 
     /**
       * Resources provided from the indicator itself
       */
     Q_PROPERTY(Latte::ViewPart::IndicatorPart::Resources *resources READ resources NOTIFY resourcesChanged)
 
 
 public:
     Indicator(Latte::View *parent);
     virtual ~Indicator();
 
     bool enabled() const;
     void setEnabled(bool enabled);
 
     bool enabledForApplets() const;
     void setEnabledForApplets(bool enabled);
 
     bool latteTasksArePresent();
     bool providesConfigUi() const;
 
     bool pluginIsReady();
 
     float padding() const;
     void setPadding(float padding);
 
     QString type() const;
     void setType(QString type);
 
+    QString uiPath() const;
+
     QString customType() const;
 
     int customPluginsCount() const;
     QStringList customPluginIds() const;
     QStringList customPluginNames() const;
     QStringList customLocalPluginIds() const;
 
     IndicatorPart::Info *info() const;
     IndicatorPart::Resources *resources() const;
 
     QObject *configuration() const;
     QQmlComponent *component() const;
     QQmlComponent *plasmaComponent() const;
 
     void load(QString type);
     void unloadIndicators();
 
 public slots:
     Q_INVOKABLE void configUiFor(QString type, QQuickItem *parent);
     Q_INVOKABLE void addIndicator();
     Q_INVOKABLE void downloadIndicator();
     Q_INVOKABLE void removeIndicator(QString pluginId);
 
 signals:
     void customPluginsChanged();
     void enabledChanged();
     void enabledForAppletsChanged();
     void customPluginChanged();
     void infoChanged();
     void latteTasksArePresentChanged();
     void paddingChanged();
     void plasmaComponentChanged();
     void pluginChanged();
     void pluginIsReadyChanged();
     void providesConfigUiChanged();
     void resourcesChanged();
 
 private:
     void loadConfig();
     void saveConfig();
 
     void setPluginIsReady(bool ready);
     void setProvidesConfigUi(bool provides);
 
     void setCustomType(QString type);
 
     void loadPlasmaComponent();
     void updateComponent();
     void updateScheme();
 
 private:
     bool m_enabled{true};
     bool m_enabledForApplets{true};
     bool m_pluginIsReady{false};
     bool m_providesConfigUi{true};
 
     float m_padding{0.08};
 
     QString m_pluginPath;
     QString m_type{"org.kde.latte.default"};
     QString m_customType;
 
     QPointer<QQmlComponent> m_component;
     QPointer<QQmlComponent> m_plasmaComponent;
     QPointer<QQmlComponent> m_configUi;
     QPointer<KConfigLoader> m_configLoader;
     QPointer<Latte::Corona> m_corona;
     QPointer<Latte::View> m_view;
 
     KPluginMetaData m_metadata;
 
     QPointer<IndicatorPart::Info> m_info;
     QPointer<IndicatorPart::Resources> m_resources;
 
     QPointer<KDeclarative::ConfigPropertyMap> m_configuration;
     QPointer<KDeclarative::QmlObjectSharedEngine> m_lastCreatedConfigUi;
 };
 
 }
 }
 
 #endif
diff --git a/app/view/indicator/indicatorresources.cpp b/app/view/indicator/indicatorresources.cpp
index 446464fd..d024bdb6 100644
--- a/app/view/indicator/indicatorresources.cpp
+++ b/app/view/indicator/indicatorresources.cpp
@@ -1,71 +1,82 @@
 /*
 *  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 "indicator.h"
 #include "indicatorresources.h"
 
 // Qt
 #include <QDebug>
+#include <QFileInfo>
 
 // Plasma
 #include <Plasma/Svg>
 
 namespace Latte {
 namespace ViewPart {
 namespace IndicatorPart {
 
-Resources::Resources(QObject *parent) :
-    QObject(parent)
+Resources::Resources(Indicator *parent) :
+    QObject(parent),
+    m_indicator(parent)
 {
 }
 
 Resources::~Resources()
 {
 }
 
 QList<QObject *> Resources::svgs() const
 {
     return m_svgs;
 }
 
 void Resources::setSvgImagePaths(QStringList paths)
 {
     if (m_svgImagePaths == paths) {
         return;
     }
 
     while (!m_svgs.isEmpty()) {
         auto svg = m_svgs[0];
         m_svgs.removeFirst();
         svg->deleteLater();
     }
 
-    for(const auto &path : paths) {
-        if (!path.isEmpty()) {
+    for(const auto &relPath : paths) {
+        if (!relPath.isEmpty()) {
             Plasma::Svg *svg = new Plasma::Svg(this);
-            svg->setImagePath(path);
-            m_svgs << svg;
+
+            bool isLocalFile = relPath.contains(".") && !relPath.startsWith("file:");
+
+            QString adjustedPath = isLocalFile ? m_indicator->uiPath() + "/" + relPath : relPath;
+
+            if ( !isLocalFile
+                 || (isLocalFile && QFileInfo(adjustedPath).exists()) ) {
+                svg->setImagePath(adjustedPath);
+                m_svgs << svg;
+            }
         }
     }
 
     emit svgsChanged();
 }
 
 }
 }
 }
diff --git a/app/view/indicator/indicatorresources.h b/app/view/indicator/indicatorresources.h
index e21d0ff1..ce31dc0f 100644
--- a/app/view/indicator/indicatorresources.h
+++ b/app/view/indicator/indicatorresources.h
@@ -1,61 +1,69 @@
 /*
 *  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/>.
 */
 
 #ifndef VIEWINDICATORRESOURCES_H
 #define VIEWINDICATORRESOURCES_H
 
 // Qt
 #include <QObject>
 
+namespace Latte {
+namespace ViewPart {
+class Indicator;
+}
+}
+
 namespace Latte {
 namespace ViewPart {
 namespace IndicatorPart {
 
 /**
  * Resources requested from indicator in order to reduce consumption
  **/
 
 class Resources: public QObject
 {
     Q_OBJECT
     Q_PROPERTY(QList<QObject *> svgs READ svgs NOTIFY svgsChanged)
 
 public:
-    Resources(QObject *parent);
+    Resources(Indicator *parent);
     virtual ~Resources();
 
     QList<QObject *> svgs() const;
 
 public slots:
     Q_INVOKABLE void setSvgImagePaths(QStringList paths);
 
 signals:
     void svgsChanged();
 
 private:
     QStringList m_svgImagePaths;
 
+    Indicator *m_indicator{nullptr};
+
     QList<QObject *> m_svgs;
 };
 
 }
 }
 }
 
 #endif