diff --git a/app/settings/settingsdialog.cpp b/app/settings/settingsdialog.cpp
index c1a1d092..6398e4ce 100644
--- a/app/settings/settingsdialog.cpp
+++ b/app/settings/settingsdialog.cpp
@@ -1,1968 +1,1975 @@
 /*
  * Copyright 2017  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 "settingsdialog.h"
 
 // local
 #include "universalsettings.h"
 #include "ui_settingsdialog.h"
 #include "../lattecorona.h"
 #include "../layout/genericlayout.h"
 #include "../layout/centrallayout.h"
 #include "../layout/sharedlayout.h"
 #include "../layouts/importer.h"
 #include "../layouts/manager.h"
 #include "../layouts/synchronizer.h"
 #include "../liblatte2/types.h"
 #include "../plasma/extended/theme.h"
 #include "delegates/activitiesdelegate.h"
 #include "delegates/checkboxdelegate.h"
 #include "delegates/colorcmbboxdelegate.h"
 #include "delegates/layoutnamedelegate.h"
 #include "delegates/shareddelegate.h"
 
 // Qt
 #include <QButtonGroup>
 #include <QColorDialog>
 #include <QDesktopServices>
 #include <QDir>
 #include <QFileDialog>
 #include <QHeaderView>
 #include <QMenuBar>
 #include <QMessageBox>
 #include <QProcess>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QTemporaryDir>
 
 // KDE
 #include <KActivities/Controller>
 #include <KArchive/KTar>
 #include <KArchive/KArchiveEntry>
 #include <KArchive/KArchiveDirectory>
 #include <KLocalizedString>
 #include <KNotification>
 #include <KWindowSystem>
 #include <KNewStuff3/KNS3/DownloadDialog>
 
 namespace Latte {
 
 const int IDCOLUMN = 0;
 const int HIDDENTEXTCOLUMN = 1;
 const int COLORCOLUMN = 2;
 const int NAMECOLUMN = 3;
 const int MENUCOLUMN = 4;
 const int BORDERSCOLUMN = 5;
 const int ACTIVITYCOLUMN = 6;
 const int SHAREDCOLUMN = 7;
 
 const int SCREENTRACKERDEFAULTVALUE = 2500;
 const int OUTLINEDEFAULTWIDTH = 1;
 
 const QChar CheckMark{0x2714};
 
 SettingsDialog::SettingsDialog(QWidget *parent, Latte::Corona *corona)
     : QDialog(parent),
       ui(new Ui::SettingsDialog),
       m_corona(corona)
 {
     ui->setupUi(this);
 
     setAttribute(Qt::WA_DeleteOnClose, true);
     setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
     resize(m_corona->universalSettings()->layoutsWindowSize());
 
     connect(ui->buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked
             , this, &SettingsDialog::apply);
     connect(ui->buttonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked
             , this, &SettingsDialog::restoreDefaults);
 
     m_model = new QStandardItemModel(m_corona->layoutsManager()->layouts().count(), 6, this);
 
     ui->layoutsView->setModel(m_model);
     ui->layoutsView->horizontalHeader()->setStretchLastSection(true);
     ui->layoutsView->verticalHeader()->setVisible(false);
 
     connect(m_corona->layoutsManager(), &Layouts::Manager::currentLayoutNameChanged, this, &SettingsDialog::layoutsChanged);
     connect(m_corona->layoutsManager(), &Layouts::Manager::centralLayoutsChanged, this, &SettingsDialog::layoutsChanged);
 
     QString iconsPath(m_corona->kPackage().path() + "../../plasmoids/org.kde.latte.containment/contents/icons/");
 
     //!find the available colors
     QDir layoutDir(iconsPath);
     QStringList filter;
     filter.append(QString("*print.jpg"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
     QStringList colors;
 
     for (auto &file : files) {
         int colorEnd = file.lastIndexOf("print.jpg");
         QString color = file.remove(colorEnd, 9);
         colors.append(color);
     }
 
     ui->layoutsView->setItemDelegateForColumn(NAMECOLUMN, new LayoutNameDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(COLORCOLUMN, new ColorCmbBoxDelegate(this, iconsPath, colors));
     ui->layoutsView->setItemDelegateForColumn(MENUCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(BORDERSCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(ACTIVITYCOLUMN, new ActivitiesDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(SHAREDCOLUMN, new SharedDelegate(this));
 
     m_inMemoryButtons = new QButtonGroup(this);
     m_inMemoryButtons->addButton(ui->singleToolBtn, Latte::Types::SingleLayout);
     m_inMemoryButtons->addButton(ui->multipleToolBtn, Latte::Types::MultipleLayouts);
     m_inMemoryButtons->setExclusive(true);
 
     if (KWindowSystem::isPlatformWayland()) {
         m_inMemoryButtons->button(Latte::Types::MultipleLayouts)->setEnabled(false);
     }
 
     m_mouseSensitivityButtons = new QButtonGroup(this);
     m_mouseSensitivityButtons->addButton(ui->lowSensitivityBtn, Latte::Types::LowSensitivity);
     m_mouseSensitivityButtons->addButton(ui->mediumSensitivityBtn, Latte::Types::MediumSensitivity);
     m_mouseSensitivityButtons->addButton(ui->highSensitivityBtn, Latte::Types::HighSensitivity);
     m_mouseSensitivityButtons->setExclusive(true);
 
     ui->screenTrackerSpinBox->setValue(m_corona->universalSettings()->screenTrackerInterval());
     ui->outlineSpinBox->setValue(m_corona->themeExtended()->outlineWidth());
 
     //! About Menu
     QMenuBar *menuBar = new QMenuBar(this);
     // QMenuBar *rightAlignedMenuBar = new QMenuBar(menuBar);
 
     layout()->setMenuBar(menuBar);
     //menuBar->setCornerWidget(rightAlignedMenuBar);
 
     QMenu *fileMenu = new QMenu(i18n("File"), menuBar);
     menuBar->addMenu(fileMenu);
 
     QMenu *helpMenu = new QMenu(i18n("Help"), menuBar);
     //rightAlignedMenuBar->addMenu(helpMenu);
     menuBar->addMenu(helpMenu);
 
     QAction *quitAction = fileMenu->addAction(i18n("Quit Latte"));
     quitAction->setIcon(QIcon::fromTheme("application-exit"));
     quitAction->setShortcut(QKeySequence(Qt::CTRL + Qt::Key_Q));
 
     QAction *aboutAction = helpMenu->addAction(i18n("About Latte"));
     aboutAction->setIcon(QIcon::fromTheme("latte-dock"));
 
     //! RTL support for labels in preferences
     if (qApp->layoutDirection() == Qt::RightToLeft) {
         ui->behaviorLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
         ui->mouseSensetivityLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
         ui->delayLbl->setAlignment(Qt::AlignRight | Qt::AlignTop);
     }
 
     loadSettings();
 
     //! SIGNALS
 
     connect(m_model, &QStandardItemModel::itemChanged, this, &SettingsDialog::itemChanged);
     connect(ui->layoutsView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, [&]() {
         updatePerLayoutButtonsState();
         updateApplyButtonsState();
     });
 
     connect(m_inMemoryButtons, static_cast<void(QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled),
             [ = ](int id, bool checked) {
         updateApplyButtonsState();
         updateSharedLayoutsStates();
         updateSharedLayoutsUiElements();
     });
 
     connect(m_mouseSensitivityButtons, static_cast<void(QButtonGroup::*)(int, bool)>(&QButtonGroup::buttonToggled),
             [ = ](int id, bool checked) {
         updateApplyButtonsState();
     });
 
     connect(ui->screenTrackerSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [ = ](int i) {
         updateApplyButtonsState();
     });
 
     connect(ui->outlineSpinBox, QOverload<int>::of(&QSpinBox::valueChanged), [ = ](int i) {
         updateApplyButtonsState();
     });
 
     connect(ui->autostartChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
+    connect(ui->badges3DStyleChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->metaPressChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->metaPressHoldChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->infoWindowChkBox, &QCheckBox::stateChanged, this, &SettingsDialog::updateApplyButtonsState);
     connect(ui->tabWidget, &QTabWidget::currentChanged, this, &SettingsDialog::updateApplyButtonsState);
 
     connect(ui->noBordersForMaximizedChkBox, &QCheckBox::stateChanged, this, [&]() {
         bool noBordersForMaximized = ui->noBordersForMaximizedChkBox->isChecked();
 
         if (noBordersForMaximized) {
             ui->layoutsView->setColumnHidden(BORDERSCOLUMN, false);
         } else {
             ui->layoutsView->setColumnHidden(BORDERSCOLUMN, true);
         }
 
         updateApplyButtonsState();
     });
 
     connect(aboutAction, &QAction::triggered, m_corona, &Latte::Corona::aboutApplication);
     connect(quitAction, &QAction::triggered, this, [&]() {
         close();
         m_corona->closeApplication();
     });
 
     //! update all layouts view when runningActivities changed. This way we update immediately
     //! the running Activities in Activities checkboxes which are shown as bold
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged,
             this, [&]() {
         ui->layoutsView->update();
     });
 
     blockDeleteOnActivityStopped();
 }
 
 SettingsDialog::~SettingsDialog()
 {
     qDebug() << Q_FUNC_INFO;
 
     qDeleteAll(m_layouts);
 
     if (m_model) {
         delete m_model;
     }
 
     if (m_corona && m_corona->universalSettings()) {
         m_corona->universalSettings()->setLayoutsWindowSize(size());
 
         QStringList columnWidths;       
         columnWidths << QString::number(ui->layoutsView->columnWidth(COLORCOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(NAMECOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(MENUCOLUMN));
         columnWidths << QString::number(ui->layoutsView->columnWidth(BORDERSCOLUMN));
 
         Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
 
         if (inMemoryOption == Latte::Types::MultipleLayouts) {
             columnWidths << QString::number(ui->layoutsView->columnWidth(ACTIVITYCOLUMN));
         } else {
             //! In Single Mode, keed recorded value for ACTIVITYCOLUMN
             QStringList currentWidths = m_corona->universalSettings()->layoutsColumnWidths();
             if (currentWidths.count()>=5) {
                 columnWidths << currentWidths[4];
             }
         }
 
         m_corona->universalSettings()->setLayoutsColumnWidths(columnWidths);
     }
 
     m_inMemoryButtons->deleteLater();
     m_mouseSensitivityButtons->deleteLater();
 
     for (const auto &tempDir : m_tempDirectories) {
         QDir tDir(tempDir);
 
         if (tDir.exists() && tempDir.startsWith("/tmp/")) {
             tDir.removeRecursively();
         }
     }
 }
 
 void SettingsDialog::blockDeleteOnActivityStopped()
 {
     connect(m_corona->activitiesConsumer(), &KActivities::Consumer::runningActivitiesChanged,
             this, [&]() {
         m_blockDeleteOnReject = true;
         m_activityClosedTimer.start();
     });
 
     m_activityClosedTimer.setSingleShot(true);
     m_activityClosedTimer.setInterval(500);
     connect(&m_activityClosedTimer, &QTimer::timeout, this, [&]() {
         m_blockDeleteOnReject = false;
     });
 }
 
 QStringList SettingsDialog::activities()
 {
     return m_corona->layoutsManager()->synchronizer()->activities();
 }
 
 QStringList SettingsDialog::availableActivities()
 {
     return m_availableActivities;
 }
 
 QStringList SettingsDialog::availableSharesFor(int row)
 {
     QStringList availables;
     QStringList regs;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QStringList shares = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
 
         if (i != row) {
             if (shares.isEmpty()) {
                 availables << id;
             } else {
                 regs << shares;
             }
         }
     }
 
     for (const auto r : regs) {
         availables.removeAll(r);
     }
 
     return availables;
 }
 
 void SettingsDialog::toggleCurrentPage()
 {
     if (ui->tabWidget->currentIndex() == 0) {
         ui->tabWidget->setCurrentIndex(1);
     } else {
         ui->tabWidget->setCurrentIndex(0);
     }
 }
 
 void SettingsDialog::on_newButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     //! find Default preset path
     for (const auto &preset : m_corona->layoutsManager()->presetsPaths()) {
         QString presetName = CentralLayout::layoutName(preset);
 
         if (presetName == "Default") {
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = uniqueLayoutName(i18n(prset_str));
 
             addLayoutForFile(preset, presetName, true, false);
             break;
         }
     }
 }
 
 void SettingsDialog::on_copyButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     //! Update original layout before copying if this layout is active
     if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         QString lName = (m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole)).toString();
 
         Layout::GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(lName);
         if (generic) {
             generic->syncToLayoutFile();
         }
     }
 
     QString tempDir = uniqueTempDirectory();
 
     QString id = m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
     QString color = m_model->data(m_model->index(row, COLORCOLUMN), Qt::BackgroundRole).toString();
     QString textColor = m_model->data(m_model->index(row, COLORCOLUMN), Qt::UserRole).toString();
     QString layoutName = uniqueLayoutName(m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString());
     bool menu = m_model->data(m_model->index(row, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
     bool disabledBorders = m_model->data(m_model->index(row, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
 
     QString copiedId = tempDir + "/" + layoutName + ".layout.latte";
     QFile(id).copy(copiedId);
 
     QFileInfo newFileInfo(copiedId);
 
     if (newFileInfo.exists() && !newFileInfo.isWritable()) {
         QFile(copiedId).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 
     CentralLayout *settings = new CentralLayout(this, copiedId);
     m_layouts[copiedId] = settings;
 
     insertLayoutInfoAtRow(row + 1, copiedId, color, textColor, layoutName, menu, disabledBorders, QStringList(), false);
 
     ui->layoutsView->selectRow(row + 1);
 }
 
 void SettingsDialog::on_downloadButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     KNS3::DownloadDialog dialog(QStringLiteral("latte-layouts.knsrc"), this);
     dialog.resize(m_corona->universalSettings()->downloadWindowSize());
     dialog.exec();
 
     bool layoutAdded{false};
 
     if (!dialog.changedEntries().isEmpty() || !dialog.installedEntries().isEmpty()) {
         for (const auto &entry : dialog.installedEntries()) {
             for (const auto &entryFile : entry.installedFiles()) {
                 Layouts::Importer::LatteFileVersion version = Layouts::Importer::fileVersion(entryFile);
 
                 if (version == Layouts::Importer::LayoutVersion2) {
                     layoutAdded = true;
                     addLayoutForFile(entryFile);
                     break;
                 }
             }
         }
     }
 
     m_corona->universalSettings()->setDownloadWindowSize(dialog.size());
 
     if (layoutAdded) {
         apply();
     }
 }
 
 void SettingsDialog::on_removeButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     QString layoutName = m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString();
 
     if (m_corona->layoutsManager()->synchronizer()->centralLayout(layoutName)) {
         return;
     }
 
     m_model->removeRow(row);
 
     updateApplyButtonsState();
 
     row = qMax(row - 1, 0);
 
     ui->layoutsView->selectRow(row);
 }
 
 void SettingsDialog::on_lockedButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     bool lockedModel = m_model->data(m_model->index(row, NAMECOLUMN), Qt::UserRole).toBool();
 
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(!lockedModel), Qt::UserRole);
 
     updatePerLayoutButtonsState();
     updateApplyButtonsState();
 }
 
 void SettingsDialog::on_sharedButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     if (isShared(row)) {
         m_model->setData(m_model->index(row, SHAREDCOLUMN), QStringList(), Qt::UserRole);
     } else {
         bool assigned{false};
         QStringList assignedList;
 
         QStringList availableShares = availableSharesFor(row);
 
         for (const auto &id : availableShares) {
             QString name = nameForId(id);
             if (m_corona->layoutsManager()->synchronizer()->layout(name)) {
                 assignedList << id;
                 m_model->setData(m_model->index(row, SHAREDCOLUMN), assignedList, Qt::UserRole);
                 assigned = true;
                 break;
             }
         }
 
         if (!assigned && availableShares.count()>0) {
             assignedList << availableShares[0];
             m_model->setData(m_model->index(row, SHAREDCOLUMN), assignedList, Qt::UserRole);
             assigned = true;
         }
     }
 
     updatePerLayoutButtonsState();
     updateApplyButtonsState();
 }
 
 void SettingsDialog::on_importButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
 
     QFileDialog *fileDialog = new QFileDialog(this, i18nc("import layout/configuration", "Import Layout/Configuration")
                                               , QDir::homePath()
                                               , QStringLiteral("layout.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptOpen);
     fileDialog->setDefaultSuffix("layout.latte");
 
     QStringList filters;
     filters << QString(i18nc("import latte layout", "Latte Dock Layout file v0.2") + "(*.layout.latte)")
             << QString(i18nc("import latte layouts/configuration", "Latte Dock Full Configuration file (v0.1, v0.2)") + "(*.latterc)");
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished
             , fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected
             , this, [&](const QString & file) {
         Layouts::Importer::LatteFileVersion version = Layouts::Importer::fileVersion(file);
         qDebug() << "VERSION :::: " << version;
 
         if (version == Layouts::Importer::LayoutVersion2) {
             addLayoutForFile(file);
         } else if (version == Layouts::Importer::ConfigVersion1) {
             auto msg = new QMessageBox(this);
             msg->setIcon(QMessageBox::Warning);
             msg->setWindowTitle(i18n("Import: Configuration file version v0.1"));
             msg->setText(
                         i18n("You are going to import an old version <b>v0.1</b> configuration file.<br><b>Be careful</b>, importing the entire configuration <b>will erase all</b> your current configuration!!!<br><br> <i>Alternative, you can <b>import safely</b> from this file<br><b>only the contained layouts...</b></i>"));
             msg->setStandardButtons(QMessageBox::Cancel);
 
             QPushButton *fullBtn = new QPushButton(msg);
             QPushButton *layoutsBtn = new QPushButton(msg);
             fullBtn->setText(i18nc("import full configuration", "Full Configuration"));
             fullBtn->setIcon(QIcon::fromTheme("settings"));
             layoutsBtn->setText(i18nc("import only the layouts", "Only Layouts"));
             layoutsBtn->setIcon(QIcon::fromTheme("user-identity"));
 
             msg->addButton(fullBtn, QMessageBox::AcceptRole);
             msg->addButton(layoutsBtn, QMessageBox::AcceptRole);
 
             msg->setDefaultButton(layoutsBtn);
 
             connect(msg, &QMessageBox::finished, msg, &QMessageBox::deleteLater);
 
             msg->open();
 
             connect(layoutsBtn, &QPushButton::clicked
                     , this, [ &, file](bool check) {
                 importLayoutsFromV1ConfigFile(file);
             });
 
             connect(fullBtn, &QPushButton::clicked
                     , this, [ &, file](bool check) {
                 //!NOTE: Restart latte for import the new configuration
                 QProcess::startDetached(qGuiApp->applicationFilePath() + " --import-full \"" + file + "\"");
                 qGuiApp->exit();
             });
         } else if (version == Layouts::Importer::ConfigVersion2) {
             auto msg = new QMessageBox(this);
             msg->setIcon(QMessageBox::Warning);
             msg->setWindowTitle(i18n("Import: Configuration file version v0.2"));
             msg->setText(
                         i18n("You are going to import a <b>v0.2</b> configuration file.<br><b>Be careful</b>, importing <b>will erase all</b> your current configuration!!!<br><br><i>Would you like to proceed?</i>"));
             msg->setStandardButtons(QMessageBox::Yes | QMessageBox::No);
             msg->setDefaultButton(QMessageBox::No);
 
             connect(msg, &QMessageBox::finished, this, [ &, msg, file](int result) {
                 if (result == QMessageBox::Yes) {
                     //!NOTE: Restart latte for import the new configuration
                     msg->deleteLater();
                     QProcess::startDetached(qGuiApp->applicationFilePath() + " --import-full \"" + file + "\"");
                     qGuiApp->exit();
                 }
             });
 
             msg->open();
         }
     });
 
     fileDialog->open();
 }
 
 bool SettingsDialog::importLayoutsFromV1ConfigFile(QString file)
 {
     KTar archive(file, QStringLiteral("application/x-tar"));
     archive.open(QIODevice::ReadOnly);
 
     //! if the file isnt a tar archive
     if (archive.isOpen()) {
         QDir tempDir{uniqueTempDirectory()};
 
         const auto archiveRootDir = archive.directory();
 
         for (const auto &name : archiveRootDir->entries()) {
             auto fileEntry = archiveRootDir->file(name);
             fileEntry->copyTo(tempDir.absolutePath());
         }
 
         QString name = Layouts::Importer::nameOfConfigFile(file);
 
         QString applets(tempDir.absolutePath() + "/" + "lattedock-appletsrc");
 
         if (QFile(applets).exists()) {
             if (m_corona->layoutsManager()->importer()->importOldLayout(applets, name, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + name + ".layout.latte", name, false);
             }
 
             QString alternativeName = name + "-" + i18nc("layout", "Alternative");
 
             if (m_corona->layoutsManager()->importer()->importOldLayout(applets, alternativeName, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + alternativeName + ".layout.latte", alternativeName, false);
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 void SettingsDialog::on_exportButton_clicked()
 {
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     QString layoutExported = m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
 
     //! Update ALL active original layouts before exporting,
     //! this is needed because the export method can export also the full configuration
     qDebug() << Q_FUNC_INFO;
 
     m_corona->layoutsManager()->synchronizer()->syncActiveLayoutsToOriginalFiles();
 
     QFileDialog *fileDialog = new QFileDialog(this, i18nc("export layout/configuration", "Export Layout/Configuration")
                                               , QDir::homePath(), QStringLiteral("layout.latte"));
 
     fileDialog->setFileMode(QFileDialog::AnyFile);
     fileDialog->setAcceptMode(QFileDialog::AcceptSave);
     fileDialog->setDefaultSuffix("layout.latte");
 
     QStringList filters;
     QString filter1(i18nc("export layout", "Latte Dock Layout file v0.2") + "(*.layout.latte)");
     QString filter2(i18nc("export full configuration", "Latte Dock Full Configuration file v0.2") + "(*.latterc)");
 
     filters << filter1
             << filter2;
 
     fileDialog->setNameFilters(filters);
 
     connect(fileDialog, &QFileDialog::finished
             , fileDialog, &QFileDialog::deleteLater);
 
     connect(fileDialog, &QFileDialog::fileSelected
             , this, [ &, layoutExported](const QString & file) {
         auto showNotificationError = []() {
             auto notification = new KNotification("export-fail", KNotification::CloseOnTimeout);
             notification->setText(i18nc("export layout", "Failed to export layout"));
             notification->sendEvent();
         };
 
         if (QFile::exists(file) && !QFile::remove(file)) {
             showNotificationError();
             return;
         }
 
         if (file.endsWith(".layout.latte")) {
             if (!QFile(layoutExported).copy(file)) {
                 showNotificationError();
                 return;
             }
 
             QFileInfo newFileInfo(file);
 
             if (newFileInfo.exists() && !newFileInfo.isWritable()) {
                 QFile(file).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
             }
 
             CentralLayout layoutS(this, file);
             layoutS.setActivities(QStringList());
             layoutS.clearLastUsedActivity();
 
             //NOTE: The pointer is automatically deleted when the event is closed
             auto notification = new KNotification("export-done", KNotification::CloseOnTimeout);
             notification->setActions({i18nc("export layout", "Open location")});
             notification->setText(i18nc("export layout", "Layout exported successfully"));
 
             connect(notification, &KNotification::action1Activated
                     , this, [file]() {
                 QDesktopServices::openUrl({QFileInfo(file).canonicalPath()});
             });
 
             notification->sendEvent();
         } else if (file.endsWith(".latterc")) {
             auto showNotificationError = []() {
                 auto notification = new KNotification("export-fail", KNotification::CloseOnTimeout);
                 notification->setText(i18nc("import/export config", "Failed to export configuration"));
                 notification->sendEvent();
             };
 
             if (m_corona->layoutsManager()->importer()->exportFullConfiguration(file)) {
 
                 auto notification = new KNotification("export-done", KNotification::CloseOnTimeout);
                 notification->setActions({i18nc("import/export config", "Open location")});
                 notification->setText(i18nc("import/export config", "Full Configuration exported successfully"));
 
                 connect(notification, &KNotification::action1Activated
                         , this, [file]() {
                     QDesktopServices::openUrl({QFileInfo(file).canonicalPath()});
                 });
 
                 notification->sendEvent();
             } else {
                 showNotificationError();
             }
         }
     });
 
 
     fileDialog->open();
 }
 
 void SettingsDialog::requestImagesDialog(int row)
 {
     QStringList mimeTypeFilters;
     mimeTypeFilters << "image/jpeg" // will show "JPEG image (*.jpeg *.jpg)
                     << "image/png";  // will show "PNG image (*.png)"
 
     QFileDialog dialog(this);
     dialog.setMimeTypeFilters(mimeTypeFilters);
 
     QString background = m_model->data(m_model->index(row, COLORCOLUMN), Qt::BackgroundRole).toString();
 
     if (background.startsWith("/") && QFileInfo(background).exists()) {
         dialog.setDirectory(QFileInfo(background).absolutePath());
         dialog.selectFile(background);
     }
 
     if (dialog.exec()) {
         QStringList files = dialog.selectedFiles();
 
         if (files.count() > 0) {
             m_model->setData(m_model->index(row, COLORCOLUMN), files[0], Qt::BackgroundRole);
         }
     }
 }
 
 void SettingsDialog::requestColorsDialog(int row)
 {
     QColorDialog dialog(this);
     QString textColor = m_model->data(m_model->index(row, COLORCOLUMN), Qt::UserRole).toString();
     dialog.setCurrentColor(QColor(textColor));
 
     if (dialog.exec()) {
         qDebug() << dialog.selectedColor().name();
         m_model->setData(m_model->index(row, COLORCOLUMN), dialog.selectedColor().name(), Qt::UserRole);
     }
 }
 
 
 void SettingsDialog::accept()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (saveAllChanges()) {
         deleteLater();
     }
 }
 
 void SettingsDialog::reject()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (!m_blockDeleteOnReject) {
         deleteLater();
     }
 }
 
 void SettingsDialog::apply()
 {
     qDebug() << Q_FUNC_INFO;
     saveAllChanges();
 
     o_settings = currentSettings();
     o_settingsLayouts = currentLayoutsSettings();
 
     updateApplyButtonsState();
     updatePerLayoutButtonsState();
 }
 
 void SettingsDialog::restoreDefaults()
 {
     qDebug() << Q_FUNC_INFO;
 
     if (ui->tabWidget->currentIndex() == 0) {
         //! Default layouts missing from layouts list
         for (const auto &preset : m_corona->layoutsManager()->presetsPaths()) {
             QString presetName = CentralLayout::layoutName(preset);
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = i18n(prset_str);
 
             if (!nameExistsInModel(presetName)) {
                 addLayoutForFile(preset, presetName);
             }
         }
     } else if (ui->tabWidget->currentIndex() == 1) {
         //! Defaults for general Latte settings
         ui->autostartChkBox->setChecked(true);
+        ui->badges3DStyleChkBox->setChecked(true);
         ui->infoWindowChkBox->setChecked(true);
         ui->metaPressChkBox->setChecked(false);
         ui->metaPressHoldChkBox->setChecked(true);
         ui->noBordersForMaximizedChkBox->setChecked(false);
         ui->highSensitivityBtn->setChecked(true);
         ui->screenTrackerSpinBox->setValue(SCREENTRACKERDEFAULTVALUE);
         ui->outlineSpinBox->setValue(OUTLINEDEFAULTWIDTH);
     }
 }
 
 void SettingsDialog::addLayoutForFile(QString file, QString layoutName, bool newTempDirectory, bool showNotification)
 {
     if (layoutName.isEmpty()) {
         layoutName = CentralLayout::layoutName(file);
     }
 
     QString copiedId;
 
     if (newTempDirectory) {
         QString tempDir = uniqueTempDirectory();
         copiedId = tempDir + "/" + layoutName + ".layout.latte";
         QFile(file).copy(copiedId);
     } else {
         copiedId = file;
     }
 
     QFileInfo newFileInfo(copiedId);
 
     if (newFileInfo.exists() && !newFileInfo.isWritable()) {
         QFile(copiedId).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
     }
 
     if (m_layouts.contains(copiedId)) {
         CentralLayout *oldSettings = m_layouts.take(copiedId);
         delete oldSettings;
     }
 
     CentralLayout *settings = new CentralLayout(this, copiedId);
     m_layouts[copiedId] = settings;
 
     QString id = copiedId;
     QString color = settings->color();
     QString textColor = settings->textColor();
     QString background = settings->background();
     bool menu = settings->showInMenu();
     bool disabledBorders = settings->disableBordersForMaximizedWindows();
     bool locked = !settings->isWritable();
 
     layoutName = uniqueLayoutName(layoutName);
 
     int row = ascendingRowFor(layoutName);
 
     if (background.isEmpty()) {
         insertLayoutInfoAtRow(row, copiedId, color, QString(), layoutName, menu, disabledBorders, QStringList(), locked);
     } else {
         insertLayoutInfoAtRow(row, copiedId, background, textColor, layoutName, menu, disabledBorders, QStringList(), locked);
     }
 
     ui->layoutsView->selectRow(row);
 
     if (showNotification) {
         //NOTE: The pointer is automatically deleted when the event is closed
         auto notification = new KNotification("import-done", KNotification::CloseOnTimeout);
         notification->setText(i18nc("import-done", "Layout: <b>%0</b> imported successfully<br>").arg(layoutName));
         notification->sendEvent();
     }
 }
 
 void SettingsDialog::loadSettings()
 {
     m_initLayoutPaths.clear();
     m_model->clear();
     m_sharesMap.clear();
 
     int i = 0;
     QStringList brokenLayouts;
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         m_corona->layoutsManager()->synchronizer()->syncActiveLayoutsToOriginalFiles();
     }
 
     for (const auto layout : m_corona->layoutsManager()->layouts()) {
         QString layoutPath = QDir::homePath() + "/.config/latte/" + layout + ".layout.latte";
         m_initLayoutPaths.append(layoutPath);
 
         CentralLayout *central = new CentralLayout(this, layoutPath);
         m_layouts[layoutPath] = central;
 
         QString background = central->background();
 
         //! add central layout properties
         if (background.isEmpty()) {
             insertLayoutInfoAtRow(i, layoutPath, central->color(), QString(), central->name(),
                                   central->showInMenu(), central->disableBordersForMaximizedWindows(),
                                   central->activities(), !central->isWritable());
         } else {
             insertLayoutInfoAtRow(i, layoutPath, background, central->textColor(), central->name(),
                                   central->showInMenu(), central->disableBordersForMaximizedWindows(),
                                   central->activities(), !central->isWritable());
         }
 
         //! create initial SHARES maps
         QString shared = central->sharedLayoutName();
         if (!shared.isEmpty()) {
             m_sharesMap[shared].append(layoutPath);
         }
 
         qDebug() << "counter:" << i << " total:" << m_model->rowCount();
 
         i++;
 
         if (central->name() == m_corona->layoutsManager()->currentLayoutName()) {
             ui->layoutsView->selectRow(i - 1);
         }
 
         Layout::GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(central->name());
 
         if ((generic && generic->layoutIsBroken()) || (!generic && central->layoutIsBroken())) {
             brokenLayouts.append(central->name());
         }
     }
 
     //! update SHARES map keys in order to use the #settingsid(s)
     QStringList forremoval;
 
     //! remove these records after updating
     for (QHash<const QString, QStringList>::iterator i=m_sharesMap.begin(); i!=m_sharesMap.end(); ++i) {
         forremoval << i.key();
     }
 
     //! update keys
     for (QHash<const QString, QStringList>::iterator i=m_sharesMap.begin(); i!=m_sharesMap.end(); ++i) {
         QString shareid = idForRow(rowForName(i.key()));
         m_sharesMap[shareid] = i.value();
     }
 
     //! remove deprecated keys
     for (const auto &key : forremoval) {
         m_sharesMap.remove(key);
     }
 
     qDebug() << "SHARES MAP ::: " << m_sharesMap;
 
     for (QHash<const QString, QStringList>::iterator i=m_sharesMap.begin(); i!=m_sharesMap.end(); ++i) {
         int sharedPos = rowForId(i.key());
 
         if (sharedPos >= 0) {
             m_model->setData(m_model->index(sharedPos, SHAREDCOLUMN), i.value(), Qt::UserRole);
         }
     }
 
     recalculateAvailableActivities();
 
     m_model->setHorizontalHeaderItem(IDCOLUMN, new QStandardItem(QString("#path")));
     m_model->setHorizontalHeaderItem(COLORCOLUMN, new QStandardItem(QIcon::fromTheme("games-config-background"),
                                                                     QString(i18nc("column for layout background", "Background"))));
     m_model->setHorizontalHeaderItem(NAMECOLUMN, new QStandardItem(QString(i18nc("column for layout name", "Name"))));
     m_model->setHorizontalHeaderItem(MENUCOLUMN, new QStandardItem(QString(i18nc("column for layout to show in menu", "In Menu"))));
     m_model->setHorizontalHeaderItem(BORDERSCOLUMN, new QStandardItem(QString(i18nc("column for layout to hide borders for maximized windows", "Borderless"))));
     m_model->setHorizontalHeaderItem(ACTIVITYCOLUMN, new QStandardItem(QIcon::fromTheme("preferences-activities"),
                                                                        QString(i18nc("column for layout to show which activities is assigned to", "Activities"))));
     m_model->setHorizontalHeaderItem(SHAREDCOLUMN, new QStandardItem(QIcon::fromTheme("document-share"),
                                                                      QString(i18nc("column for shared layout to show which layouts is assigned to", "Shared To"))));
 
     //! this line should be commented for debugging layouts window functionality
     ui->layoutsView->setColumnHidden(IDCOLUMN, true);
     ui->layoutsView->setColumnHidden(HIDDENTEXTCOLUMN, true);
 
     if (m_corona->universalSettings()->canDisableBorders()) {
         ui->layoutsView->setColumnHidden(BORDERSCOLUMN, false);
     } else {
         ui->layoutsView->setColumnHidden(BORDERSCOLUMN, true);
     }
 
     ui->layoutsView->resizeColumnsToContents();
 
     QStringList columnWidths = m_corona->universalSettings()->layoutsColumnWidths();
 
     if (!columnWidths.isEmpty()) {
         for (int i=0; i<qMin(columnWidths.count(),4); ++i) {
             ui->layoutsView->setColumnWidth(COLORCOLUMN+i, columnWidths[i].toInt());
         }
     }
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) {
         ui->singleToolBtn->setChecked(true);
     } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         ui->multipleToolBtn->setChecked(true);
     }
 
     updatePerLayoutButtonsState();
     updateSharedLayoutsStates();
 
     ui->autostartChkBox->setChecked(m_corona->universalSettings()->autostart());
+    ui->badges3DStyleChkBox->setChecked(m_corona->universalSettings()->badges3DStyle());
     ui->infoWindowChkBox->setChecked(m_corona->universalSettings()->showInfoWindow());
     ui->metaPressChkBox->setChecked(m_corona->universalSettings()->metaForwardedToLatte());
     ui->metaPressHoldChkBox->setChecked(m_corona->universalSettings()->metaPressAndHoldEnabled());
     ui->noBordersForMaximizedChkBox->setChecked(m_corona->universalSettings()->canDisableBorders());
 
     if (m_corona->universalSettings()->mouseSensitivity() == Types::LowSensitivity) {
         ui->lowSensitivityBtn->setChecked(true);
     } else if (m_corona->universalSettings()->mouseSensitivity() == Types::MediumSensitivity) {
         ui->mediumSensitivityBtn->setChecked(true);
     } else if (m_corona->universalSettings()->mouseSensitivity() == Types::HighSensitivity) {
         ui->highSensitivityBtn->setChecked(true);
     }
 
     o_settings = currentSettings();
     o_settingsLayouts = currentLayoutsSettings();
     updateApplyButtonsState();
     updateSharedLayoutsUiElements();
 
     //! there are broken layouts and the user must be informed!
     if (brokenLayouts.count() > 0) {
         auto msg = new QMessageBox(this);
         msg->setIcon(QMessageBox::Warning);
         msg->setWindowTitle(i18n("Layout Warning"));
         msg->setText(i18n("The layout(s) <b>%0</b> have <i>broken configuration</i>!!! Please <b>remove them</b> to improve the system stability...").arg(brokenLayouts.join(",")));
         msg->setStandardButtons(QMessageBox::Ok);
 
         msg->open();
     }
 }
 
 QList<int> SettingsDialog::currentSettings()
 {
     QList<int> settings;
     settings << m_inMemoryButtons->checkedId();
     settings << (int)ui->autostartChkBox->isChecked();
+    settings << (int)ui->badges3DStyleChkBox->isChecked();
     settings << (int)ui->infoWindowChkBox->isChecked();
     settings << (int)ui->metaPressChkBox->isChecked();
     settings << (int)ui->metaPressHoldChkBox->isChecked();
     settings << (int)ui->noBordersForMaximizedChkBox->isChecked();
     settings << m_mouseSensitivityButtons->checkedId();
     settings << ui->screenTrackerSpinBox->value();
     settings << ui->outlineSpinBox->value();
     settings << m_model->rowCount();
 
     return settings;
 }
 
 QStringList SettingsDialog::currentLayoutsSettings()
 {
     QStringList layoutSettings;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString color = m_model->data(m_model->index(i, COLORCOLUMN), Qt::BackgroundRole).toString();
         QString textColor = m_model->data(m_model->index(i, COLORCOLUMN), Qt::UserRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         bool borders = m_model->data(m_model->index(i, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         QStringList lActivities = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
         QStringList shares = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
 
         layoutSettings << id;
         layoutSettings << color;
         layoutSettings << textColor;
         layoutSettings << name;
         layoutSettings << QString::number((int)locked);
         layoutSettings << QString::number((int)menu);
         layoutSettings << QString::number((int)borders);
         layoutSettings << lActivities;
         layoutSettings << shares;
     }
 
     return layoutSettings;
 }
 
 
 void SettingsDialog::insertLayoutInfoAtRow(int row, QString path, QString color, QString textColor, QString name, bool menu,
                                            bool disabledBorders, QStringList activities, bool locked)
 {
     QStandardItem *pathItem = new QStandardItem(path);
 
     QStandardItem *hiddenTextItem = new QStandardItem();
 
     QStandardItem *colorItem = new QStandardItem();
     colorItem->setSelectable(false);
 
     QStandardItem *nameItem = new QStandardItem(name);
     nameItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *menuItem = new QStandardItem();
     menuItem->setEditable(false);
     menuItem->setSelectable(true);
     menuItem->setText(menu ? CheckMark : QString());
     menuItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *bordersItem = new QStandardItem();
     bordersItem->setEditable(false);
     bordersItem->setSelectable(true);
     bordersItem->setText(disabledBorders ? CheckMark : QString());
     bordersItem->setTextAlignment(Qt::AlignCenter);
 
     QStandardItem *activitiesItem = new QStandardItem(activities.join(","));
 
     QStandardItem *sharesItem = new QStandardItem();
 
     QList<QStandardItem *> items;
 
     items.append(pathItem);
     items.append(hiddenTextItem);
     items.append(colorItem);
     items.append(nameItem);
     items.append(menuItem);
     items.append(bordersItem);
     items.append(activitiesItem);
     items.append(sharesItem);
 
     if (row > m_model->rowCount() - 1) {
         m_model->appendRow(items);
         row = m_model->rowCount() - 1;
 
         qDebug() << "append row at:" << row << " rows:" << m_model->rowCount();
     } else {
         m_model->insertRow(row, items);
         qDebug() << "insert row at:" << row << " rows:" << m_model->rowCount();
     }
 
     m_model->setData(m_model->index(row, IDCOLUMN), path, Qt::DisplayRole);
     m_model->setData(m_model->index(row, COLORCOLUMN), color, Qt::BackgroundRole);
     m_model->setData(m_model->index(row, COLORCOLUMN), textColor, Qt::UserRole);
 
     QFont font;
 
     if (m_corona->layoutsManager()->synchronizer()->layout(name)) {
         font.setBold(true);
     } else {
         font.setBold(false);
     }
 
     if (path.startsWith("/tmp/")) {
         font.setItalic(true);
     } else {
         font.setItalic(false);
     }
 
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(name), Qt::DisplayRole);
     m_model->setData(m_model->index(row, NAMECOLUMN), font, Qt::FontRole);
     m_model->setData(m_model->index(row, NAMECOLUMN), QVariant(locked), Qt::UserRole);
 
     m_model->setData(m_model->index(row, ACTIVITYCOLUMN), activities, Qt::UserRole);
 }
 
 
 void SettingsDialog::on_switchButton_clicked()
 {
     if (ui->buttonBox->button(QDialogButtonBox::Apply)->isEnabled()) {
         //! thus there are changes in the settings
 
         QString lName;
         QStringList lActivities;
 
         if (m_inMemoryButtons->checkedId() == Latte::Types::MultipleLayouts) {
             lName = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole).toString();
             lActivities = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), ACTIVITYCOLUMN), Qt::UserRole).toStringList();
         }
 
         apply();
 
         if (!lName.isEmpty() && !lActivities.isEmpty()) {
             //! an activities-assigned layout is chosen and at the same time we are moving
             //! to multiple layouts state
             m_corona->layoutsManager()->switchToLayout(lName);
         }
     } else {
         QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
 
         if (value.isValid()) {
             m_corona->layoutsManager()->switchToLayout(value.toString());
         } else {
             qDebug() << "not valid layout";
         }
     }
 
     updatePerLayoutButtonsState();
 }
 
 void SettingsDialog::on_pauseButton_clicked()
 {
     ui->pauseButton->setEnabled(false);
 
     QString id = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), IDCOLUMN), Qt::DisplayRole).toString();
     CentralLayout *layout = m_layouts[id];
 
     if (layout) {
         m_corona->layoutsManager()->synchronizer()->pauseLayout(layout->name());
     }
 }
 
 void SettingsDialog::layoutsChanged()
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QModelIndex nameIndex = m_model->index(i, NAMECOLUMN);
         QVariant value = m_model->data(nameIndex);
 
         if (value.isValid()) {
             QString name = value.toString();
             QFont font;
 
             if (m_corona->layoutsManager()->currentLayoutName() == name) {
                 font.setBold(true);
                 // ui->layoutsView->selectRow(i);
             } else {
                 Layout::GenericLayout *layout = m_corona->layoutsManager()->synchronizer()->layout(name);
 
                 if (layout && (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts)) {
                     font.setBold(true);
                 } else {
                     font.setBold(false);
                 }
             }
 
             m_model->setData(nameIndex, font, Qt::FontRole);
         }
     }
 }
 
 void SettingsDialog::itemChanged(QStandardItem *item)
 {
     updatePerLayoutButtonsState();
 
     if (item->column() == ACTIVITYCOLUMN) {
         //! recalculate the available activities
         recalculateAvailableActivities();
     } else if (item->column() == NAMECOLUMN) {
         int currentRow = ui->layoutsView->currentIndex().row();
 
         QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
         QFont font = qvariant_cast<QFont>(m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::FontRole));
 
         if (m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name())) {
             font.setBold(true);
         } else {
             font.setBold(false);
         }
 
         if (m_layouts[id]->name() != name) {
             font.setItalic(true);
         } else {
             font.setItalic(false);
         }
 
         m_model->setData(m_model->index(currentRow, NAMECOLUMN), font, Qt::FontRole);
 
     } else if (item->column() == SHAREDCOLUMN) {
         updateSharedLayoutsStates();
     }
 
     updateApplyButtonsState();
 }
 
 void SettingsDialog::updateApplyButtonsState()
 {
     bool changed{false};
 
     //! Ok, Apply Buttons
     if ((o_settings != currentSettings())
             || (o_settingsLayouts != currentLayoutsSettings())) {
         changed = true;
     }
 
     if (changed) {
         ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
         ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
     } else {
         //ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
         ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
     }
 
     //! RestoreDefaults Button
     if (ui->tabWidget->currentIndex() == 0) {
         //! Check Default layouts missing from layouts list
 
         bool layoutMissing{false};
 
         for (const auto &preset : m_corona->layoutsManager()->presetsPaths()) {
             QString presetName = CentralLayout::layoutName(preset);
             QByteArray presetNameChars = presetName.toUtf8();
             const char *prset_str = presetNameChars.data();
             presetName = i18n(prset_str);
 
             if (!nameExistsInModel(presetName)) {
                 layoutMissing = true;
                 break;
             }
         }
 
         if (layoutMissing) {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(true);
         } else {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
         }
     } else if (ui->tabWidget->currentIndex() == 1) {
         //! Defaults for general Latte settings
 
         if (!ui->autostartChkBox->isChecked()
+                || ui->badges3DStyleChkBox->isChecked()
                 || ui->metaPressChkBox->isChecked()
                 || !ui->metaPressHoldChkBox->isChecked()
                 || !ui->infoWindowChkBox->isChecked()
                 || ui->noBordersForMaximizedChkBox->isChecked()
                 || !ui->highSensitivityBtn->isChecked()
                 || ui->screenTrackerSpinBox->value() != SCREENTRACKERDEFAULTVALUE
                 || ui->outlineSpinBox->value() != OUTLINEDEFAULTWIDTH ) {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(true);
         } else {
             ui->buttonBox->button(QDialogButtonBox::RestoreDefaults)->setEnabled(false);
         }
     }
 }
 
 void SettingsDialog::updatePerLayoutButtonsState()
 {
     int currentRow = ui->layoutsView->currentIndex().row();
 
     QString id = m_model->data(m_model->index(currentRow, IDCOLUMN), Qt::DisplayRole).toString();
     QString nameInModel = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::DisplayRole).toString();
     QString originalName = m_layouts.contains(id) ? m_layouts[id]->name() : "";
     bool lockedInModel = m_model->data(m_model->index(currentRow, NAMECOLUMN), Qt::UserRole).toBool();
     bool sharedInModel = !m_model->data(m_model->index(currentRow, SHAREDCOLUMN), Qt::UserRole).toStringList().isEmpty();
 
     //! Switch Button
     if (id.startsWith("/tmp/") || originalName != nameInModel) {
         ui->switchButton->setEnabled(false);
     } else {
         ui->switchButton->setEnabled(true);
     }
 
     //! Pause Button
     if (m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) {
         ui->pauseButton->setVisible(false);
     } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         ui->pauseButton->setVisible(true);
 
         QStringList lActivities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         Latte::CentralLayout *layout = m_layouts[id];
 
         if (!lActivities.isEmpty() && layout && m_corona->layoutsManager()->synchronizer()->centralLayout(layout->name())) {
             ui->pauseButton->setEnabled(true);
         } else {
             ui->pauseButton->setEnabled(false);
         }
     }
 
     //! Remove Layout Button
     if (originalName != nameInModel
             || (originalName == m_corona->layoutsManager()->currentLayoutName())
             || (m_corona->layoutsManager()->synchronizer()->centralLayout(originalName))
             || lockedInModel) {
         ui->removeButton->setEnabled(false);
     } else {
         ui->removeButton->setEnabled(true);
     }
 
     //! Layout Locked Button
     if (lockedInModel) {
         ui->lockedButton->setChecked(true);
     } else {
         ui->lockedButton->setChecked(false);
     }
 
     //! Layout Shared Button
     if (sharedInModel) {
         ui->sharedButton->setChecked(true);
     } else {
         ui->sharedButton->setChecked(false);
     }
 }
 
 void SettingsDialog::updateSharedLayoutsStates()
 {
     bool inMultiple{inMultipleLayoutsLook()};
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QStringList shares = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
 
         if (shares.isEmpty() || !inMultiple) {
             QStandardItem *item = m_model->item(i, MENUCOLUMN);
             item->setEnabled(true);
             item = m_model->item(i, BORDERSCOLUMN);
             item->setEnabled(true);
             item = m_model->item(i, ACTIVITYCOLUMN);
             item->setEnabled(true);
         } else {
             QStandardItem *item = m_model->item(i, MENUCOLUMN);
             item->setEnabled(false);
             item = m_model->item(i, BORDERSCOLUMN);
             item->setEnabled(false);
             item = m_model->item(i, ACTIVITYCOLUMN);
             item->setEnabled(false);
         }
 
         //! refresh LayoutName
         QStandardItem *nameItem = m_model->item(i, NAMECOLUMN);
         nameItem->setEnabled(false);
         nameItem->setEnabled(true);
     }  
 }
 
 void SettingsDialog::updateSharedLayoutsUiElements()
 {
     //! UI Elements that need to be enabled/disabled
 
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
     if (inMemoryOption == Latte::Types::MultipleLayouts) {
         ui->layoutsView->setColumnHidden(SHAREDCOLUMN, false);
         ui->sharedButton->setVisible(true);
 
         //! column widths
         QStringList cWidths = m_corona->universalSettings()->layoutsColumnWidths();
 
         if (cWidths.count()>=5) {
             ui->layoutsView->setColumnWidth(ACTIVITYCOLUMN, cWidths[4].toInt());
         }
     } else {
         ui->layoutsView->setColumnHidden(SHAREDCOLUMN, true);
         ui->sharedButton->setVisible(false);
     }
 }
 
 void SettingsDialog::recalculateAvailableActivities()
 {
     QStringList tempActivities = m_corona->layoutsManager()->synchronizer()->activities();
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QStringList assigned = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         for (const auto &activity : assigned) {
             if (tempActivities.contains(activity)) {
                 tempActivities.removeAll(activity);
             }
         }
     }
 
     m_availableActivities = tempActivities;
 }
 
 bool SettingsDialog::dataAreAccepted()
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString layout1 = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         for (int j = i + 1; j < m_model->rowCount(); ++j) {
             QString temp = m_model->data(m_model->index(j, NAMECOLUMN), Qt::DisplayRole).toString();
 
             //!same layout name exists again
             if (layout1 == temp) {
                 auto msg = new QMessageBox(this);
                 msg->setIcon(QMessageBox::Warning);
                 msg->setWindowTitle(i18n("Layout Warning"));
                 msg->setText(i18n("There are layouts with the same name, that is not permitted!!! Please update these names to re-apply the changes..."));
                 msg->setStandardButtons(QMessageBox::Ok);
 
                 connect(msg, &QMessageBox::finished, this, [ &, i, j](int result) {
                     QItemSelectionModel::SelectionFlags flags = QItemSelectionModel::ClearAndSelect;
                     QModelIndex indexBase = m_model->index(i, NAMECOLUMN);
                     ui->layoutsView->selectionModel()->select(indexBase, flags);
 
                     QModelIndex indexOccurence = m_model->index(j, NAMECOLUMN);
                     ui->layoutsView->edit(indexOccurence);
                 });
 
 
                 msg->open();
 
                 return false;
             }
         }
     }
 
     return true;
 }
 
 bool SettingsDialog::saveAllChanges()
 {
     if (!dataAreAccepted()) {
         return false;
     }
 
     //! Update universal settings
     Latte::Types::MouseSensitivity sensitivity = static_cast<Latte::Types::MouseSensitivity>(m_mouseSensitivityButtons->checkedId());
     bool autostart = ui->autostartChkBox->isChecked();
+    bool badges3DStyle = ui->badges3DStyleChkBox->isChecked();
     bool forwardMetaPress = ui->metaPressChkBox->isChecked();
     bool metaPressAndHold = ui->metaPressHoldChkBox->isChecked();
     bool showInfoWindow = ui->infoWindowChkBox->isChecked();
     bool noBordersForMaximized = ui->noBordersForMaximizedChkBox->isChecked();
 
     m_corona->universalSettings()->setMouseSensitivity(sensitivity);
     m_corona->universalSettings()->setAutostart(autostart);
+    m_corona->universalSettings()->setBadges3DStyle(badges3DStyle);
     m_corona->universalSettings()->forwardMetaToLatte(forwardMetaPress);
     m_corona->universalSettings()->setMetaPressAndHoldEnabled(metaPressAndHold);
     m_corona->universalSettings()->setShowInfoWindow(showInfoWindow);
     m_corona->universalSettings()->setCanDisableBorders(noBordersForMaximized);
     m_corona->universalSettings()->setScreenTrackerInterval(ui->screenTrackerSpinBox->value());
 
     m_corona->themeExtended()->setOutlineWidth(ui->outlineSpinBox->value());
 
     //! Update Layouts
     QStringList knownActivities = activities();
 
     QTemporaryDir layoutTempDir;
 
     qDebug() << "Temporary Directory ::: " << layoutTempDir.path();
 
     QStringList fromRenamePaths;
     QStringList toRenamePaths;
     QStringList toRenameNames;
 
     QString switchToLayout;
 
     QHash<QString, Layout::GenericLayout *> activeLayoutsToRename;
 
     //! remove layouts that have been removed from the user
     for (const auto &initLayout : m_initLayoutPaths) {
         if (!idExistsInModel(initLayout)) {
             QFile(initLayout).remove();
 
             if (m_layouts.contains(initLayout)) {
                 CentralLayout *removedLayout = m_layouts.take(initLayout);
                 delete removedLayout;
             }
         }
     }
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString color = m_model->data(m_model->index(i, COLORCOLUMN), Qt::BackgroundRole).toString();
         QString textColor = m_model->data(m_model->index(i, COLORCOLUMN), Qt::UserRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         bool disabledBorders = m_model->data(m_model->index(i, BORDERSCOLUMN), Qt::DisplayRole).toString() == CheckMark;
         QStringList lActivities = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         QStringList cleanedActivities;
 
         //!update only activities that are valid
         for (const auto &activity : lActivities) {
             if (knownActivities.contains(activity)) {
                 cleanedActivities.append(activity);
             }
         }
 
         //qDebug() << i << ". " << id << " - " << color << " - " << name << " - " << menu << " - " << lActivities;
         //! update the generic parts of the layouts
         Layout::GenericLayout *genericActive= m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name());
         Layout::GenericLayout *generic = genericActive ? genericActive : m_layouts[id];
 
         //! unlock read-only layout
         if (!generic->isWritable()) {
             generic->unlock();
         }
 
         if (color.startsWith("/")) {
             //it is image file in such case
             if (color != generic->background()) {
                 generic->setBackground(color);
             }
 
             if (generic->textColor() != textColor) {
                 generic->setTextColor(textColor);
             }
         } else {
             if (color != generic->color()) {
                 generic->setColor(color);
                 generic->setBackground(QString());
                 generic->setTextColor(QString());
             }
         }
 
         //! update only the Central-specific layout parts
         CentralLayout *centralActive= m_corona->layoutsManager()->synchronizer()->centralLayout(m_layouts[id]->name());
         CentralLayout *central = centralActive ? centralActive : m_layouts[id];
 
         if (central->showInMenu() != menu) {
             central->setShowInMenu(menu);
         }
 
         if (central->disableBordersForMaximizedWindows() != disabledBorders) {
             central->setDisableBordersForMaximizedWindows(disabledBorders);
         }
 
         if (central->activities() != cleanedActivities) {
             central->setActivities(cleanedActivities);
         }
 
         //! If the layout name changed OR the layout path is a temporary one
         if (generic->name() != name || (id.startsWith("/tmp/"))) {
             //! If the layout is Active in MultipleLayouts
             if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts && generic->isActive()) {
                 qDebug() << " Active Layout Should Be Renamed From : " << generic->name() << " TO :: " << name;
                 activeLayoutsToRename[name] = generic;
             }
 
             QString tempFile = layoutTempDir.path() + "/" + QString(generic->name() + ".layout.latte");
             qDebug() << "new temp file ::: " << tempFile;
 
             if ((m_corona->layoutsManager()->memoryUsage() == Types::SingleLayout) && (generic->name() == m_corona->layoutsManager()->currentLayoutName())) {
                 switchToLayout = name;
             }
 
             generic = m_layouts.take(id);
             delete generic;
 
             QFile(id).rename(tempFile);
 
             fromRenamePaths.append(id);
             toRenamePaths.append(tempFile);
             toRenameNames.append(name);
         }
     }
 
     //! this is necessary in case two layouts have to swap names
     //! so we copy first the layouts in a temp directory and afterwards all
     //! together we move them in the official layout directory
     for (int i = 0; i < toRenamePaths.count(); ++i) {
         QString newFile = QDir::homePath() + "/.config/latte/" + toRenameNames[i] + ".layout.latte";
         QFile(toRenamePaths[i]).rename(newFile);
 
         CentralLayout *nLayout = new CentralLayout(this, newFile);
         m_layouts[newFile] = nLayout;
 
         //! updating the #SETTINGSID in the model for the layout that was renamed
         for (int j = 0; j < m_model->rowCount(); ++j) {
             QString tId = m_model->data(m_model->index(j, IDCOLUMN), Qt::DisplayRole).toString();
 
             if (tId == fromRenamePaths[i]) {
                 m_model->setData(m_model->index(j, IDCOLUMN), newFile, Qt::DisplayRole);
                 m_initLayoutPaths.append(newFile);
 
                 QFont font = qvariant_cast<QFont>(m_model->data(m_model->index(j, NAMECOLUMN), Qt::FontRole));
 
                 font.setItalic(false);
                 m_model->setData(m_model->index(j, NAMECOLUMN), font, Qt::FontRole);
             }
         }
     }
 
     QString orphanedLayout;
 
     if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
         for (const auto &newLayoutName : activeLayoutsToRename.keys()) {
             Layout::GenericLayout *layout = activeLayoutsToRename[newLayoutName];
             qDebug() << " Active Layout of Type: " << layout->type() << " Is Renamed From : " << activeLayoutsToRename[newLayoutName]->name() << " TO :: " << newLayoutName;
             layout->renameLayout(newLayoutName);
 
             if (layout->type() == Layout::Type::Central) {
                 CentralLayout *central = qobject_cast<CentralLayout *>(layout);
 
                 if (central->activities().isEmpty()) {
                     //! that means it is an active layout for orphaned Activities
                     orphanedLayout = newLayoutName;
                 }
             }
 
             //! broadcast the name change
             int row = rowForName(newLayoutName);
             QStandardItem *item = m_model->item(row, NAMECOLUMN);
             if (item) {
                 emit itemChanged(item);
             }
         }
     }
 
     //! lock layouts in the end when the user has chosen it
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
         QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool locked = m_model->data(m_model->index(i, NAMECOLUMN), Qt::UserRole).toBool();
 
         Layout::GenericLayout *generic = m_corona->layoutsManager()->synchronizer()->layout(m_layouts[id]->name());
         Layout::GenericLayout *layout = generic ? generic : m_layouts[id];
 
         if (layout && locked && layout->isWritable()) {
             layout->lock();
         }
     }
 
     //! update SharedLayouts that are Active
     syncActiveShares();
 
     //! reload layouts in layoutsmanager
     m_corona->layoutsManager()->synchronizer()->loadLayouts();
 
     //! send to layout manager in which layout to switch
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
 
     if (m_corona->layoutsManager()->memoryUsage() != inMemoryOption) {
         Types::LayoutsMemoryUsage previousMemoryUsage = m_corona->layoutsManager()->memoryUsage();
         m_corona->layoutsManager()->setMemoryUsage(inMemoryOption);
 
         QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
         QString layoutName = value.toString();
 
         m_corona->layoutsManager()->switchToLayout(layoutName, previousMemoryUsage);
     } else {
         if (!switchToLayout.isEmpty()) {
             m_corona->layoutsManager()->switchToLayout(switchToLayout);
         } else if (m_corona->layoutsManager()->memoryUsage() == Types::MultipleLayouts) {
             m_corona->layoutsManager()->synchronizer()->syncMultipleLayoutsToActivities(orphanedLayout);
         }
     }
 
     return true;
 }
 
 void SettingsDialog::syncActiveShares()
 {
     if (m_corona->layoutsManager()->memoryUsage() != Types::MultipleLayouts) {
         return;
     }
 
     QHash<const QString, QStringList> currentSharesIdMap;
     Layouts::SharesMap  currentSharesNamesMap;
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         if (isShared(i)) {
             QString id = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
             QString name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
             QStringList shareIds = m_model->data(m_model->index(i, SHAREDCOLUMN), Qt::UserRole).toStringList();
             QStringList shareNames;
 
             for (const auto &shareid : shareIds) {
                 QString shareName = nameForId(shareid);
                 shareNames << shareName;
             }
 
             currentSharesIdMap[id] = shareIds;
             currentSharesNamesMap[name] = shareNames;
         }
     }
 
     QStringList deprecatedShares;
 
     for (const auto &oldSharesIds : m_sharesMap) {
         for(const auto &oldId : oldSharesIds) {
             QString oldShareName = nameForId(oldId);
             if (!m_corona->layoutsManager()->synchronizer()->mapHasRecord(oldShareName, currentSharesNamesMap)) {
                 deprecatedShares << oldShareName;
             }
         }
     }
 
     qDebug() << " CURRENT SHARES ID MAP  :: " << currentSharesIdMap;
     m_corona->layoutsManager()->synchronizer()->syncActiveShares(currentSharesNamesMap, deprecatedShares);
 
     m_sharesMap.clear();
     m_sharesMap = currentSharesIdMap;
 }
 
 void SettingsDialog::addActivityInCurrent(const QString &activityId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList activities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
     if (!activities.contains(activityId)) {
         activities << activityId;
         m_model->setData(m_model->index(currentRow, ACTIVITYCOLUMN), activities, Qt::UserRole);
     }
 }
 
 void SettingsDialog::removeActivityFromCurrent(const QString &activityId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList activities = m_model->data(m_model->index(currentRow, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
     if (activities.contains(activityId)) {
         activities.removeAll(activityId);
         m_model->setData(m_model->index(currentRow, ACTIVITYCOLUMN), activities, Qt::UserRole);
     }
 }
 
 void SettingsDialog::addShareInCurrent(const QString &layoutId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList shares = m_model->data(m_model->index(currentRow, SHAREDCOLUMN), Qt::UserRole).toStringList();
     if (!shares.contains(layoutId)) {
         shares << layoutId;
         m_model->setData(m_model->index(currentRow, SHAREDCOLUMN), shares, Qt::UserRole);
     }
 }
 
 void SettingsDialog::removeShareFromCurrent(const QString &layoutId)
 {
     int currentRow = ui->layoutsView->currentIndex().row();
     QStringList shares = m_model->data(m_model->index(currentRow, SHAREDCOLUMN), Qt::UserRole).toStringList();
     if (shares.contains(layoutId)) {
         shares.removeAll(layoutId);
         m_model->setData(m_model->index(currentRow, SHAREDCOLUMN), shares, Qt::UserRole);
     }
 }
 
 bool SettingsDialog::idExistsInModel(QString id)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowId = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
 
         if (rowId == id) {
             return true;
         }
     }
 
     return false;
 }
 
 bool SettingsDialog::nameExistsInModel(QString name)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName == name) {
             return true;
         }
     }
 
     return false;
 }
 
 bool SettingsDialog::inMultipleLayoutsLook() const
 {
     Latte::Types::LayoutsMemoryUsage inMemoryOption = static_cast<Latte::Types::LayoutsMemoryUsage>(m_inMemoryButtons->checkedId());
     return inMemoryOption == Latte::Types::MultipleLayouts;
 }
 
 bool SettingsDialog::isActive(QString layoutName) const
 {
     return (m_corona->layoutsManager()->synchronizer()->layout(layoutName) != nullptr);
 }
 
 bool SettingsDialog::isMenuCell(int column) const
 {
     return column == MENUCOLUMN;
 }
 
 bool SettingsDialog::isShared(int row) const
 {
     if (row >=0 ) {
         QStringList shares = m_model->data(m_model->index(row, SHAREDCOLUMN), Qt::UserRole).toStringList();
         if (!shares.isEmpty()) {
             return true;
         }
     }
 
     return false;
 }
 
 int SettingsDialog::ascendingRowFor(QString name)
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName.toUpper() > name.toUpper()) {
             return i;
         }
     }
 
     return m_model->rowCount();
 }
 
 int SettingsDialog::rowForId(QString id) const
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowId = m_model->data(m_model->index(i, IDCOLUMN), Qt::DisplayRole).toString();
 
         if (rowId == id) {
             return i;
         }
     }
 
     return -1;
 }
 
 int SettingsDialog::rowForName(QString layoutName) const
 {
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QString rowName = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
 
         if (rowName == layoutName) {
             return i;
         }
     }
 
     return -1;
 }
 
 QString SettingsDialog::idForRow(int row) const
 {
     return m_model->data(m_model->index(row, IDCOLUMN), Qt::DisplayRole).toString();
 }
 
 QString SettingsDialog::nameForId(QString id) const
 {
     int row = rowForId(id);
     return m_model->data(m_model->index(row, NAMECOLUMN), Qt::DisplayRole).toString();
 }
 
 QString SettingsDialog::uniqueTempDirectory()
 {
     QTemporaryDir tempDir;
     tempDir.setAutoRemove(false);
     m_tempDirectories.append(tempDir.path());
 
     return tempDir.path();
 }
 
 QString SettingsDialog::uniqueLayoutName(QString name)
 {
     int pos_ = name.lastIndexOf(QRegExp(QString("[-][0-9]+")));
 
     if (nameExistsInModel(name) && pos_ > 0) {
         name = name.left(pos_);
     }
 
     int i = 2;
 
     QString namePart = name;
 
     while (nameExistsInModel(name)) {
         name = namePart + "-" + QString::number(i);
         i++;
     }
 
     return name;
 }
 
 }//end of namespace
 
diff --git a/app/settings/settingsdialog.ui b/app/settings/settingsdialog.ui
index f8a3b00b..884be53b 100644
--- a/app/settings/settingsdialog.ui
+++ b/app/settings/settingsdialog.ui
@@ -1,1176 +1,1232 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
  <class>SettingsDialog</class>
  <widget class="QDialog" name="SettingsDialog">
   <property name="geometry">
    <rect>
     <x>0</x>
     <y>0</y>
-    <width>850</width>
-    <height>663</height>
+    <width>941</width>
+    <height>703</height>
    </rect>
   </property>
   <property name="windowTitle">
    <string comment="latte settings window">Settings</string>
   </property>
   <layout class="QVBoxLayout" name="verticalLayout_2">
    <item>
     <widget class="QTabWidget" name="tabWidget">
      <property name="currentIndex">
       <number>0</number>
      </property>
      <widget class="QWidget" name="layoutsTab">
       <attribute name="title">
        <string>Layouts</string>
       </attribute>
       <layout class="QHBoxLayout" name="horizontalLayout">
        <item>
         <layout class="QVBoxLayout" name="verticalLayout_3">
          <item>
           <layout class="QHBoxLayout" name="horizontalLayout_3">
            <item>
             <spacer name="horizontalSpacer">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
              <property name="sizeHint" stdset="0">
               <size>
                <width>40</width>
                <height>20</height>
               </size>
              </property>
             </spacer>
            </item>
            <item>
             <widget class="QToolButton" name="singleToolBtn">
              <property name="sizePolicy">
               <sizepolicy hsizetype="Fixed" vsizetype="Fixed">
                <horstretch>0</horstretch>
                <verstretch>0</verstretch>
               </sizepolicy>
              </property>
              <property name="toolTip">
               <string>Only one layout can be present in memory at all cases</string>
              </property>
              <property name="text">
               <string comment="single layout">Single</string>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
             </widget>
            </item>
            <item>
             <widget class="QToolButton" name="multipleToolBtn">
              <property name="toolTip">
               <string>Multiple layouts can be present and active in memory at the same time</string>
              </property>
              <property name="text">
               <string comment="multiple layouts">Multiple</string>
              </property>
              <property name="checkable">
               <bool>true</bool>
              </property>
              <property name="checked">
               <bool>false</bool>
              </property>
             </widget>
            </item>
            <item>
             <spacer name="horizontalSpacer_2">
              <property name="orientation">
               <enum>Qt::Horizontal</enum>
              </property>
              <property name="sizeHint" stdset="0">
               <size>
                <width>40</width>
                <height>20</height>
               </size>
              </property>
             </spacer>
            </item>
           </layout>
          </item>
          <item>
           <layout class="QHBoxLayout" name="horizontalLayout_2">
            <item>
             <widget class="QTableView" name="layoutsView">
              <property name="showDropIndicator" stdset="0">
               <bool>true</bool>
              </property>
              <property name="alternatingRowColors">
               <bool>true</bool>
              </property>
              <property name="selectionMode">
               <enum>QAbstractItemView::SingleSelection</enum>
              </property>
              <property name="selectionBehavior">
               <enum>QAbstractItemView::SelectRows</enum>
              </property>
              <property name="showGrid">
               <bool>false</bool>
              </property>
              <attribute name="horizontalHeaderVisible">
               <bool>true</bool>
              </attribute>
              <attribute name="horizontalHeaderCascadingSectionResizes">
               <bool>true</bool>
              </attribute>
              <attribute name="horizontalHeaderHighlightSections">
               <bool>false</bool>
              </attribute>
              <attribute name="horizontalHeaderShowSortIndicator" stdset="0">
               <bool>false</bool>
              </attribute>
              <attribute name="verticalHeaderVisible">
               <bool>false</bool>
              </attribute>
              <attribute name="verticalHeaderHighlightSections">
               <bool>false</bool>
              </attribute>
             </widget>
            </item>
            <item>
             <widget class="QWidget" name="widget" native="true">
              <layout class="QVBoxLayout" name="verticalLayout">
               <item>
                <widget class="QPushButton" name="switchButton">
                 <property name="toolTip">
                  <string>Switch to selected layout</string>
                 </property>
                 <property name="text">
                  <string comment="switch to layout">Switch</string>
                 </property>
                 <property name="icon">
                  <iconset theme="user-identity">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="pauseButton">
                 <property name="toolTip">
                  <string>Pause all activities from the selected layout</string>
                 </property>
                 <property name="text">
                  <string>Pause</string>
                 </property>
                 <property name="icon">
                  <iconset theme="media-playback-pause">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer_5">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::Preferred</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
                   <height>15</height>
                  </size>
                 </property>
                </spacer>
               </item>
               <item>
                <widget class="Line" name="line_2">
                 <property name="minimumSize">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer_4">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::Preferred</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
                   <height>15</height>
                  </size>
                 </property>
                </spacer>
               </item>
               <item>
                <widget class="QPushButton" name="newButton">
                 <property name="toolTip">
                  <string>New layout</string>
                 </property>
                 <property name="text">
                  <string comment="new layout">New</string>
                 </property>
                 <property name="icon">
                  <iconset theme="add">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="copyButton">
                 <property name="toolTip">
                  <string>Copy selected layout</string>
                 </property>
                 <property name="text">
                  <string comment="copy layout">Copy</string>
                 </property>
                 <property name="icon">
                  <iconset theme="edit-copy">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                 <property name="flat">
                  <bool>false</bool>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="removeButton">
                 <property name="toolTip">
                  <string>Remove selected layout</string>
                 </property>
                 <property name="text">
                  <string comment="remove layout">Remove</string>
                 </property>
                 <property name="icon">
                  <iconset theme="delete">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer_10">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::Fixed</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>1</width>
                   <height>11</height>
                  </size>
                 </property>
                </spacer>
               </item>
               <item>
                <widget class="QPushButton" name="lockedButton">
                 <property name="toolTip">
                  <string>Lock layout and make it read-only</string>
                 </property>
                 <property name="text">
                  <string comment="locked layout">Locked</string>
                 </property>
                 <property name="icon">
                  <iconset theme="object-locked">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                 <property name="checkable">
                  <bool>true</bool>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="sharedButton">
                 <property name="toolTip">
                  <string>Share that layout with other central layouts</string>
                 </property>
                 <property name="text">
                  <string>Shared</string>
                 </property>
                 <property name="icon">
                  <iconset theme="document-share">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                 <property name="checkable">
                  <bool>true</bool>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer_2">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::Preferred</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
                   <height>15</height>
                  </size>
                 </property>
                </spacer>
               </item>
               <item>
                <widget class="Line" name="line">
                 <property name="sizePolicy">
                  <sizepolicy hsizetype="Minimum" vsizetype="Fixed">
                   <horstretch>0</horstretch>
                   <verstretch>0</verstretch>
                  </sizepolicy>
                 </property>
                 <property name="sizeIncrement">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="baseSize">
                  <size>
                   <width>0</width>
                   <height>0</height>
                  </size>
                 </property>
                 <property name="lineWidth">
                  <number>1</number>
                 </property>
                 <property name="orientation">
                  <enum>Qt::Horizontal</enum>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer_3">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeType">
                  <enum>QSizePolicy::Preferred</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
                   <height>15</height>
                  </size>
                 </property>
                </spacer>
               </item>
               <item>
                <widget class="QPushButton" name="importButton">
                 <property name="toolTip">
                  <string>Import a layout or full configuration file</string>
                 </property>
                 <property name="text">
                  <string comment="import layout">Import</string>
                 </property>
                 <property name="icon">
                  <iconset theme="document-import">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                 <property name="default">
                  <bool>false</bool>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="exportButton">
                 <property name="toolTip">
                  <string>Export selected layout or full configuration into a file</string>
                 </property>
                 <property name="text">
                  <string comment="export layout">Export</string>
                 </property>
                 <property name="icon">
                  <iconset theme="document-export">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                </widget>
               </item>
               <item>
                <widget class="QPushButton" name="downloadButton">
                 <property name="toolTip">
                  <string>Download community layouts from the Internet</string>
                 </property>
                 <property name="text">
                  <string comment="download layout">Download</string>
                 </property>
                 <property name="icon">
                  <iconset theme="get-hot-new-stuff">
                   <normaloff>.</normaloff>.</iconset>
                 </property>
                </widget>
               </item>
               <item>
                <spacer name="verticalSpacer">
                 <property name="orientation">
                  <enum>Qt::Vertical</enum>
                 </property>
                 <property name="sizeHint" stdset="0">
                  <size>
                   <width>20</width>
                   <height>40</height>
                  </size>
                 </property>
                </spacer>
               </item>
              </layout>
             </widget>
            </item>
           </layout>
          </item>
         </layout>
        </item>
       </layout>
      </widget>
      <widget class="QWidget" name="preferencesTab">
       <property name="sizePolicy">
        <sizepolicy hsizetype="Expanding" vsizetype="Expanding">
         <horstretch>0</horstretch>
         <verstretch>0</verstretch>
        </sizepolicy>
       </property>
       <attribute name="title">
        <string>Preferences</string>
       </attribute>
       <layout class="QHBoxLayout" name="horizontalLayout_4">
        <property name="rightMargin">
         <number>9</number>
        </property>
        <item>
         <widget class="QScrollArea" name="scrollArea">
          <property name="frameShape">
           <enum>QFrame::NoFrame</enum>
          </property>
          <property name="lineWidth">
           <number>0</number>
          </property>
          <property name="verticalScrollBarPolicy">
           <enum>Qt::ScrollBarAsNeeded</enum>
          </property>
          <property name="horizontalScrollBarPolicy">
           <enum>Qt::ScrollBarAlwaysOff</enum>
          </property>
          <property name="widgetResizable">
           <bool>true</bool>
          </property>
          <widget class="QWidget" name="scrollAreaWidgetContents">
           <property name="geometry">
            <rect>
             <x>0</x>
             <y>0</y>
-            <width>496</width>
-            <height>575</height>
+            <width>890</width>
+            <height>662</height>
            </rect>
           </property>
           <layout class="QHBoxLayout" name="horizontalLayout_9">
            <property name="spacing">
             <number>0</number>
            </property>
            <property name="leftMargin">
             <number>0</number>
            </property>
            <property name="topMargin">
             <number>0</number>
            </property>
            <property name="rightMargin">
             <number>0</number>
            </property>
            <property name="bottomMargin">
             <number>0</number>
            </property>
            <item>
             <layout class="QVBoxLayout" name="verticalLayout_4">
              <item>
               <spacer name="verticalSpacer_8">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeType">
                 <enum>QSizePolicy::Fixed</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>10</height>
                 </size>
                </property>
               </spacer>
              </item>
+             <item>
+              <widget class="QLabel" name="appearanceLbl">
+               <property name="font">
+                <font>
+                 <weight>75</weight>
+                 <bold>true</bold>
+                </font>
+               </property>
+               <property name="text">
+                <string>Appearance</string>
+               </property>
+              </widget>
+             </item>
+             <item>
+              <layout class="QHBoxLayout" name="horizontalLayout_12">
+               <item>
+                <spacer name="horizontalSpacer_12">
+                 <property name="orientation">
+                  <enum>Qt::Horizontal</enum>
+                 </property>
+                 <property name="sizeType">
+                  <enum>QSizePolicy::Fixed</enum>
+                 </property>
+                 <property name="sizeHint" stdset="0">
+                  <size>
+                   <width>20</width>
+                   <height>20</height>
+                  </size>
+                 </property>
+                </spacer>
+               </item>
+               <item>
+                <widget class="QCheckBox" name="badges3DStyleChkBox">
+                 <property name="text">
+                  <string>Use 3D style for notification and shortcut badges</string>
+                 </property>
+                </widget>
+               </item>
+              </layout>
+             </item>
+             <item>
+              <spacer name="verticalSpacer_14">
+               <property name="orientation">
+                <enum>Qt::Vertical</enum>
+               </property>
+               <property name="sizeType">
+                <enum>QSizePolicy::Fixed</enum>
+               </property>
+               <property name="sizeHint" stdset="0">
+                <size>
+                 <width>20</width>
+                 <height>20</height>
+                </size>
+               </property>
+              </spacer>
+             </item>
              <item>
               <widget class="QLabel" name="behaviorLbl">
                <property name="sizePolicy">
                 <sizepolicy hsizetype="Preferred" vsizetype="Preferred">
                  <horstretch>0</horstretch>
                  <verstretch>0</verstretch>
                 </sizepolicy>
                </property>
                <property name="font">
                 <font>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Behavior</string>
                </property>
                <property name="alignment">
                 <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignTop</set>
                </property>
               </widget>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_5">
                <item>
                 <spacer name="horizontalSpacer_3">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QCheckBox" name="autostartChkBox">
                  <property name="toolTip">
                   <string>Start the application automatically after each relogin</string>
                  </property>
                  <property name="text">
                   <string>Enable autostart during startup</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_6">
                <item>
                 <spacer name="horizontalSpacer_4">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QCheckBox" name="infoWindowChkBox">
                  <property name="toolTip">
                   <string>Provide visual feedback when layouts are activated automatically</string>
                  </property>
                  <property name="text">
                   <string>Show informative window for layouts automatic activation</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_14">
                <item>
                 <spacer name="horizontalSpacer_10">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Maximum</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QCheckBox" name="noBordersForMaximizedChkBox">
                  <property name="toolTip">
                   <string>Activate support for borderless maximized windows between different layouts</string>
                  </property>
                  <property name="text">
                   <string>Support borderless maximized windows in different layouts</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item>
               <spacer name="verticalSpacer_7">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeType">
                 <enum>QSizePolicy::Fixed</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item>
               <widget class="QLabel" name="label">
                <property name="font">
                 <font>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Actions</string>
                </property>
               </widget>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_11">
                <item>
                 <spacer name="horizontalSpacer_11">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QCheckBox" name="metaPressChkBox">
                  <property name="toolTip">
                   <string>Forward ⌘ press from KWin to Latte in order to activate Application Launcher. It is suggested to disable that option if you remove Latte.</string>
                  </property>
                  <property name="text">
                   <string>Press ⌘ to activate Application Launcher</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_13">
                <item>
                 <spacer name="horizontalSpacer_14">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QCheckBox" name="metaPressHoldChkBox">
                  <property name="toolTip">
                   <string>Press and hold ⌘ to show shortcuts badges for applets and tasks</string>
                  </property>
                  <property name="text">
                   <string>Press and Hold ⌘ to show shortcuts badges</string>
                  </property>
                 </widget>
                </item>
               </layout>
              </item>
              <item>
               <spacer name="verticalSpacer_12">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeType">
                 <enum>QSizePolicy::Fixed</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item>
               <widget class="QLabel" name="mouseSensetivityLbl">
                <property name="font">
                 <font>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Mouse Sensitivity</string>
                </property>
               </widget>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_7">
                <item>
                 <spacer name="horizontalSpacer_5">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QLabel" name="parabolicEffectLbl">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="Maximum" vsizetype="Preferred">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="text">
                   <string>Parabolic Effect</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <spacer name="horizontalSpacer_6">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>7</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <layout class="QHBoxLayout" name="horizontalLayout_8">
                  <item>
                   <widget class="QToolButton" name="lowSensitivityBtn">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="toolTip">
                     <string>Low sensitivity for parabolic effect (low cpu usage and performance)</string>
                    </property>
                    <property name="text">
                     <string comment="low sensitivity">Low</string>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="mediumSensitivityBtn">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="toolTip">
                     <string>Medium sensitivity for parabolic effect (normal cpu usage and performance)</string>
                    </property>
                    <property name="text">
                     <string comment="medium sensitivity">Medium</string>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                  <item>
                   <widget class="QToolButton" name="highSensitivityBtn">
                    <property name="sizePolicy">
                     <sizepolicy hsizetype="Expanding" vsizetype="Fixed">
                      <horstretch>0</horstretch>
                      <verstretch>0</verstretch>
                     </sizepolicy>
                    </property>
                    <property name="toolTip">
                     <string>High sensitivity for parabolic effect (high cpu usage and performance)</string>
                    </property>
                    <property name="text">
                     <string comment="high sensitivity">High</string>
                    </property>
                    <property name="checkable">
                     <bool>true</bool>
                    </property>
                   </widget>
                  </item>
                 </layout>
                </item>
                <item>
                 <spacer name="horizontalSpacer_8">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
               </layout>
              </item>
              <item>
               <spacer name="verticalSpacer_9">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeType">
                 <enum>QSizePolicy::Fixed</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item>
               <widget class="QLabel" name="delayLbl">
                <property name="font">
                 <font>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Delay</string>
                </property>
               </widget>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_10">
                <item>
                 <spacer name="horizontalSpacer_7">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QLabel" name="trackScreensDelayLbl">
                  <property name="toolTip">
                   <string>Different hardware can have different delays during screen changes.
 This tracker is used in order to not lose any screen related update.</string>
                  </property>
                  <property name="text">
                   <string>React to screen changes after</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QSpinBox" name="screenTrackerSpinBox">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="maximumSize">
                   <size>
                    <width>200</width>
                    <height>16777215</height>
                   </size>
                  </property>
                  <property name="toolTip">
                   <string>Different hardware can have different delays during screen changes.
 This tracker is used in order to not lose any screen related update.</string>
                  </property>
                  <property name="alignment">
                   <set>Qt::AlignLeading|Qt::AlignLeft|Qt::AlignVCenter</set>
                  </property>
                  <property name="specialValueText">
                   <string/>
                  </property>
                  <property name="suffix">
                   <string> ms.</string>
                  </property>
                  <property name="minimum">
                   <number>1000</number>
                  </property>
                  <property name="maximum">
                   <number>10000</number>
                  </property>
                  <property name="singleStep">
                   <number>100</number>
                  </property>
                  <property name="value">
                   <number>2500</number>
                  </property>
                 </widget>
                </item>
                <item>
                 <spacer name="horizontalSpacer_9">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
               </layout>
              </item>
              <item>
               <spacer name="verticalSpacer_11">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeType">
                 <enum>QSizePolicy::Fixed</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item>
               <widget class="QLabel" name="plasmaLbl">
                <property name="font">
                 <font>
                  <weight>75</weight>
                  <bold>true</bold>
                 </font>
                </property>
                <property name="text">
                 <string>Plasma Theme</string>
                </property>
               </widget>
              </item>
              <item>
               <layout class="QHBoxLayout" name="horizontalLayout_15">
                <item>
                 <spacer name="horizontalSpacer_16">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
                <item>
                 <widget class="QLabel" name="outlineLbl">
                  <property name="enabled">
                   <bool>true</bool>
                  </property>
                  <property name="toolTip">
                   <string>Outline width used from background to draw its borders</string>
                  </property>
                  <property name="text">
                   <string>Outline width</string>
                  </property>
                 </widget>
                </item>
                <item>
                 <widget class="QSpinBox" name="outlineSpinBox">
                  <property name="sizePolicy">
                   <sizepolicy hsizetype="MinimumExpanding" vsizetype="Fixed">
                    <horstretch>0</horstretch>
                    <verstretch>0</verstretch>
                   </sizepolicy>
                  </property>
                  <property name="minimumSize">
                   <size>
                    <width>111</width>
                    <height>30</height>
                   </size>
                  </property>
                  <property name="maximumSize">
                   <size>
                    <width>200</width>
                    <height>16777215</height>
                   </size>
                  </property>
                  <property name="toolTip">
                   <string>Outline width used from background to draw its borders</string>
                  </property>
                  <property name="suffix">
                   <string> px.</string>
                  </property>
                  <property name="minimum">
                   <number>1</number>
                  </property>
                  <property name="maximum">
                   <number>16</number>
                  </property>
                 </widget>
                </item>
                <item>
                 <spacer name="horizontalSpacer_15">
                  <property name="orientation">
                   <enum>Qt::Horizontal</enum>
                  </property>
                  <property name="sizeType">
                   <enum>QSizePolicy::Fixed</enum>
                  </property>
                  <property name="sizeHint" stdset="0">
                   <size>
                    <width>20</width>
                    <height>20</height>
                   </size>
                  </property>
                 </spacer>
                </item>
               </layout>
              </item>
              <item>
               <spacer name="verticalSpacer_13">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeType">
                 <enum>QSizePolicy::Fixed</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>20</height>
                 </size>
                </property>
               </spacer>
              </item>
              <item>
               <spacer name="verticalSpacer_6">
                <property name="orientation">
                 <enum>Qt::Vertical</enum>
                </property>
                <property name="sizeHint" stdset="0">
                 <size>
                  <width>20</width>
                  <height>40</height>
                 </size>
                </property>
               </spacer>
              </item>
             </layout>
            </item>
           </layout>
          </widget>
         </widget>
        </item>
       </layout>
      </widget>
     </widget>
    </item>
    <item>
     <widget class="QDialogButtonBox" name="buttonBox">
      <property name="orientation">
       <enum>Qt::Horizontal</enum>
      </property>
      <property name="standardButtons">
       <set>QDialogButtonBox::Apply|QDialogButtonBox::Cancel|QDialogButtonBox::Ok|QDialogButtonBox::RestoreDefaults</set>
      </property>
     </widget>
    </item>
   </layout>
  </widget>
  <resources/>
  <connections>
   <connection>
    <sender>buttonBox</sender>
    <signal>accepted()</signal>
    <receiver>SettingsDialog</receiver>
    <slot>accept()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>254</x>
      <y>341</y>
     </hint>
     <hint type="destinationlabel">
      <x>157</x>
      <y>274</y>
     </hint>
    </hints>
   </connection>
   <connection>
    <sender>buttonBox</sender>
    <signal>rejected()</signal>
    <receiver>SettingsDialog</receiver>
    <slot>reject()</slot>
    <hints>
     <hint type="sourcelabel">
      <x>322</x>
      <y>341</y>
     </hint>
     <hint type="destinationlabel">
      <x>286</x>
      <y>274</y>
     </hint>
    </hints>
   </connection>
  </connections>
 </ui>
diff --git a/app/settings/universalsettings.cpp b/app/settings/universalsettings.cpp
index 11fcec21..6565d506 100644
--- a/app/settings/universalsettings.cpp
+++ b/app/settings/universalsettings.cpp
@@ -1,559 +1,578 @@
 /*
 *  Copyright 2017  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 "universalsettings.h"
 
 // local
 #include "../layouts/importer.h"
 #include "../layouts/manager.h"
 
 // Qt
 #include <QDebug>
 #include <QDir>
 #include <QProcess>
 #include <QtDBus>
 
 // KDE
 #include <KActivities/Consumer>
 #include <KDirWatch>
 
 #define KWINMETAFORWARDTOLATTESTRING "org.kde.lattedock,/Latte,org.kde.LatteDock,activateLauncherMenu"
 #define KWINMETAFORWARDTOPLASMASTRING "org.kde.plasmashell,/PlasmaShell,org.kde.PlasmaShell,activateLauncherMenu"
 
 #define KWINCOLORSSCRIPT "kwin/scripts/lattewindowcolors"
 
 namespace Latte {
 
 UniversalSettings::UniversalSettings(KSharedConfig::Ptr config, QObject *parent)
     : QObject(parent),
       m_config(config),
       m_universalGroup(KConfigGroup(config, QStringLiteral("UniversalSettings")))
 {
     m_corona = qobject_cast<Latte::Corona *>(parent);
 
+    connect(this, &UniversalSettings::badges3DStyleChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::canDisableBordersChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::currentLayoutNameChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::downloadWindowSizeChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::lastNonAssignedLayoutNameChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::launchersChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsColumnWidthsChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsMemoryUsageChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::layoutsWindowSizeChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::metaPressAndHoldEnabledChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::mouseSensitivityChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::screenTrackerIntervalChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::showInfoWindowChanged, this, &UniversalSettings::saveConfig);
     connect(this, &UniversalSettings::versionChanged, this, &UniversalSettings::saveConfig);
 
     connect(this, &UniversalSettings::screenScalesChanged, this, &UniversalSettings::saveScalesConfig);
 
     connect(qGuiApp, &QGuiApplication::screenAdded, this, &UniversalSettings::screensCountChanged);
     connect(qGuiApp, &QGuiApplication::screenRemoved, this, &UniversalSettings::screensCountChanged);
 }
 
 UniversalSettings::~UniversalSettings()
 {
     saveConfig();
     cleanupSettings();
 }
 
 void UniversalSettings::load()
 {
     //! check if user has set the autostart option
     bool autostartUserSet = m_universalGroup.readEntry("userConfiguredAutostart", false);
 
     if (!autostartUserSet && !autostart()) {
         setAutostart(true);
     }
 
     //! init screen scales
     m_screenScalesGroup = m_universalGroup.group("ScreenScales");
 
     //! load configuration
     loadConfig();
 
     //! Track KWin Colors Script Presence
     updateColorsScriptIsPresent();
 
     QStringList colorsScriptPaths = Layouts::Importer::standardPathsFor(KWINCOLORSSCRIPT);
     for(auto path: colorsScriptPaths) {
         KDirWatch::self()->addDir(path);
     }
 
     connect(KDirWatch::self(), &KDirWatch::created, this, &UniversalSettings::colorsScriptChanged);
     connect(KDirWatch::self(), &KDirWatch::deleted, this, &UniversalSettings::colorsScriptChanged);
 
     //! this is needed to inform globalshortcuts to update its modifiers tracking
     emit metaPressAndHoldEnabledChanged();
 }
 
 bool UniversalSettings::showInfoWindow() const
 {
     return m_showInfoWindow;
 }
 
 void UniversalSettings::setShowInfoWindow(bool show)
 {
     if (m_showInfoWindow == show) {
         return;
     }
 
     m_showInfoWindow = show;
     emit showInfoWindowChanged();
 }
 
 int UniversalSettings::version() const
 {
     return m_version;
 }
 
 void UniversalSettings::setVersion(int ver)
 {
     if (m_version == ver) {
         return;
     }
 
     m_version = ver;
 
     emit versionChanged();
 }
 
 int UniversalSettings::screenTrackerInterval() const
 {
     return m_screenTrackerInterval;
 }
 
 void UniversalSettings::setScreenTrackerInterval(int duration)
 {
     if (m_screenTrackerInterval == duration) {
         return;
     }
 
     m_screenTrackerInterval = duration;
     emit screenTrackerIntervalChanged();
 }
 
 QString UniversalSettings::currentLayoutName() const
 {
     return m_currentLayoutName;
 }
 
 void UniversalSettings::setCurrentLayoutName(QString layoutName)
 {
     if (m_currentLayoutName == layoutName) {
         return;
     }
 
     m_currentLayoutName = layoutName;
     emit currentLayoutNameChanged();
 }
 
 QString UniversalSettings::lastNonAssignedLayoutName() const
 {
     return m_lastNonAssignedLayoutName;
 }
 
 void UniversalSettings::setLastNonAssignedLayoutName(QString layoutName)
 {
     if (m_lastNonAssignedLayoutName == layoutName) {
         return;
     }
 
     m_lastNonAssignedLayoutName = layoutName;
     emit lastNonAssignedLayoutNameChanged();
 }
 
 QSize UniversalSettings::downloadWindowSize() const
 {
     return m_downloadWindowSize;
 }
 
 void UniversalSettings::setDownloadWindowSize(QSize size)
 {
     if (m_downloadWindowSize == size) {
         return;
     }
 
     m_downloadWindowSize = size;
     emit downloadWindowSizeChanged();
 }
 
 
 QSize UniversalSettings::layoutsWindowSize() const
 {
     return m_layoutsWindowSize;
 }
 
 void UniversalSettings::setLayoutsWindowSize(QSize size)
 {
     if (m_layoutsWindowSize == size) {
         return;
     }
 
     m_layoutsWindowSize = size;
     emit layoutsWindowSizeChanged();
 }
 
 QStringList UniversalSettings::layoutsColumnWidths() const
 {
     return m_layoutsColumnWidths;
 }
 
 void UniversalSettings::setLayoutsColumnWidths(QStringList widths)
 {
     if (m_layoutsColumnWidths == widths) {
         return;
     }
 
     m_layoutsColumnWidths = widths;
     emit layoutsColumnWidthsChanged();
 }
 
 QStringList UniversalSettings::launchers() const
 {
     return m_launchers;
 }
 
 void UniversalSettings::setLaunchers(QStringList launcherList)
 {
     if (m_launchers == launcherList) {
         return;
     }
 
     m_launchers = launcherList;
     emit launchersChanged();
 }
 
 
 bool UniversalSettings::autostart() const
 {
     QFile autostartFile(QDir::homePath() + "/.config/autostart/org.kde.latte-dock.desktop");
     return autostartFile.exists();
 }
 
 void UniversalSettings::setAutostart(bool state)
 {
     //! remove old autostart file
     QFile oldAutostartFile(QDir::homePath() + "/.config/autostart/latte-dock.desktop");
 
     if (oldAutostartFile.exists()) {
         oldAutostartFile.remove();
     }
 
     //! end of removal of old autostart file
 
     QFile autostartFile(QDir::homePath() + "/.config/autostart/org.kde.latte-dock.desktop");
     QFile metaFile(Layouts::Importer::standardPath("applications", false)+"/org.kde.latte-dock.desktop");
 
     if (!state && autostartFile.exists()) {
         //! the first time that the user disables the autostart, this is recorded
         //! and from now own it will not be recreated it in the beginning
         if (!m_universalGroup.readEntry("userConfiguredAutostart", false)) {
             m_universalGroup.writeEntry("userConfiguredAutostart", true);
         }
 
         autostartFile.remove();
         emit autostartChanged();
     } else if (state && metaFile.exists()) {
         //! check if autostart folder exists and create otherwise
         QDir autostartDir(QDir::homePath() + "/.config/autostart");
         if (!autostartDir.exists()) {
             QDir configDir(QDir::homePath() + "/.config");
             configDir.mkdir("autostart");
         }
 
         metaFile.copy(autostartFile.fileName());
         //! I haven't added the flag "OnlyShowIn=KDE;" into the autostart file
         //! because I fall onto a Plasma 5.8 case that this flag
         //! didn't let the plasma desktop to start
         emit autostartChanged();
     }
 }
 
+bool UniversalSettings::badges3DStyle() const
+{
+    return m_badges3DStyle;
+}
+
+void UniversalSettings::setBadges3DStyle(bool enable)
+{
+    if (m_badges3DStyle == enable) {
+        return;
+    }
+
+    m_badges3DStyle = enable;
+    emit badges3DStyleChanged();
+}
+
+
 bool UniversalSettings::canDisableBorders() const
 {
     return m_canDisableBorders;
 }
 
 void UniversalSettings::setCanDisableBorders(bool enable)
 {
     if (m_canDisableBorders == enable) {
         return;
     }
 
     m_canDisableBorders = enable;
     emit canDisableBordersChanged();
 }
 
 bool UniversalSettings::colorsScriptIsPresent() const
 {
     return m_colorsScriptIsPresent;
 }
 
 void UniversalSettings::setColorsScriptIsPresent(bool present)
 {
     if (m_colorsScriptIsPresent == present) {
         return;
     }
 
     m_colorsScriptIsPresent = present;
     emit colorsScriptIsPresentChanged();
 }
 
 void UniversalSettings::updateColorsScriptIsPresent()
 {
     setColorsScriptIsPresent(!Layouts::Importer::standardPath(KWINCOLORSSCRIPT).isEmpty());
 }
 
 void UniversalSettings::colorsScriptChanged(const QString &file)
 {
     if (!file.endsWith(KWINCOLORSSCRIPT)) {
         return;
     }
 
     updateColorsScriptIsPresent();
 }
 
 bool UniversalSettings::metaForwardedToLatte() const
 {
     return kwin_metaForwardedToLatte();
 }
 
 void UniversalSettings::forwardMetaToLatte(bool forward)
 {
     kwin_forwardMetaToLatte(forward);
 }
 
 bool UniversalSettings::kwin_metaForwardedToLatte() const
 {
     QProcess process;
     process.start("kreadconfig5 --file kwinrc --group ModifierOnlyShortcuts --key Meta");
     process.waitForFinished();
     QString output(process.readAllStandardOutput());
 
     output = output.remove("\n");
 
     return (output == KWINMETAFORWARDTOLATTESTRING);
 }
 
 void UniversalSettings::kwin_forwardMetaToLatte(bool forward)
 {
     if (kwin_metaForwardedToLatte() == forward) {
         return;
     }
 
     QProcess process;
     QStringList parameters;
     parameters << "--file" << "kwinrc" << "--group" << "ModifierOnlyShortcuts" << "--key" << "Meta";
 
     if (forward) {
         parameters << KWINMETAFORWARDTOLATTESTRING;
     } else {
         parameters << KWINMETAFORWARDTOPLASMASTRING;
     }
 
     process.start("kwriteconfig5", parameters);
     process.waitForFinished();
 
     QDBusInterface iface("org.kde.KWin", "/KWin", "", QDBusConnection::sessionBus());
 
     if (iface.isValid()) {
         iface.call("reconfigure");
     }
 }
 
 bool UniversalSettings::metaPressAndHoldEnabled() const
 {
     return m_metaPressAndHoldEnabled;
 }
 
 void UniversalSettings::setMetaPressAndHoldEnabled(bool enabled)
 {
     if (m_metaPressAndHoldEnabled == enabled) {
         return;
     }
 
     m_metaPressAndHoldEnabled = enabled;
 
     emit metaPressAndHoldEnabledChanged();
 }
 
 Types::LayoutsMemoryUsage UniversalSettings::layoutsMemoryUsage() const
 {
     return m_memoryUsage;
 }
 
 void UniversalSettings::setLayoutsMemoryUsage(Types::LayoutsMemoryUsage layoutsMemoryUsage)
 {
     if (m_memoryUsage == layoutsMemoryUsage) {
         return;
     }
 
     m_memoryUsage = layoutsMemoryUsage;
     emit layoutsMemoryUsageChanged();
 }
 
 Types::MouseSensitivity UniversalSettings::mouseSensitivity() const
 {
     return m_mouseSensitivity;
 }
 
 void UniversalSettings::setMouseSensitivity(Types::MouseSensitivity sensitivity)
 {
     if (m_mouseSensitivity == sensitivity) {
         return;
     }
 
     m_mouseSensitivity = sensitivity;
     emit mouseSensitivityChanged();
 }
 
 float UniversalSettings::screenWidthScale(QString screenName) const
 {
     if (!m_screenScales.contains(screenName)) {
         return 1;
     }
 
     return m_screenScales[screenName].first;
 }
 
 float UniversalSettings::screenHeightScale(QString screenName) const
 {
     if (!m_screenScales.contains(screenName)) {
         return 1;
     }
 
     return m_screenScales[screenName].second;
 }
 
 void UniversalSettings::setScreenScales(QString screenName, float widthScale, float heightScale)
 {
     if (!m_screenScales.contains(screenName)) {
         m_screenScales[screenName].first = widthScale;
         m_screenScales[screenName].second = heightScale;
     } else {
         if (m_screenScales[screenName].first == widthScale
                 && m_screenScales[screenName].second == heightScale) {
             return;
         }
 
         m_screenScales[screenName].first = widthScale;
         m_screenScales[screenName].second = heightScale;
     }
 
     emit screenScalesChanged();
 }
 
 void UniversalSettings::loadConfig()
 {
     m_version = m_universalGroup.readEntry("version", 1);
+    m_badges3DStyle = m_universalGroup.readEntry("badges3DStyle", false);
     m_canDisableBorders = m_universalGroup.readEntry("canDisableBorders", false);
     m_currentLayoutName = m_universalGroup.readEntry("currentLayout", QString());
     m_downloadWindowSize = m_universalGroup.readEntry("downloadWindowSize", QSize(800, 550));
     m_lastNonAssignedLayoutName = m_universalGroup.readEntry("lastNonAssignedLayout", QString());
     m_layoutsWindowSize = m_universalGroup.readEntry("layoutsWindowSize", QSize(700, 450));
     m_layoutsColumnWidths = m_universalGroup.readEntry("layoutsColumnWidths", QStringList());
     m_launchers = m_universalGroup.readEntry("launchers", QStringList());
     m_metaPressAndHoldEnabled = m_universalGroup.readEntry("metaPressAndHoldEnabled", true);
     m_screenTrackerInterval = m_universalGroup.readEntry("screenTrackerInterval", 2500);
     m_showInfoWindow = m_universalGroup.readEntry("showInfoWindow", true);
     m_memoryUsage = static_cast<Types::LayoutsMemoryUsage>(m_universalGroup.readEntry("memoryUsage", (int)Types::SingleLayout));
     m_mouseSensitivity = static_cast<Types::MouseSensitivity>(m_universalGroup.readEntry("mouseSensitivity", (int)Types::HighSensitivity));
 
     loadScalesConfig();
 }
 
 void UniversalSettings::saveConfig()
 {
     m_universalGroup.writeEntry("version", m_version);
+    m_universalGroup.writeEntry("badges3DStyle", m_badges3DStyle);
     m_universalGroup.writeEntry("canDisableBorders", m_canDisableBorders);
     m_universalGroup.writeEntry("currentLayout", m_currentLayoutName);
     m_universalGroup.writeEntry("downloadWindowSize", m_downloadWindowSize);
     m_universalGroup.writeEntry("lastNonAssignedLayout", m_lastNonAssignedLayoutName);
     m_universalGroup.writeEntry("layoutsWindowSize", m_layoutsWindowSize);
     m_universalGroup.writeEntry("layoutsColumnWidths", m_layoutsColumnWidths);
     m_universalGroup.writeEntry("launchers", m_launchers);
     m_universalGroup.writeEntry("metaPressAndHoldEnabled", m_metaPressAndHoldEnabled);
     m_universalGroup.writeEntry("screenTrackerInterval", m_screenTrackerInterval);
     m_universalGroup.writeEntry("showInfoWindow", m_showInfoWindow);
     m_universalGroup.writeEntry("memoryUsage", (int)m_memoryUsage);
     m_universalGroup.writeEntry("mouseSensitivity", (int)m_mouseSensitivity);
 
     m_universalGroup.sync();
 }
 
 void UniversalSettings::cleanupSettings()
 {
     KConfigGroup containments = KConfigGroup(m_config, QStringLiteral("Containments"));
     containments.deleteGroup();
 
     containments.sync();
 }
 
 QString UniversalSettings::splitterIconPath()
 {
     return m_corona->kPackage().filePath("splitter");
 }
 
 QString UniversalSettings::trademarkIconPath()
 {
     return m_corona->kPackage().filePath("trademark");
 }
 
 QQmlListProperty<QScreen> UniversalSettings::screens()
 {
     return QQmlListProperty<QScreen>(this, nullptr, &countScreens, &atScreens);
 }
 
 int UniversalSettings::countScreens(QQmlListProperty<QScreen> *property)
 {
     Q_UNUSED(property)
     return qGuiApp->screens().count();
 }
 
 QScreen *UniversalSettings::atScreens(QQmlListProperty<QScreen> *property, int index)
 {
     Q_UNUSED(property)
     return qGuiApp->screens().at(index);
 }
 
 void UniversalSettings::loadScalesConfig()
 {
     for (const auto &screenName : m_screenScalesGroup.keyList()) {
         QString scalesStr = m_screenScalesGroup.readEntry(screenName, QString());
         QStringList scales = scalesStr.split(";");
         if (scales.count() == 2) {
             m_screenScales[screenName] = qMakePair(scales[0].toFloat(), scales[1].toFloat());
         }
     }
 }
 
 void UniversalSettings::saveScalesConfig()
 {
     for (const auto &screenName : m_screenScales.keys()) {
         QStringList scales;
         scales << QString::number(m_screenScales[screenName].first) << QString::number(m_screenScales[screenName].second);
         m_screenScalesGroup.writeEntry(screenName, scales.join(";"));
     }
 
     m_screenScalesGroup.sync();
 }
 
 }
diff --git a/app/settings/universalsettings.h b/app/settings/universalsettings.h
index 1b0842da..01caf1c6 100644
--- a/app/settings/universalsettings.h
+++ b/app/settings/universalsettings.h
@@ -1,206 +1,212 @@
 /*
 *  Copyright 2017  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 UNIVERSALSETTINGS_H
 #define UNIVERSALSETTINGS_H
 
 // local
 #include "../lattecorona.h"
 #include "../liblatte2/types.h"
 
 // Qt
 #include <QObject>
 #include <QAbstractItemModel>
 #include <QHash>
 #include <QPair>
 #include <QPointer>
 #include <QQmlListProperty>
 #include <QScreen>
 
 // KDE
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 namespace Latte {
 namespace Layouts {
 class Manager;
 }
 }
 
 namespace Latte {
 //width_scale, height_scale
 typedef QPair<float, float> ScreenScales;
 
 //! This class holds all the settings that are universally available
 //! independent of layouts
 class UniversalSettings : public QObject
 {
     Q_OBJECT
     Q_PROPERTY(bool autostart READ autostart WRITE setAutostart NOTIFY autostartChanged)
+    Q_PROPERTY(bool badges3DStyle READ badges3DStyle WRITE setBadges3DStyle NOTIFY badges3DStyleChanged)
     Q_PROPERTY(bool colorsScriptIsPresent READ colorsScriptIsPresent NOTIFY colorsScriptIsPresentChanged)
     Q_PROPERTY(bool showInfoWindow READ showInfoWindow WRITE setShowInfoWindow NOTIFY showInfoWindowChanged)
 
     Q_PROPERTY(QString currentLayoutName READ currentLayoutName WRITE setCurrentLayoutName NOTIFY currentLayoutNameChanged)
 
     Q_PROPERTY(QStringList launchers READ launchers WRITE setLaunchers NOTIFY launchersChanged)
 
     Q_PROPERTY(Latte::Types::MouseSensitivity mouseSensitivity READ mouseSensitivity WRITE setMouseSensitivity NOTIFY mouseSensitivityChanged)
 
     Q_PROPERTY(QQmlListProperty<QScreen> screens READ screens)
 
 public:
     UniversalSettings(KSharedConfig::Ptr config, QObject *parent = nullptr);
     ~UniversalSettings() override;
 
     void load();
 
     bool autostart() const;
     void setAutostart(bool state);
 
+    bool badges3DStyle() const;
+    void setBadges3DStyle(bool enable);
+
     bool canDisableBorders() const;
     void setCanDisableBorders(bool enable);
 
     bool colorsScriptIsPresent() const;
 
     bool metaForwardedToLatte() const;
     void forwardMetaToLatte(bool forward);
 
     bool metaPressAndHoldEnabled() const;
     void setMetaPressAndHoldEnabled(bool enabled);
 
     bool showInfoWindow() const;
     void setShowInfoWindow(bool show);
 
     int version() const;
     void setVersion(int ver);
 
     int screenTrackerInterval() const;
     void setScreenTrackerInterval(int duration);
 
     QString currentLayoutName() const;
     void setCurrentLayoutName(QString layoutName);
 
     QString lastNonAssignedLayoutName() const;
     void setLastNonAssignedLayoutName(QString layoutName);
 
     QSize downloadWindowSize() const;
     void setDownloadWindowSize(QSize size);
 
     QSize layoutsWindowSize() const;
     void setLayoutsWindowSize(QSize size);
 
     QStringList layoutsColumnWidths() const;
     void setLayoutsColumnWidths(QStringList widths);
 
     QStringList launchers() const;
     void setLaunchers(QStringList launcherList);
 
     Types::MouseSensitivity mouseSensitivity() const;
     void setMouseSensitivity(Types::MouseSensitivity sensitivity);
 
     QQmlListProperty<QScreen> screens();
     static int countScreens(QQmlListProperty<QScreen> *property); //! is needed by screens()
     static QScreen *atScreens(QQmlListProperty<QScreen> *property, int index); //! is needed by screens()
 
 public slots:
     Q_INVOKABLE QString splitterIconPath();
     Q_INVOKABLE QString trademarkIconPath();
 
     Q_INVOKABLE float screenWidthScale(QString screenName) const;
     Q_INVOKABLE float screenHeightScale(QString screenName) const;
     Q_INVOKABLE void setScreenScales(QString screenName, float widthScale, float heightScale);
 
 signals:
     void autostartChanged();
+    void badges3DStyleChanged();
     void canDisableBordersChanged();
     void colorsScriptIsPresentChanged();
     void currentLayoutNameChanged();
     void downloadWindowSizeChanged();
     void lastNonAssignedLayoutNameChanged();
     void layoutsColumnWidthsChanged();
     void layoutsWindowSizeChanged();
     void launchersChanged();
     void layoutsMemoryUsageChanged();
     void metaPressAndHoldEnabledChanged();
     void mouseSensitivityChanged();
     void screensCountChanged();
     void screenScalesChanged();
     void screenTrackerIntervalChanged();
     void showInfoWindowChanged();
     void versionChanged();
 
 private slots:
     void loadConfig();
     void loadScalesConfig();
     void saveConfig();
     void saveScalesConfig();
 
     void updateColorsScriptIsPresent();
     void colorsScriptChanged(const QString &file);
 
 private:
     void cleanupSettings();
 
     bool kwin_metaForwardedToLatte() const;
     void kwin_forwardMetaToLatte(bool forward);
 
     void setColorsScriptIsPresent(bool present);
 
     Types::LayoutsMemoryUsage layoutsMemoryUsage() const;
     void setLayoutsMemoryUsage(Types::LayoutsMemoryUsage layoutsMemoryUsage);
 
 private:
+    bool m_badges3DStyle{false};
     bool m_canDisableBorders{false};
     bool m_colorsScriptIsPresent{false};
     bool m_metaPressAndHoldEnabled{true};
     bool m_showInfoWindow{true};
 
     //when there isnt a version it is an old universal file
     int m_version{1};
 
     int m_screenTrackerInterval{2500};
 
     QString m_currentLayoutName;
     QString m_lastNonAssignedLayoutName;
     QSize m_downloadWindowSize{800, 550};
     QSize m_layoutsWindowSize{700, 450};
 
     QStringList m_layoutsColumnWidths;
     QStringList m_launchers;
 
     Types::LayoutsMemoryUsage m_memoryUsage;
     Types::MouseSensitivity m_mouseSensitivity{Types::HighSensitivity};
 
     //! ScreenName, <width_scale, height_scale>
     QHash<QString, ScreenScales> m_screenScales;
 
     QPointer<Latte::Corona> m_corona;
 
     KConfigGroup m_screenScalesGroup;
     KConfigGroup m_universalGroup;
     KSharedConfig::Ptr m_config;
 
     friend class Layouts::Manager;
     friend class Latte::Corona;
 };
 
 }
 
 #endif //UNIVERSALSETTINGS_H
diff --git a/containment/package/contents/ui/applet/ShortcutBadge.qml b/containment/package/contents/ui/applet/ShortcutBadge.qml
index 71e763b3..2c5392a4 100644
--- a/containment/package/contents/ui/applet/ShortcutBadge.qml
+++ b/containment/package/contents/ui/applet/ShortcutBadge.qml
@@ -1,119 +1,121 @@
 /*
 *  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/>.
 */
 
 import QtQuick 2.1
 import QtGraphicalEffects 1.0
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 Loader{
     id: appletNumberLoader
 
     active: appletItem.canShowAppletNumberBadge &&
             (root.showLatteShortcutBadges
              || root.showAppletShortcutBadges
              || root.showMetaBadge && applet.id===applicationLauncherId)
 
     asynchronous: true
     visible: badgeString!==""
 
     property int fixedIndex: -1
     property string badgeString: ""
 
     onActiveChanged: {
         if (active && root.showLatteShortcutBadges && root.unifiedGlobalShortcuts) {
             fixedIndex = parabolicManager.pseudoAppletIndex(index);
         } else {
             fixedIndex = -1;
         }
     }
 
     Component.onCompleted: {
         if (active && root.showLatteShortcutBadges && root.unifiedGlobalShortcuts) {
             fixedIndex = parabolicManager.pseudoAppletIndex(index);
         } else {
             fixedIndex = -1;
         }
     }
 
     Binding{
         target: appletNumberLoader
         property:"badgeString"
         value: {
             //! don't change value on hiding/releasing
             if (!root.showMetaBadge && !root.showAppletShortcutBadges) {
                 return;
             }
 
             if (root.showAppletShortcutBadges) {
                 var plasmaShortcut = applet ? shortcutsEngine.appletShortcutBadge(applet.id) : "";
 
                 if (plasmaShortcut !== "") {
                     return plasmaShortcut;
                 }
             }
 
             if (root.showMetaBadge && applet && applet.id === applicationLauncherId) {
                 return '\u2318';
             } else if (appletNumberLoader.fixedIndex>=1 && appletNumberLoader.fixedIndex<20) {
                 return root.badgesForActivate[appletNumberLoader.fixedIndex-1];
             } else {
                 return "";
             }
         }
     }
 
     sourceComponent: Item{
         Loader{
             anchors.fill: appletNumber
             active: root.enableShadows
 
             sourceComponent: DropShadow{
                 color: root.appShadowColor
                 fast: true
                 samples: 2 * radius
                 source: appletNumber
                 radius: root.appShadowSize/2
                 verticalOffset: 2
             }
         }
 
         LatteComponents.BadgeText {
             id: appletNumber
 
             // when iconSize < 48, height is always = 24, height / iconSize > 50%
             // we prefer center aligned badges to top-left aligned ones
             property bool centerInParent: root.iconSize < 48
 
             anchors.left: centerInParent? undefined : parent.left
             anchors.top: centerInParent? undefined : parent.top
             anchors.centerIn: centerInParent? parent : undefined
             minimumWidth: 0.4 * (wrapper.zoomScale * root.iconSize)
             height: Math.max(24, 0.4 * (wrapper.zoomScale * root.iconSize))
 
             borderColor: colorizerManager.originalLightTextColor
             proportion: 0
             radiusPerCentage: 100
             showNumber: false
             showText: true
             textValue: appletNumberLoader.badgeString
+
+            style3d: root.badges3DStyle
         }
     }
 }
diff --git a/containment/package/contents/ui/main.qml b/containment/package/contents/ui/main.qml
index 61fcf099..b674fa6b 100644
--- a/containment/package/contents/ui/main.qml
+++ b/containment/package/contents/ui/main.qml
@@ -1,1894 +1,1895 @@
 /*
 *  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.Layouts 1.1
 import QtQuick.Window 2.2
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.kquickcontrolsaddons 2.0
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "applet" as Applet
 import "colorizer" as Colorizer
 import "editmode" as EditMode
 import "indicators" as Indicators
 import "layouts" as Layouts
 import "../code/LayoutManager.js" as LayoutManager
 
 Item {
     id: root
     objectName: "containmentViewLayout"
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.isVertical
     LayoutMirroring.childrenInherit: true
 
     //// BEGIN SIGNALS
     signal clearZoomSignal();
     signal destroyInternalViewSplitters();
     signal emptyAreasWheel(QtObject wheel);
     signal separatorsUpdated();
     signal signalActivateEntryAtIndex(int entryIndex);
     signal signalNewInstanceForEntryAtIndex(int entryIndex);
     signal updateEffectsArea();
     signal updateIndexes();
     signal updateScale(int delegateIndex, real newScale, real step);
 
     signal broadcastedToApplet(string pluginName, string action, variant value);
     //// END SIGNALS
 
     ////BEGIN properties
     property bool debugMode: Qt.application.arguments.indexOf("--graphics")>=0
     property bool debugModeSpacers: Qt.application.arguments.indexOf("--spacers")>=0
     property bool debugModeTimers: Qt.application.arguments.indexOf("--timers")>=0
     property bool debugModeWindow: Qt.application.arguments.indexOf("--with-window")>=0
     property bool debugModeOverloadedIcons: Qt.application.arguments.indexOf("--overloaded-icons")>=0
 
     readonly property int version: Latte.WindowSystem.makeVersion(0,9,0)
 
     property bool globalDirectRender: false //it is used as a globalDirectRender for all elements in the dock
     property int directRenderAnimationTime: 0
 
     property bool addLaunchersMessage: false
     property bool addLaunchersInTaskManager: plasmoid.configuration.addLaunchersInTaskManager
     // when there are only plasma style task managers OR any applets that fill width or height
     // the automatic icon size algorithm should better be disabled
     property bool autoDecreaseIconSize: !containsOnlyPlasmaTasks && layoutsContainer.fillApplets<=0
     property bool backgroundOnlyOnMaximized: plasmoid.configuration.backgroundOnlyOnMaximized
     property bool behaveAsPlasmaPanel: {
         if (!latteView || !latteView.visibility) {
             return false;
         }
 
         return (visibilityManager.panelIsBiggerFromIconSize && (maxZoomFactor === 1.0)
                 && (latteView.visibility.mode === Latte.Types.AlwaysVisible || latteView.visibility.mode === Latte.Types.WindowsGoBelow)
                 && (plasmoid.configuration.panelPosition === Latte.Types.Justify)
                 && !root.editMode);
     }
 
     property int viewType: {
         if ((plasmoid.configuration.panelPosition === Latte.Types.Justify)
                 && (plasmoid.configuration.useThemePanel)
                 && (plasmoid.configuration.panelSize === 100)
                 && (maxZoomFactor === 1.0)) {
             return Latte.Types.PanelView;
         }
 
         return Latte.Types.DockView;
     }
 
     property bool blurEnabled: plasmoid.configuration.blurEnabled && (!forceTransparentPanel || forcePanelForBusyBackground)
 
     readonly property Item dragInfo: Item {
         property bool entered: backDropArea.dragInfo.entered || foreDropArea.dragInfo.entered
         property bool isTask: backDropArea.dragInfo.isTask || foreDropArea.dragInfo.isTask
         property bool isPlasmoid: backDropArea.dragInfo.isPlasmoid || foreDropArea.dragInfo.isPlasmoid
         property bool isSeparator: backDropArea.dragInfo.isSeparator || foreDropArea.dragInfo.isSeparator
         property bool isLatteTasks: backDropArea.dragInfo.isLatteTasks || foreDropArea.dragInfo.isLatteTasks
         property bool onlyLaunchers: backDropArea.dragInfo.onlyLaunchers || foreDropArea.dragInfo.onlyLaunchers
 
         //  onIsPlasmoidChanged: console.log("isPlasmoid :: " + backDropArea.dragInfo.isPlasmoid + " _ " + foreDropArea.dragInfo.isPlasmoid );
         //  onEnteredChanged: console.log("entered :: " + backDropArea.dragInfo.entered + " _ " + foreDropArea.dragInfo.entered );
     }
 
     property bool containsOnlyPlasmaTasks: false //this is flag to indicate when from tasks only a plasma based one is found
     property bool dockContainsMouse: latteView && latteView.visibility ? latteView.visibility.containsMouse : false
 
     property bool disablePanelShadowMaximized: plasmoid.configuration.disablePanelShadowForMaximized && Latte.WindowSystem.compositingActive
     property bool drawShadowsExternal: panelShadowsActive && behaveAsPlasmaPanel && !visibilityManager.inTempHiding
     property bool editMode: editModeVisual.inEditMode
     property bool windowIsTouching: latteView && latteView.windowsTracker
                                     && (latteView.windowsTracker.currentScreen.activeWindowTouching || hasExpandedApplet)
 
     property bool forceSolidPanel: (latteView && latteView.visibility
                                     && Latte.WindowSystem.compositingActive
                                     && !inConfigureAppletsMode
                                     && userShowPanelBackground
                                     && ( (plasmoid.configuration.solidBackgroundForMaximized
                                           && !(hasExpandedApplet && !plasmaBackgroundForPopups)
                                           && latteView.windowsTracker.currentScreen.existsWindowTouching)
                                         || (hasExpandedApplet && plasmaBackgroundForPopups) ))
                                    || !Latte.WindowSystem.compositingActive
 
     property bool forceTransparentPanel: root.backgroundOnlyOnMaximized
                                          && latteView && latteView.visibility
                                          && Latte.WindowSystem.compositingActive
                                          && !inConfigureAppletsMode
                                          && !forceSolidPanel
                                          && !(windowColors === Latte.Types.TouchingWindowColors && latteView.windowsTracker.currentScreen.activeWindowTouching)
                                          && !(windowColors === Latte.Types.ActiveWindowColors && selectedWindowsTracker.existsWindowActive)
 
     property bool forcePanelForBusyBackground: userShowPanelBackground && root.forceTransparentPanel
                                                && colorizerManager.mustBeShown && colorizerManager.backgroundIsBusy
 
     property int themeColors: plasmoid.configuration.themeColors
     property int windowColors: plasmoid.configuration.windowColors
 
     property bool colorizerEnabled: themeColors !== Latte.Types.PlasmaThemeColors || windowColors !== Latte.Types.NoneWindowColors
 
     property bool plasmaBackgroundForPopups: plasmoid.configuration.plasmaBackgroundForPopups
 
     readonly property bool hasExpandedApplet: plasmoid.applets.some(function (item) {
         return (item.status >= PlasmaCore.Types.NeedsAttentionStatus && item.status !== PlasmaCore.Types.HiddenStatus
                 && item.pluginName !== root.plasmoidName
                 && item.pluginName !== "org.kde.plasma.appmenu"
                 && item.pluginName !== "org.kde.windowappmenu"
                 && item.pluginName !== "org.kde.activeWindowControl");
     })
 
     readonly property bool hasUserSpecifiedBackground: (latteView && latteView.layout && latteView.layout.background.startsWith("/")) ?
                                                            true : false
 
     readonly property bool inConfigureAppletsMode: root.editMode && (plasmoid.configuration.inConfigureAppletsMode || !Latte.WindowSystem.compositingActive)
     readonly property bool parabolicEffectEnabled: zoomFactor>1 && !inConfigureAppletsMode
 
     property bool dockIsShownCompletely: !(dockIsHidden || inSlidingIn || inSlidingOut) && !root.editMode
     property bool dragActiveWindowEnabled: plasmoid.configuration.dragActiveWindowEnabled
     property bool immutable: plasmoid.immutable
     property bool inFullJustify: (plasmoid.configuration.panelPosition === Latte.Types.Justify) && (plasmoid.configuration.maxLength===100)
     property bool inSlidingIn: visibilityManager ? visibilityManager.inSlidingIn : false
     property bool inSlidingOut: visibilityManager ? visibilityManager.inSlidingOut : false
     property bool inStartup: true
     property bool isHalfShown: false //is used to disable the zoom hovering effect at sliding in-out the dock
     property bool isHorizontal: plasmoid.formFactor === PlasmaCore.Types.Horizontal
     property bool isReady: !(dockIsHidden || inSlidingIn || inSlidingOut)
     property bool isVertical: !isHorizontal
     property bool isHovered: latteApplet ? ((latteAppletHoveredIndex !== -1) || (layoutsContainer.hoveredIndex !== -1)) //|| wholeArea.containsMouse
                                          : (layoutsContainer.hoveredIndex !== -1) //|| wholeArea.containsMouse
     property bool mouseWheelActions: plasmoid.configuration.mouseWheelActions
     property bool onlyAddingStarup: true //is used for the initialization phase in startup where there aren't removals, this variable provides a way to grow icon size
     property bool shrinkThickMargins: plasmoid.configuration.shrinkThickMargins
     property bool showLatteShortcutBadges: false
     property bool showAppletShortcutBadges: false
     property bool showMetaBadge: false
     property int applicationLauncherId: -1
 
     //FIXME: possibly this is going to be the default behavior, this user choice
     //has been dropped from the Dock Configuration Window
     //property bool smallAutomaticIconJumps: plasmoid.configuration.smallAutomaticIconJumps
     property bool smallAutomaticIconJumps: true
 
     property bool userShowPanelBackground: Latte.WindowSystem.compositingActive ? plasmoid.configuration.useThemePanel : true
     property bool useThemePanel: noApplets === 0 || !Latte.WindowSystem.compositingActive ?
                                      true : (plasmoid.configuration.useThemePanel || plasmoid.configuration.solidBackgroundForMaximized)
 
     property alias hoveredIndex: layoutsContainer.hoveredIndex
     property alias directRenderDelayerIsRunning: directRenderDelayerForEnteringTimer.running
 
     property int actionsBlockHiding: 0 //actions that block hiding
 
     property int animationsNeedBothAxis:0 //animations need space in both axes, e.g zooming a task
     property int animationsNeedLength: 0 // animations need length, e.g. adding a task
     property int animationsNeedThickness: 0 // animations need thickness, e.g. bouncing animation
     readonly property bool thickAnimated: animationsNeedBothAxis>0 || animationsNeedThickness>0
 
     property int animationTime: durationTime*2.8*units.longDuration
 
     property int appletsNeedWindowsTracking: 0
 
     property int automaticIconSizeBasedSize: -1 //it is not set, this is the defautl
 
     //what is the highest icon size based on what icon size is used, screen calculated or user specified
     property int maxIconSize: proportionIconSize!==-1 ? proportionIconSize : plasmoid.configuration.iconSize
     property int iconSize: automaticIconSizeBasedSize > 0 && autoDecreaseIconSize ?
                                Math.min(automaticIconSizeBasedSize, root.maxIconSize) :
                                root.maxIconSize
 
     property int proportionIconSize: { //icon size based on screen height
         if ((plasmoid.configuration.proportionIconSize===-1) || !latteView)
             return -1;
 
         return Math.max(16,Math.round(latteView.screenGeometry.height * plasmoid.configuration.proportionIconSize/100/8)*8);
     }
 
     property int iconStep: 8
     property int latteAppletPos: -1
     property int maxLength: {
         if (root.isHorizontal) {
             return behaveAsPlasmaPanel ? width : width * (plasmoid.configuration.maxLength/100)
         } else {
             return behaveAsPlasmaPanel ? height : height * (plasmoid.configuration.maxLength/100)
         }
     }
 
     property int leftClickAction: plasmoid.configuration.leftClickAction
     property int middleClickAction: plasmoid.configuration.middleClickAction
     property int hoverAction: plasmoid.configuration.hoverAction
     property int modifier: plasmoid.configuration.modifier
     property int modifierClickAction: plasmoid.configuration.modifierClickAction
     property int modifierClick: plasmoid.configuration.modifierClick
     property int scrollAction: plasmoid.configuration.scrollAction
 
     property bool panelOutline: plasmoid.configuration.panelOutline
     property int panelEdgeSpacing: Math.max(panelBoxBackground.lengthMargins, 1.5*appShadowSize)
     property int panelTransparency: plasmoid.configuration.panelTransparency //user set
     property int currentPanelTransparency: 0 //application override
 
     readonly property real currentPanelOpacity: currentPanelTransparency/100
 
     property bool panelShadowsActive: {
         if (!userShowPanelBackground) {
             return false;
         }
 
         if (inConfigureAppletsMode) {
             return plasmoid.configuration.panelShadows;
         }
 
         var transparencyCheck = (blurEnabled || (!blurEnabled && currentPanelTransparency>20));
 
         //! Draw shadows for isBusy state only when current panelTransparency is greater than 10%
         if (plasmoid.configuration.panelShadows && root.forcePanelForBusyBackground && transparencyCheck) {
             return true;
         }
 
         if (( (plasmoid.configuration.panelShadows && !root.backgroundOnlyOnMaximized)
              || (plasmoid.configuration.panelShadows && root.backgroundOnlyOnMaximized && !root.forceTransparentPanel))
                 && !(disablePanelShadowMaximized && latteView && latteView.windowsTracker
                      && latteView.windowsTracker.currentScreen.activeWindowMaximized)) {
             return true;
         }
 
         if (hasExpandedApplet && plasmaBackgroundForPopups) {
             return true;
         }
 
         return false;
     }
 
     property int appShadowOpacity: (plasmoid.configuration.shadowOpacity/100) * 255
     property int appShadowSize: enableShadows ? (0.5*root.iconSize) * (plasmoid.configuration.shadowSize/100) : 0
     property int appShadowSizeOriginal: enableShadows ? (0.5*maxIconSize) * (plasmoid.configuration.shadowSize/100) : 0
 
     property string appChosenShadowColor: {
         if (plasmoid.configuration.shadowColorType === Latte.Types.ThemeColorShadow) {
             var strC = String(theme.textColor);
             return strC.indexOf("#") === 0 ? strC.substr(1) : strC;
         } else if (plasmoid.configuration.shadowColorType === Latte.Types.UserColorShadow) {
             return plasmoid.configuration.shadowColor;
         }
 
         // default shadow color
         return "080808";
     }
 
     property string appShadowColor: "#" + decimalToHex(appShadowOpacity) + appChosenShadowColor
     property string appShadowColorSolid: "#" + appChosenShadowColor
 
     property int totalPanelEdgeSpacing: 0 //this is set by PanelBox
     //FIXME: this is not needed any more probably
     property int previousAllTasks: -1    //is used to forbid updateAutomaticIconSize when hovering
     property int offset: {
         if (behaveAsPlasmaPanel) {
             return 0;
         }
 
         if (root.isHorizontal) {
             return width * (plasmoid.configuration.offset/100);
         } else {
             height * (plasmoid.configuration.offset/100)
         }
     }
 
     //center the layout correctly when the user uses an offset
     property int offsetFixed: (offset===0 || panelAlignment === Latte.Types.Center || plasmoid.configuration.panelPosition === Latte.Types.Justify)?
                                   offset : offset+panelMarginLength/2+totalPanelEdgeSpacing/2
 
     property int realPanelSize: 0
     property int realPanelLength: 0
     property int realPanelThickness: 0
     //this is set by the PanelBox
     property int panelThickMarginBase: 0
     property int panelThickMarginHigh: 0
     property int panelMarginLength: 0
     property int panelShadow: 0 //shadowsSize
     property int editShadow: {
         if (!Latte.WindowSystem.compositingActive) {
             return 0;
         } else if (latteView && latteView.screenGeometry) {
             return latteView.screenGeometry.height/90;
         } else {
             return 7;
         }
     }
 
     property int themePanelThickness: {
         var panelBase = root.panelThickMarginHigh;
         var margin = shrinkThickMargins ? 0 : thickMargins;
         var maxPanelSize = (iconSize + margin) - panelBase;
         var percentage = Latte.WindowSystem.compositingActive ? plasmoid.configuration.panelSize/100 : 1;
         return Math.max(panelBase, panelBase + percentage*maxPanelSize);
     }
 
     property int lengthIntMargin: lengthIntMarginFactor * root.iconSize
     property int lengthExtMargin: lengthExtMarginFactor * root.iconSize
     property real lengthIntMarginFactor: indicators.isEnabled ? indicators.padding : 0
     property real lengthExtMarginFactor: plasmoid.configuration.lengthExtMargin / 100
 
     property real thickMarginFactor: {
         if (shrinkThickMargins) {
             return indicators.info.minThicknessPadding;
         }
 
         //0.075 old statesLineSize and 0.06 old default thickMargin
         return  Math.max(indicators.info.minThicknessPadding, plasmoid.configuration.thickMargin / 100)
     }
     property int thickMargin: thickMarginFactor * root.iconSize
 
     //! thickness margins are always two and equal in order for items
     //! to be always correctly centered
     property int thickMargins: 2 * thickMargin
 
     //it is used in order to not break the calculations for the thickness placement
     //especially in automatic icon sizes calculations
     property int maxThickMargin: thickMarginFactor * maxIconSize
 
     property int lengthMargin: lengthIntMargin + lengthExtMargin
     property int lengthMargins: 2 * lengthMargin
 
     property int widthMargins: root.isVertical ? thickMargins : lengthMargins
     property int heightMargins: root.isHorizontal ? thickMargins : lengthMargins
 
     property int internalWidthMargins: root.isVertical ? thickMargins : 2 * lengthIntMargin
     property int internalHeightMargins: root.isHorizontal ? thickMargins : 2 * lengthIntMargin
 
     ///FIXME: <delete both> I can't remember why this is needed, maybe for the anchorings!!! In order for the Double Layout to not mess the anchorings...
     //property int layoutsContainer.mainLayoutPosition: !plasmoid.immutable ? Latte.Types.Center : (root.isVertical ? Latte.Types.Top : Latte.Types.Left)
     //property int panelAlignment: plasmoid.configuration.panelPosition !== Latte.Types.Justify ? plasmoid.configuration.panelPosition : layoutsContainer.mainLayoutPosition
 
     property int panelAlignment: !root.inConfigureAppletsMode ? plasmoid.configuration.panelPosition :
                                                                 ( plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                                                      Latte.Types.Center : plasmoid.configuration.panelPosition )
 
     property int panelUserSetAlignment: plasmoid.configuration.panelPosition
 
     property real zoomFactor: Latte.WindowSystem.compositingActive && root.animationsEnabled ? ( 1 + (plasmoid.configuration.zoomLevel / 20) ) : 1
 
     readonly property string plasmoidName: "org.kde.latte.plasmoid"
 
     property var badgesForActivate: {
         if (!shortcutsEngine) {
             return ['1','2','3','4','5','6','7','8','9','0', 'z', 'x', 'c', 'v', 'b', 'n', 'm', ',', '.'];
         }
 
         return shortcutsEngine.badgesForActivate;
     }
 
     property var iconsArray: [16, 22, 32, 48, 64, 96, 128, 256]
 
     property Item dragOverlay
     property Item toolBox
     property Item latteAppletContainer
     property Item latteApplet
     readonly property Item indicatorsManager: indicators
     readonly property Item parabolicManager: _parabolicManager
     readonly property Item maskManager: visibilityManager
     readonly property Item layoutsContainerItem: layoutsContainer
 
     property QtObject latteView: null
     property QtObject shortcutsEngine: null
     property QtObject themeExtended: null
     property QtObject universalSettings: null
     property QtObject layoutsManager: null
     property QtObject viewLayout: latteView && latteView.layout ? latteView.layout : null
     property QtObject selectedWindowsTracker: {
         if (latteView && latteView.windowsTracker) {
             switch(plasmoid.configuration.activeWindowFilter) {
             case Latte.Types.ActiveInCurrentScreen:
                 return latteView.windowsTracker.currentScreen;
             case Latte.Types.ActiveFromAllScreens:
                 return latteView.windowsTracker.allScreens;
             }
         }
 
         return null;
     }
 
     // TO BE DELETED, if not needed: property int counter:0;
 
     ///BEGIN properties provided to Latte Plasmoid
     //shadows for applets, it should be removed as the appleitems don't need it any more
+    property bool badges3DStyle: universalSettings ? universalSettings.badges3DStyle : true
     property bool enableShadows: plasmoid.configuration.shadows || (root.forceTransparentPanel && plasmoid.configuration.shadows>0)
     property bool dockIsHidden: latteView ? latteView.visibility.isHidden : true
     property bool groupTasksByDefault: plasmoid.configuration.groupTasksByDefault
 
     property bool showInfoBadge: plasmoid.configuration.showInfoBadge
     property bool showProgressBadge: plasmoid.configuration.showProgressBadge
     property bool showAudioBadge: plasmoid.configuration.showAudioBadge
     property bool audioBadgeActionsEnabled: plasmoid.configuration.audioBadgeActionsEnabled
     property bool infoBadgeProminentColorEnabled: plasmoid.configuration.infoBadgeProminentColorEnabled
 
     property bool scrollTasksEnabled: plasmoid.configuration.scrollTasksEnabled
     property bool autoScrollTasksEnabled: plasmoid.configuration.autoScrollTasksEnabled
     property int manualScrollTasksType: plasmoid.configuration.manualScrollTasksType
 
     property bool showWindowActions: plasmoid.configuration.showWindowActions
     property bool showWindowsOnlyFromLaunchers: plasmoid.configuration.showWindowsOnlyFromLaunchers
     property bool showOnlyCurrentScreen: plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: plasmoid.configuration.showOnlyCurrentActivity
 
     property bool titleTooltips: plasmoid.configuration.titleTooltips
     property bool unifiedGlobalShortcuts: plasmoid.configuration.unifiedGlobalShortcuts
 
     readonly property bool hasInternalSeparator: latteApplet ? latteApplet.hasInternalSeparator : false
 
     property int animationStep: {
         if (!universalSettings || universalSettings.mouseSensitivity === Latte.Types.HighSensitivity) {
             return 1;
         } else if (universalSettings.mouseSensitivity === Latte.Types.MediumSensitivity) {
             return Math.max(3, root.iconSize / 18);
         } else if (universalSettings.mouseSensitivity === Latte.Types.LowSensitivity) {
             return Math.max(5, root.iconSize / 10);
         }
     }
 
     property int latteAppletHoveredIndex: latteApplet ? latteApplet.hoveredIndex : -1
     property int launchersGroup: plasmoid.configuration.launchersGroup
     property int tasksCount: latteApplet ? latteApplet.tasksCount : 0
 
     //! Animations
     property bool animationsEnabled: plasmoid.configuration.animationsEnabled && Latte.WindowSystem.compositingActive
     property bool animationLauncherBouncing: animationsEnabled && latteApplet && plasmoid.configuration.animationLauncherBouncing
     property bool animationWindowInAttention: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowInAttention
     property bool animationNewWindowSliding: animationsEnabled && latteApplet && plasmoid.configuration.animationNewWindowSliding
     property bool animationWindowAddedInGroup: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowAddedInGroup
     property bool animationWindowRemovedFromGroup: animationsEnabled && latteApplet && plasmoid.configuration.animationWindowRemovedFromGroup
 
     property real appliedDurationTime: animationsEnabled ? durationTime : 2
     property real durationTime: {
         if (!animationsEnabled) {
             return 0;
         }
 
         /*if ((latteView && latteView.effects && latteView.effects.animationsBlocked)
                 || !animationsEnabled) {
             return 0;
         }*/
 
         if (plasmoid.configuration.durationTime === 0 || plasmoid.configuration.durationTime === 2 )
             return plasmoid.configuration.durationTime;
 
         if (plasmoid.configuration.durationTime === 1)
             return 1.65;
         else if (plasmoid.configuration.durationTime === 3)
             return 2.35;
 
         return 2;
     }
 
     property real animationsZoomFactor : {
         if (!animationsEnabled) {
             return 1;
         }
 
         if (latteApplet && (animationLauncherBouncing || animationWindowInAttention || animationWindowAddedInGroup)) {
             return 1.65;
         }
 
         return 1;
     }
 
     property real maxZoomFactor: Math.max(zoomFactor, animationsZoomFactor)
 
     property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property color minimizedDotColor: colorizerManager.minimizedDotColor
     ///END properties from latteApplet
 
 
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     //// BEGIN properties in functions
     property int noApplets: {
         var count1 = 0;
         var count2 = 0;
 
         count1 = layoutsContainer.mainLayout.children.length;
         var tempLength = layoutsContainer.mainLayout.children.length;
 
         for (var i=tempLength-1; i>=0; --i) {
             var applet = layoutsContainer.mainLayout.children[i];
             if (applet && (applet === dndSpacer || applet === lastSpacer ||  applet.isInternalViewSplitter))
                 count1--;
         }
 
         count2 = layoutsContainer.endLayout.children.length;
         tempLength = layoutsContainer.endLayout.children.length;
 
         for (var i=tempLength-1; i>=0; --i) {
             var applet = layoutsContainer.endLayout.children[i];
             if (applet && (applet === dndSpacer || applet === lastSpacer  || applet.isInternalViewSplitter))
                 count2--;
         }
 
         return (count1 + count2);
     }
 
     ///The index of user's current icon size
     property int currentIconIndex:{
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === iconSize){
                 return i;
             }
         }
         return 3;
     }
 
     //// END properties in functions
 
     ////////////////END properties
 
     //// BEGIN OF Behaviors
     Behavior on thickMargin {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on lengthIntMargin {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on lengthExtMargin {
         NumberAnimation {
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
 
     Behavior on iconSize {
         enabled: !(root.editMode && root.behaveAsPlasmaPanel)
         NumberAnimation {
             duration: 0.8 * root.animationTime
 
             onRunningChanged: {
                 if (!running) {
                     delayUpdateMaskArea.start();
                 }
             }
         }
     }
 
     Behavior on offset {
         enabled: editModeVisual.editAnimationInFullThickness
         NumberAnimation {
             id: offsetAnimation
 
             duration: 0.8 * root.animationTime
             easing.type: Easing.OutCubic
         }
     }
     //// END OF Behaviors
 
     //////////////START OF CONNECTIONS
     onContainsOnlyPlasmaTasksChanged: updateAutomaticIconSize();
 
     onEditModeChanged: {
         if (editMode) {
             visibilityManager.updateMaskArea();
             updateAutomaticIconSize();
             clearZoom();
         } else {
             updateAutomaticIconSize();
             layoutsContainer.updateSizeForAppletsInFill();
         }
 
         //! This is used in case the dndspacer has been left behind
         //! e.g. the user drops a folder and a context menu is appearing
         //! but the user decides to not make a choice for the applet type
         if (dndSpacer.parent !== root) {
             dndSpacer.parent = root;
         }
     }
 
     onInConfigureAppletsModeChanged: {
         if (inConfigureAppletsMode && panelUserSetAlignment===Latte.Types.Justify) {
             joinLayoutsToMainLayout();
         } else if (!inConfigureAppletsMode) {
             splitMainLayoutToLayouts();
         }
 
         updateIndexes();
     }
 
     //! It is used only when the user chooses different alignment types
     //! and not during startup
     onPanelUserSetAlignmentChanged: {
         if (!root.editMode) {
             return;
         }
 
         if (!inConfigureAppletsMode){
             if (panelUserSetAlignment===Latte.Types.Justify) {
                 addInternalViewSplitters();
                 splitMainLayoutToLayouts();
             } else {
                 joinLayoutsToMainLayout();
                 root.destroyInternalViewSplitters();
             }
         } else {
             if (panelUserSetAlignment===Latte.Types.Justify) {
                 addInternalViewSplitters();
             } else {
                 root.destroyInternalViewSplitters();
             }
         }
 
         LayoutManager.save();
         updateIndexes();
     }
 
     onLatteViewChanged: {
         if (latteView) {
             latteView.onXChanged.connect(visibilityManager.updateMaskArea);
             latteView.onYChanged.connect(visibilityManager.updateMaskArea);
             latteView.onWidthChanged.connect(visibilityManager.updateMaskArea);
             latteView.onHeightChanged.connect(visibilityManager.updateMaskArea);
 
             latteView.positioner.hideDockDuringLocationChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.connect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.connect(visibilityManager.slotShowDockAfterLocationChange);
 
 
             latteView.visibility.onContainsMouseChanged.connect(visibilityManager.slotContainsMouseChanged);
             latteView.visibility.onMustBeHide.connect(visibilityManager.slotMustBeHide);
             latteView.visibility.onMustBeShown.connect(visibilityManager.slotMustBeShown);
 
             updateContainsOnlyPlasmaTasks();
         }
     }
 
     onDockContainsMouseChanged: {
         if (!dockContainsMouse) {
             initializeHoveredIndexes();
         }
     }
 
     onMaxLengthChanged: {
         layoutsContainer.updateSizeForAppletsInFill();
         if (root.editMode) {
             updateAutomaticIconSize();
         }
     }
 
     onToolBoxChanged: {
         if (toolBox) {
             toolBox.visible = false;
         }
     }
 
     property bool automaticSizeAnimation: false;
     onAutomaticIconSizeBasedSizeChanged: {
         if (!automaticSizeAnimation) {
             automaticSizeAnimation = true;
             slotAnimationsNeedBothAxis(1);
         }
     }
 
     onIconSizeChanged: {
         if (((iconSize === automaticIconSizeBasedSize) || (iconSize === root.maxIconSize)) && automaticSizeAnimation){
             slotAnimationsNeedBothAxis(-1);
             automaticSizeAnimation=false;
         }
     }
 
     onIsReadyChanged: {
         if (isReady && !titleTooltipDialog.visible && titleTooltipDialog.activeItemHovered){
             titleTooltipDialog.show(titleTooltipDialog.activeItem, titleTooltipDialog.activeItemText);
         }
     }
 
     onIsVerticalChanged: {
         if (isVertical) {
             if (plasmoid.configuration.panelPosition === Latte.Types.Left)
                 plasmoid.configuration.panelPosition = Latte.Types.Top;
             else if (plasmoid.configuration.panelPosition === Latte.Types.Right)
                 plasmoid.configuration.panelPosition = Latte.Types.Bottom;
         } else {
             if (plasmoid.configuration.panelPosition === Latte.Types.Top)
                 plasmoid.configuration.panelPosition = Latte.Types.Left;
             else if (plasmoid.configuration.panelPosition === Latte.Types.Bottom)
                 plasmoid.configuration.panelPosition = Latte.Types.Right;
         }
     }
 
     onProportionIconSizeChanged: {
         if (proportionIconSize!==-1)
             updateAutomaticIconSize();
     }
 
     //  onIconSizeChanged: console.log("Icon Size Changed:"+iconSize);
 
     Component.onCompleted: {
         //  currentLayout.isLayoutHorizontal = isHorizontal
         LayoutManager.plasmoid = plasmoid;
         LayoutManager.root = root;
         LayoutManager.layout = layoutsContainer.mainLayout;
         LayoutManager.layoutS = layoutsContainer.startLayout;
         LayoutManager.layoutE = layoutsContainer.endLayout;
         LayoutManager.lastSpacer = lastSpacer;
         LayoutManager.restore();
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         inStartupTimer.start();
     }
 
     Component.onDestruction: {
         console.debug("Destroying Latte Dock Containment ui...");
 
         if (latteView) {
             latteView.onXChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onYChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onWidthChanged.disconnect(visibilityManager.updateMaskArea);
             latteView.onHeightChanged.disconnect(visibilityManager.updateMaskArea);
 
             latteView.positioner.hideDockDuringLocationChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterLocationChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringScreenChangeStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterScreenChangeFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
             latteView.positioner.hideDockDuringMovingToLayoutStarted.disconnect(visibilityManager.slotHideDockDuringLocationChange);
             latteView.positioner.showDockAfterMovingToLayoutFinished.disconnect(visibilityManager.slotShowDockAfterLocationChange);
 
             if (latteView.visibility) {
                 latteView.visibility.onContainsMouseChanged.disconnect(visibilityManager.slotContainsMouseChanged);
                 latteView.visibility.onMustBeHide.disconnect(visibilityManager.slotMustBeHide);
                 latteView.visibility.onMustBeShown.disconnect(visibilityManager.slotMustBeShown);
             }
         }
     }
 
     Containment.onAppletAdded: {
         addApplet(applet, x, y);
         console.log(applet.pluginName);
         LayoutManager.save();
         updateIndexes();
     }
 
     Containment.onAppletRemoved: {
         LayoutManager.removeApplet(applet);
         var flexibleFound = false;
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var applet = layoutsContainer.mainLayout.children[i].applet;
             if (applet && ((root.isHorizontal && applet.Layout.fillWidth) ||
                            (!root.isHorizontal && applet.Layout.fillHeight)) &&
                     applet.visible) {
                 flexibleFound = true;
                 break
             }
         }
         if (!flexibleFound) {
             lastSpacer.parent = layoutsContainer.mainLayout;
         }
 
         console.log(applet.pluginName);
         LayoutManager.save();
 
         updateIndexes();
         updateContainsOnlyPlasmaTasks();
     }
 
     Plasmoid.onUserConfiguringChanged: {
         if (plasmoid.immutable) {
             if (dragOverlay) {
                 dragOverlay.destroy();
             }
             return;
         }
 
         // console.debug("user configuring", plasmoid.userConfiguring)
 
         if (plasmoid.userConfiguring) {
             latteView.setBlockHiding(true);
 
             //  console.log("applets------");
             for (var i = 0; i < plasmoid.applets.length; ++i) {
                 //    console.log("applet:"+i);
                 plasmoid.applets[i].expanded = false;
             }
             if (!dragOverlay) {
                 var component = Qt.createComponent("editmode/ConfigOverlay.qml");
                 if (component.status == Component.Ready) {
                     dragOverlay = component.createObject(root);
                 } else {
                     console.log("Could not create ConfigOverlay");
                     console.log(component.errorString());
                 }
                 component.destroy();
             } else {
                 dragOverlay.visible = true;
             }
         } else {
             latteView.setBlockHiding(false);
 
             if (latteView.visibility.isHidden) {
                 latteView.visibility.mustBeShown();
             }
 
             if (dragOverlay) {
                 dragOverlay.visible = false;
                 dragOverlay.destroy();
             }
         }
     }
 
     Plasmoid.onImmutableChanged: {
         plasmoid.action("configure").visible = !plasmoid.immutable;
         plasmoid.action("configure").enabled = !plasmoid.immutable;
 
         ///Set Preferred Sizes///
         ///Notice: they are set here because if they are set with a binding
         ///they break the !immutable experience, the latteView becomes too small
         ///to add applets
         /*   if (plasmoid.immutable) {
             if(root.isHorizontal) {
                 root.Layout.preferredWidth = (plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                                   layoutsContainer.width + 0.5*iconMargin : layoutsContainer.mainLayout.width + iconMargin);
             } else {
                 root.Layout.preferredHeight = (plasmoid.configuration.panelPosition === Latte.Types.Justify ?
                                                    layoutsContainer.height + 0.5*iconMargin : layoutsContainer.mainLayout.height + iconMargin);
             }
         } else {
             if (root.isHorizontal) {
                 root.Layout.preferredWidth = Screen.width;
             } else {
                 root.Layout.preferredHeight = Screen.height;
             }
         }*/
 
         visibilityManager.updateMaskArea();
     }
     //////////////END OF CONNECTIONS
 
     //////////////START OF FUNCTIONS
     function addApplet(applet, x, y) {
         var container = appletContainerComponent.createObject(dndSpacer.parent)
 
         container.applet = applet;
         applet.parent = container.appletWrapper;
 
         applet.anchors.fill = container.appletWrapper;
 
         applet.visible = true;
 
 
         // don't show applet if it chooses to be hidden but still make it
         // accessible in the panelcontroller
         container.visible = Qt.binding(function() {
             return applet.status !== PlasmaCore.Types.HiddenStatus || (!plasmoid.immutable && root.inConfigureAppletsMode)
         })
 
         addContainerInLayout(container, applet, x, y);
 
         updateContainsOnlyPlasmaTasks();
     }
 
     function addContainerInLayout(container, applet, x, y){
         // Is there a DND placeholder? Replace it!
         if ( (dndSpacer.parent === layoutsContainer.mainLayout)
                 || (dndSpacer.parent === layoutsContainer.startLayout)
                 || (dndSpacer.parent===layoutsContainer.endLayout)) {
             LayoutManager.insertBeforeForLayout(dndSpacer.parent, dndSpacer, container);
             dndSpacer.parent = root;
             return;
             // If the provided position is valid, use it.
         } else if (x >= 0 && y >= 0) {
             var index = LayoutManager.insertAtCoordinates2(container, x , y);
 
             // Fall through to determining an appropriate insert position.
         } else {
             var before = null;
             container.animationsEnabled = false;
 
             if (lastSpacer.parent === layoutsContainer.mainLayout) {
                 before = lastSpacer;
             }
 
             // Insert icons to the left of whatever is at the center (usually a Task Manager),
             // if it exists.
             // FIXME TODO: This is a real-world fix to produce a sensible initial position for
             // launcher icons added by launcher menu applets. The basic approach has been used
             // since Plasma 1. However, "add launcher to X" is a generic-enough concept and
             // frequent-enough occurrence that we'd like to abstract it further in the future
             // and get rid of the ugliness of parties external to the containment adding applets
             // of a specific type, and the containment caring about the applet type. In a better
             // system the containment would be informed of requested launchers, and determine by
             // itself what it wants to do with that information.
             if (applet.pluginName == "org.kde.plasma.icon") {
                 var middle = layoutsContainer.mainLayout.childAt(root.width / 2, root.height / 2);
 
                 if (middle) {
                     before = middle;
                 }
 
                 // Otherwise if lastSpacer is here, enqueue before it.
             }
 
             if (before) {
                 LayoutManager.insertBefore(before, container);
 
                 // Fall through to adding at the end.
             } else {
                 container.parent = layoutsContainer.mainLayout;
             }
         }
 
         //Important, removes the first children of the layoutsContainer.mainLayout after the first
         //applet has been added
         lastSpacer.parent = root;
 
         updateIndexes();
     }
 
     function addInternalViewSplitters(){
         if (internalViewSplittersCount() === 0) {
             addInternalViewSplitter(plasmoid.configuration.splitterPosition);
             addInternalViewSplitter(plasmoid.configuration.splitterPosition2);
         }
     }
 
     function addInternalViewSplitter(pos){
         var splittersCount = internalViewSplittersCount();
         if(splittersCount<2){
             var container = appletContainerComponent.createObject(root);
 
             container.internalSplitterId = splittersCount+1;
             container.visible = true;
 
             if(pos>=0 ){
                 LayoutManager.insertAtIndex(container, pos);
             } else {
                 LayoutManager.insertAtIndex(container, Math.floor(layoutsContainer.mainLayout.count / 2));
             }
         }
     }
 
     //! it is used in order to check the right click position
     //! the only way to take into account the visual appearance
     //! of the applet (including its spacers)
     function appletContainsPos(appletId, pos){
         for (var i = 0; i < layoutsContainer.startLayout.children.length; ++i) {
             var child = layoutsContainer.startLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.mainLayout.children.length; ++i) {
             var child = layoutsContainer.mainLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         for (var i = 0; i < layoutsContainer.endLayout.children.length; ++i) {
             var child = layoutsContainer.endLayout.children[i];
 
             if (child && child.applet && child.applet.id === appletId && child.containsPos(pos))
                 return true;
         }
 
         return false;
     }
 
     function checkLastSpacer() {
         lastSpacer.parent = root
 
         var expands = false;
 
         if (isHorizontal) {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillWidth) {
                     expands = true;
                 }
             }
         } else {
             for (var container in layoutsContainer.mainLayout.children) {
                 var item = layoutsContainer.mainLayout.children[container];
                 if (item.Layout && item.Layout.fillHeight) {
                     expands = true;
                 }
             }
         }
         if (!expands) {
             lastSpacer.parent = layoutsContainer.mainLayout
         }
     }
 
     function clearZoom(){
         if (latteApplet){
             latteApplet.clearZoom();
         }
 
         root.clearZoomSignal();
     }
 
     function containmentActions(){
         return latteView.containmentActions();
     }
 
     function decimalToHex(d, padding) {
         var hex = Number(d).toString(16);
         padding = typeof (padding) === "undefined" || padding === null ? padding = 2 : padding;
 
         while (hex.length < padding) {
             hex = "0" + hex;
         }
 
         return hex;
     }
 
 
     function disableDirectRender(){
         //  root.globalDirectRender = false;
     }
 
     function internalViewSplittersCount(){
         var splitters = 0;
         for (var container in layoutsContainer.startLayout.children) {
             var item = layoutsContainer.startLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.mainLayout.children) {
             var item = layoutsContainer.mainLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         for (var container in layoutsContainer.endLayout.children) {
             var item = layoutsContainer.endLayout.children[container];
             if(item && item.isInternalViewSplitter) {
                 splitters = splitters + 1;
             }
         }
 
         return splitters;
     }
 
     function initializeHoveredIndexes() {
         layoutsContainer.hoveredIndex = -1;
         layoutsContainer.currentSpot = -1000;
         if (latteApplet) {
             latteApplet.initializeHoveredIndex();
         }
     }
 
     function layoutManager() {
         return LayoutManager;
     }
 
     function layoutManagerInsertBefore(place, item) {
         LayoutManager.insertBefore(place, item);
     }
 
     function layoutManagerInsertAfter(place, item) {
         LayoutManager.insertAfter(place, item);
     }
 
     function layoutManagerSave() {
         LayoutManager.save();
     }
 
     function layoutManagerSaveOptions() {
         LayoutManager.saveOptions();
     }
 
     function mouseInCanBeHoveredApplet(){
         if (latteApplet && latteApplet.containsMouse())
             return true;
 
         var applets = layoutsContainer.startLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         applets = layoutsContainer.mainLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         ///check second layout also
         applets = layoutsContainer.endLayout.children;
 
         for(var i=0; i<applets.length; ++i){
             var applet = applets[i];
 
             if(applet && applet.containsMouse && !applet.originalAppletBehavior && applet.canBeHovered){
                 return true;
             }
         }
 
         return false;
     }
 
     function mouseInHoverableArea() {
         return (latteView.visibility.containsMouse && !rootMouseArea.containsMouse && mouseInCanBeHoveredApplet());
     }
 
     function setHoveredIndex(ind) {
         layoutsContainer.hoveredIndex = ind;
     }
 
     function hideTooltipLabel(debug){
         titleTooltipDialog.hide(debug);
     }
 
     //! this is called from globalshortcuts c++ side
     function setShowAppletShortcutBadges(showLatteShortcuts, showShortcuts, showMeta, applicationLauncher){
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.setShowTaskShortcutBadges(showLatteShortcuts);
         }
 
         showLatteShortcutBadges = showLatteShortcuts;
         showAppletShortcutBadges = showShortcuts;
         showMetaBadge = showMeta;
         applicationLauncherId = applicationLauncher;
 
         if (latteApplet) {
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
     }
 
     // This is called by dockcorona in response to a Meta+number shortcut.
     function activateEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalActivateEntryAtIndex(index);
     }
 
     // This is called by dockcorona in response to a Meta+Alt+number shortcut.
     function newInstanceForEntryAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         if (latteApplet) {
             var base = unifiedGlobalShortcuts ? parabolicManager.pseudoAppletIndex(latteAppletPos) : 1;
             latteApplet.setTasksBaseIndex(base - 1);
             latteApplet.parabolicManager.updateTasksEdgesIndexes();
         }
 
         signalNewInstanceForEntryAtIndex(index);
     }
 
 
     function showTooltipLabel(taskItem, text){
         titleTooltipDialog.show(taskItem, text);
     }
 
     function sizeIsFromAutomaticMode(size){
 
         for(var i=iconsArray.length-1; i>=0; --i){
             if(iconsArray[i] === size){
                 return true;
             }
         }
 
         return false;
     }
 
     function slotAnimationsNeedBothAxis(step) {
         if (step === 0) {
             return;
         }
 
         animationsNeedBothAxis = Math.max(animationsNeedBothAxis + step, 0);
 
         visibilityManager.updateMaskArea();
     }
 
     function slotAnimationsNeedLength(step) {
         if (step === 0) {
             return;
         }
 
         animationsNeedLength = Math.max(animationsNeedLength + step, 0);
 
         //when need length animations are ended it would be a good idea
         //to update the tasks geometries in the plasmoid
         if(animationsNeedLength === 0 && latteApplet) {
             latteApplet.publishTasksGeometries();
         }
 
         visibilityManager.updateMaskArea();
     }
 
     function slotAnimationsNeedThickness(step) {
         if (step === 0) {
             return;
         }
 
         animationsNeedThickness = Math.max(animationsNeedThickness + step, 0);
 
         visibilityManager.updateMaskArea();
     }
 
     function slotAppletsNeedWindowsTracking(step) {
         if (step === 0) {
             return;
         }
 
         appletsNeedWindowsTracking = Math.max(appletsNeedWindowsTracking + step, 0);
     }
 
     //this is used when dragging a task in order to not hide the dock
     //and also by the menu appearing from tasks for the same reason
     function slotActionsBlockHiding(step) {
         //if (root.editMode) {
         //    return;
         // }
 
         if ((step === 0) || (!latteView)) {
             return;
         }
 
         actionsBlockHiding = Math.max(actionsBlockHiding + step, 0);
 
         if (actionsBlockHiding > 0){
             latteView.setBlockHiding(true);
         } else {
             if (!root.editMode)
                 latteView.setBlockHiding(false);
         }
     }
 
     function slotPreviewsShown(){
         if (latteView) {
             latteView.deactivateApplets();
         }
     }
 
     function startCheckRestoreZoomTimer(){
         checkRestoreZoom.start();
     }
 
     function stopCheckRestoreZoomTimer(){
         checkRestoreZoom.stop();
     }
 
     function startDirectRenderDelayerDuringEntering(){
         directRenderDelayerForEnteringTimer.start();
     }
 
     function setGlobalDirectRender(value) {
         if (latteApplet && latteApplet.tasksExtendedManager.waitingLaunchersLength() > 0)
             return;
 
         if (value === true) {
             if (mouseInCanBeHoveredApplet()) {
                 root.globalDirectRender = true;
             } else {
                 //    console.log("direct render true ignored...");
             }
         } else {
             root.globalDirectRender = false;
         }
     }
 
     function updateAutomaticIconSize() {
         if ( !blockAutomaticUpdateIconSize.running && !visibilityManager.inTempHiding
                 && ((visibilityManager.normalState || root.editMode)
                     && (root.autoDecreaseIconSize || (!root.autoDecreaseIconSize && root.iconSize!=root.maxIconSize)))
                 && (iconSize===root.maxIconSize || iconSize === automaticIconSizeBasedSize) ) {
             blockAutomaticUpdateIconSize.start();
 
             var layoutLength;
             var maxLength = root.maxLength;
 
             //console.log("------Entered check-----");
             //console.log("max length: "+ maxLength);
 
             if (root.isVertical) {
                 layoutLength = (plasmoid.configuration.panelPosition === Latte.Types.Justify) ?
                             layoutsContainer.startLayout.height+layoutsContainer.mainLayout.height+layoutsContainer.endLayout.height : layoutsContainer.mainLayout.height
             } else {
                 layoutLength = (plasmoid.configuration.panelPosition === Latte.Types.Justify) ?
                             layoutsContainer.startLayout.width+layoutsContainer.mainLayout.width+layoutsContainer.endLayout.width : layoutsContainer.mainLayout.width
             }
 
             var toShrinkLimit = maxLength-((root.zoomFactor-1)*(iconSize + thickMargins));
             var toGrowLimit = maxLength-1.5*((root.zoomFactor-1)*(iconSize + thickMargins));
 
             var newIconSizeFound = false;
             if (layoutLength > toShrinkLimit) { //must shrink
                 //  console.log("step3");
                 var nextIconSize = root.maxIconSize;
 
                 do {
                     nextIconSize = nextIconSize - iconStep;
                     var factor = nextIconSize / iconSize;
                     var nextLength = factor * layoutLength;
 
                 } while ( (nextLength>toShrinkLimit) && (nextIconSize !== 16));
 
                 automaticIconSizeBasedSize = nextIconSize;
                 newIconSizeFound = true;
                 console.log("Step 3 - found:"+automaticIconSizeBasedSize);
             } else if ((layoutLength<toGrowLimit
                         && (iconSize === automaticIconSizeBasedSize)) ) { //must grow probably
                 //  console.log("step4");
                 var nextIconSize2 = automaticIconSizeBasedSize;
                 var foundGoodSize = -1;
 
                 do {
                     nextIconSize2 = nextIconSize2 + iconStep;
                     var factor2 = nextIconSize2 / automaticIconSizeBasedSize;
                     var nextLength2 = factor2 * layoutLength;
 
                     if (nextLength2 < toGrowLimit) {
                         foundGoodSize = nextIconSize2;
                     }
                 } while ( (nextLength2<toGrowLimit) && (nextIconSize2 !== root.maxIconSize ));
 
                 if (foundGoodSize > 0) {
                     if (foundGoodSize === root.maxIconSize) {
                         automaticIconSizeBasedSize = -1;
                     } else {
                         automaticIconSizeBasedSize = foundGoodSize;
                     }
                     newIconSizeFound = true
                     //        console.log("Step 4 - found:"+automaticIconSizeBasedSize);
                 } else {
                     //       console.log("Step 4 - did not found...");
                 }
             }
         }
     }
 
     function updateContainsOnlyPlasmaTasks() {
         if (latteView) {
             root.containsOnlyPlasmaTasks = (latteView.tasksPresent() && !latteApplet);
         } else {
             root.containsOnlyPlasmaTasks = false;
         }
     }
 
     function updateSizeForAppletsInFill() {
         layoutsContainer.updateSizeForAppletsInFill();
     }
 
     function splitMainLayoutToLayouts() {
         if (internalViewSplittersCount() === 2) {
             console.log("LAYOUTS: Moving applets from MAIN to THREE Layouts mode...");
             var splitter = -1;
             var splitter2 = -1;
 
             var totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=0; i<totalChildren; ++i) {
                 var item = layoutsContainer.mainLayout.children[i];
 
                 if(item.isInternalViewSplitter && splitter === -1) {
                     splitter = i;
                 } else if (item.isInternalViewSplitter && splitter>=0 && splitter2 === -1) {
                     splitter2 = i;
                 }
             }
 
             // console.log("update layouts 1:"+splitter + " - "+splitter2);
             for (var i=0; i<=splitter; ++i){
                 var item = layoutsContainer.mainLayout.children[0];
                 item.parent = layoutsContainer.startLayout;
             }
 
             splitter2 = splitter2 - splitter - 1;
             // console.log("update layouts 2:"+splitter + " - "+splitter2);
 
             totalChildren = layoutsContainer.mainLayout.children.length;
             for (var i=splitter2+1; i<totalChildren; ++i){
                 var item = layoutsContainer.mainLayout.children[splitter2+1];
                 item.parent = layoutsContainer.endLayout;
             }
         }
     }
 
     function joinLayoutsToMainLayout() {
         console.log("LAYOUTS: Moving applets from THREE to MAIN Layout mode...");
         var totalChildren1 = layoutsContainer.mainLayout.children.length;
         for (var i=totalChildren1-1; i>=0; --i) {
             var item1 = layoutsContainer.mainLayout.children[0];
             item1.parent = layoutsContainer.startLayout;
         }
 
         var totalChildren2 = layoutsContainer.endLayout.children.length;
 
         for (var i=totalChildren2-1; i>=0; --i) {
             var item2 = layoutsContainer.endLayout.children[0];
             item2.parent = layoutsContainer.startLayout;
         }
 
         var totalChildrenL = layoutsContainer.startLayout.children.length;
         for (var i=totalChildrenL-1; i>=0; --i) {
             var itemL = layoutsContainer.startLayout.children[0];
             itemL.parent = layoutsContainer.mainLayout;
         }
     }
     //END functions
 
 
     ////BEGIN interfaces
 
     Connections {
         target: Latte.WindowSystem
 
         onCompositingActiveChanged: {
             visibilityManager.updateMaskArea();
         }
     }
 
     Connections {
         target: latteView
         onWidthChanged:{
             if (root.isHorizontal && proportionIconSize!==-1)
                 updateAutomaticIconSize();
         }
 
         onHeightChanged:{
             if (root.isVertical && proportionIconSize!==-1)
                 updateAutomaticIconSize();
         }
 
         onContextMenuIsShownChanged: {
             if (!latteView.contextMenuIsShown) {
                 checkRestoreZoom.start();
             } else {
                 root.setGlobalDirectRender(false);
             }
         }
     }
 
     Connections{
         target: latteView && latteView.visibility ? latteView.visibility : root
 
         ignoreUnknownSignals : true
 
         onContainsMouseChanged: {
             if (mouseInHoverableArea()) {
                 stopCheckRestoreZoomTimer();
             } else {
                 startCheckRestoreZoomTimer();
             }
         }
     }
 
     Connections{
         target: layoutsContainer
 
         onHoveredIndexChanged: {
             if (latteApplet && layoutsContainer.hoveredIndex>-1){
                 latteApplet.setHoveredIndex(-1);
             }
 
             if (latteApplet && latteApplet.windowPreviewIsShown && layoutsContainer.hoveredIndex>-1) {
                 latteApplet.hidePreview();
             }
         }
     }
 
     ////END interfaces
 
     /////BEGIN: Title Tooltip///////////
     PlasmaCore.Dialog{
         id: titleTooltipDialog
 
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: plasmoid.location
         mainItem: RowLayout{
             Layout.fillWidth: true
             Layout.fillHeight: true
             PlasmaComponents.Label{
                 id:titleLbl
                 Layout.leftMargin: 4
                 Layout.rightMargin: 4
                 Layout.topMargin: 2
                 Layout.bottomMargin: 2
                 text: titleTooltipDialog.title
             }
         }
 
         visible: false
 
         property string title: ""
 
         property bool activeItemHovered: false
         property Item activeItem: null
         property Item activeItemTooltipParent: null
         property string activeItemText: ""
 
 
         Component.onCompleted: {
             root.clearZoomSignal.connect(titleTooltipDialog.hide);
         }
 
         Component.onDestruction: {
             root.clearZoomSignal.disconnect(titleTooltipDialog.hide);
         }
 
         function hide(debug){
             if (!root.titleTooltips)
                 return;
 
             activeItemHovered = false;
             hideTitleTooltipTimer.start();
         }
 
         function show(taskItem, text){
             if (!root.titleTooltips || (latteApplet && latteApplet.contextMenu)){
                 return;
             }
 
             activeItemHovered = true;
 
             if (activeItem !== taskItem) {
                 activeItem = taskItem;
                 activeItemTooltipParent = taskItem.tooltipVisualParent;
                 activeItemText = text;
             }
 
             if (isReady) {
                 showTitleTooltipTimer.start();
             }
 
         }
 
         function update() {
             activeItemHovered = true
             title = activeItemText;
             visualParent = activeItemTooltipParent;
             if (latteApplet && latteApplet.windowPreviewIsShown) {
                 latteApplet.hidePreview();
             }
 
             visible = true;
         }
     }
 
     Timer {
         id: showTitleTooltipTimer
         interval: 100
         onTriggered: {
             if (latteView && latteView.visibility && latteView.visibility.containsMouse) {
                 titleTooltipDialog.update();
             }
 
             if (titleTooltipDialog.visible) {
                 titleTooltipCheckerToNotShowTimer.start();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: showTitleTooltipTimer called...");
             }
         }
     }
 
     Timer {
         id: hideTitleTooltipTimer
         interval: 200
         onTriggered: {
             if (!titleTooltipDialog.activeItemHovered) {
                 titleTooltipDialog.visible = false;
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: hideTitleTooltipTimer called...");
             }
 
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown
     Timer {
         id: titleTooltipCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (titleTooltipDialog.visible && latteApplet && (latteApplet.contextMenu || latteApplet.windowPreviewIsShown)) {
                 titleTooltipDialog.visible = false;
             }
         }
     }
     /////END: Title Tooltip///////////
 
     ///////////////BEGIN components
     Component {
         id: appletContainerComponent
         Applet.AppletItem{}
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     Indicators.Manager{
         id: indicators
     }
 
     ///////////////END components
 
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
 
     ///////////////BEGIN UI elements
 
     //it is used to check if the mouse is outside the layoutsContainer borders,
     //so in that case the onLeave event behavior should be trigerred
     RootMouseArea{
         id: rootMouseArea
     }
 
     Loader{
         active: root.debugModeWindow
         sourceComponent: DebugWindow{}
     }
 
     //! Load a sepia background in order to avoid black background
     Loader{
         anchors.fill: parent
         active: !Latte.WindowSystem.compositingActive
         sourceComponent: Image{
             anchors.fill: parent
             fillMode: Image.Tile
             source: root.hasUserSpecifiedBackground ? latteView.layout.background : "../icons/wheatprint.jpg"
         }
     }
 
     EditMode.Visual{
         id:editModeVisual
         //   z: root.behaveAsPlasmaPanel ? 1 : 0
     }
 
     Item {
         id: lastSpacer
         parent: layoutsContainer.mainLayout
 
         Layout.fillWidth: true
         Layout.fillHeight: true
         z:10
 
         Rectangle{
             anchors.fill: parent
             color: "transparent"
             border.color: "yellow"
             border.width: 1
         }
     }
 
     Loader{
         anchors.fill: parent
         active: root.debugMode
         z:10
 
         sourceComponent: Item{
             Rectangle{
                 anchors.fill: parent
                 color: "yellow"
                 opacity: 0.06
             }
         }
     }
 
     VisibilityManager{ id: visibilityManager }
 
     DragDropArea {
         id: backDropArea
         anchors.fill: parent
         readonly property bool higherPriority: latteView && latteView.containsDrag
                                                && ((root.dragInfo.isPlasmoid && root.dragInfo.isSeparator)
                                                || (foreDropArea.dragInfo.computationsAreValid && !root.dragInfo.isPlasmoid && !root.dragInfo.onlyLaunchers))
 
         readonly property bool ignoreRegularFiles: !root.editMode
                                                    && (dragInfo.computationsAreValid || foreDropArea.dragInfo.computationsAreValid)
                                                    && !root.dragInfo.isPlasmoid
                                                    && !root.dragInfo.onlyLaunchers
 
         Item{
             id: panelBox
             anchors.fill: layoutsContainer
 
             PanelBox{
                 id: panelBoxBackground
             }
         }
 
         Layouts.LayoutsContainer {
             id: layoutsContainer
         }
 
         DragDropArea {
             id: foreDropArea
             anchors.fill: parent
             visible: !backDropArea.higherPriority
             isForeground: true
 
             /* Rectangle {
                 anchors.fill: parent
                 color: "blue"
                 opacity: 0.5
             }*/
         }
     }
 
     Colorizer.Manager {
         id: colorizerManager
     }
 
     Item {
         id: dndSpacer
 
         width: root.isHorizontal ? length : thickness
         height: root.isHorizontal ? thickness : length
 
         readonly property int length: root.iconSize + root.lengthMargins
         readonly property int thickness: root.iconSize + root.thickMargins
 
         Layout.preferredWidth: width
         Layout.preferredHeight: height
         opacity: 0
         z:1500
 
         LatteComponents.AddItem{
             anchors.fill: parent
         }
     }
 
     ///////////////END UI elements
 
     ///////////////BEGIN TIMER elements
 
 
     //Timer to check if the mouse is still outside the latteView in order to restore zooms to 1.0
     Timer{
         id:checkRestoreZoom
         interval: 90
 
         onTriggered: {
             if (latteApplet && (latteApplet.previewContainsMouse() || latteApplet.contextMenu))
                 return;
 
             if (latteView.contextMenuIsShown)
                 return;
 
             if (!mouseInHoverableArea()) {
                 setGlobalDirectRender(false);
                 root.initializeHoveredIndexes();
                 root.clearZoom();
             }
 
             if (root.debugModeTimers) {
                 console.log("containment timer: checkRestoreZoom called...");
             }
         }
     }
 
     //! Delayer in order to not activate directRendering when the mouse
     //! enters until the timer has ended. This way we make sure that the
     //! zoom-in animations will have ended.
     Timer{
         id:directRenderDelayerForEnteringTimer
         interval: 3.2 * root.durationTime * units.shortDuration
     }
 
     //this is a delayer to update mask area, it is used in cases
     //that animations can not catch up with animations signals
     //e.g. the automaicIconSize case
     Timer{
         id:delayUpdateMaskArea
         repeat:false;
         interval:300;
 
         onTriggered: {
             if (layoutsContainer.animationSent) {
                 root.slotAnimationsNeedLength(-1);
                 layoutsContainer.animationSent = false;
             }
 
             visibilityManager.updateMaskArea();
 
             if (root.debugModeTimers) {
                 console.log("containment timer: delayUpdateMaskArea called...");
             }
         }
     }
 
     // This function is very costly! This timer makes sure that it can be called
     // only once every 1sec.
     Timer{
         id:blockAutomaticUpdateIconSize
         interval: 1000
         repeat: false
         onTriggered: root.updateAutomaticIconSize();
     }
 
     //! It is used in order to slide-in the latteView on startup
     Timer{
         id: inStartupTimer
         interval: 1500
         repeat: false
         onTriggered: {
             if (inStartup) {
                 visibilityManager.slotMustBeShown();
             }
         }
     }
 
     ///////////////END TIMER elements
 }
diff --git a/declarativeimports/components/BadgeText.qml b/declarativeimports/components/BadgeText.qml
index 700f6b7c..5ad2fee1 100644
--- a/declarativeimports/components/BadgeText.qml
+++ b/declarativeimports/components/BadgeText.qml
@@ -1,182 +1,188 @@
 /*
 *  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/>.
 */
 
 import QtQuick 2.2
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.plasmoid 2.0
 
 Rectangle {
     property double proportion: 0
 
     property double previousProportion: 0
 
     property bool style3d: true
 
     property int numberValue
     property string textValue
 
     property bool fullCircle: true
     property bool showNumber: true
     property bool showText: false
     property bool textWithBackgroundColor: false
 
     property int radiusPerCentage: 100
     property int minimumWidth: 0
     property int maximumWidth: 9999
 
     property double circleOpacity: 1
     property double fontPixelSize: partSize // * 0.55
 
     property double stdThickness: partSize < 0 ? 0 : partSize  //  "/2.1"
     property double circleThicknessAttr: fullCircle ? 0 : stdThickness * 0.9
     property double partSize: height / 2
     property double pi2: Math.PI * 2
 
     width: Math.max(minimumWidth, valueText.width + 4*units.smallSpacing)
 
     color: theme.backgroundColor
     radius: (radiusPerCentage / 100) * (height / 2)
     border.width: 0 //Math.max(1,width/64)
 
     property int borderWidth: 1
     property real borderOpacity: 1
     property color borderColor: theme.textColor
     property color textColor: theme.textColor
     property color highlightedColor: theme.buttonFocusColor
 
     readonly property bool singleCharacter: (showNumber && numberValue<=9 && numberValue>=0)|| (showText && textValue.length===1)
 
     onProportionChanged: {
         //  console.log(previousProportion + " - "+proportion);
         if ((proportion - 0.03 >= previousProportion) || (proportion===1)) {
             //   console.log("request repaint...");
             previousProportion = proportion;
             repaint();
         }
     }
 
     function repaint() {
         canvas.requestPaint()
     }
 
     Canvas {
         id: canvas
 
         property int lineWidth: 1
         property bool fill: true
         property bool stroke: true
         property real alpha: 1.0
 
         // edge bleeding fix
         readonly property double filler: 0.01
 
         width: parent.width - 2 * parent.borderWidth
         height: parent.height - 2 * parent.borderWidth
         opacity: proportion > 0 ? 1 : 0
 
         anchors.centerIn: parent
 
         property color drawColor: highlightedColor
 
         onDrawColorChanged: requestPaint();
 
         onPaint: {
             var ctx = getContext('2d');
             ctx.clearRect(0, 0, canvas.width, canvas.height);
             ctx.fillStyle = drawColor;
 
             var startRadian = - Math.PI / 2;
 
             var radians = pi2 * proportion;
 
             ctx.beginPath();
             ctx.arc(width/2, height/2, stdThickness, startRadian, startRadian + radians + filler, false);
             ctx.arc(width/2, height/2, circleThicknessAttr, startRadian + radians + filler, startRadian, true);
 
             ctx.closePath();
             ctx.fill();
         }
     }
 
     Rectangle {
         id: badgerBackground
         anchors.fill: canvas
         color: canvas.drawColor
 
         visible: proportion === 100 && showNumber
         radius: parent.radius
     }
 
     Text {
         id: valueText
         anchors.centerIn: canvas
 
         width: Math.min(maximumWidth - 4*units.smallSpacing, implicitWidth)
         horizontalAlignment: Text.AlignHCenter
         verticalAlignment: Text.AlignVCenter
 
         elide: Text.ElideRight
 
         text: {
             if (showNumber) {
                 if (numberValue > 9999) {
                     return i18nc("Over 9999 new messages, overlay, keep short", "9,999+");
                 } else if (numberValue > 0) {
                     return numberValue.toLocaleString(Qt.locale(), 'f', 0);
                 }
             }
 
             if (showText) {
                 return textValue;
             }
 
             return "";
         }
         font.pixelSize: 0.62 * parent.height
         font.bold: true
         color: textWithBackgroundColor ? parent.color : parent.textColor
         visible: showNumber || showText
     }
 
     Rectangle{
         anchors.fill: parent
         anchors.topMargin: parent.borderWidth
         anchors.bottomMargin: parent.borderWidth
         anchors.leftMargin: parent.borderWidth
         anchors.rightMargin: parent.borderWidth
         color: "transparent"
         border.width: parent.borderWidth > 0 ? parent.borderWidth+1 : 0
         border.color: "black"
         radius: parent.radius
         opacity: 0.4
 
         visible: style3d
     }
 
     Rectangle{
         anchors.fill: parent
         border.width: parent.borderWidth
-        border.color: style3d ? parent.borderColor : parent.color
+        border.color: {
+            if (style3d) {
+                return parent.borderColor
+            }
+
+            return proportion === 100 ? parent.highlightedColor : parent.color
+        }
         color: "transparent"
         radius: parent.radius
         opacity: parent.borderOpacity
     }
 }
 
diff --git a/plasmoid/package/contents/ui/main.qml b/plasmoid/package/contents/ui/main.qml
index 3fba13dd..412f727a 100644
--- a/plasmoid/package/contents/ui/main.qml
+++ b/plasmoid/package/contents/ui/main.qml
@@ -1,2201 +1,2202 @@
 /*
 *  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.0
 import QtQuick.Layouts 1.1
 import QtGraphicalEffects 1.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 import org.kde.plasma.components 2.0 as PlasmaComponents
 import org.kde.plasma.plasmoid 2.0
 
 import org.kde.taskmanager 0.1 as TaskManager
 import org.kde.plasma.private.taskmanager 0.1 as TaskManagerApplet
 
 import org.kde.activities 0.1 as Activities
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 import "previews" as Previews
 import "task" as Task
 import "taskslayout" as TasksLayout
 import "../code/tools.js" as TaskTools
 import "../code/activitiesTools.js" as ActivitiesTools
 import "../code/ColorizerTools.js" as ColorizerTools
 
 Item {
     id:root
 
     Layout.fillWidth: scrollingEnabled && !root.vertical
     Layout.fillHeight: scrollingEnabled && root.vertical
 
     ///IMPORTANT: These values must be tested when the Now Dock Panel support
     ///also the four new anchors. A small issue is shown between the animation
     /// of the now dock plasmoid and the neighbour widgets...
     Layout.minimumWidth: -1 //(userPanelPosition !== 0)&&(!latteView) ? clearWidth : -1
     Layout.minimumHeight: -1 //(userPanelPosition !== 0)&&(!latteView) ? clearHeight : -1
     Layout.preferredWidth: tasksWidth   //(userPanelPosition !== 0)&&(!latteView) ? tasksWidth : tasksWidth
     Layout.preferredHeight: tasksHeight //(userPanelPosition !== 0)&&(!latteView) ? tasksHeight : tasksHeight
     Layout.maximumWidth: -1
     Layout.maximumHeight: -1
 
     LayoutMirroring.enabled: Qt.application.layoutDirection === Qt.RightToLeft && !root.vertical
     LayoutMirroring.childrenInherit: true
 
     property bool debugLocation: false
 
     //it is used to check both the applet and the containment for direct render
     property bool globalDirectRender: latteView ? latteView.globalDirectRender : icList.directRender
 
     property bool plasma515: Latte.WindowSystem.plasmaDesktopVersion >= Latte.WindowSystem.makeVersion(5,14,90)
 
     property bool editMode: latteView ? latteView.editMode : plasmoid.userConfiguring
     property bool inConfigureAppletsMode: latteView ? latteView.inConfigureAppletsMode : true
     property bool disableRestoreZoom: false //blocks restore animation in rightClick
     property bool disableAllWindowsFunctionality: root.showWindowsOnlyFromLaunchers && !indicators.isEnabled
     property bool dropNewLauncher: false
     readonly property bool hasInternalSeparator: parabolicManager.hasInternalSeparator
     property bool inActivityChange: false
     property bool inDraggingPhase: false
     property bool initializationStep: false //true
     property bool isHovered: false
     property bool showBarLine: plasmoid.configuration.showBarLine
     property bool showTaskShortcutBadges: false
     property int tasksBaseIndex: 0
     property bool useThemePanel: plasmoid.configuration.useThemePanel
     property bool taskInAnimation: noTasksInAnimation > 0 ? true : false
     property bool transparentPanel: plasmoid.configuration.transparentPanel
     property bool vertical: plasmoid.formFactor === PlasmaCore.Types.Vertical ? true : false
 
     property int clearWidth
     property int clearHeight
 
     property int newLocationDebugUse: PlasmaCore.Types.BottomPositioned
     property int newDroppedPosition: -1
     property int noInitCreatedBuffers: 0
     property int noTasksInAnimation: 0
     property int themePanelSize: plasmoid.configuration.panelSize
 
     property int position : PlasmaCore.Types.BottomPositioned
     property int tasksStarting: 0
 
     ///Don't use Math.floor it adds one pixel in animations and creates glitches
     property int widthMargins: root.vertical ? thickMargins : lengthMargins
     property int heightMargins: !root.vertical ? thickMargins : lengthMargins
 
     property int internalWidthMargins: root.vertical ? thickMargins : 2 * lengthIntMargin
     property int internalHeightMargins: !root.vertical ? thickMargins : 2 * lengthIntMargin
 
     property real textColorBrightness: ColorizerTools.colorBrightness(themeTextColor)
     property color minimizedDotColor: {
         if (latteView) {
             return latteView.minimizedDotColor;
         }
 
         return textColorBrightness > 127.5 ? Qt.darker(themeTextColor, 1.7) : Qt.lighter(themeBackgroundColor, 7)
     }
 
     property color themeTextColor: theme.textColor
     property color themeBackgroundColor: theme.backgroundColor
 
     property color lightTextColor: textColorBrightness > 127.5 ? themeTextColor : themeBackgroundColor
 
     //a small badgers record (id,value)
     //in order to track badgers when there are changes
     //in launcher reference from libtaskmanager
     property variant badgers:[]
     property variant launchersOnActivities: []
 
     //global plasmoid reference to the context menu
     property QtObject contextMenu: null
     property QtObject contextMenuComponent: Qt.createComponent("ContextMenu.qml");
     property Item dragSource: null
     property Item parabolicManager: _parabolicManager
     property Item tasksExtendedManager: _tasksExtendedManager
 
     //separator calculations based on audoban's design
     property int maxSeparatorLength: {
         if (root.vertical)
             return 5 + heightMargins;
         else
             return 5 + widthMargins;
     }
 
     property real missingSeparatorLength: {
         if (!root.isVertical)
             return ((iconSize + widthMargins) * zoomFactor) - maxSeparatorLength;
         else
             return ((iconSize + heightMargins) * zoomFactor) - maxSeparatorLength;
     }
 
     readonly property alias containsDrag: mouseHandler.containsDrag
     readonly property bool dragAreaEnabled: latteView ? (root.dragSource !== null
                                                          || latteView.dragInfo.isSeparator
                                                          || latteView.dragInfo.isTask
                                                          || !latteView.dragInfo.isPlasmoid)
                                                       : true
 
     //! it is used to play the animation correct when the user removes a launcher
     property string launcherForRemoval: ""
 
     //BEGIN Latte Dock properties
+    property bool badges3DStyle: latteView ? latteView.badges3DStyle : true
     property bool dockIsShownCompletely: latteView ? latteView.dockIsShownCompletely : true
     property bool enableShadows: latteView ? latteView.enableShadows > 0 : plasmoid.configuration.showShadows
     property bool forceHidePanel: false
     property bool directRenderDelayerIsRunning: latteView ? latteView.directRenderDelayerIsRunning : directRenderDelayerForEnteringTimer.running
     property bool disableLeftSpacer: false
     property bool disableRightSpacer: false
     property bool dockIsHidden: latteView ? latteView.dockIsHidden : false
     property bool groupTasksByDefault: latteView ? latteView.groupTasksByDefault: true
     property bool highlightWindows: latteView ? latteView.hoverAction === Latte.Types.HighlightWindows || latteView.hoverAction === Latte.Types.PreviewAndHighlightWindows :
                                                 plasmoid.configuration.highlightWindows
     property bool mouseWheelActions: latteView ? latteView.mouseWheelActions : true
     property bool parabolicEffectEnabled: latteView ? latteView.parabolicEffectEnabled : zoomFactor>1 && !root.editMode
 
     property bool scrollingEnabled: latteView ? latteView.scrollTasksEnabled : false
     property bool autoScrollTasksEnabled: latteView ? (scrollingEnabled && latteView.autoScrollTasksEnabled) : false
     property bool manualScrollTasksEnabled: latteView ? (scrollingEnabled &&  manualScrollTasksType !== Latte.Types.ManualScrollDisabled) : Latte.Types.ManualScrollDisabled
     property int manualScrollTasksType: latteView ? latteView.manualScrollTasksType : 0
 
     property bool showInfoBadge: latteView ? latteView.showInfoBadge : plasmoid.configuration.showInfoBadge
     property bool showProgressBadge: latteView ? latteView.showProgressBadge : plasmoid.configuration.showInfoBadge
     property bool showAudioBadge: latteView ? latteView.showAudioBadge : plasmoid.configuration.showAudioBadge
     property bool infoBadgeProminentColorEnabled: latteView ? latteView.infoBadgeProminentColorEnabled : false
     property bool audioBadgeActionsEnabled: latteView ? latteView.audioBadgeActionsEnabled : true
     property bool showOnlyCurrentScreen: latteView ? latteView.showOnlyCurrentScreen : plasmoid.configuration.showOnlyCurrentScreen
     property bool showOnlyCurrentDesktop: latteView ? latteView.showOnlyCurrentDesktop : plasmoid.configuration.showOnlyCurrentDesktop
     property bool showOnlyCurrentActivity: latteView ? latteView.showOnlyCurrentActivity : plasmoid.configuration.showOnlyCurrentActivity
     property bool showPreviews:  latteView ? latteView.hoverAction === Latte.Types.PreviewWindows || latteView.hoverAction === Latte.Types.PreviewAndHighlightWindows :
                                              plasmoid.configuration.showToolTips
     property bool showWindowActions: latteView ? latteView.showWindowActions : plasmoid.configuration.showWindowActions
     property bool showWindowsOnlyFromLaunchers: latteView ? latteView.showWindowsOnlyFromLaunchers : false
 
     property bool titleTooltips: latteView ? latteView.titleTooltips : false
     property alias windowPreviewIsShown: windowsPreviewDlg.visible
 
     property int animationStep: latteView ? latteView.animationStep : 1
     property int directRenderAnimationTime: latteView ? latteView.directRenderAnimationTime : 0
     property int dockHoveredIndex : latteView ? latteView.hoveredIndex : -1
 
     property int iconSize: latteView ? latteView.iconSize : Math.max(plasmoid.configuration.iconSize, 16)
     property int maxIconSize: latteView ? latteView.maxIconSize : iconSize
 
     property int leftClickAction: latteView ? latteView.leftClickAction : Latte.Types.PresentWindows
     property int middleClickAction: latteView ? latteView.middleClickAction : plasmoid.configuration.middleClickAction
     property int hoverAction: latteView ? latteView.hoverAction : Latte.Types.NoneAction
     property int modifier: latteView ? latteView.modifier : -1
     property int modifierClickAction: latteView ? latteView.modifierClickAction : -1
     property int modifierClick: latteView ? latteView.modifierClick : -1
     property int modifierQt:{
         if (modifier === Latte.Types.Shift)
             return Qt.ShiftModifier;
         else if (modifier === Latte.Types.Ctrl)
             return Qt.ControlModifier;
         else if (modifier === Latte.Types.Alt)
             return Qt.AltModifier;
         else if (modifier === Latte.Types.Meta)
             return Qt.MetaModifier;
         else return -1;
     }
 
     property int thickMargin: latteView ? latteView.thickMargin : 0.16*iconSize
     property int thickMargins: 2 * thickMargin
     property int lengthIntMargin: latteView ? latteView.lengthIntMargin : 0.04*iconSize
     property int lengthExtMargin: latteView ? latteView.lengthExtMargin : 0.1 * iconSize
     property int lengthMargin: lengthIntMargin + lengthExtMargin
     property int lengthMargins: 2 * lengthMargin
 
     property int tasksHeight: mouseHandler.height
     property int tasksWidth: mouseHandler.width
     //updated from Binding
     property int userPanelPosition
 
     readonly property real currentPanelOpacity: latteView ? latteView.currentPanelTransparency / 100 : 1
 
     //! Animations
     property bool animationsEnabled: latteView ? latteView.animationsEnabled : durationTime !== 0
     property bool animationLauncherBouncing: latteView ? latteView.animationLauncherBouncing : durationTime !== 0
     property bool animationWindowInAttention: latteView ? latteView.animationWindowInAttention : durationTime !== 0
     property bool animationNewWindowSliding: latteView ? latteView.animationNewWindowSliding : durationTime !== 0
     property bool animationWindowAddedInGroup: latteView ? latteView.animationWindowAddedInGroup : durationTime !== 0
     property bool animationWindowRemovedFromGroup: latteView ? latteView.animationWindowRemovedFromGroup : durationTime !== 0
 
     property real animationsZoomFactor: latteView ? latteView.animationsZoomFactor : durationTime === 0 ? 1 : 1.65
     property real maxZoomFactor: latteView ? latteView.maxZoomFactor : Math.max(zoomFactor, animationsZoomFactor)
 
     property real appliedDurationTime: animationsEnabled ? durationTime : 2
     property real durationTime: latteView ? latteView.durationTime : plasmoid.configuration.durationTime
     property real zoomFactor: latteView ? latteView.zoomFactor : ( 1 + (plasmoid.configuration.zoomLevel / 20) )
 
     property int appShadowSize: latteView ? latteView.appShadowSize : Math.ceil(0.12*iconSize)
     property string appShadowColor: latteView ? latteView.appShadowColor : "#ff080808"
     property string appShadowColorSolid: latteView ? latteView.appShadowColorSolid : "#ff080808"
 
     property alias tasksCount: tasksModel.count
     property alias hoveredIndex: icList.hoveredIndex
 
     readonly property rect screenGeometry: latteView ? latteView.screenGeometry : plasmoid.screenGeometry
 
     readonly property bool viewLayoutIsCurrent: latteView && viewLayout && latteView.layoutsManager
                                                 && viewLayout.name === latteView.layoutsManager.currentLayoutName
     readonly property string viewLayoutName: viewLayout ? viewLayout.name : ""
     readonly property QtObject viewLayout : latteView && latteView.viewLayout ? latteView.viewLayout : null
 
     property var badgesForActivate: latteView ? latteView.badgesForActivate : []
 
 
     property Item latteView: null
     readonly property Item indicators: latteView ? latteView.indicatorsManager : indicatorsStandaloneLoader.item
     //END Latte Dock Panel properties
 
     //BEGIN Latte Dock Communicator
     property QtObject latteBridge: null
     onLatteBridgeChanged: {
         if (latteBridge) {
             latteBridge.actions.setProperty(plasmoid.id, "latteSideColoringEnabled", false);
         }
     }
     //END  Latte Dock Communicator
     //BEGIN Latte based properties
     readonly property bool enforceLattePalette: latteBridge && latteBridge.applyPalette && latteBridge.palette
     readonly property bool latteInEditMode: latteBridge && latteBridge.inEditMode
     //END Latte based properties
 
     Plasmoid.preferredRepresentation: Plasmoid.fullRepresentation
     Plasmoid.backgroundHints: PlasmaCore.Types.NoBackground
 
     signal clearZoomSignal();
     signal draggingFinished();
     signal hiddenTasksUpdated();
     signal launchersUpdatedFor(string launcher);
     signal presentWindows(variant winIds);
     signal requestLayout;
     signal separatorsUpdated();
     signal signalActionsBlockHiding(int value);
     signal signalAnimationsNeedBothAxis(int value);
     signal signalAnimationsNeedLength(int value);
     signal signalAnimationsNeedThickness(int value);
     signal signalPreviewsShown();
     //signal signalDraggingState(bool value);
     signal showPreviewForTasks(QtObject group);
     //trigger updating scaling of neighbour delegates of zoomed delegate
     signal updateScale(int delegateIndex, real newScale, real step)
     signal mimicEnterForParabolic();
     signal publishTasksGeometries();
     signal windowsHovered(variant winIds, bool hovered)
 
     //onAnimationsChanged: console.log(animations);
     /* Rectangle{
                 anchors.fill: parent
                 border.width: 1
                 border.color: "red"
                 color: "white"
             } */
     onLatteViewChanged: {
         if (latteView) {
             plasmoid.action("configure").visible = false;
             plasmoid.action("remove").visible = false;
             plasmoid.configuration.isInLatteDock = true;
         } else {
             plasmoid.configuration.isInLatteDock = false;
         }
     }
 
 
     Connections {
         target: plasmoid
         onLocationChanged: {
             root.updatePosition();
             iconGeometryTimer.start();
         }
     }
 
     Connections {
         target: plasmoid.configuration
 
         // onLaunchersChanged: tasksModel.launcherList = plasmoid.configuration.launchers
         onGroupingAppIdBlacklistChanged: tasksModel.groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
         onGroupingLauncherUrlBlacklistChanged: tasksModel.groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
     }
 
 
     Connections{
         target: latteView
         onDockIsHiddenChanged:{
             if (latteView.dockIsHidden) {
                 windowsPreviewDlg.hide("3.3");
             }
         }
 
         onLaunchersGroupChanged:{
             if( latteView && latteView.editMode) {
                 tasksModel.updateLaunchersList();
             }
         }
     }
 
 
     Connections{
         target: latteView && latteView.layoutsManager ? latteView.layoutsManager : null
 
         onCurrentLayoutNameChanged: root.publishTasksGeometries();
     }
 
     Connections{
         target: icList
 
         onHoveredIndexChanged:{
             if (latteView && icList.hoveredIndex>-1){
                 latteView.setHoveredIndex(-1);
             }
         }
     }
 
 
     /////
     PlasmaCore.ColorScope{
         id: colorScopePalette
     }
 
     Loader {
         id: indicatorsStandaloneLoader
         active: !latteView && !plasmoid.configuration.isInLatteDock
         source: "indicators/Manager.qml"
     }
 
     Binding {
         target: root
         property: "userPanelPosition"
         value: {
             if (latteView) {
                 if (latteView.panelUserSetAlignment === -1) {
                     return;
                 }
 
                 if (inConfigureAppletsMode) {
                     return Latte.Types.Center;
                 } else if (latteView.panelUserSetAlignment === Latte.Types.Justify) {
                     if (latteView.latteAppletPos>=0 && latteView.latteAppletPos<100) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? Latte.Types.Left : Latte.Types.Top;
                     } else if (latteView.latteAppletPos>=100 && latteView.latteAppletPos<200) {
                         return Latte.Types.Center;
                     } else if (latteView.latteAppletPos>=200) {
                         return plasmoid.formFactor === PlasmaCore.Types.Horizontal ? Latte.Types.Right : Latte.Types.Bottom;
                     }
 
                     return Latte.Types.Center;
                 }
 
                 return latteView.panelUserSetAlignment;
             }
 
             return plasmoid.configuration.plasmoidPosition;
         }
     }
 
     /////
 
     function initializeHoveredIndex() {
         icList.hoveredIndex = -1;
         icList.currentSpot = -1000;
     }
 
     function launchersDropped(urls){
         mouseHandler.urlsDropped(urls);
     }
 
     ///UPDATE
     function launcherExists(url) {
         return (ActivitiesTools.getIndex(url, tasksModel.launcherList)>=0);
     }
 
     function taskExists(url) {
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.launcherUrl===url && task.isWindow) {
                 return true;
             }
         }
         return false;
     }
 
     function launchersDrop(event) {
         var createLaunchers = false;
 
         if (event.mimeData.hasUrls) {
             createLaunchers = event.mimeData.urls.every(function (item) {
                 return backend.isApplication(item)
             });
         }
 
         return createLaunchers;
     }
 
     function currentLauncherList() {
         var launch = [];
         var launchersList = [];
 
         if (viewLayout) {
             if (latteView && latteView.layoutsManager
                     && latteView.viewLayout && latteView.universalSettings
                     && (latteView.launchersGroup === Latte.Types.LayoutLaunchers
                         || latteView.launchersGroup === Latte.Types.GlobalLaunchers)) {
 
                 if (latteView.launchersGroup === Latte.Types.LayoutLaunchers) {
                     launchersList = latteView.viewLayout.launchers;
                 } else if (latteView.launchersGroup === Latte.Types.GlobalLaunchers) {
                     launchersList = latteView.universalSettings.launchers;
                 }
             }
         } else {
             launchersList = plasmoid.configuration.launchers59;
         }
 
 
         for(var i=0; i<launchersList.length; ++i){
             var launcherRecord = launchersList[i];
 
             if (launcherRecord.indexOf("[") === -1) {
                 //global launcher
                 launch.push(launcherRecord);
             } else {
                 //launcher assigned to activities
                 var end = launcherRecord.indexOf("\n");
                 var explicitLauncher = launcherRecord.substring(end+1,launcherRecord.length);
                 if (explicitLauncher !== "" && launcherRecord.indexOf(activityInfo.currentActivity) > -1) {
                     launch.push(explicitLauncher);
                 }
             }
         }
 
         return launch;
     }
 
     function currentListViewLauncherList() {
         var launch = [];
 
         var tasks = icList.contentItem.children;
         for(var i=0; i<tasks.length; ++i){
             var task = icList.childAtIndex(i);
 
             if (task!==undefined && task.launcherUrl!=="" && tasksModel.launcherInCurrentActivity(task.launcherUrl)) {
                 launch.push(task.launcherUrl);
             }
         }
 
         return launch;
     }
 
     function hidePreview(){
         windowsPreviewDlg.hide(11);
     }
 
     onDragSourceChanged: {
         if (dragSource == null) {
             root.draggingFinished();
             root.signalActionsBlockHiding(-1);
             tasksModel.syncLaunchers();
 
             restoreDraggingPhaseTimer.start();
         } else {
             inDraggingPhase = true;
             root.signalActionsBlockHiding(1);
         }
     }
 
     /////Window previews///////////
 
     Previews.ToolTipDelegate2 {
         id: toolTipDelegate
         visible: false
     }
 
     ////BEGIN interfaces
 
     PlasmaCore.Dialog{
         id: windowsPreviewDlg
         // hideOnWindowDeactivate: false
         type: PlasmaCore.Dialog.Tooltip
         flags: Qt.WindowStaysOnTopHint | Qt.WindowDoesNotAcceptFocus | Qt.ToolTip
 
         location: plasmoid.location
         mainItem: toolTipDelegate
         visible: false
 
         property bool signalSent: false
         property Item activeItem: null
 
         Component.onCompleted: mainItem.visible = true;
 
         function hide(debug){
             // console.log("on hide previews event called: "+debug);
 
             if (latteView && signalSent) {
                 //it is used to unblock dock hiding
                 root.signalActionsBlockHiding(-1);
                 signalSent = false;
             }
 
             if (!root.contextMenu)
                 root.disableRestoreZoom = false;
 
             hidePreviewWinTimer.start();
         }
 
         function show(taskItem){
             if (root.disableAllWindowsFunctionality) {
                 return;
             }
 
             hidePreviewWinTimer.stop();
 
             // console.log("preview show called...");
             if ((!activeItem || (activeItem !== taskItem)) && !root.contextMenu) {
                 //console.log("preview show called: accepted...");
 
                 //this can be used from others to hide their appearance
                 //e.g but applets from the dock to hide themselves
                 if (!visible) {
                     root.signalPreviewsShown();
                 }
 
                 activeItem = taskItem;
                 toolTipDelegate.parentTask = taskItem;
 
                 if (latteView && !signalSent) {
                     //it is used to block dock hiding
                     root.signalActionsBlockHiding(1);
                     signalSent = true;
                 }
 
                 //! Workaround in order to update properly the previews thumbnails
                 //! when switching between single thumbnail to another single thumbnail
                 mainItem.visible = false;
                 visible = true;
                 mainItem.visible = true;
             }
         }
     }
 
     //! Delay windows previews hiding
     Timer {
         id: hidePreviewWinTimer
         interval: 350
         onTriggered: {
             windowsPreviewDlg.visible = false;
             windowsPreviewDlg.mainItem.visible = false;
             windowsPreviewDlg.activeItem = null;
         }
     }
 
     //! Timer to fix #811, rare cases that both a window preview and context menu are
     //! shown. It is mostly used under wayland in order to avoid crashes. When the context
     //! menu will be shown there is a chance that previews window has already appeared in that
     //! case the previews window must become hidden
     Timer {
         id: windowsPreviewCheckerToNotShowTimer
         interval: 250
 
         onTriggered: {
             if (windowsPreviewDlg.visible && root.contextMenu) {
                 windowsPreviewDlg.hide("8.2");
             }
         }
     }
 
     //! Timer to delay the removal of the window through the context menu in case the
     //! the window is zoomed
     Timer{
         id: delayWindowRemovalTimer
         //this is the animation time needed in order for tasks to restore their zoom first
         interval: 7 * (root.durationTime * units.shortDuration)
 
         property var modelIndex
 
         onTriggered: {
             tasksModel.requestClose(delayWindowRemovalTimer.modelIndex)
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: delayWindowRemovalTimer called...");
             }
         }
     }
 
     Timer {
         id: activityChangeDelayer
         interval: 150
         onTriggered: {
             root.inActivityChange = false;
             activityInfo.previousActivity = activityInfo.currentActivity;
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: activityChangeDelayer called...");
             }
         }
     }
 
     /////Window Previews/////////
 
 
     property bool loadLaunchersFirstTime: false;
 
     onViewLayoutChanged: {
         if (viewLayout && !loadLaunchersFirstTime) {
             tasksModel.updateLaunchersList();
             loadLaunchersFirstTime = true;
         }
     }
 
     TaskManager.TasksModel {
         id: tasksModel
 
         virtualDesktop: virtualDesktopInfo.currentDesktop
         screenGeometry: root.screenGeometry
         // comment in order to support LTS Plasma 5.8
         // screen: plasmoid.screen
         activity: activityInfo.currentActivity
 
         filterByVirtualDesktop: root.showOnlyCurrentDesktop
         filterByScreen: root.showOnlyCurrentScreen
         filterByActivity: root.showOnlyCurrentActivity
 
         launchInPlace: true
         separateLaunchers: true
         groupInline: false
 
         groupMode: groupTasksByDefault ? TaskManager.TasksModel.GroupApplications : TaskManager.TasksModel.GroupDisabled
         sortMode: TaskManager.TasksModel.SortManual
 
         function updateLaunchersList(){
             if (latteView.universalSettings
                     && (latteView.launchersGroup === Latte.Types.LayoutLaunchers
                         || latteView.launchersGroup === Latte.Types.GlobalLaunchers)) {
                 if (latteView.launchersGroup === Latte.Types.LayoutLaunchers) {
                     tasksModel.launcherList = latteView.viewLayout.launchers;
                 } else if (latteView.launchersGroup === Latte.Types.GlobalLaunchers) {
                     tasksModel.launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 tasksModel.launcherList = plasmoid.configuration.launchers59;
             }
         }
 
         function launcherInCurrentActivity(url) {
             var activities = tasksModel.launcherActivities(url);
 
             var NULL_UUID = "00000000-0000-0000-0000-000000000000";
 
             if (activities.indexOf(NULL_UUID) !== -1 || activities.indexOf(activityInfo.currentActivity) !== -1)
                 return true;
 
             return false;
         }
 
         onActivityChanged: {
             ActivitiesTools.currentActivity = String(activity);
         }
 
         onLauncherListChanged: {
             if (viewLayout) {
                 if (latteView && latteView.layoutsManager
                         && latteView.viewLayout && latteView.universalSettings
                         && (latteView.launchersGroup === Latte.Types.LayoutLaunchers
                             || latteView.launchersGroup === Latte.Types.GlobalLaunchers)) {
 
                     if (latteView.launchersGroup === Latte.Types.LayoutLaunchers) {
                         latteView.viewLayout.launchers = launcherList;
                     } else if (latteView.launchersGroup === Latte.Types.GlobalLaunchers) {
                         latteView.universalSettings.launchers = launcherList;
                     }
 
                     if (inDraggingPhase) {
                         if (latteView && latteView.launchersGroup >= Latte.Types.LayoutLaunchers) {
                             latteView.layoutsManager.launchersSignals.validateLaunchersOrder(root.viewLayoutName,
                                                                                              plasmoid.id,
                                                                                              latteView.launchersGroup,
                                                                                              currentLauncherList());
                         }
                     }
                 } else {
                     plasmoid.configuration.launchers59 = launcherList;
                 }
             } else {
                 plasmoid.configuration.launchers59 = launcherList;
             }
         }
 
         onGroupingAppIdBlacklistChanged: {
             plasmoid.configuration.groupingAppIdBlacklist = groupingAppIdBlacklist;
         }
 
         onGroupingLauncherUrlBlacklistChanged: {
             plasmoid.configuration.groupingLauncherUrlBlacklist = groupingLauncherUrlBlacklist;
         }
 
         onAnyTaskDemandsAttentionChanged: {
             if (anyTaskDemandsAttention){
                 plasmoid.status = PlasmaCore.Types.RequiresAttentionStatus;
                 attentionTimerComponent.createObject(root);
             }
         }
 
 
         Component.onCompleted: {
             ActivitiesTools.launchersOnActivities = root.launchersOnActivities
             ActivitiesTools.currentActivity = String(activityInfo.currentActivity);
             ActivitiesTools.plasmoid = plasmoid;
 
             //var loadedLaunchers = ActivitiesTools.restoreLaunchers();
             ActivitiesTools.importLaunchersToNewArchitecture();
 
             if (viewLayout && latteView.universalSettings
                     && (latteView.launchersGroup === Latte.Types.LayoutLaunchers
                         || latteView.launchersGroup === Latte.Types.GlobalLaunchers)) {
 
                 if (latteView.launchersGroup === Latte.Types.LayoutLaunchers) {
                     launcherList = latteView.viewLayout.launchers;
                 } else if (latteView.launchersGroup === Latte.Types.GlobalLaunchers) {
                     launcherList = latteView.universalSettings.launchers;
                 }
             } else {
                 launcherList = plasmoid.configuration.launchers59;
             }
 
             groupingAppIdBlacklist = plasmoid.configuration.groupingAppIdBlacklist;
             groupingLauncherUrlBlacklist = plasmoid.configuration.groupingLauncherUrlBlacklist;
 
             icList.model = tasksModel;
             tasksStarting = count;
 
             ///Plasma 5.9 enforce grouping at all cases
             if (Latte.WindowSystem.plasmaDesktopVersion >= Latte.WindowSystem.makeVersion(5,9,0)) {
                 groupingWindowTasksThreshold = -1;
             }
         }
     }
 
     //! TaskManagerBackend required a groupDialog setting otherwise it crashes. This patch
     //! sets one just in order not to crash TaskManagerBackend
     PlasmaCore.Dialog {
         //ghost group Dialog to not crash TaskManagerBackend
         id: groupDialogGhost
         visible: false
 
         type: PlasmaCore.Dialog.PopupMenu
         flags: Qt.WindowStaysOnTopHint
         hideOnWindowDeactivate: true
         location: plasmoid.location
     }
 
 
     TaskManagerApplet.Backend {
         id: backend
 
         taskManagerItem: root
         toolTipItem: toolTipDelegate
         highlightWindows: root.highlightWindows
 
         onAddLauncher: {
             tasksModel.requestAddLauncher(url);
         }
 
         Component.onCompleted: {
             //! In Plasma 5.9 TaskManagerBackend required a groupDialog setting
             //! otherwise it crashes.
             //! frameworks 5.29.0 provide id 335104
             //! work only after Plasma 5.9 and frameworks 5.29
             //! + added a check for groupDialog also when it is present
             //!   in plasma 5.8 (that was introduced after 5.8.5)
             if (Latte.WindowSystem.frameworksVersion >= 335104 || (groupDialog !== undefined)) {
                 groupDialog = groupDialogGhost;
             }
         }
     }
 
     TaskManagerApplet.DragHelper {
         id: dragHelper
 
         dragIconSize: units.iconSizes.medium
     }
 
     TaskManager.VirtualDesktopInfo {
         id: virtualDesktopInfo
     }
 
     TaskManager.ActivityInfo {
         id: activityInfo
 
         property string previousActivity: ""
         onCurrentActivityChanged: {
             root.inActivityChange = true;
             activityChangeDelayer.start();
         }
 
         Component.onCompleted: previousActivity = currentActivity;
     }
 
     PlasmaCore.DataSource {
         id: mpris2Source
         engine: "mpris2"
         connectedSources: sources
         function sourceNameForLauncherUrl(launcherUrl, pid) {
             if (!launcherUrl || launcherUrl == "") {
                 return "";
             }
 
             // MPRIS spec explicitly mentions that "DesktopEntry" is with .desktop extension trimmed
             // Moreover, remove URL parameters, like wmClass (part after the question mark)
             var desktopFileName = launcherUrl.toString().split('/').pop().split('?')[0].replace(".desktop", "")
             if (desktopFileName.indexOf("applications:") === 0) {
                 desktopFileName = desktopFileName.substr(13)
             }
 
             for (var i = 0, length = connectedSources.length; i < length; ++i) {
                 var source = connectedSources[i];
                 // we intend to connect directly, otherwise the multiplexer steals the connection away
                 if (source === "@multiplex") {
                     continue;
                 }
 
                 var sourceData = data[source];
                 if (!sourceData || sourceData.DesktopEntry !== desktopFileName) {
                     continue;
                 }
 
                 if (pid === undefined || sourceData.InstancePid === pid) {
                     return source;
                 }
 
                 var metadata = sourceData.Metadata;
                 if (metadata) {
                     var kdePid = metadata["kde:pid"];
                     if (kdePid && pid === kdePid) {
                         return source;
                     }
                 }
             }
 
             return ""
         }
 
         function startOperation(source, op) {
             var service = serviceForSource(source)
             var operation = service.operationDescription(op)
             return service.startOperationCall(operation)
         }
 
         function goPrevious(source) {
             startOperation(source, "Previous");
         }
         function goNext(source) {
             startOperation(source, "Next");
         }
         function playPause(source) {
             startOperation(source, "PlayPause");
         }
         function stop(source) {
             startOperation(source, "Stop");
         }
         function raise(source) {
             startOperation(source, "Raise");
         }
         function quit(source) {
             startOperation(source, "Quit");
         }
     }
 
     Loader {
         id: pulseAudio
         source: "PulseAudio.qml"
         active: root.showAudioBadge
     }
 
     ParabolicManager{
         id: _parabolicManager
     }
 
     TasksExtendedManager {
         id: _tasksExtendedManager
     }
 
     /*  IconsModel{
         id: iconsmdl
     }*/
 
     Component{
         id: attentionTimerComponent
         Timer{
             id: attentionTimer
             interval:8500
             onTriggered: {
                 plasmoid.status = PlasmaCore.Types.PassiveStatus;
                 destroy();
 
                 if (latteView && latteView.debugModeTimers) {
                     console.log("plasmoid timer: attentionTimer called...");
                 }
             }
             Component.onCompleted: {
                 start();
             }
         }
     }
 
     //Timer to check if the mouse is still inside the ListView
     //IMPORTANT ::: This timer should be used only when the Latte plasmoid
     //is not inside a Latte dock
     Timer{
         id:checkListHovered
         repeat:false;
         interval: 120
 
         property int normalInterval: Math.max(120, 2 * (root.durationTime * 1.2 * units.shortDuration) + 50)
 
         onTriggered: {
             if(root.latteView)
                 console.log("Plasmoid, checkListHoveredTimer was called, even though it shouldn't...");
 
             if (!root.containsMouse()) {
 
                 icList.directRender = false;
 
                 root.clearZoom();
             }
 
             interval = normalInterval;
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: checkListHovered called...");
             }
         }
 
         function startNormal(){
             interval = normalInterval;
 
             start();
         }
 
         function startDuration( duration){
             interval = duration;
 
             start();
         }
     }
 
     //! Delayer in order to not activate directRendering when the mouse
     //! enters until the timer has ended. This way we make sure that the
     //! zoom-in animations will have ended.
     Timer{
         id:directRenderDelayerForEnteringTimer
         interval: 3.2 * root.durationTime * units.shortDuration
     }
 
     //this timer restores the draggingPhase flag to false
     //after a dragging has finished... This delay is needed
     //in order to not animate any tasks are added after a
     //dragging
     Timer {
         id: restoreDraggingPhaseTimer
         interval: 150
         onTriggered: inDraggingPhase = false;
     }
 
     ///Red Liner!!! show the upper needed limit for animations
     Rectangle{
         anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
         anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
         width: root.vertical ? 1 : 2 * root.iconSize
         height: root.vertical ? 2 * root.iconSize : 1
         color: "red"
         x: (root.position === PlasmaCore.Types.LeftPositioned) ? neededSpace : parent.width - neededSpace
         y: (root.position === PlasmaCore.Types.TopPositioned) ? neededSpace : parent.height - neededSpace
 
         visible: plasmoid.configuration.zoomHelper
 
         property int neededSpace: zoomFactor*(iconSize+lengthMargins)
     }
 
     Item{
         id:barLine
 
         width: ( icList.orientation === Qt.Horizontal ) ? icList.width + spacing : smallSize
         height: ( icList.orientation === Qt.Vertical ) ? icList.height + spacing : smallSize
 
         property int spacing: latteView ? 0 : root.iconSize / 2
         property int smallSize: Math.max(0.10 * root.iconSize, 16)
 
         Behavior on opacity{
             NumberAnimation { duration: root.durationTime*units.longDuration }
         }
 
         /// plasmoid's default panel
         BorderImage{
             anchors.fill:parent
             source: "../images/panel-west.png"
             border { left:8; right:8; top:8; bottom:8 }
 
             opacity: (plasmoid.configuration.showBarLine && !plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
 
             visible: (opacity == 0) ? false : true
 
             horizontalTileMode: BorderImage.Stretch
             verticalTileMode: BorderImage.Stretch
 
             Behavior on opacity{
                 NumberAnimation { duration: root.durationTime*units.longDuration }
             }
         }
 
 
         /// item which is used as anchors for the plasma's theme
         Item{
             id:belower
 
             width: (root.position === PlasmaCore.Types.LeftPositioned) ? shadowsSvgItem.margins.left : shadowsSvgItem.margins.right
             height: (root.position === PlasmaCore.Types.BottomPositioned)? shadowsSvgItem.margins.bottom : shadowsSvgItem.margins.top
 
             anchors.top: (root.position === PlasmaCore.Types.BottomPositioned) ? parent.bottom : undefined
             anchors.bottom: (root.position === PlasmaCore.Types.TopPositioned) ? parent.top : undefined
             anchors.right: (root.position === PlasmaCore.Types.LeftPositioned) ? parent.left : undefined
             anchors.left: (root.position === PlasmaCore.Types.RightPositioned) ? parent.right : undefined
         }
 
 
         /// the current theme's panel
         PlasmaCore.FrameSvgItem{
             id: shadowsSvgItem
 
             anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? belower.bottom : undefined
             anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? belower.top : undefined
             anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? belower.left : undefined
             anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? belower.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? parent.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? parent.verticalCenter : undefined
 
             width: root.vertical ? panelSize + margins.left + margins.right: parent.width
             height: root.vertical ? parent.height : panelSize + margins.top + margins.bottom
 
             imagePath: "translucent/widgets/panel-background"
             prefix:"shadow"
 
             opacity: (plasmoid.configuration.showBarLine && plasmoid.configuration.useThemePanel && !root.forceHidePanel) ? 1 : 0
             visible: (opacity == 0) ? false : true
 
             property int panelSize: ((root.position === PlasmaCore.Types.BottomPositioned) ||
                                      (root.position === PlasmaCore.Types.TopPositioned)) ?
                                         plasmoid.configuration.panelSize + belower.height:
                                         plasmoid.configuration.panelSize + belower.width
 
             Behavior on opacity{
                 NumberAnimation { duration: root.durationTime*units.longDuration }
             }
 
 
             PlasmaCore.FrameSvgItem{
                 anchors.margins: belower.width-1
                 anchors.fill:parent
                 imagePath: plasmoid.configuration.transparentPanel ? "translucent/widgets/panel-background" :
                                                                      "widgets/panel-background"
             }
         }
 
 
         TasksLayout.MouseHandler {
             id: mouseHandler
             anchors.bottom: (root.position === PlasmaCore.Types.BottomPositioned) ? scrollableList.bottom : undefined
             anchors.top: (root.position === PlasmaCore.Types.TopPositioned) ? scrollableList.top : undefined
             anchors.left: (root.position === PlasmaCore.Types.LeftPositioned) ? scrollableList.left : undefined
             anchors.right: (root.position === PlasmaCore.Types.RightPositioned) ? scrollableList.right : undefined
 
             anchors.horizontalCenter: !root.vertical ? scrollableList.horizontalCenter : undefined
             anchors.verticalCenter: root.vertical ? scrollableList.verticalCenter : undefined
 
             width: root.vertical ? maxSize : icList.width
             height: root.vertical ? icList.height : maxSize
 
             target: icList
 
             visible: root.dragAreaEnabled
 
             property int maxSize: (((root.hoveredIndex>=0 || dockHoveredIndex>=0 ) || windowPreviewIsShown) && !root.dragSource) ?
                                       root.zoomFactor * (root.iconSize + root.thickMargins) :
                                       root.iconSize + root.thickMargins
 
             function onlyLaunchersInList(list){
                 return list.every(function (item) {
                     return backend.isApplication(item)
                 });
             }
 
             function urlsDroppedOnArea(urls){
                 // If all dropped URLs point to application desktop files, we'll add a launcher for each of them.
                 if (onlyLaunchersInList(urls)) {
                     urls.forEach(function (item) {
                         addLauncher(item);
                     });
                     return;
                 }
 
                 if (!hoveredItem) {
                     return;
                 }
 
                 // DeclarativeMimeData urls is a QJsonArray but requestOpenUrls expects a proper QList<QUrl>.
                 var urlsList = backend.jsonArrayToUrlList(urls);
 
                 // Otherwise we'll just start a new instance of the application with the URLs as argument,
                 // as you probably don't expect some of your files to open in the app and others to spawn launchers.
                 tasksModel.requestOpenUrls(hoveredItem.modelIndex(), urlsList);
             }
 
             onUrlsDropped: {               
                 //! inform synced docks for new dropped launchers
                 if (latteView && latteView.launchersGroup >= Latte.Types.LayoutLaunchers && onlyLaunchersInList(urls)) {
                     latteView.layoutsManager.launchersSignals.urlsDropped(root.viewLayoutName,
                                                                           latteView.launchersGroup, urls);
                     return;
                 }
 
                 //! if the list does not contain only launchers then just open the corresponding
                 //! urls with the relevant app
                 urlsDroppedOnArea(urls);
             }
         }
 
         /* Rectangle {
             anchors.fill: scrollableList
             color: "transparent"
             border.width: 1
             border.color: "blue"
         } */
 
         TasksLayout.ScrollableList {
             id: scrollableList
             width: !root.vertical ? Math.min(root.width, icList.width) : thickness
             height: root.vertical ? Math.min(root.height, icList.height) : thickness
             contentWidth: icList.width
             contentHeight: icList.height
 
             property int thickness: {
                 if (latteView) {
                     return !latteView.thickAnimated ? latteView.maskManager.thicknessNormal : latteView.maskManager.thicknessZoom;
                 }
 
                 return (root.thickMargins + root.iconSize) * root.zoomFactor;
             }
 
             //onCurrentPosChanged: console.log("CP :: "+ currentPos + " icW:"+icList.width + " rw: "+root.width + " w:" +width);
 
             layer.enabled: contentsExceed && root.scrollingEnabled
             layer.effect: OpacityMask {
                 maskSource: TasksLayout.ScrollOpacityMask{
                     width: scrollableList.width
                     height: scrollableList.height
                 }
             }
 
             TasksLayout.ScrollPositioner {
                 id: listViewBase
 
                 ListView {
                     id:icList
                     width: !root.vertical ? contentWidth : mouseHandler.maxSize
                     height: root.vertical ? contentHeight : mouseHandler.maxSize
                     boundsBehavior: Flickable.StopAtBounds
                     orientation: Qt.Horizontal
                     delegate: Task.TaskItem{}
 
                     property int currentSpot : -1000
                     property int hoveredIndex : -1
                     property int previousCount : 0
 
                     property int tasksCount: tasksModel.count
 
                     property bool directRender: false
 
                     //the duration of this animation should be as small as possible
                     //it fixes a small issue with the dragging an item to change it's
                     //position, if the duration is too big there is a point in the
                     //list that an item is going back and forth too fast
 
                     //more of a trouble
                     moveDisplaced: Transition {
                         NumberAnimation { properties: "x,y"; duration: root.durationTime*units.longDuration; easing.type: Easing.Linear }
                     }
 
                     ///this transition can not be used with dragging !!!! I breaks
                     ///the lists indexes !!!!!
                     ///move: Transition {
                     ///    NumberAnimation { properties: "x,y"; duration: 400; easing.type: Easing.Linear }
                     ///}
 
                     function childAtPos(x, y){
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             var choords = mapFromItem(task,0, 0);
 
                             if( (task.objectName==="TaskItem") && (x>=choords.x) && (x<=choords.x+task.width)
                                     && (y>=choords.y) && (y<=choords.y+task.height)){
                                 return task;
                             }
                         }
 
                         return null;
                     }
 
                     function childAtIndex(position) {
                         var tasks = icList.contentItem.children;
 
                         if (position < 0)
                             return;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task.lastValidIndex === position
                                     || (task.lastValidIndex === -1 && task.itemIndex === position )) {
                                 return task;
                             }
                         }
 
                         return undefined;
                     }
 
                     function launcherModelIndex(url) {
                         var tasks = icList.contentItem.children;
 
                         for(var i=0; i<tasks.length; ++i){
                             var task = tasks[i];
 
                             if (task && (task.launcherUrl===url)) {
                                 return task.itemIndex;
                             }
                         }
 
                         return -1;
                     }
                 }
             } // ScrollPositioner
         } // ScrollableList
 
         TasksLayout.ScrollEdgeShadows {
             id: scrollShadows
             width: !root.vertical ? scrollableList.width : thickness
             height: !root.vertical ? thickness : scrollableList.height
             visible: scrollableList.contentsExceed
 
             flickable: scrollableList
         } // ScrollEdgeShadows
 
         LatteComponents.AddingArea {
             id: newDroppedLauncherVisual
             anchors.fill: mouseHandler
             visible: backgroundOpacity > 0
             radius: root.iconSize/10
             backgroundOpacity: root.dropNewLauncher && mouseHandler.onlyLaunchers && (root.dragSource == null)? 0.75 : 0
             duration: root.durationTime
 
             title: i18n("Tasks Area")
         }
     }
 
     //// helpers
 
     Timer {
         id: iconGeometryTimer
         // INVESTIGATE: such big interval but unfortunately it does not work otherwise
         interval: 500
         repeat: false
 
         onTriggered: {
             root.publishTasksGeometries();
 
             if (latteView && latteView.debugModeTimers) {
                 console.log("plasmoid timer: iconGeometryTimer called...");
             }
         }
     }
 
 
     ///REMOVE
     ////Activities List
     ////it can be used to cleanup the launchers from garbage-deleted activities....
     Item{
         id: activityModelInstance
         property int count: activityModelRepeater.count
 
         Repeater {
             id:activityModelRepeater
             model: Activities.ActivityModel {
                 id: activityModel
                 //  shownStates: "Running"
             }
             delegate: Item {
                 visible: false
                 property string activityId: model.id
                 property string activityName: model.name
             }
         }
 
         function activities(){
             var activitiesResult = [];
 
             for(var i=0; i<activityModelInstance.count; ++i){
                 console.log(children[i].activityId);
                 activitiesResult.push(children[i].activityId);
             }
 
             return activitiesResult;
         }
 
         ///REMOVE
         onCountChanged: {
             /*  if(activityInfo.currentActivity != "00000000-0000-0000-0000-000000000000"){
                 console.log("----------- Latte Plasmoid Signal: Activities number was changed ---------");
                 var allActivities = activities();
                 ActivitiesTools.cleanupRecords(allActivities);
                 console.log("----------- Latte Plasmoid Signal End ---------");
             }*/
         }
     }
 
     Timer{
         id:launchersOrderValidatorTimer
         interval: 400
 
         property var launchers: []
 
         function launchersAreInSync() {
             return arraysAreEqual(currentListViewLauncherList(), launchers);
         }
 
         function launcherValidPos(url) {
             for (var i=0; i<launchers.length; ++i) {
                 if (launchers[i] === url) {
                     return i;
                 }
             }
 
             return -1;
         }
 
         function arraysAreEqual(list1, list2) {
             if (list1.length !== list2.length) {
                 console.log("  arrays have different size...")
                 return false;
             }
 
             for (var i=0; i<list1.length; ++i) {
                 if (list1[i] !== list2[i]) {
                     return false;
                 }
             }
 
             return true;
         }
 
         //! true if upward is the best way to iterate through current
         //! in order to make it equal with goal
         function upwardIsBetter(current, goal)
         {
             var tCurrent = current.slice();
 
             if (!arraysAreEqual(tCurrent, goal)) {
                 for (var i=0; i<tCurrent.length; ++i) {
                     if (tCurrent[i] !== goal[i]) {
                         var val = tCurrent[i];
                         tCurrent.splice(i, 1);
                         tCurrent.splice(goal.indexOf(val), 0, val);
 
                         if (arraysAreEqual(tCurrent, goal)){
                             return true;
                         } else {
                             return false;
                         }
                     }
                 }
             }
 
             return false;
         }
 
 
         onTriggered: {
             if (launchersAreInSync()) {
                 stop();
                 console.log("launchers synced at:" + launchers);
                 launchers.length = 0;
                 parabolicManager.updateTasksEdgesIndexes();
                 root.separatorsUpdated();
                 tasksModel.syncLaunchers();
             } else {
                 var currentLaunchers = currentListViewLauncherList();
 
                 if (upwardIsBetter(currentLaunchers, launchers)) {
                     console.log("UPWARD....");
                     for (var i=0; i<currentLaunchers.length; ++i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 } else {
                     console.log("DOWNWARD....");
                     for (var i=currentLaunchers.length-1; i>=0; --i) {
                         if (currentLaunchers[i] !== launchers[i]) {
                             var p = launcherValidPos(currentLaunchers[i]);
                             if (p === -1) {
                                 console.log("No pos found for :"+currentLaunchers[i] + " at: "+launchers);
                                 restart();
                                 return;
                             }
                             var launcherModelIndex = icList.launcherModelIndex(currentLaunchers[i]);
 
                             if (launcherModelIndex === -1) {
                                 console.log(" launcher was not found in model, syncing stopped...");
                                 stop();
                                 return;
                             }
 
                             console.log(" moving:" +launcherModelIndex + " _ " + p );
                             tasksModel.move(launcherModelIndex, p);
                             restart();
                             return;
                         }
                     }
                 }
 
                 console.log("why we reached ??? ");
                 console.log("CURRENT ::: " + currentLaunchers);
                 console.log("VALID   ::: " + launchers);
             }
         }
     }
 
     /////////
 
     //// functions
     function movePanel(obj, newPosition){
         var bLine = obj;
         if (newPosition === PlasmaCore.Types.BottomPositioned){
             bLine.anchors.horizontalCenter = bLine.parent.horizontalCenter;
             bLine.anchors.verticalCenter = undefined;
             bLine.anchors.bottom = bLine.parent.bottom;
             bLine.anchors.top = undefined;
             bLine.anchors.left = undefined;
             bLine.anchors.right = undefined;
         }
         else if (newPosition === PlasmaCore.Types.TopPositioned){
             bLine.anchors.horizontalCenter = bLine.parent.horizontalCenter;
             bLine.anchors.verticalCenter = undefined;
             bLine.anchors.bottom = undefined;
             bLine.anchors.top = bLine.parent.top;
             bLine.anchors.left = undefined;
             bLine.anchors.right = undefined;
         }
         else if (newPosition === PlasmaCore.Types.LeftPositioned){
             bLine.anchors.horizontalCenter = undefined;
             bLine.anchors.verticalCenter = bLine.parent.verticalCenter;
             bLine.anchors.bottom = undefined;
             bLine.anchors.top = undefined;
             bLine.anchors.left = bLine.parent.left;
             bLine.anchors.right = undefined;
         }
         else if (newPosition === PlasmaCore.Types.RightPositioned){
             bLine.anchors.horizontalCenter = undefined;
             bLine.anchors.verticalCenter = bLine.parent.verticalCenter;
             bLine.anchors.bottom = undefined;
             bLine.anchors.top = undefined;
             bLine.anchors.left =undefined;
             bLine.anchors.right = bLine.parent.right;
         }
     }
 
     property int ncounter:0
 
     function updateImplicits(){
         if(icList.previousCount !== icList.count){
             icList.previousCount = icList.count;
 
             var zoomedLength = Math.floor( 1.2 * (iconSize+thickMargins) * (root.zoomFactor));
             var bigAxis = (tasksModel.count-1) * (iconSize+thickMargins) + zoomedLength;
             var smallAxis = zoomedLength;
 
             var clearBigAxis = tasksModel.count * (iconSize+thickMargins) + (barLine.spacing/2);
             var clearSmallAxis = iconSize+thickMargins;
 
             //  debugging code
             //     ncounter++;
             //      console.log("Implicits______ "+ncounter+". - "+tasksModel.count);
 
             if (root.vertical){
                 root.implicitWidth = smallAxis;
                 root.implicitHeight = bigAxis;
                 root.clearWidth = clearSmallAxis;
                 root.clearHeight = clearBigAxis;
             }
             else{
                 root.implicitWidth = bigAxis;
                 root.implicitHeight = smallAxis;
                 root.clearWidth = clearBigAxis;
                 root.clearHeight = clearSmallAxis;
             }
 
             iconGeometryTimer.restart();
         }
     }
 
     PlasmaComponents.Button{
         id: orientationBtn
         text:"Orientation"
 
         anchors.centerIn: parent
         visible: root.debugLocation
 
         onClicked:{
             switch(root.position){
             case PlasmaCore.Types.BottomPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.LeftEdge;
                 break;
             case PlasmaCore.Types.LeftPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.TopEdge;
                 break;
             case PlasmaCore.Types.TopPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.RightEdge;
                 break;
             case PlasmaCore.Types.RightPositioned:
                 root.newLocationDebugUse = PlasmaCore.Types.BottomEdge;
                 break;
             }
             updatePosition();
         }
     }
 
     function addInternalSeparatorAtPos(pos) {
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && latteView.launchersGroup >= Latte.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(root.viewLayoutName,
                                                                       latteView.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     // This is called by dockcorona in response to a Meta+number shortcut.
     function activateTaskAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         var tasks = icList.contentItem.children;
 
         //! this is used to bypass the internal separators if they exist
         var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.itemIndex === confirmedIndex) {
                 if (task.isGroupParent) {
                     task.activateNextTask();
                 } else {
                     task.activateTask();
                 }
                 break;
             }
         }
     }
 
     // This is called by dockcorona in response to a Meta+Alt+number shortcut.
     function newInstanceForTaskAtIndex(index) {
         if (typeof index !== "number") {
             return;
         }
 
         var tasks = icList.contentItem.children;
 
         //! this is used to bypass the internal separators if they exist
         var confirmedIndex = parabolicManager.realTaskIndex(index - 1);
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task.itemIndex === confirmedIndex) {
                 TaskTools.activateTask(task.modelIndex(), task.m, Qt.ControlModifier , task);
                 break;
             }
         }
     }
 
     function setHoveredIndex(ind) {
         icList.hoveredIndex = ind;
     }
 
     function updatePosition(){
         var newPosition;
         var tempVertical=false;
 
         var positionUsed;
 
 
         if (root.debugLocation)
             positionUsed = root.newLocationDebugUse;
         else
             positionUsed = plasmoid.location;
 
         switch (positionUsed) {
         case PlasmaCore.Types.LeftEdge:
             newPosition = PlasmaCore.Types.LeftPositioned;
             tempVertical = true;
             break;
         case PlasmaCore.Types.RightEdge:
             newPosition = PlasmaCore.Types.RightPositioned;
             tempVertical = true;
             break;
         case PlasmaCore.Types.TopEdge:
             newPosition = PlasmaCore.Types.TopPositioned;
             break;
         default:
             newPosition = PlasmaCore.Types.BottomPositioned;
             break
         }
 
         movePanel(barLine,newPosition);
         movePanel(icList,newPosition);
 
         if(tempVertical)
             icList.orientation = Qt.Vertical;
         else
             icList.orientation = Qt.Horizontal;
 
         root.position = newPosition;
     }
 
     function getBadger(identifier) {
         var ident1 = identifier;
         var n = ident1.lastIndexOf('/');
 
         var result = n>=0 ? ident1.substring(n + 1) : identifier;
 
         for(var i=0; i<badgers.length; ++i) {
             if (result.indexOf(badgers[i].id) >= 0) {
                 return badgers[i];
             }
         }
     }
 
     function updateBadge(identifier, value) {
         var tasks = icList.contentItem.children;
         var identifierF = identifier.concat(".desktop");
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if (task && task.launcherUrl && task.launcherUrl.indexOf(identifierF) >= 0) {
                 task.badgeIndicator = value === "" ? 0 : Number(value);
                 var badge = getBadger(identifierF);
                 if (badge) {
                     badge.value = value;
                 } else {
                     badgers.push({id: identifierF, value: value});
                 }
             }
         }
     }
 
     function getLauncherList() {
         return plasmoid.configuration.launchers59;
     }
 
     //! BEGIN ::: external launchers signals in order to update the tasks model
     function extSignalAddLauncher(group, launcher) {
         if (group === latteView.launchersGroup) {
             tasksModel.requestAddLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncher(group, launcher) {
         if (group === latteView.launchersGroup) {
             root.launcherForRemoval = launcher;
             tasksModel.requestRemoveLauncher(launcher);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalAddLauncherToActivity(group, launcher, activity) {
         if (group === latteView.launchersGroup) {
             var launcherActivities = tasksModel.launcherActivities(launcher);
 
             if (activity !== tasksModel.activity && (launcherActivities[0] === "00000000-0000-0000-0000-000000000000")) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestAddLauncherToActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalRemoveLauncherFromActivity(group, launcher, activity) {
         if (group === latteView.launchersGroup) {
             if (activity === tasksModel.activity) {
                 root.launcherForRemoval = launcher;
             }
 
             tasksModel.requestRemoveLauncherFromActivity(launcher, activity);
             launchersUpdatedFor(launcher);
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalUrlsDropped(group, urls) {
         if (group === latteView.launchersGroup) {
             mouseHandler.urlsDroppedOnArea(urls);
         }
     }
 
     function extSignalMoveTask(group, from, to) {
         if (group === latteView.launchersGroup && !root.dragSource) {
             tasksModel.move(from, to);
             parabolicManager.updateTasksEdgesIndexes();
             root.separatorsUpdated();
             tasksModel.syncLaunchers();
         }
     }
 
     function extSignalValidateLaunchersOrder(group, launchers) {
         if (group === latteView.launchersGroup && !root.dragSource) {
             launchersOrderValidatorTimer.stop();
             launchersOrderValidatorTimer.launchers = launchers;
             launchersOrderValidatorTimer.start();
         }
     }
 
     //! END ::: external launchers signals in order to update the tasks model
 
 
     //! it is used to add the fake desktop file which represents
     //! the separator (fake launcher)
     function addSeparator(pos){
         var separatorName = parabolicManager.freeAvailableSeparatorName();
 
         if (separatorName !== "") {
             tasksExtendedManager.addLauncherToBeMoved(separatorName, Math.max(0,pos));
 
             if (latteView && latteView.launchersGroup >= Latte.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.addLauncher(latteView.launchersGroup, separatorName);
             } else {
                 tasksModel.requestAddLauncher(separatorName);
             }
         }
     }
 
     function removeLastSeparator(){
         var separatorName = parabolicManager.lastPresentSeparatorName();
 
         if (separatorName !== "") {
             if (latteView && latteView.launchersGroup >= Latte.Types.LayoutLaunchers) {
                 latteView.layoutsManager.launchersSignals.removeLauncher(root.viewLayoutName,
                                                                          latteView.launchersGroup, separatorName);
             } else {
                 root.launcherForRemoval = separatorName;
                 tasksModel.requestRemoveLauncher(separatorName);
             }
         }
     }
 
     //! show/hide tasks numbered badges e.g. from global shortcuts
     function setShowTaskShortcutBadges(showBadges){
         showTaskShortcutBadges = showBadges;
     }
 
     //! setup the tasks first index based on the fact that this is a plasmoid
     //! and applets could exist before it
     function setTasksBaseIndex(base){
         tasksBaseIndex = base;
     }
 
     function previewContainsMouse() {
         if(toolTipDelegate && toolTipDelegate.containsMouse && toolTipDelegate.parentTask) {
             return true;
         } else {
             return false;
         }
     }
 
     function containsMouse(){
         //console.log("s1...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         //if (previewContainsMouse())
         //  windowsPreviewDlg.hide(4);
 
         if (previewContainsMouse())
             return true;
 
         //console.log("s3...");
         var tasks = icList.contentItem.children;
 
         for(var i=0; i<tasks.length; ++i){
             var task = tasks[i];
 
             if(task && task.containsMouse){
                 // console.log("Checking "+i+" - "+task.index+" - "+task.containsMouse);
                 return true;
             }
         }
 
         return false;
     }
 
     function clearZoom(){
         //console.log("Plasmoid clear...");
         if (disableRestoreZoom && (root.contextMenu || windowsPreviewDlg.visible)) {
             return;
         } else {
             disableRestoreZoom = false;
         }
 
         if (!previewContainsMouse())
             windowsPreviewDlg.hide(4.2);
 
         if (!latteView) {
             initializeHoveredIndex();
         }
 
         root.clearZoomSignal();
     }
 
     function hasLauncher(url) {
         return tasksModel.launcherPosition(url) != -1;
     }
 
     function addLauncher(url) {
         //workaround to protect in case the launcher contains the iconData
         var pos = url.indexOf("?iconData=");
 
         if (pos>0) {
             url = url.substring( 0, url.indexOf("?iconData=" ) );
         }
 
         var path = url;
         var filename = path.split("/").pop();
         tasksExtendedManager.addToBeAddedLauncher(filename);
 
         tasksModel.requestAddLauncher(url);
         launchersUpdatedFor(url);
         tasksModel.syncLaunchers();
     }
 
     function resetDragSource() {
         dragSource.z = 0;
         dragSource = null;
     }
 
     function setGlobalDirectRender(value) {
         if (tasksExtendedManager.waitingLaunchersLength() > 0)
             return;
 
         if (latteView) {
             latteView.setGlobalDirectRender(value);
         } else {
             if (value === true) {
                 if (root.containsMouse()) {
                     icList.directRender = true;
                 } else {
                     //    console.log("direct render true ignored...");
                 }
             } else {
                 icList.directRender = false;
             }
         }
     }
 
     function startCheckRestoreZoomTimer(duration) {
         if (latteView) {
             latteView.startCheckRestoreZoomTimer();
         } else {
             if (duration > 0) {
                 checkListHovered.startDuration(duration);
             } else {
                 checkListHovered.startNormal();
             }
         }
     }
 
     function stopCheckRestoreZoomTimer() {
         if (latteView) {
             latteView.stopCheckRestoreZoomTimer();
         } else {
             checkListHovered.stop();
         }
     }
 
     function startDirectRenderDelayerDuringEntering(){
         if (latteView) {
             latteView.startDirectRenderDelayerDuringEntering();
         } else {
             directRenderDelayerForEnteringTimer.start();
         }
     }
 
     ///REMOVE
     /*function createContextMenu(task) {
         var menu = root.contextMenuComponent.createObject(task);
         menu.visualParent = task;
         menu.mpris2Source = mpris2Source;
         menu.activitiesCount = activityModelInstance.count;
         return menu;
     }*/
 
     function createContextMenu(rootTask, modelIndex, args) {
         var initialArgs = args || {}
         initialArgs.visualParent = rootTask;
         initialArgs.modelIndex = modelIndex;
         initialArgs.mpris2Source = mpris2Source;
         initialArgs.backend = backend;
 
         root.contextMenu = root.contextMenuComponent.createObject(rootTask, initialArgs);
 
         return root.contextMenu;
     }
 
     Component.onCompleted:  {
         updatePosition();
 
         root.presentWindows.connect(backend.presentWindows);
         root.windowsHovered.connect(backend.windowsHovered);
         dragHelper.dropped.connect(resetDragSource);
     }
 
     Component.onDestruction: {
         root.presentWindows.disconnect(backend.presentWindows);
         root.windowsHovered.disconnect(backend.windowsHovered);
         dragHelper.dropped.disconnect(resetDragSource);
     }
 
     //BEGIN states
     //user set Panel Positions
     // 0-Center, 1-Left, 2-Right, 3-Top, 4-Bottom
     states: [
         ///Bottom Edge
         State {
             name: "bottomCenter"
             when: ((plasmoid.location===PlasmaCore.Types.BottomEdge || plasmoid.location===PlasmaCore.Types.Floating)
                    && root.userPanelPosition===Latte.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomLeft"
             when: ((plasmoid.location===PlasmaCore.Types.BottomEdge || plasmoid.location===PlasmaCore.Types.Floating)
                    && root.userPanelPosition===Latte.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "bottomRight"
             when: ((plasmoid.location===PlasmaCore.Types.BottomEdge || plasmoid.location===PlasmaCore.Types.Floating)
                    && root.userPanelPosition===Latte.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Top Edge
         State {
             name: "topCenter"
             when: (plasmoid.location===PlasmaCore.Types.TopEdge && root.userPanelPosition===Latte.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:undefined; horizontalCenter:parent.horizontalCenter; verticalCenter:undefined}
             }
         },
         State {
             name: "topLeft"
             when: (plasmoid.location===PlasmaCore.Types.TopEdge && root.userPanelPosition===Latte.Types.Left)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "topRight"
             when: (plasmoid.location===PlasmaCore.Types.TopEdge && root.userPanelPosition===Latte.Types.Right)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ////Left Edge
         State {
             name: "leftCenter"
             when: (plasmoid.location===PlasmaCore.Types.LeftEdge && root.userPanelPosition===Latte.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "leftTop"
             when: (plasmoid.location===PlasmaCore.Types.LeftEdge && root.userPanelPosition===Latte.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "leftBottom"
             when: (plasmoid.location===PlasmaCore.Types.LeftEdge && root.userPanelPosition===Latte.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:parent.left; right:undefined; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         ///Right Edge
         State {
             name: "rightCenter"
             when: (plasmoid.location===PlasmaCore.Types.RightEdge && root.userPanelPosition===Latte.Types.Center)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:parent.verticalCenter}
             }
         },
         State {
             name: "rightTop"
             when: (plasmoid.location===PlasmaCore.Types.RightEdge && root.userPanelPosition===Latte.Types.Top)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         },
         State {
             name: "rightBottom"
             when: (plasmoid.location===PlasmaCore.Types.RightEdge && root.userPanelPosition===Latte.Types.Bottom)
 
             AnchorChanges {
                 target: barLine
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
             AnchorChanges {
                 target: icList
                 anchors{ top:undefined; bottom:parent.bottom; left:undefined; right:parent.right; horizontalCenter:undefined; verticalCenter:undefined}
             }
         }
 
     ]
     //END states
 
 }
diff --git a/plasmoid/package/contents/ui/task/AudioStream.qml b/plasmoid/package/contents/ui/task/AudioStream.qml
index d701fb4b..10090738 100644
--- a/plasmoid/package/contents/ui/task/AudioStream.qml
+++ b/plasmoid/package/contents/ui/task/AudioStream.qml
@@ -1,136 +1,138 @@
 /***************************************************************************
  *   Copyright (C) 2017 Kai Uwe Broulik <kde@privat.broulik.de>            *
  *                                                                         *
  *   This program 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.                                   *
  *                                                                         *
  *   This program 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, write to the                         *
  *   Free Software Foundation, Inc.,                                       *
  *   51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA .        *
  ***************************************************************************/
 
 import QtQuick 2.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 Item {
     id: background
 
     Item {
         id: subRectangle
         width: parent.width/ 2
         height: width
 
         states: [
             State {
                 name: "default"
                 when: (root.position !== PlasmaCore.Types.RightPositioned)
 
                 AnchorChanges {
                     target: subRectangle
                     anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined;}
                 }
             },
             State {
                 name: "right"
                 when: (root.position === PlasmaCore.Types.RightPositioned)
 
                 AnchorChanges {
                     target: subRectangle
                     anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right;}
                 }
             }
         ]
 
         LatteComponents.BadgeText {
             anchors.centerIn: parent
             width: 0.8 * parent.width
             height: width
             minimumWidth: width
             maximumWidth: width
 
             fullCircle: true
             showNumber: false
             showText: true
 
             color: theme.backgroundColor
             borderColor: root.lightTextColor
             proportion: 0
             radiusPerCentage: 100
 
+            style3d: root.badges3DStyle
+
             Latte.IconItem{
                 id: audioStreamIcon
                 anchors.centerIn: parent
                 width: 0.9*parent.width
                 height: width
                 colorGroup: PlasmaCore.Theme.ButtonColorGroup
                 usesPlasmaTheme: true
 
                 //opacity: taskItem.playingAudio && !taskItem.muted ? 1 : 0.85
                 source: {
                     if (taskItem.volume <= 0 || taskItem.muted) {
                         return "audio-volume-muted";
                     } else if (taskItem.volume <= 25) {
                         return "audio-volume-low";
                     } else if (taskItem.volume <= 75) {
                         return "audio-volume-medium";
                     } else {
                         return "audio-volume-high" ;
                     }
                 }
 
                 MouseArea{
                     id: audioBadgeMouseArea
                     anchors.fill: parent
                     enabled: root.audioBadgeActionsEnabled
 
                     property bool wheelIsBlocked: false;
 
                     onClicked: {
                         taskItem.toggleMuted();
                     }
 
                     onWheel: {
                         if (wheelIsBlocked) {
                             return;
                         }
 
                         wheelIsBlocked = true;
                         scrollDelayer.start();
 
                         var angle = wheel.angleDelta.y / 8;
 
                         if (angle > 2) {
                             taskItem.increaseVolume();
                         } else if (angle < -2) {
                             taskItem.decreaseVolume();
                         }
                     }
 
                     //! A timer is needed in order to handle also touchpads that probably
                     //! send too many signals very fast. This way the signals per sec are limited.
                     //! The user needs to have a steady normal scroll in order to not
                     //! notice a annoying delay
                     Timer{
                         id: scrollDelayer
 
                         interval: 80
 
                         onTriggered: audioBadgeMouseArea.wheelIsBlocked = false;
                     }
                 }
             }
         }
     }
 }
diff --git a/plasmoid/package/contents/ui/task/ProgressOverlay.qml b/plasmoid/package/contents/ui/task/ProgressOverlay.qml
index 2bf6465c..db296167 100644
--- a/plasmoid/package/contents/ui/task/ProgressOverlay.qml
+++ b/plasmoid/package/contents/ui/task/ProgressOverlay.qml
@@ -1,127 +1,127 @@
 /*
 *  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.0
 
 import org.kde.plasma.core 2.0 as PlasmaCore
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 Item {
     id: background
 
     readonly property int contentWidth: progressCircle.width + 0.1*height
 
     Item {
         id: subRectangle
         width: contentWidth
         height: parent.height / 2
 
         states: [
             State {
                 name: "default"
                 when: (root.position !== PlasmaCore.Types.RightPositioned)
 
                 AnchorChanges {
                     target: subRectangle
                     anchors{ top:parent.top; bottom:undefined; left:undefined; right:parent.right;}
                 }
             },
             State {
                 name: "right"
                 when: (root.position === PlasmaCore.Types.RightPositioned)
 
                 AnchorChanges {
                     target: subRectangle
                     anchors{ top:parent.top; bottom:undefined; left:parent.left; right:undefined;}
                 }
             }
         ]
 
         LatteComponents.BadgeText {
             id: progressCircle
             anchors.centerIn: parent
             minimumWidth: Math.min(0.8 * parent.height, maximumWidth)
             maximumWidth: {
                 if (showsAudioBadge) {
                     return height;
                 } else if ( index === parabolicManager.firstRealTaskIndex && !taskItem.containsMouse) {
                     return (wrapper.mScale * (root.iconSize - (root.enableShadows ? shadowSize/2 : 0)));
                 } else {
                     return 999999;
                 }
             }
             height: 0.8 * parent.height
             numberValue: {
                 if (taskIcon.smartLauncherItem && (taskIcon.smartLauncherItem.countVisible || taskIcon.smartLauncherItem.progressVisible)) {
                     return taskIcon.smartLauncherItem.count;
                 } else if (taskItem.badgeIndicator > 0) {
                     return taskItem.badgeIndicator;
                 }
 
                 return 0;
             }
             fullCircle: true
             showNumber: true
 
             color: theme.backgroundColor
             textColor: {
                 if (showsInfoBadge) {
                     return root.infoBadgeProminentColorEnabled ? prominentTextColor : theme.highlightedTextColor
                 }
 
                 return theme.textColor;
             }
             borderColor: root.lightTextColor
 
             highlightedColor: {
                 if (showsInfoBadge) {
                     return root.infoBadgeProminentColorEnabled ? prominentBackColor : theme.highlightColor
                 }
 
                 return theme.buttonFocusColor;
             }
 
-
+            style3d: root.badges3DStyle
             textWithBackgroundColor: false
 
             proportion: {
                 if (taskIcon.smartLauncherItem && taskIcon.smartLauncherItem.progressVisible) {
                     return taskIcon.smartLauncherItem.progress / 100;
                 }
 
                 if (taskItem.badgeIndicator > 0 || (taskIcon.smartLauncherItem && taskIcon.smartLauncherItem.countVisible)) {
                     return 100;
                 }
 
                 return 0;
             }
 
             readonly property color prominentBackColor: "#cc0000" //redish  (deprecated: theme.negativeTextColor)
             readonly property color prominentTextColor: "#f3f3f3" //whitish (deprecated: root.lightTextColor)
 
             readonly property bool showsInfoBadge: ((taskItem.badgeIndicator > 0)
                                                     || (taskIcon.smartLauncherItem && taskIcon.smartLauncherItem.countVisible && !taskIcon.smartLauncherItem.progressVisible))
 
             readonly property bool showsAudioBadge: root.showAudioBadge && taskItem.hasAudioStream && taskItem.playingAudio && !taskItem.isSeparator
         }
     }
 }
diff --git a/plasmoid/package/contents/ui/task/ShortcutBadge.qml b/plasmoid/package/contents/ui/task/ShortcutBadge.qml
index 8aa77708..380422ac 100644
--- a/plasmoid/package/contents/ui/task/ShortcutBadge.qml
+++ b/plasmoid/package/contents/ui/task/ShortcutBadge.qml
@@ -1,81 +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/>.
 */
 
 import QtQuick 2.7
 import QtGraphicalEffects 1.0
 
 import org.kde.latte 0.2 as Latte
 import org.kde.latte.components 1.0 as LatteComponents
 
 Loader{
     id: shorcutBadge
     anchors.fill: iconImageBuffer
     active: root.showTaskShortcutBadges && !taskItem.isSeparator && fixedIndex>=0 && fixedIndex<20
     asynchronous: true
     visible: badgeString !== ""
 
     property int fixedIndex:-1
     property string badgeString: (shorcutBadge.fixedIndex>=1 && shorcutBadge.fixedIndex<20 && root.badgesForActivate.length===19) ?
                                      root.badgesForActivate[shorcutBadge.fixedIndex-1] : ""
 
     Connections {
         target: root
         onShowTaskShortcutBadgesChanged: shorcutBadge.fixedIndex = parabolicManager.pseudoTaskIndex(index+1);
     }
 
     Component.onCompleted: fixedIndex = parabolicManager.pseudoTaskIndex(index+1);
 
     sourceComponent: Item{
         Loader{
             anchors.fill: taskNumber
             active: root.enableShadows
 
             sourceComponent: DropShadow{
                 color: root.appShadowColor
                 fast: true
                 samples: 2 * radius
                 source: taskNumber
                 radius: root.appShadowSize/2
                 verticalOffset: 2
             }
         }
 
         LatteComponents.BadgeText {
             id: taskNumber
             // when iconSize < 48, height is always = 24, height / iconSize > 50%
             // we prefer center aligned badges to top-left aligned ones
             property bool centerInParent: root.iconSize < 48
 
             anchors.left: centerInParent? undefined : parent.left
             anchors.top: centerInParent? undefined : parent.top
             anchors.centerIn: centerInParent? parent : undefined
             minimumWidth: 0.4 * (wrapper.mScale * root.iconSize)
             height: Math.max(24, 0.4 * (wrapper.mScale * root.iconSize))
 
+            style3d: root.badges3DStyle
             textValue: shorcutBadge.badgeString
             borderColor: root.lightTextColor
 
             showNumber: false
             showText: true
 
             proportion: 0
             radiusPerCentage: 100
         }
     }
 }