diff --git a/gui/pimsettingexporterwindow.cpp b/gui/pimsettingexporterwindow.cpp
index 4601fe8..d056306 100644
--- a/gui/pimsettingexporterwindow.cpp
+++ b/gui/pimsettingexporterwindow.cpp
@@ -1,421 +1,436 @@
 /*
    Copyright (C) 2012-2017 Montel Laurent <montel@kde.org>
 
    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; see the file COPYING.  If not, write to
    the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    Boston, MA 02110-1301, USA.
 */
 
 #include "pimsettingexporterwindow.h"
 #include "dialog/showarchivestructuredialog.h"
 #include "importexportprogressindicatorgui.h"
 #include "widgets/logwidget.h"
 #include "pimsettingexportgui_debug.h"
 #include "job/fullsynchronizeresourcesjob.h"
 #include "trayicon/pimsettingstrayicon.h"
 
 #include "pimsettingimportdatainfofile.h"
 #include "pimsettingexporterkernel.h"
 #include "dialog/selectiontypedialog.h"
 #include "utils.h"
 #include "pimsettingsbackuprestoreui.h"
 #include "dialog/synchronizeresourcedialog.h"
 
 #include "dialog/backupfilestructureinfodialog.h"
 
 #include <MailCommon/MailKernel>
 #include <MailCommon/FilterManager>
 
 #include "PimCommon/PimUtil"
 
 #include <AkonadiWidgets/ControlGui>
 
 #include <KStandardAction>
 #include <KConfigGroup>
 #include <KActionCollection>
 #include <KMessageBox>
 #include <KLocalizedString>
 #include <QStatusBar>
 #include <KRecentFilesAction>
 #include <QPointer>
 #include <KSharedConfig>
 #include <KFileWidget>
 #include <KRecentDirs>
 #include <QStandardPaths>
 #include <QLocale>
 #include <QFileDialog>
 #include <QCommandLineParser>
 
 #include <dialog/pimsettingexporterconfiguredialog.h>
 
 PimSettingExporterWindow::PimSettingExporterWindow(QWidget *parent)
     : KXmlGuiWindow(parent)
     , mBackupAction(nullptr)
     , mRestoreAction(nullptr)
     , mSaveLogAction(nullptr)
     , mArchiveStructureInfo(nullptr)
     , mShowArchiveInformationsAction(nullptr)
     , mPimSettingsBackupRestoreUI(nullptr)
     , mTrayIcon(nullptr)
 {
     //Initialize filtermanager
     (void)MailCommon::FilterManager::instance();
     PimSettingExporterKernel *kernel = new PimSettingExporterKernel(this);
     CommonKernel->registerKernelIf(kernel);   //register KernelIf early, it is used by the Filter classes
     CommonKernel->registerSettingsIf(kernel);   //SettingsIf is used in FolderTreeWidget
 
     setupActions(true);
     setupGUI(Keys | StatusBar | Save | Create, QStringLiteral("pimsettingexporter.rc"));
     mLogWidget = new LogWidget(this);
 
     setCentralWidget(mLogWidget);
     resize(800, 600);
     Akonadi::ControlGui::widgetNeedsAkonadi(this);
     statusBar()->hide();
     mTrayIcon = new PimSettingsTrayIcon(this);
 }
 
 PimSettingExporterWindow::~PimSettingExporterWindow()
 {
     MailCommon::FilterManager::instance()->cleanup();
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup groupConfig = config->group(QStringLiteral("Recent File"));
     mRecentFilesAction->saveEntries(groupConfig);
 }
 
 void PimSettingExporterWindow::initializeBackupRestoreUi()
 {
     mPimSettingsBackupRestoreUI = new PimSettingsBackupRestoreUI(this, this);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::addInfo, this, &PimSettingExporterWindow::slotAddInfo);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::addEndLine, this, &PimSettingExporterWindow::slotAddEndLine);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::addError, this, &PimSettingExporterWindow::slotAddError);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::addTitle, this, &PimSettingExporterWindow::slotAddTitle);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::updateActions, this, &PimSettingExporterWindow::slotUpdateActions);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::jobFinished, this, &PimSettingExporterWindow::slotJobFinished);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::backupDone, this, &PimSettingExporterWindow::slotShowBackupFinishDialogInformation);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::jobFailed, this, &PimSettingExporterWindow::slotJobFailed);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestoreUI::needSyncResource, this, &PimSettingExporterWindow::slotAddResourceToSync);
     connect(mPimSettingsBackupRestoreUI, &PimSettingsBackupRestore::restoreDone, this, &PimSettingExporterWindow::slotRestoreDone);
 }
 
 void PimSettingExporterWindow::slotAddResourceToSync(const QString &name, const QString &identifier)
 {
     mNeedToSyncResources.insert(name, identifier);
 }
 
 void PimSettingExporterWindow::slotJobFinished()
 {
     mPimSettingsBackupRestoreUI->nextStep();
 }
 
 void PimSettingExporterWindow::slotJobFailed()
 {
     mPimSettingsBackupRestoreUI->closeArchive();
 }
 
 void PimSettingExporterWindow::slotRestoreDone()
 {
     if (!mNeedToSyncResources.isEmpty()) {
         QPointer<SynchronizeResourceDialog> dlg = new SynchronizeResourceDialog(this);
         dlg->setResources(mNeedToSyncResources);
         QStringList list;
         if (dlg->exec()) {
             list = dlg->resources();
         }
         delete dlg;
         if (!list.isEmpty()) {
             slotAddInfo(i18n("Full sync starts..."));
             FullSynchronizeResourcesJob *job = new FullSynchronizeResourcesJob(this);
             job->setWindowParent(this);
             job->setResources(list);
             connect(job, &FullSynchronizeResourcesJob::synchronizeFinished, this, &PimSettingExporterWindow::slotFullSyncFinished);
             connect(job, &FullSynchronizeResourcesJob::synchronizeInstanceDone, this, &PimSettingExporterWindow::slotFullSyncInstanceDone);
             connect(job, &FullSynchronizeResourcesJob::synchronizeInstanceFailed, this, &PimSettingExporterWindow::slotFullSyncInstanceFailed);
             job->start();
         }
     } else {
         slotUpdateActions(false);
     }
 }
 
 void PimSettingExporterWindow::slotShowBackupFinishDialogInformation()
 {
     showFinishInformation();
 }
 
 void PimSettingExporterWindow::slotFullSyncFinished()
 {
     slotUpdateActions(false);
     const QString str = i18n("Full sync finished.");
     slotAddInfo(str);
     mTrayIcon->setStatus(KStatusNotifierItem::Passive);
     mTrayIcon->setToolTipSubTitle(str);
 }
 
 void PimSettingExporterWindow::slotFullSyncInstanceDone(const QString &identifier)
 {
     slotAddInfo(i18n("Full sync for \"%1\" done.", identifier));
 }
 
 void PimSettingExporterWindow::slotFullSyncInstanceFailed(const QString &identifier)
 {
     slotAddError(i18n("Full sync for \"%1\" failed.", identifier));
 }
 
 void PimSettingExporterWindow::showFinishInformation()
 {
-    KMessageBox::information(this, i18n("For restoring data, you must use \"pimsettingexporter\". Be careful it can overwrite existing settings, data."), i18n("Backup infos."),
-                             QStringLiteral("setProgressDialogLabelBackupInfos"));
+    KMessageBox::information(
+        this,
+        i18n("For restoring data, you must use \"pimsettingexporter\". "
+             "Be careful as it can overwrite your existing settings and data."),
+        i18n("Backup"),
+        QStringLiteral("setProgressDialogLabelBackupInfos"));
     mTrayIcon->setStatus(KStatusNotifierItem::Passive);
 }
 
 void PimSettingExporterWindow::handleCommandLine(const QCommandLineParser &parser)
 {
     QString templateFile;
     if (parser.isSet(QStringLiteral("template"))) {
         templateFile = parser.value(QStringLiteral("template"));
     }
     if (parser.isSet(QStringLiteral("import"))) {
         if (!parser.positionalArguments().isEmpty()) {
             loadData(parser.positionalArguments().at(0), templateFile);
         }
     } else if (parser.isSet(QStringLiteral("export"))) {
         if (!parser.positionalArguments().isEmpty()) {
             backupData(parser.positionalArguments().at(0), templateFile);
         }
     }
 }
 
 void PimSettingExporterWindow::setupActions(bool canZipFile)
 {
     KActionCollection *ac = actionCollection();
 
     mBackupAction = ac->addAction(QStringLiteral("backup"), this, &PimSettingExporterWindow::slotBackupData);
     mBackupAction->setText(i18n("Export Data..."));
     mBackupAction->setEnabled(canZipFile);
 
     mRestoreAction = ac->addAction(QStringLiteral("restore"), this, &PimSettingExporterWindow::slotRestoreData);
     mRestoreAction->setText(i18n("Import Data..."));
     mRestoreAction->setEnabled(canZipFile);
 
     mSaveLogAction = ac->addAction(QStringLiteral("save_log"), this, &PimSettingExporterWindow::slotSaveLog);
     mSaveLogAction->setText(i18n("Save log..."));
 
     mArchiveStructureInfo = ac->addAction(QStringLiteral("show_structure_info"), this, &PimSettingExporterWindow::slotShowStructureInfos);
     mArchiveStructureInfo->setText(i18n("Show Archive Structure Information..."));
 
     mShowArchiveInformationsAction = ac->addAction(QStringLiteral("show_archive_info"), this, &PimSettingExporterWindow::slotShowArchiveInformations);
     mShowArchiveInformationsAction->setText(i18n("Show Archive Information..."));
 
     mShowArchiveInformationsAboutCurrentArchiveAction = ac->addAction(QStringLiteral("show_current_archive_info"), this, &PimSettingExporterWindow::slotShowCurrentArchiveInformations);
     mShowArchiveInformationsAboutCurrentArchiveAction->setText(i18n("Show Information on current Archive..."));
     mShowArchiveInformationsAboutCurrentArchiveAction->setEnabled(false);
 
     KStandardAction::quit(this, &PimSettingExporterWindow::close, ac);
     mRecentFilesAction = KStandardAction::openRecent(this, &PimSettingExporterWindow::slotRestoreFile, ac);
 
     KSharedConfig::Ptr config = KSharedConfig::openConfig();
     KConfigGroup groupConfig = config->group(QStringLiteral("Recent File"));
     mRecentFilesAction->loadEntries(groupConfig);
 
     KStandardAction::preferences(this, &PimSettingExporterWindow::slotConfigure, ac);
 }
 
 void PimSettingExporterWindow::slotConfigure()
 {
     PimSettingExporterConfigureDialog dlg(this);
     dlg.exec();
 }
 
 void PimSettingExporterWindow::slotUpdateActions(bool inAction)
 {
     mBackupAction->setEnabled(!inAction);
     mRestoreAction->setEnabled(!inAction);
     mSaveLogAction->setEnabled(!inAction);
     mArchiveStructureInfo->setEnabled(!inAction);
     mShowArchiveInformationsAction->setEnabled(!inAction);
     mShowArchiveInformationsAboutCurrentArchiveAction->setEnabled(!inAction && !mLastArchiveFileName.isEmpty());
 }
 
 void PimSettingExporterWindow::slotRestoreFile(const QUrl &url)
 {
     if (!url.isEmpty()) {
         loadData(url.path());
     }
 }
 
 void PimSettingExporterWindow::slotShowArchiveInformations()
 {
     const QString filename = QFileDialog::getOpenFileName(this, i18n("Select Archive"), QString(), i18n("Zip file (*.zip)"));
     if (filename.isEmpty()) {
         return;
     }
 
     QPointer<ShowArchiveStructureDialog> dlg = new ShowArchiveStructureDialog(filename, this);
     dlg->exec();
     delete dlg;
 }
 
 void PimSettingExporterWindow::slotSaveLog()
 {
     if (mLogWidget->isEmpty()) {
         KMessageBox::information(this, i18n("Log is empty."), i18n("Save log"));
         return;
     }
     const QString log = mLogWidget->toHtml();
     const QString filter(i18n("HTML Files (*.html)"));
     PimCommon::Util::saveTextAs(log, filter, this);
 }
 
 void PimSettingExporterWindow::slotBackupData()
 {
-    if (KMessageBox::warningContinueCancel(this, i18n("Before backing up data, it is recommended to quit all kdepim applications."), i18n("Backup")) == KMessageBox::Cancel) {
+    if (KMessageBox::warningContinueCancel(
+        this,
+        i18n("Please quit all kdepim applications before backing up your data."),
+        i18n("Backup")) == KMessageBox::Cancel) {
         return;
     }
     backupData();
 }
 
 void PimSettingExporterWindow::backupData(const QString &filename, const QString &templateFile)
 {
     QString currentFileName = filename;
     QPointer<SelectionTypeDialog> dialog = new SelectionTypeDialog(this);
     dialog->loadTemplate(templateFile);
     if (dialog->exec()) {
         mLogWidget->clear();
         initializeBackupRestoreUi();
         mPimSettingsBackupRestoreUI->setStoredParameters(dialog->storedType());
         mPimSettingsBackupRestoreUI->setExportedInfoFileName(dialog->exportedFileInfo());
         delete dialog;
 
         if (currentFileName.isEmpty()) {
             QString recentDirClass;
             currentFileName = QFileDialog::getSaveFileName(this, i18n("Create backup"),
                                                            KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///pimsettingexporter")), recentDirClass).toLocalFile(),
                                                            i18n("Zip file (*.zip)"));
             if (currentFileName.isEmpty()) {
                 return;
             }
             if (!recentDirClass.isEmpty()) {
                 KRecentDirs::add(recentDirClass, currentFileName);
             }
             mRecentFilesAction->addUrl(QUrl::fromLocalFile(currentFileName));
         }
         mTrayIcon->setStatus(KStatusNotifierItem::Active);
         mTrayIcon->setToolTipSubTitle(i18n("Backup in progress..."));
         if (!mPimSettingsBackupRestoreUI->backupStart(currentFileName)) {
             qCDebug(PIMSETTINGEXPORTERGUI_LOG) << " backup Start failed";
         }
         mLastArchiveFileName = currentFileName;
     } else {
         delete dialog;
     }
 }
 
 void PimSettingExporterWindow::slotAddInfo(const QString &info)
 {
     mLogWidget->addInfoLogEntry(info);
     qApp->processEvents();
 }
 
 void PimSettingExporterWindow::slotAddError(const QString &info)
 {
     mLogWidget->addErrorLogEntry(info);
     qApp->processEvents();
 }
 
 void PimSettingExporterWindow::slotAddTitle(const QString &info)
 {
     mLogWidget->addTitleLogEntry(info);
     qApp->processEvents();
 }
 
 void PimSettingExporterWindow::slotAddEndLine()
 {
     mLogWidget->addEndLineLogEntry();
     qApp->processEvents();
 }
 
 void PimSettingExporterWindow::slotRestoreData()
 {
     loadData();
 }
 
 void PimSettingExporterWindow::loadData(const QString &filename, const QString &templateFile)
 {
-    if (KMessageBox::warningYesNo(this, i18n("Before to restore data, close all kdepim applications. Do you want to continue?"), i18n("Backup")) == KMessageBox::No) {
+    if (KMessageBox::warningYesNo(
+        this,
+        i18n("Before restoring data you must close all kdepim applications. "
+             "Do you want to continue?"),
+        i18n("Backup")) == KMessageBox::No) {
         return;
     }
 
     //First select filename.
     QString currentFileName = filename;
     if (currentFileName.isEmpty()) {
         QString recentDirClass;
-        currentFileName = QFileDialog::getOpenFileName(this, i18n("Restore backup"),
-                                                       KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///pimsettingexporter")), recentDirClass).toLocalFile(),
-                                                       i18n("Zip File (*.zip)"));
+        currentFileName =
+            QFileDialog::getOpenFileName(
+                this,
+                i18n("Restore backup"),
+                KFileWidget::getStartUrl(QUrl(QStringLiteral("kfiledialog:///pimsettingexporter")),
+                                         recentDirClass).toLocalFile(),
+                i18n("Zip File (*.zip)"));
         if (currentFileName.isEmpty()) {
             return;
         }
         if (!recentDirClass.isEmpty()) {
             KRecentDirs::add(recentDirClass, currentFileName);
         }
     }
     // Don't put it in 'if' otherwise temporary file will be removed after that.
     QString templateFileName;
     PimSettingImportDataInfoFile dataInfo;
     bool cleanupItems = false;
     if (templateFile.isEmpty()) {
         dataInfo.setCurrentFileName(currentFileName);
         templateFileName = dataInfo.importDataInfoPath();
         cleanupItems = true;
     } else {
         templateFileName = templateFile;
     }
     QPointer<SelectionTypeDialog> dialog = new SelectionTypeDialog(this);
     dialog->loadTemplate(templateFileName);
     if (cleanupItems) {
         dialog->removeNotSelectedItems();
     }
     if (dialog->exec()) {
         mLogWidget->clear();
         mNeedToSyncResources.clear();
         initializeBackupRestoreUi();
         mPimSettingsBackupRestoreUI->setStoredParameters(dialog->storedType());
         delete dialog;
 
         mTrayIcon->setStatus(KStatusNotifierItem::Active);
         mTrayIcon->setToolTipSubTitle(i18n("Restore in progress..."));
         if (!mPimSettingsBackupRestoreUI->restoreStart(currentFileName)) {
             qCDebug(PIMSETTINGEXPORTERGUI_LOG) << " PimSettingExporterWindow restore failed";
         }
     } else {
         delete dialog;
     }
 }
 
 void PimSettingExporterWindow::slotShowStructureInfos()
 {
     QPointer<BackupFileStructureInfoDialog> dlg = new BackupFileStructureInfoDialog(this);
     dlg->exec();
     delete dlg;
 }
 
 void PimSettingExporterWindow::slotShowCurrentArchiveInformations()
 {
     if (!mLastArchiveFileName.isEmpty()) {
         QPointer<ShowArchiveStructureDialog> dlg = new ShowArchiveStructureDialog(mLastArchiveFileName, this);
         dlg->exec();
         delete dlg;
     }
 }