diff --git a/app/layoutconfigdialog.cpp b/app/layoutconfigdialog.cpp
index 918983da..c5489c4d 100644
--- a/app/layoutconfigdialog.cpp
+++ b/app/layoutconfigdialog.cpp
@@ -1,937 +1,955 @@
 /*
  * 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 "ui_layoutconfigdialog.h"
 #include "layoutconfigdialog.h"
 #include "layoutsettings.h"
 #include "layoutsDelegates/checkboxdelegate.h"
 #include "layoutsDelegates/colorcmbboxdelegate.h"
 #include "layoutsDelegates/activitycmbboxdelegate.h"
 
 #include <QDesktopServices>
 #include <QDir>
 #include <QFileDialog>
 #include <QHeaderView>
 #include <QMessageBox>
 #include <QProcess>
 #include <QStandardItem>
 #include <QStandardItemModel>
 #include <QTemporaryDir>
 
 #include <KArchive/KTar>
 #include <KArchive/KArchiveEntry>
 #include <KArchive/KArchiveDirectory>
 #include <KLocalizedString>
 #include <KNotification>
 
 
 namespace Latte {
 
 const int IDCOLUMN = 0;
 const int COLORCOLUMN = 1;
 const int NAMECOLUMN = 2;
 const int MENUCOLUMN = 3;
 const int ACTIVITYCOLUMN = 4;
 const QChar CheckMark{0x2714};
 
 LayoutConfigDialog::LayoutConfigDialog(QWidget *parent, LayoutManager *manager)
     : QDialog(parent),
       ui(new Ui::LayoutConfigDialog),
       m_manager(manager)
 {
     ui->setupUi(this);
 
     setWindowTitle(i18n("Layouts Editor"));
 
     setAttribute(Qt::WA_DeleteOnClose, true);
     setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
     resize(m_manager->corona()->universalSettings()->layoutsWindowSize());
 
     connect(ui->buttonBox->button(QDialogButtonBox::Apply), &QPushButton::clicked
             , this, &LayoutConfigDialog::apply);
     connect(ui->buttonBox->button(QDialogButtonBox::RestoreDefaults), &QPushButton::clicked
             , this, &LayoutConfigDialog::restoreDefaults);
 
     m_model = new QStandardItemModel(manager->layouts().count(), 5, this);
 
     ui->layoutsView->setModel(m_model);
     ui->layoutsView->setSelectionBehavior(QAbstractItemView::SelectRows);
     ui->layoutsView->horizontalHeader()->setStretchLastSection(true);
     ui->layoutsView->verticalHeader()->setVisible(false);
 
     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
     ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
 
     connect(m_manager, &LayoutManager::currentLayoutNameChanged, this, &LayoutConfigDialog::currentLayoutNameChanged);
 
     loadLayouts();
 
     QString iconsPath(m_manager->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;
 
     foreach (auto file, files) {
         int colorEnd = file.lastIndexOf("print.jpg");
         QString color = file.remove(colorEnd, 9);
         colors.append(color);
     }
 
     ui->layoutsView->setItemDelegateForColumn(COLORCOLUMN, new ColorCmbBoxDelegate(this, iconsPath, colors));
     ui->layoutsView->setItemDelegateForColumn(MENUCOLUMN, new CheckBoxDelegate(this));
     ui->layoutsView->setItemDelegateForColumn(ACTIVITYCOLUMN, new ActivityCmbBoxDelegate(this));
 
     ui->newButton->setText(i18nc("new button", "New"));
     ui->copyButton->setText(i18nc("copy button", "Copy"));
     ui->removeButton->setText(i18nc("remove button", "Remove"));
     ui->switchButton->setText(i18nc("switch button", "Switch"));
     ui->importButton->setText(i18nc("import button", "Import"));
     ui->exportButton->setText(i18nc("export button", "Export"));
 
     connect(m_model, &QStandardItemModel::itemChanged, this, &LayoutConfigDialog::itemChanged);
     connect(ui->layoutsView->selectionModel(), &QItemSelectionModel::currentRowChanged, this, &LayoutConfigDialog::currentRowChanged);
 }
 
 LayoutConfigDialog::~LayoutConfigDialog()
 {
     qDebug() << Q_FUNC_INFO;
 
     qDeleteAll(m_layouts);
 
     if (m_model) {
         delete m_model;
     }
 
     if (m_manager && m_manager->corona() && m_manager->corona()->universalSettings()) {
         m_manager->corona()->universalSettings()->setLayoutsWindowSize(size());
     }
 
     foreach (auto tempDir, m_tempDirectories) {
         QDir tDir(tempDir);
 
         if (tDir.exists() && tempDir.startsWith("/tmp/")) {
             tDir.removeRecursively();
         }
     }
 }
 
 QStringList LayoutConfigDialog::activities()
 {
     return m_manager->activities();
 }
 
 QStringList LayoutConfigDialog::availableActivities()
 {
     return m_availableActivities;
 }
 
 void LayoutConfigDialog::on_newButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     //! find Default preset path
     foreach (auto preset, m_manager->presetsPaths()) {
         QString presetName = LayoutSettings::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 LayoutConfigDialog::on_copyButton_clicked()
 {
     qDebug() << Q_FUNC_INFO;
 
     int row = ui->layoutsView->currentIndex().row();
 
     if (row < 0) {
         return;
     }
 
     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 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;
 
     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);
+    }
+
     LayoutSettings *settings = new LayoutSettings(this, copiedId);
     m_layouts[copiedId] = settings;
 
     insertLayoutInfoAtRow(row + 1, copiedId, color, layoutName, menu, QStringList());
 
     ui->layoutsView->selectRow(row + 1);
 }
 
 void LayoutConfigDialog::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 (layoutName == m_manager->currentLayoutName()) {
         return;
     }
 
     m_model->removeRow(row);
 
     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
     ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 
 
     row = qMax(row - 1, 0);
 
     ui->layoutsView->selectRow(row);
 }
 
 void LayoutConfigDialog::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) {
         Importer::LatteFileVersion version = Importer::fileVersion(file);
         qDebug() << "VERSION :::: " << version;
 
         if (version == Importer::LayoutVersion2) {
             addLayoutForFile(file);
         } else if (version == 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 \"" + file + "\"");
                 qGuiApp->exit();
             });
         } else if (version == 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 \"" + file + "\"");
                     qGuiApp->exit();
                 }
             });
 
             msg->open();
         }
     });
 
     fileDialog->open();
 }
 
 bool LayoutConfigDialog::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();
 
         foreach (auto &name, archiveRootDir->entries()) {
             auto fileEntry = archiveRootDir->file(name);
             fileEntry->copyTo(tempDir.absolutePath());
         }
 
         QString name = Importer::nameOfConfigFile(file);
 
         QString applets(tempDir.absolutePath() + "/" + "lattedock-appletsrc");
 
         if (QFile(applets).exists()) {
             if (m_manager->importer()->importOldLayout(applets, name, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + name + ".layout.latte", name, false);
             }
 
             QString alternativeName = name + "-" + i18nc("layout", "Alternative");
 
             if (m_manager->importer()->importOldLayout(applets, alternativeName, false, tempDir.absolutePath())) {
                 addLayoutForFile(tempDir.absolutePath() + "/" + alternativeName + ".layout.latte", alternativeName, false);
             }
         }
 
         return true;
     }
 
     return false;
 }
 
 
 void LayoutConfigDialog::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();
 
     qDebug() << Q_FUNC_INFO;
 
     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 configuraion", "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);
+            }
+
             LayoutSettings layoutS(this, file);
             layoutS.setActivities(QStringList());
 
             //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_manager->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 LayoutConfigDialog::accept()
 {
     qDebug() << Q_FUNC_INFO;
 
     //setVisible(false);
     if (saveAllChanges()) {
         deleteLater();
     }
 }
 
 void LayoutConfigDialog::reject()
 {
     qDebug() << Q_FUNC_INFO;
 
     deleteLater();
 }
 
 void LayoutConfigDialog::apply()
 {
     qDebug() << Q_FUNC_INFO;
     saveAllChanges();
     updateButtonsState();
 }
 
 void LayoutConfigDialog::restoreDefaults()
 {
     qDebug() << Q_FUNC_INFO;
 
     foreach (auto preset, m_manager->presetsPaths()) {
         QString presetName = LayoutSettings::layoutName(preset);
         QByteArray presetNameChars = presetName.toUtf8();
         const char *prset_str = presetNameChars.data();
         presetName = i18n(prset_str);
 
         if (!nameExistsInModel(presetName)) {
             addLayoutForFile(preset, presetName);
         }
     }
 }
 
 void LayoutConfigDialog::addLayoutForFile(QString file, QString layoutName, bool newTempDirectory, bool showNotification)
 {
     if (layoutName.isEmpty()) {
         layoutName = LayoutSettings::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);
+    }
+
     LayoutSettings *settings = new LayoutSettings(this, copiedId);
     m_layouts[copiedId] = settings;
 
     QString id = copiedId;
     QString color = settings->color();
     bool menu = settings->showInMenu();
 
     layoutName = uniqueLayoutName(layoutName);
 
     int row = ascendingRowFor(layoutName);
     insertLayoutInfoAtRow(row, copiedId, color, layoutName, menu, QStringList());
 
     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\n").arg(layoutName));
         notification->sendEvent();
     }
 }
 
 void LayoutConfigDialog::loadLayouts()
 {
     m_initLayoutPaths.clear();
     m_model->clear();
 
     int i = 0;
     QStringList brokenLayouts;
 
     foreach (auto layout, m_manager->layouts()) {
         QString layoutPath = QDir::homePath() + "/.config/latte/" + layout + ".layout.latte";
         m_initLayoutPaths.append(layoutPath);
 
         LayoutSettings *layoutSets = new LayoutSettings(this, layoutPath);
         m_layouts[layoutPath] = layoutSets;
 
         insertLayoutInfoAtRow(i, layoutPath, layoutSets->color(), layoutSets->name(),
                               layoutSets->showInMenu(), layoutSets->activities());
 
         qDebug() << "counter:" << i << " total:" << m_model->rowCount();
 
         i++;
 
         if (layoutSets->name() == m_manager->currentLayoutName()) {
             ui->layoutsView->selectRow(i - 1);
         }
 
         if (layoutSets->fileIsBroken()) {
             brokenLayouts.append(layoutSets->name());
         }
     }
 
     recalculateAvailableActivities();
 
     m_model->setHorizontalHeaderItem(IDCOLUMN, new QStandardItem(QString("#path")));
     m_model->setHorizontalHeaderItem(COLORCOLUMN, new QStandardItem(QString(i18n("Color"))));
     m_model->setHorizontalHeaderItem(NAMECOLUMN, new QStandardItem(QString(i18n("Name"))));
     m_model->setHorizontalHeaderItem(MENUCOLUMN, new QStandardItem(QString(i18n("In Menu"))));
     m_model->setHorizontalHeaderItem(ACTIVITYCOLUMN, new QStandardItem(QString(i18n("Activities"))));
 
     //! this line should be commented for debugging layouts window functionality
     ui->layoutsView->setColumnHidden(IDCOLUMN, true);
 
     //! 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();
     }
 }
 
 void LayoutConfigDialog::insertLayoutInfoAtRow(int row, QString path, QString color, QString name, bool menu, QStringList activities)
 {
     QStandardItem *pathItem = new QStandardItem(path);
 
     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 *activitiesItem = new QStandardItem(activities.join(","));
 
     QList<QStandardItem *> items;
 
     items.append(pathItem);
     items.append(colorItem);
     items.append(nameItem);
     items.append(menuItem);
     items.append(activitiesItem);
 
     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);
 
     QFont font;
 
     if (name == m_manager->currentLayoutName()) {
         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, ACTIVITYCOLUMN), activities, Qt::UserRole);
 }
 
 
 void LayoutConfigDialog::on_switchButton_clicked()
 {
     QVariant value = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), NAMECOLUMN), Qt::DisplayRole);
 
     if (value.isValid()) {
         m_manager->switchToLayout(value.toString());
     } else {
         qDebug() << "not valid layout";
     }
 }
 
 void LayoutConfigDialog::currentLayoutNameChanged()
 {
     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()) {
             QFont font;
 
             if (m_manager->currentLayoutName() == value.toString()) {
                 font.setBold(true);
                 ui->layoutsView->selectRow(i);
             } else {
                 font.setBold(false);
             }
 
             m_model->setData(nameIndex, font, Qt::FontRole);
         }
     }
 }
 
 void LayoutConfigDialog::itemChanged(QStandardItem *item)
 {
     ui->buttonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
     ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(true);
 
     if (item->column() == ACTIVITYCOLUMN) {
         //! recalculate the available activities
         recalculateAvailableActivities();
     }
 }
 
 void LayoutConfigDialog::currentRowChanged(const QModelIndex &current, const QModelIndex &previous)
 {
     updateButtonsState();
 }
 
 void LayoutConfigDialog::updateButtonsState()
 {
     QString id = m_model->data(m_model->index(ui->layoutsView->currentIndex().row(), IDCOLUMN), Qt::DisplayRole).toString();
 
     if (m_layouts[id]->name() == m_manager->currentLayoutName()) {
         ui->removeButton->setEnabled(false);
     } else {
         ui->removeButton->setEnabled(true);
     }
 
     if (id.startsWith("/tmp/")) {
         ui->switchButton->setEnabled(false);
     } else {
         ui->switchButton->setEnabled(true);
     }
 }
 
 void LayoutConfigDialog::recalculateAvailableActivities()
 {
     QStringList tempActivities = m_manager->activities();
 
     for (int i = 0; i < m_model->rowCount(); ++i) {
         QStringList assigned = m_model->data(m_model->index(i, ACTIVITYCOLUMN), Qt::UserRole).toStringList();
 
         foreach (auto activity, assigned) {
             if (tempActivities.contains(activity)) {
                 tempActivities.removeAll(activity);
             }
         }
     }
 
     m_availableActivities = tempActivities;
 }
 
 bool LayoutConfigDialog::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 LayoutConfigDialog::saveAllChanges()
 {
     if (!dataAreAccepted()) {
         return false;
     }
 
     QStringList knownActivities = activities();
 
     QTemporaryDir layoutTempDir;
 
     qDebug() << "Temporary Directory ::: " << layoutTempDir.path();
 
     QStringList fromRenamePaths;
     QStringList toRenamePaths;
     QStringList toRenameNames;
 
     QString switchToLayout;
 
     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 name = m_model->data(m_model->index(i, NAMECOLUMN), Qt::DisplayRole).toString();
         bool menu = m_model->data(m_model->index(i, MENUCOLUMN), 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
         foreach (auto activity, lActivities) {
             if (knownActivities.contains(activity)) {
                 cleanedActivities.append(activity);
             }
         }
 
         //qDebug() << i << ". " << id << " - " << color << " - " << name << " - " << menu << " - " << lActivities;
 
         LayoutSettings *layout = name == m_manager->currentLayoutName() ? m_manager->currentLayout() : m_layouts[id];
 
         if (layout->color() != color) {
             layout->setColor(color);
         }
 
         if (layout->showInMenu() != menu) {
             layout->setShowInMenu(menu);
         }
 
         if (layout->activities() != cleanedActivities) {
             layout->setActivities(cleanedActivities);
         }
 
         //!if the layout name changed or when the layout path is a temporary one
         if (layout->name() != name || (id.startsWith("/tmp/"))) {
             QString tempFile = layoutTempDir.path() + "/" + QString(layout->name() + ".layout.latte");
             qDebug() << "new temp file ::: " << tempFile;
 
             if (layout->name() == m_manager->currentLayoutName()) {
                 switchToLayout = name;
                 m_manager->corona()->unload();
             }
 
             layout = m_layouts.take(id);
             delete layout;
 
             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);
 
         LayoutSettings *nLayout = new LayoutSettings(this, newFile);
         m_layouts[newFile] = nLayout;
 
         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);
             }
         }
     }
 
     //! remove layouts that have been removed from the user
     foreach (auto initLayout, m_initLayoutPaths) {
         if (!idExistsInModel(initLayout)) {
             QFile(initLayout).remove();
         }
     }
 
     m_manager->loadLayouts();
 
     if (!switchToLayout.isNull()) {
         m_manager->switchToLayout(switchToLayout);
     }
 
     return true;
 }
 
 bool LayoutConfigDialog::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 LayoutConfigDialog::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;
 }
 
 int LayoutConfigDialog::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();
 }
 
 QString LayoutConfigDialog::uniqueTempDirectory()
 {
     QTemporaryDir tempDir;
     tempDir.setAutoRemove(false);
     m_tempDirectories.append(tempDir.path());
 
     return tempDir.path();
 }
 
 QString LayoutConfigDialog::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/layoutmanager.cpp b/app/layoutmanager.cpp
index 21970639..61bae349 100644
--- a/app/layoutmanager.cpp
+++ b/app/layoutmanager.cpp
@@ -1,440 +1,452 @@
 /*
 *  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 "layoutmanager.h"
 #include "infoview.h"
 
 #include <QDir>
 #include <QFile>
 #include <QQmlProperty>
 #include <QtDBus/QtDBus>
 
 #include <KActivities/Consumer>
 #include <KLocalizedString>
 #include <KNotification>
 
 namespace Latte {
 
 LayoutManager::LayoutManager(QObject *parent)
     : QObject(parent),
       m_importer(new Importer(this)),
       m_launchersSignals(new LaunchersSignals(this))
 {
     m_corona = qobject_cast<DockCorona *>(parent);
 
     if (m_corona) {
         //! create the add widgets action
         const QIcon addWidIcon = QIcon::fromTheme("add");
         m_addWidgetsAction = new QAction(addWidIcon, i18n("Add Widgets..."), this);
         m_addWidgetsAction->setStatusTip(i18n("Show Plasma Widget Explorer"));
         connect(m_addWidgetsAction, &QAction::triggered, this, &LayoutManager::showWidgetsExplorer);
 
         connect(m_corona->universalSettings(), &UniversalSettings::currentLayoutNameChanged, this, &LayoutManager::currentLayoutNameChanged);
         connect(m_corona->universalSettings(), &UniversalSettings::showInfoWindowChanged, this, &LayoutManager::showInfoWindowChanged);
 
         m_dynamicSwitchTimer.setSingleShot(true);
         showInfoWindowChanged();
         connect(&m_dynamicSwitchTimer, &QTimer::timeout, this, &LayoutManager::confirmDynamicSwitch);
     }
 }
 
 LayoutManager::~LayoutManager()
 {
     m_importer->deleteLater();
     m_launchersSignals->deleteLater();
 
     if (m_currentLayout) {
         m_currentLayout->deleteLater();
     }
 }
 
 void LayoutManager::load()
 {
     int configVer = m_corona->universalSettings()->version();
     qDebug() << "Universal Settings version : " << configVer;
 
     if (configVer < 2 && QFile(QDir::homePath() + "/.config/lattedockrc").exists()) {
         qDebug() << "Latte must update its configuration...";
         m_importer->updateOldConfiguration();
         importPresets(false);
     } else if (!QFile(QDir::homePath() + "/.config/lattedockrc").exists()) {
         //startup create what is necessary....
         QDir layoutDir(QDir::homePath() + "/.config/latte");
 
         if (!layoutDir.exists()) {
             QDir(QDir::homePath() + "/.config").mkdir("latte");
         }
 
         newLayout(i18n("My Layout"));
         importPresets(false);
         m_corona->universalSettings()->setCurrentLayoutName(i18n("My Layout"));
         m_corona->universalSettings()->setVersion(2);
     }
 
     qDebug() << "Latte is loading  its layouts...";
 
     connect(m_corona->m_activityConsumer, &KActivities::Consumer::currentActivityChanged,
             this, &LayoutManager::currentActivityChanged);
 
     loadLayouts();
 }
 
 DockCorona *LayoutManager::corona()
 {
     return m_corona;
 }
 
 Importer *LayoutManager::importer()
 {
     return m_importer;
 }
 
 QAction *LayoutManager::addWidgetsAction()
 {
     return m_addWidgetsAction;
 }
 
 LayoutSettings *LayoutManager::currentLayout()
 {
     return m_currentLayout;
 }
 
 LaunchersSignals *LayoutManager::launchersSignals()
 {
     return m_launchersSignals;
 }
 
 QString LayoutManager::currentLayoutName() const
 {
     if (m_corona && m_corona->universalSettings()) {
         return m_corona->universalSettings()->currentLayoutName();
     }
 
     return QString();
 }
 
 QStringList LayoutManager::layouts() const
 {
     return m_layouts;
 }
 
 QStringList LayoutManager::menuLayouts() const
 {
     QStringList fixedMenuLayouts = m_menuLayouts;
 
     //! in case the current layout isnt checked to be shown in the menus
     //! we must add it on top
     if (!fixedMenuLayouts.contains(currentLayoutName())) {
         fixedMenuLayouts.prepend(currentLayoutName());
     }
 
     return fixedMenuLayouts;
 }
 
 void LayoutManager::setMenuLayouts(QStringList layouts)
 {
     if (m_menuLayouts == layouts) {
         return;
     }
 
     m_menuLayouts = layouts;
     emit menuLayoutsChanged();
 }
 
 QStringList LayoutManager::activities()
 {
     return m_corona->m_activityConsumer->activities();
 }
 
 QStringList LayoutManager::presetsPaths() const
 {
     return m_presetsPaths;
 }
 
 QString LayoutManager::layoutPath(QString layoutName)
 {
     QString path = QDir::homePath() + "/.config/latte/" + layoutName + ".layout.latte";
 
     if (!QFile(path).exists()) {
         path = "";
     }
 
     return path;
 }
 
 void LayoutManager::currentActivityChanged(const QString &id)
 {
     qDebug() << "activity changed :: " << id;
 
     m_shouldSwitchToLayout = shouldSwitchToLayout(id);
 
     m_dynamicSwitchTimer.start();
 }
 
 void LayoutManager::showInfoWindowChanged()
 {
     if (m_corona->universalSettings()->showInfoWindow()) {
         m_dynamicSwitchTimer.setInterval(1800);
     } else {
         m_dynamicSwitchTimer.setInterval(2300);
     }
 }
 
 QString LayoutManager::shouldSwitchToLayout(QString activityId)
 {
     if (m_assignedLayouts.contains(activityId) && m_assignedLayouts[activityId] != currentLayoutName()) {
         return m_assignedLayouts[activityId];
     } else if (!m_assignedLayouts.contains(activityId) && !m_corona->universalSettings()->lastNonAssignedLayoutName().isEmpty()
                && m_corona->universalSettings()->lastNonAssignedLayoutName() != currentLayoutName()) {
         return m_corona->universalSettings()->lastNonAssignedLayoutName();
     }
 
     return QString();
 }
 
 void LayoutManager::confirmDynamicSwitch()
 {
     QString tempShouldSwitch = shouldSwitchToLayout(m_corona->m_activityConsumer->currentActivity());
 
     if (tempShouldSwitch.isEmpty()) {
         return;
     }
 
     if (m_shouldSwitchToLayout == tempShouldSwitch && m_shouldSwitchToLayout != currentLayoutName()) {
         qDebug() << "dynamic switch to layout :: " << m_shouldSwitchToLayout;
 
         if (m_corona->universalSettings()->showInfoWindow()) {
             showInfoWindow(i18n("Switching to layout <b>%0</b> ...").arg(m_shouldSwitchToLayout), 4000);
 
             QTimer::singleShot(500, [this, tempShouldSwitch]() {
                 switchToLayout(tempShouldSwitch);
             });
         } else {
             switchToLayout(m_shouldSwitchToLayout);
         }
 
     } else {
         m_shouldSwitchToLayout = tempShouldSwitch;
         m_dynamicSwitchTimer.start();
     }
 }
 
 void LayoutManager::loadLayouts()
 {
     m_layouts.clear();
     m_menuLayouts.clear();
     m_presetsPaths.clear();
     m_assignedLayouts.clear();
 
     QDir layoutDir(QDir::homePath() + "/.config/latte");
     QStringList filter;
     filter.append(QString("*.layout.latte"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
 
     foreach (auto layout, files) {
         LayoutSettings layoutSets(this, layoutDir.absolutePath() + "/" + layout);
 
         QStringList validActivityIds = validActivities(layoutSets.activities());
         layoutSets.setActivities(validActivityIds);
 
         foreach (auto activity, validActivityIds) {
             m_assignedLayouts[activity] = layoutSets.name();
         }
 
         m_layouts.append(layoutSets.name());
 
         if (layoutSets.showInMenu()) {
             m_menuLayouts.append(layoutSets.name());
         }
     }
 
     m_presetsPaths.append(m_corona->kPackage().filePath("preset1"));
     m_presetsPaths.append(m_corona->kPackage().filePath("preset2"));
     m_presetsPaths.append(m_corona->kPackage().filePath("preset3"));
     m_presetsPaths.append(m_corona->kPackage().filePath("preset4"));
 
     emit layoutsChanged();
     emit menuLayoutsChanged();
 }
 
 bool LayoutManager::switchToLayout(QString layoutName)
 {
     if (m_currentLayout && m_currentLayout->name() == layoutName) {
         return false;
     }
 
     QString lPath = layoutPath(layoutName);
 
     if (lPath.isEmpty() && layoutName == i18n("Alternative")) {
         lPath = newLayout(i18n("Alternative"), i18n("Default"));
     }
 
     if (!lPath.isEmpty()) {
         //! this code must be called asynchronously because it is called
         //! also from qml (Tasks plasmoid). This change fixes a very important
         //! crash when switching sessions through the Tasks plasmoid Context menu
         //! Latte was unstable and was crashing very often during changing
         //! sessions.
         QTimer::singleShot(0, [this, layoutName, lPath]() {
             qDebug() << layoutName << " - " << lPath;
 
             m_corona->loadLatteLayout(lPath);
             m_corona->universalSettings()->setCurrentLayoutName(layoutName);
 
             if (!layoutIsAssigned(layoutName)) {
                 m_corona->universalSettings()->setLastNonAssignedLayoutName(layoutName);
             }
 
             if (m_currentLayout) {
                 m_currentLayout->deleteLater();
             }
 
             m_currentLayout = new LayoutSettings(this, lPath, layoutName);
 
             emit currentLayoutChanged();
         });
     }
 
     return true;
 }
 
 QString LayoutManager::newLayout(QString layoutName, QString preset)
 {
     QDir layoutDir(QDir::homePath() + "/.config/latte");
     QStringList filter;
     filter.append(QString(layoutName + "*.layout.latte"));
     QStringList files = layoutDir.entryList(filter, QDir::Files | QDir::NoSymLinks);
 
     //! if the newLayout already exists provide a newName that doesnt
     if (files.count() >= 1) {
         int newCounter = files.count() + 1;
 
         layoutName = layoutName + "-" + QString::number(newCounter);
     }
 
     QString newLayoutPath = layoutDir.absolutePath() + "/" + layoutName + ".layout.latte";
 
     qDebug() << "adding layout : " << layoutName << " based on preset:" << preset;
 
     if (preset == i18n("Default") && !QFile(newLayoutPath).exists()) {
         qDebug() << "adding layout : succeed";
         QFile(m_corona->kPackage().filePath("preset1")).copy(newLayoutPath);
+
+        QFileInfo newFileInfo(newLayoutPath);
+
+        if (newFileInfo.exists() && !newFileInfo.isWritable()) {
+            QFile(newLayoutPath).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
+        }
     }
 
     return newLayoutPath;
 }
 
 void LayoutManager::importPresets(bool includeDefault)
 {
     int start = 1;
 
     if (!includeDefault) {
         start = 2;
     }
 
     for (int i = start; i <= 4; ++i) {
         QByteArray presetNameOrig = QString("preset" + QString::number(i)).toUtf8();
         QString presetPath = m_corona->kPackage().filePath(presetNameOrig);
         QString presetName = LayoutSettings::layoutName(presetPath);
         QByteArray presetNameChars = presetName.toUtf8();
         presetName = i18n(presetNameChars);
 
         QString newLayoutFile = QDir::homePath() + "/.config/latte/" + presetName + ".layout.latte";
 
         if (!QFile(newLayoutFile).exists()) {
             QFile(presetPath).copy(newLayoutFile);
+
+            QFileInfo newFileInfo(newLayoutFile);
+
+            if (newFileInfo.exists() && !newFileInfo.isWritable()) {
+                QFile(newLayoutFile).setPermissions(QFileDevice::ReadUser | QFileDevice::WriteUser | QFileDevice::ReadGroup | QFileDevice::ReadOther);
+            }
         }
     }
 }
 
 QStringList LayoutManager::validActivities(QStringList currentList)
 {
     QStringList validIds;
 
     foreach (auto activity, currentList) {
         if (activities().contains(activity)) {
             validIds.append(activity);
         }
     }
 
     return validIds;
 }
 
 bool LayoutManager::layoutIsAssigned(QString layoutName)
 {
     QHashIterator<const QString, QString> i(m_assignedLayouts);
 
     while (i.hasNext()) {
         i.next();
 
         if (i.value() == layoutName) {
             return true;
         }
     }
 
     return false;
 }
 
 void LayoutManager::showLayoutConfigDialog()
 {
     if (!m_layoutConfigDialog)
         m_layoutConfigDialog = new LayoutConfigDialog(nullptr, this);
 
     m_layoutConfigDialog->show();
 
     if (m_layoutConfigDialog->isMinimized()) {
         m_layoutConfigDialog->showNormal();
     }
 
     m_layoutConfigDialog->activateWindow();
 }
 
 void LayoutManager::showInfoWindow(QString info, int duration)
 {
     foreach (auto screen, qGuiApp->screens()) {
         InfoView *infoView = new InfoView(m_corona, info, screen);
 
         infoView->show();
 
         QTimer::singleShot(duration, [this, infoView]() {
             infoView->deleteLater();
         });
     }
 }
 
 void LayoutManager::showWidgetsExplorer()
 {
     QDBusInterface iface("org.kde.plasmashell", "/PlasmaShell", "", QDBusConnection::sessionBus());
 
     if (iface.isValid()) {
         iface.call("toggleWidgetExplorer");
     }
 }
 
 //! it is used just in order to provide translations for the presets
 void LayoutManager::ghostForTranslatedPresets()
 {
     QString preset1 = i18n("Default");
     QString preset2 = i18n("Plasma");
     QString preset3 = i18n("Unity");
     QString preset4 = i18n("Extended");
 }
 
 }