diff --git a/src/commands/importcertificatescommand.cpp b/src/commands/importcertificatescommand.cpp
index bba6d03f6..cf7dacf62 100644
--- a/src/commands/importcertificatescommand.cpp
+++ b/src/commands/importcertificatescommand.cpp
@@ -1,678 +1,679 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/importcertificatescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007, 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "importcertificatescommand.h"
 #include "importcertificatescommand_p.h"
 #include "certifycertificatecommand.h"
 #include "kleopatra_debug.h"
 
 #include <Libkleo/Algorithm>
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/KeyListJob>
 #include <QGpgME/Protocol>
 #include <QGpgME/ImportJob>
 #include <QGpgME/ImportFromKeyserverJob>
 #include <QGpgME/ChangeOwnerTrustJob>
 
 #include <gpgme++/global.h>
 #include <gpgme++/importresult.h>
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QByteArray>
 #include <QEventLoop>
 #include <QString>
 #include <QWidget>
 #include <QTreeView>
 #include <QTextDocument> // for Qt::escape
 
 #include <memory>
 #include <algorithm>
 #include <map>
 #include <set>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace QGpgME;
 
 namespace
 {
 
 make_comparator_str(ByImportFingerprint, .fingerprint());
 
 class ImportResultProxyModel : public AbstractKeyListSortFilterProxyModel
 {
     Q_OBJECT
 public:
     ImportResultProxyModel(const std::vector<ImportResult> &results, const QStringList &ids, QObject *parent = nullptr)
         : AbstractKeyListSortFilterProxyModel(parent)
     {
         updateFindCache(results, ids);
     }
 
     ~ImportResultProxyModel() override {}
 
     ImportResultProxyModel *clone() const override
     {
         // compiler-generated copy ctor is fine!
         return new ImportResultProxyModel(*this);
     }
 
     void setImportResults(const std::vector<ImportResult> &results, const QStringList &ids)
     {
         updateFindCache(results, ids);
         invalidateFilter();
     }
 
 protected:
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid() || role != Qt::ToolTipRole) {
             return AbstractKeyListSortFilterProxyModel::data(index, role);
         }
         const QString fpr = index.data(KeyList::FingerprintRole).toString();
         // find information:
         const std::vector<Import>::const_iterator it
             = Kleo::binary_find(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                                 fpr.toLatin1().constData(),
                                 ByImportFingerprint<std::less>());
         if (it == m_importsByFingerprint.end()) {
             return AbstractKeyListSortFilterProxyModel::data(index, role);
         } else {
             QStringList rv;
             const auto ids = m_idsByFingerprint[it->fingerprint()];
             rv.reserve(ids.size());
             std::copy(ids.cbegin(), ids.cend(), std::back_inserter(rv));
             return Formatting::importMetaData(*it, rv);
         }
     }
     bool filterAcceptsRow(int source_row, const QModelIndex &source_parent) const override
     {
         //
         // 0. Keep parents of matching children:
         //
         const QModelIndex index = sourceModel()->index(source_row, 0, source_parent);
         Q_ASSERT(index.isValid());
         for (int i = 0, end = sourceModel()->rowCount(index); i != end; ++i)
             if (filterAcceptsRow(i, index)) {
                 return true;
             }
         //
         // 1. Check that this is an imported key:
         //
         const QString fpr = index.data(KeyList::FingerprintRole).toString();
 
         return std::binary_search(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                                   fpr.toLatin1().constData(),
                                   ByImportFingerprint<std::less>());
     }
 
 private:
     void updateFindCache(const std::vector<ImportResult> &results, const QStringList &ids)
     {
         Q_ASSERT(results.size() == static_cast<unsigned>(ids.size()));
         m_importsByFingerprint.clear();
         m_idsByFingerprint.clear();
         m_results = results;
         for (unsigned int i = 0, end = results.size(); i != end; ++i) {
             const std::vector<Import> imports = results[i].imports();
             m_importsByFingerprint.insert(m_importsByFingerprint.end(), imports.begin(), imports.end());
             const QString &id = ids[i];
             for (std::vector<Import>::const_iterator it = imports.begin(), end = imports.end(); it != end; ++it) {
                 m_idsByFingerprint[it->fingerprint()].insert(id);
             }
         }
         std::sort(m_importsByFingerprint.begin(), m_importsByFingerprint.end(),
                   ByImportFingerprint<std::less>());
     }
 
 private:
     mutable std::vector<Import> m_importsByFingerprint;
     mutable std::map< const char *, std::set<QString>, ByImportFingerprint<std::less> > m_idsByFingerprint;
     std::vector<ImportResult> m_results;
 };
 
 }
 
 ImportCertificatesCommand::Private::Private(ImportCertificatesCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       waitForMoreJobs(false),
       containedExternalCMSCerts(false),
       nonWorkingProtocols(),
       idsByJob(),
       jobs(),
       results(),
       ids()
 {
 
 }
 
 ImportCertificatesCommand::Private::~Private() {}
 
 #define d d_func()
 #define q q_func()
 
 ImportCertificatesCommand::ImportCertificatesCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
 
 }
 
 ImportCertificatesCommand::ImportCertificatesCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
 
 }
 
 ImportCertificatesCommand::~ImportCertificatesCommand() {}
 
 static QString format_ids(const QStringList &ids)
 {
     QStringList escapedIds;
     for (const QString &id : ids) {
         if (!id.isEmpty()) {
             escapedIds << id.toHtmlEscaped();
         }
     }
     return escapedIds.join(QLatin1String("<br>"));
 }
 
 static QString make_tooltip(const QStringList &ids)
 {
     if (ids.empty()) {
         return QString();
     }
     if (ids.size() == 1)
         if (ids.front().isEmpty()) {
             return QString();
         } else
             return i18nc("@info:tooltip",
                          "Imported Certificates from %1",
                          ids.front().toHtmlEscaped());
     else
         return i18nc("@info:tooltip",
                      "Imported certificates from these sources:<br/>%1",
                      format_ids(ids));
 }
 
 void ImportCertificatesCommand::Private::setImportResultProxyModel(const std::vector<ImportResult> &results, const QStringList &ids)
 {
     if (std::none_of(results.cbegin(), results.cend(), std::mem_fn(&ImportResult::numConsidered))) {
         return;
     }
     q->addTemporaryView(i18nc("@title:tab", "Imported Certificates"),
                         new ImportResultProxyModel(results, ids),
                         make_tooltip(ids));
     if (QTreeView *const tv = qobject_cast<QTreeView *>(parentWidgetOrView())) {
         tv->expandAll();
     }
 }
 
 int sum(const std::vector<ImportResult> &res, int (ImportResult::*fun)() const)
 {
     return kdtools::accumulate_transform(res.begin(), res.end(), std::mem_fn(fun), 0);
 }
 
 static QString make_report(const std::vector<ImportResult> &res, const QString &id = QString())
 {
 
     const KLocalizedString normalLine = ki18n("<tr><td align=\"right\">%1</td><td>%2</td></tr>");
     const KLocalizedString boldLine = ki18n("<tr><td align=\"right\"><b>%1</b></td><td>%2</td></tr>");
     const KLocalizedString headerLine = ki18n("<tr><th colspan=\"2\" align=\"center\">%1</th></tr>");
 
 #define SUM( x ) sum( res, &ImportResult::x )
 
     QStringList lines;
     if (!id.isEmpty()) {
         lines.push_back(headerLine.subs(id).toString());
     }
     lines.push_back(normalLine.subs(i18n("Total number processed:"))
                     .subs(SUM(numConsidered)).toString());
     lines.push_back(normalLine.subs(i18n("Imported:"))
                     .subs(SUM(numImported)).toString());
     if (const int n = SUM(newSignatures))
         lines.push_back(normalLine.subs(i18n("New signatures:"))
                         .subs(n).toString());
     if (const int n = SUM(newUserIDs))
         lines.push_back(normalLine.subs(i18n("New user IDs:"))
                         .subs(n).toString());
     if (const int n = SUM(numKeysWithoutUserID))
         lines.push_back(normalLine.subs(i18n("Certificates without user IDs:"))
                         .subs(n).toString());
     if (const int n = SUM(newSubkeys))
         lines.push_back(normalLine.subs(i18n("New subkeys:"))
                         .subs(n).toString());
     if (const int n = SUM(newRevocations))
         lines.push_back(boldLine.subs(i18n("Newly revoked:"))
                         .subs(n).toString());
     if (const int n = SUM(notImported))
         lines.push_back(boldLine.subs(i18n("Not imported:"))
                         .subs(n).toString());
     if (const int n = SUM(numUnchanged))
         lines.push_back(normalLine.subs(i18n("Unchanged:"))
                         .subs(n).toString());
     if (const int n = SUM(numSecretKeysConsidered))
         lines.push_back(normalLine.subs(i18n("Secret keys processed:"))
                         .subs(n).toString());
     if (const int n = SUM(numSecretKeysImported))
         lines.push_back(normalLine.subs(i18n("Secret keys imported:"))
                         .subs(n).toString());
     if (const int n = SUM(numSecretKeysConsidered) - SUM(numSecretKeysImported) - SUM(numSecretKeysUnchanged))
         if (n > 0)
             lines.push_back(boldLine.subs(i18n("Secret keys <em>not</em> imported:"))
                             .subs(n).toString());
     if (const int n = SUM(numSecretKeysUnchanged))
         lines.push_back(normalLine.subs(i18n("Secret keys unchanged:"))
                         .subs(n).toString());
     if (const int n = SUM(numV3KeysSkipped))
         lines.push_back(normalLine.subs(i18n("Deprecated PGP-2 keys skipped:"))
                         .subs(n).toString());
 
 #undef sum
 
     return lines.join(QString());
 }
 
 static QString make_message_report(const std::vector<ImportResult> &res, const QStringList &ids)
 {
 
     Q_ASSERT(res.size() == static_cast<unsigned>(ids.size()));
 
     if (res.empty()) {
         return i18n("No imports (should not happen, please report a bug).");
     }
 
     if (res.size() == 1)
         return ids.front().isEmpty()
                ? i18n("<qt><p>Detailed results of certificate import:</p>"
                       "<table width=\"100%\">%1</table></qt>", make_report(res))
                : i18n("<qt><p>Detailed results of importing %1:</p>"
                       "<table width=\"100%\">%2</table></qt>", ids.front(), make_report(res));
 
     return i18n("<qt><p>Detailed results of certificate import:</p>"
                 "<table width=\"100%\">%1</table></qt>", make_report(res, i18n("Totals")));
 }
 
 // Returns false on error, true if please certify was shown.
 bool ImportCertificatesCommand::Private::showPleaseCertify(const GpgME::Import &imp)
 {
     const char *fpr = imp.fingerprint();
     if (!fpr) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Import without fingerprint";
         return false;
     }
     // Exactly one public key imported. Let's see if it is openpgp. We are async here so
     // we can just fetch it.
 
     auto ctx = GpgME::Context::createForProtocol(GpgME::OpenPGP);
     if (!ctx) {
         // WTF
         qCWarning(KLEOPATRA_LOG) << "Failed to create OpenPGP proto";
         return false;
     }
     GpgME::Error err;
     auto key = ctx->key(fpr, err, false);
     delete ctx;
 
     if (key.isNull() || err) {
         // No such key most likely not OpenPGP
         return false;
     }
 
     for (const auto &uid: key.userIDs()) {
         if (uid.validity() >= GpgME::UserID::Marginal) {
             // Already marginal so don't bug the user
             return false;
         }
     }
 
     const QStringList suggestions = QStringList() << i18n("A phone call to the person.")
         << i18n("Using a business card.")
         << i18n("Confirming it on a trusted website.");
 
     auto sel = KMessageBox::questionYesNo(parentWidgetOrView(),
                 i18n("In order to mark the certificate as valid (green) it needs to be certified.") + QStringLiteral("<br>") +
                 i18n("Certifying means that you check the Fingerprint.") + QStringLiteral("<br>") +
                 i18n("Some suggestions to do this are:") +
                 QStringLiteral("<li><ul>%1").arg(suggestions.join(QStringLiteral("</ul><ul>"))) +
                 QStringLiteral("</ul></li>") +
                 i18n("Do you wish to start this process now?"),
                 i18nc("@title", "You have imported a new certificate (public key)"),
                 KStandardGuiItem::yes(), KStandardGuiItem::no(), QStringLiteral("CertifyQuestion"));
     if (sel == KMessageBox::Yes) {
         QEventLoop loop;
         auto cmd = new Commands::CertifyCertificateCommand(key);
         cmd->setParentWidget(parentWidgetOrView());
         loop.connect(cmd, SIGNAL(finished()), SLOT(quit()));
         QMetaObject::invokeMethod(cmd, &Commands::CertifyCertificateCommand::start, Qt::QueuedConnection);
         loop.exec();
     }
     return true;
 }
 
 void ImportCertificatesCommand::Private::showDetails(QWidget *parent, const std::vector<ImportResult> &res, const QStringList &ids)
 {
     if (res.size() == 1 && res[0].numImported() == 1 && res[0].imports().size() == 1) {
         if (showPleaseCertify(res[0].imports()[0])) {
             return;
         }
     }
     setImportResultProxyModel(res, ids);
     KMessageBox::information(parent, make_message_report(res, ids), i18n("Certificate Import Result"));
 }
 
 void ImportCertificatesCommand::Private::showDetails(const std::vector<ImportResult> &res, const QStringList &ids)
 {
     showDetails(parentWidgetOrView(), res, ids);
 }
 
 static QString make_error_message(const Error &err, const QString &id)
 {
     Q_ASSERT(err);
     Q_ASSERT(!err.isCanceled());
     return id.isEmpty()
            ? i18n("<qt><p>An error occurred while trying "
                   "to import the certificate:</p>"
                   "<p><b>%1</b></p></qt>",
                   QString::fromLocal8Bit(err.asString()))
            : i18n("<qt><p>An error occurred while trying "
                   "to import the certificate %1:</p>"
                   "<p><b>%2</b></p></qt>",
                   id, QString::fromLocal8Bit(err.asString()));
 }
 
 void ImportCertificatesCommand::Private::showError(QWidget *parent, const Error &err, const QString &id)
 {
     if (parent) {
         KMessageBox::error(parent, make_error_message(err, id), i18n("Certificate Import Failed"));
     } else {
         showError(err, id);
     }
 }
 
 void ImportCertificatesCommand::Private::showError(const Error &err, const QString &id)
 {
     error(make_error_message(err, id), i18n("Certificate Import Failed"));
 }
 
 void ImportCertificatesCommand::Private::setWaitForMoreJobs(bool wait)
 {
     if (wait == waitForMoreJobs) {
         return;
     }
     waitForMoreJobs = wait;
     tryToFinish();
 }
 
 void ImportCertificatesCommand::Private::importResult(const ImportResult &result)
 {
 
     jobs.erase(std::remove(jobs.begin(), jobs.end(), q->sender()), jobs.end());
 
     importResult(result, idsByJob[q->sender()]);
 }
 
 void ImportCertificatesCommand::Private::importResult(const ImportResult &result, const QString &id)
 {
 
     results.push_back(result);
     ids.push_back(id);
 
     tryToFinish();
 }
 
 static void handleOwnerTrust(const std::vector<GpgME::ImportResult> &results)
 {
     //iterate over all imported certificates
     for (const ImportResult &result : results) {
         //when a new certificate got a secret key
         if (result.numSecretKeysImported() >= 1) {
             const char *fingerPr = result.imports()[0].fingerprint();
             GpgME::Error err;
             QScopedPointer<Context>
                 ctx(Context::createForProtocol(GpgME::Protocol::OpenPGP));
 
             if (!ctx){
                 qCWarning(KLEOPATRA_LOG) << "Failed to get context";
                 continue;
             }
 
             const Key toTrustOwner = ctx->key(fingerPr, err , false);
 
             if (toTrustOwner.isNull()) {
                 return;
             }
 
             QStringList uids;
-            uids.reserve(toTrustOwner.userIDs().size());
-            Q_FOREACH (const UserID &uid, toTrustOwner.userIDs()) {
+            const auto toTrustOwnerUserIDs{toTrustOwner.userIDs()};
+            uids.reserve(toTrustOwnerUserIDs.size());
+            for (const UserID &uid : toTrustOwnerUserIDs) {
                 uids << Formatting::prettyNameAndEMail(uid);
             }
 
             const QString str = xi18nc("@info",
                 "<title>You have imported a Secret Key.</title>"
                 "<para>The key has the fingerprint:<nl/>"
                 "<numid>%1</numid>"
                 "</para>"
                 "<para>And claims the User IDs:"
                 "<list><item>%2</item></list>"
                 "</para>"
                 "Is this your own key? (Set trust level to ultimate)",
                 QString::fromUtf8(fingerPr),
                 uids.join(QLatin1String("</item><item>")));
 
             int k = KMessageBox::questionYesNo(nullptr, str, i18nc("@title:window",
                                                                "Secret key imported"));
 
             if (k == KMessageBox::Yes) {
                 //To use the ChangeOwnerTrustJob over
                 //the CryptoBackendFactory
                 const QGpgME::Protocol *const backend = QGpgME::openpgp();
 
                 if (!backend){
                     qCWarning(KLEOPATRA_LOG) << "Failed to get CryptoBackend";
                     return;
                 }
 
                 ChangeOwnerTrustJob *const j = backend->changeOwnerTrustJob();
                 j->start(toTrustOwner, Key::Ultimate);
             }
         }
     }
 }
 
 void ImportCertificatesCommand::Private::handleExternalCMSImports()
 {
     QStringList fingerprints;
     // For external CMS Imports we have to manually do a keylist
     // with validation to get the intermediate and root ca imported
     // automatically if trusted-certs and extra-certs are used.
     for (const ImportResult &result : std::as_const(results)) {
         const auto imports = result.imports();
         for (const Import &import : imports) {
             if (!import.fingerprint()) {
                 continue;
             }
             fingerprints << QString::fromLatin1(import.fingerprint());
         }
     }
 
     auto job = QGpgME::smime()->keyListJob(false, true, true);
 
     // Old connect here because of Windows.
     connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)),
             q, SLOT(keyListDone(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)));
     job->start(fingerprints, false);
 }
 
 void ImportCertificatesCommand::Private::keyListDone(const GpgME::KeyListResult &,
                                                      const std::vector<GpgME::Key> &keys,
                                                      const QString &, const GpgME::Error&)
 {
     KeyCache::mutableInstance()->refresh(keys);
     showDetails(results, ids);
 
     auto tv = dynamic_cast<QTreeView *> (view());
     if (!tv) {
         qCDebug(KLEOPATRA_LOG) << "Failed to find treeview";
     } else {
         tv->expandAll();
     }
     finished();
 }
 
 void ImportCertificatesCommand::Private::tryToFinish()
 {
 
     if (waitForMoreJobs || !jobs.empty()) {
         return;
     }
 
     if (std::any_of(results.cbegin(), results.cend(),
                     [](const GpgME::ImportResult &result) {
                         return result.error().code();
                     })) {
         setImportResultProxyModel(results, ids);
         if (std::all_of(results.cbegin(), results.cend(),
                         [](const GpgME::ImportResult &result) {
                             return result.error().isCanceled();
                         })) {
             Q_EMIT q->canceled();
         } else {
             for (unsigned int i = 0, end = results.size(); i != end; ++i)
                 if (const Error err = results[i].error()) {
                     showError(err, ids[i]);
                 }
         }
     } else {
         if (containedExternalCMSCerts) {
             handleExternalCMSImports();
             // We emit finished and do show details
             // after the keylisting.
             return;
         } else {
             handleOwnerTrust(results);
         }
         showDetails(results, ids);
     }
     finished();
 }
 
 static std::unique_ptr<ImportJob> get_import_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         return std::unique_ptr<ImportJob>(backend->importJob());
     } else {
         return std::unique_ptr<ImportJob>();
     }
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const QByteArray &data, const QString &id)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
         return;
     }
 
     std::unique_ptr<ImportJob> job = get_import_job(protocol);
     if (!job.get()) {
         nonWorkingProtocols.push_back(protocol);
         error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.",
                    Formatting::displayName(protocol)),
               i18n("Certificate Import Failed"));
         importResult(ImportResult(), id);
         return;
     }
 
     connect(job.get(), SIGNAL(result(GpgME::ImportResult)),
             q, SLOT(importResult(GpgME::ImportResult)));
     connect(job.get(), &Job::progress,
             q, &Command::progress);
     const GpgME::Error err = job->start(data);
     if (err.code()) {
         importResult(ImportResult(err), id);
     } else {
         jobs.push_back(job.release());
         idsByJob[jobs.back()] = id;
     }
 }
 
 static std::unique_ptr<ImportFromKeyserverJob> get_import_from_keyserver_job(GpgME::Protocol protocol)
 {
     Q_ASSERT(protocol != UnknownProtocol);
     if (const auto backend = (protocol == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime())) {
         return std::unique_ptr<ImportFromKeyserverJob>(backend->importFromKeyserverJob());
     } else {
         return std::unique_ptr<ImportFromKeyserverJob>();
     }
 }
 
 void ImportCertificatesCommand::Private::startImport(GpgME::Protocol protocol, const std::vector<Key> &keys, const QString &id)
 {
     Q_ASSERT(protocol != UnknownProtocol);
 
     if (std::find(nonWorkingProtocols.cbegin(), nonWorkingProtocols.cend(), protocol) != nonWorkingProtocols.cend()) {
         return;
     }
 
     std::unique_ptr<ImportFromKeyserverJob> job = get_import_from_keyserver_job(protocol);
     if (!job.get()) {
         nonWorkingProtocols.push_back(protocol);
         error(i18n("The type of this certificate (%1) is not supported by this Kleopatra installation.",
                    Formatting::displayName(protocol)),
               i18n("Certificate Import Failed"));
         importResult(ImportResult(), id);
         return;
     }
 
     if (protocol == GpgME::CMS) {
         containedExternalCMSCerts = true;
     }
 
     connect(job.get(), SIGNAL(result(GpgME::ImportResult)),
             q, SLOT(importResult(GpgME::ImportResult)));
     connect(job.get(), &Job::progress,
             q, &Command::progress);
     const GpgME::Error err = job->start(keys);
     if (err.code()) {
         importResult(ImportResult(err), id);
     } else {
         jobs.push_back(job.release());
         idsByJob[jobs.back()] = id;
     }
 }
 
 void ImportCertificatesCommand::doCancel()
 {
     std::for_each(d->jobs.begin(), d->jobs.end(), [](Job *job) { job->slotCancel(); });
 }
 
 #undef d
 #undef q
 
 #include "moc_importcertificatescommand.cpp"
 #include "importcertificatescommand.moc"
 
diff --git a/src/crypto/decryptverifyemailcontroller.cpp b/src/crypto/decryptverifyemailcontroller.cpp
index fae33f818..bd0c439bf 100644
--- a/src/crypto/decryptverifyemailcontroller.cpp
+++ b/src/crypto/decryptverifyemailcontroller.cpp
@@ -1,479 +1,479 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifyemailcontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 #include "decryptverifyemailcontroller.h"
 #include "kleopatra_debug.h"
 
 #include "emailoperationspreferences.h"
 
 #include <crypto/gui/newresultpage.h>
 #include <crypto/decryptverifytask.h>
 #include <crypto/taskcollection.h>
 
 #include <Libkleo/GnuPG>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <QGpgME/Protocol>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Classify>
 
 #include <KMime/HeaderParsing>
 
 #include <KLocalizedString>
 
 #include <QPoint>
 #include <QPointer>
 #include <QTimer>
 
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace KMime::Types;
 
 namespace
 {
 
 class DecryptVerifyEMailWizard : public QWizard
 {
     Q_OBJECT
 public:
     explicit DecryptVerifyEMailWizard(QWidget *parent = nullptr, Qt::WindowFlags f = {})
         : QWizard(parent, f),
           m_resultPage(this)
     {
         KDAB_SET_OBJECT_NAME(m_resultPage);
 
         m_resultPage.setSubTitle(i18n("Status and progress of the crypto operations is shown here."));
 
         addPage(&m_resultPage);
     }
 
     void addTaskCollection(const std::shared_ptr<TaskCollection> &coll)
     {
         m_resultPage.addTaskCollection(coll);
     }
 
 public Q_SLOTS:
     void accept() override
     {
         EMailOperationsPreferences prefs;
         prefs.setDecryptVerifyPopupGeometry(geometry());
         prefs.save();
         QWizard::accept();
     }
 
 private:
     NewResultPage m_resultPage;
 };
 
 }
 
 class DecryptVerifyEMailController::Private
 {
     DecryptVerifyEMailController *const q;
 public:
 
     explicit Private(DecryptVerifyEMailController *qq);
 
     void slotWizardCanceled();
     void schedule();
 
     std::vector<std::shared_ptr<AbstractDecryptVerifyTask> > buildTasks();
 
     static DecryptVerifyEMailWizard *findOrCreateWizard(unsigned int id);
 
     void ensureWizardCreated();
     void ensureWizardVisible();
     void reportError(int err, const QString &details)
     {
         q->setLastError(err, details);
         q->emitDoneOrError();
     }
 
     void cancelAllTasks();
 
     std::vector<std::shared_ptr<Input> > m_inputs, m_signedDatas;
     std::vector<std::shared_ptr<Output> > m_outputs;
 
     unsigned int m_sessionId;
     QPointer<DecryptVerifyEMailWizard> m_wizard;
     std::vector<std::shared_ptr<const DecryptVerifyResult> > m_results;
     std::vector<std::shared_ptr<AbstractDecryptVerifyTask> > m_runnableTasks, m_completedTasks;
     std::shared_ptr<AbstractDecryptVerifyTask> m_runningTask;
     bool m_silent;
     bool m_operationCompleted;
     DecryptVerifyOperation m_operation;
     Protocol m_protocol;
     VerificationMode m_verificationMode;
     std::vector<KMime::Types::Mailbox> m_informativeSenders;
 };
 
 DecryptVerifyEMailController::Private::Private(DecryptVerifyEMailController *qq)
     : q(qq),
       m_sessionId(0),
       m_silent(false),
       m_operationCompleted(false),
       m_operation(DecryptVerify),
       m_protocol(UnknownProtocol),
       m_verificationMode(Detached)
 {
     qRegisterMetaType<VerificationResult>();
 }
 
 void DecryptVerifyEMailController::Private::slotWizardCanceled()
 {
     qCDebug(KLEOPATRA_LOG);
     if (!m_operationCompleted) {
         reportError(gpg_error(GPG_ERR_CANCELED), i18n("User canceled"));
     }
 }
 
 void DecryptVerifyEMailController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(task);
 
     // We could just delete the tasks here, but we can't use
     // Qt::QueuedConnection here (we need sender()) and other slots
     // might not yet have executed. Therefore, we push completed tasks
     // into a burial container
 
     if (task == d->m_runningTask.get()) {
         d->m_completedTasks.push_back(d->m_runningTask);
         const std::shared_ptr<const DecryptVerifyResult> &dvr = std::dynamic_pointer_cast<const DecryptVerifyResult>(result);
         Q_ASSERT(dvr);
         d->m_results.push_back(dvr);
         d->m_runningTask.reset();
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 
 }
 
 void DecryptVerifyEMailController::Private::schedule()
 {
     if (!m_runningTask && !m_runnableTasks.empty()) {
         const std::shared_ptr<AbstractDecryptVerifyTask> t = m_runnableTasks.back();
         m_runnableTasks.pop_back();
         t->start();
         m_runningTask = t;
     }
     if (!m_runningTask) {
         kleo_assert(m_runnableTasks.empty());
         for (const std::shared_ptr<const DecryptVerifyResult> &i : std::as_const(m_results)) {
             Q_EMIT q->verificationResult(i->verificationResult());
         }
         // if there is a popup, wait for either the client cancel or the user closing the popup.
         // Otherwise (silent case), finish immediately
         m_operationCompleted = true;
         q->emitDoneOrError();
     }
 }
 
 void DecryptVerifyEMailController::Private::ensureWizardCreated()
 {
     if (m_wizard) {
         return;
     }
 
     DecryptVerifyEMailWizard *w = findOrCreateWizard(m_sessionId);
     connect(w, SIGNAL(destroyed()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection);
     m_wizard = w;
 
 }
 
 namespace
 {
 template <typename C>
 void collectGarbage(C &c)
 {
     auto it = c.begin();
     while (it != c.end() /*sic!*/)
         if (it->second) {
             ++it;
         } else {
             c.erase(it++ /*sic!*/);
         }
 }
 }
 
 // static
 DecryptVerifyEMailWizard *DecryptVerifyEMailController::Private::findOrCreateWizard(unsigned int id)
 {
 
     static std::map<unsigned int, QPointer<DecryptVerifyEMailWizard> > s_wizards;
 
     collectGarbage(s_wizards);
 
     qCDebug(KLEOPATRA_LOG) << "id = " << id;
 
     if (id != 0) {
 
         const auto it
             = s_wizards.find(id);
 
         if (it != s_wizards.end()) {
             Q_ASSERT(it->second && "This should have been garbage-collected");
             return it->second;
         }
 
     }
 
     auto w = new DecryptVerifyEMailWizard;
     w->setWindowTitle(i18nc("@title:window", "Decrypt/Verify E-Mail"));
     w->setAttribute(Qt::WA_DeleteOnClose);
 
     const QRect preferredGeometry = EMailOperationsPreferences().decryptVerifyPopupGeometry();
     if (preferredGeometry.isValid()) {
         w->setGeometry(preferredGeometry);
     }
 
     s_wizards[id] = w;
 
     return w;
 }
 
 std::vector< std::shared_ptr<AbstractDecryptVerifyTask> > DecryptVerifyEMailController::Private::buildTasks()
 {
     const uint numInputs = m_inputs.size();
     const uint numMessages = m_signedDatas.size();
     const uint numOutputs = m_outputs.size();
     const uint numInformativeSenders = m_informativeSenders.size();
 
     // these are duplicated from DecryptVerifyCommandEMailBase::Private::checkForErrors with slightly modified error codes/messages
     if (!numInputs)
         throw Kleo::Exception(makeGnuPGError(GPG_ERR_CONFLICT),
                               i18n("At least one input needs to be provided"));
 
     if (numInformativeSenders > 0 && numInformativeSenders != numInputs)
         throw Kleo::Exception(makeGnuPGError(GPG_ERR_CONFLICT),     //TODO use better error code if possible
                               i18n("Informative sender/signed data count mismatch"));
 
     if (numMessages) {
         if (numMessages != numInputs)
             throw Kleo::Exception(makeGnuPGError(GPG_ERR_CONFLICT),     //TODO use better error code if possible
                                   i18n("Signature/signed data count mismatch"));
         else if (m_operation != Verify || m_verificationMode != Detached)
             throw Kleo::Exception(makeGnuPGError(GPG_ERR_CONFLICT),
                                   i18n("Signed data can only be given for detached signature verification"));
     }
 
     if (numOutputs) {
         if (numOutputs != numInputs)
             throw Kleo::Exception(makeGnuPGError(GPG_ERR_CONFLICT),    //TODO use better error code if possible
                                   i18n("Input/Output count mismatch"));
         else if (numMessages)
             throw Kleo::Exception(makeGnuPGError(GPG_ERR_CONFLICT),
                                   i18n("Cannot use output and signed data simultaneously"));
     }
 
     kleo_assert(m_protocol != UnknownProtocol);
 
     const QGpgME::Protocol *const backend = (m_protocol == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     if (!backend) {
         throw Kleo::Exception(makeGnuPGError(GPG_ERR_UNSUPPORTED_PROTOCOL), i18n("No backend support for %1", Formatting::displayName(m_protocol)));
     }
 
     if (m_operation != Decrypt && !m_silent) {
         ensureWizardVisible();
     }
 
     std::vector< std::shared_ptr<AbstractDecryptVerifyTask> > tasks;
 
     for (unsigned int i = 0; i < numInputs; ++i) {
         std::shared_ptr<AbstractDecryptVerifyTask> task;
         switch (m_operation) {
         case Decrypt: {
             std::shared_ptr<DecryptTask> t(new DecryptTask);
             t->setInput(m_inputs.at(i));
             Q_ASSERT(numOutputs);
             t->setOutput(m_outputs.at(i));
             t->setProtocol(m_protocol);
             task = t;
         }
         break;
         case Verify: {
             if (m_verificationMode == Detached) {
                 std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
                 t->setInput(m_inputs.at(i));
                 t->setSignedData(m_signedDatas.at(i));
                 if (numInformativeSenders > 0) {
                     t->setInformativeSender(m_informativeSenders.at(i));
                 }
                 t->setProtocol(m_protocol);
                 task = t;
             } else {
                 std::shared_ptr<VerifyOpaqueTask> t(new VerifyOpaqueTask);
                 t->setInput(m_inputs.at(i));
                 if (numOutputs) {
                     t->setOutput(m_outputs.at(i));
                 }
                 if (numInformativeSenders > 0) {
                     t->setInformativeSender(m_informativeSenders.at(i));
                 }
                 t->setProtocol(m_protocol);
                 task = t;
             }
         }
         break;
         case DecryptVerify: {
             std::shared_ptr<DecryptVerifyTask> t(new DecryptVerifyTask);
             t->setInput(m_inputs.at(i));
             Q_ASSERT(numOutputs);
             t->setOutput(m_outputs.at(i));
             if (numInformativeSenders > 0) {
                 t->setInformativeSender(m_informativeSenders.at(i));
             }
             t->setProtocol(m_protocol);
             task = t;
         }
         }
 
         Q_ASSERT(task);
         tasks.push_back(task);
     }
 
     return tasks;
 }
 
 void DecryptVerifyEMailController::Private::ensureWizardVisible()
 {
     ensureWizardCreated();
     q->bringToForeground(m_wizard);
 }
 
 DecryptVerifyEMailController::DecryptVerifyEMailController(QObject *parent) : Controller(parent), d(new Private(this))
 {
 }
 
 DecryptVerifyEMailController::DecryptVerifyEMailController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *parent) : Controller(ctx, parent), d(new Private(this))
 {
 }
 
 DecryptVerifyEMailController::~DecryptVerifyEMailController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void DecryptVerifyEMailController::start()
 {
     d->m_runnableTasks = d->buildTasks();
 
     const std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task> > tsks;
-    Q_FOREACH (const std::shared_ptr<Task> &i, d->m_runnableTasks) {
+    for (std::shared_ptr<Task> i : std::as_const(d->m_runnableTasks)) {
         connectTask(i);
         tsks.push_back(i);
     }
     coll->setTasks(tsks);
     d->ensureWizardCreated();
     d->m_wizard->addTaskCollection(coll);
 
     d->ensureWizardVisible();
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 void DecryptVerifyEMailController::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_inputs.resize(1, input);
 }
 
 void DecryptVerifyEMailController::setInputs(const std::vector<std::shared_ptr<Input> > &inputs)
 {
     d->m_inputs = inputs;
 }
 
 void DecryptVerifyEMailController::setSignedData(const std::shared_ptr<Input> &data)
 {
     d->m_signedDatas.resize(1, data);
 }
 
 void DecryptVerifyEMailController::setSignedData(const std::vector<std::shared_ptr<Input> > &data)
 {
     d->m_signedDatas = data;
 }
 
 void DecryptVerifyEMailController::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_outputs.resize(1, output);
 }
 
 void DecryptVerifyEMailController::setOutputs(const std::vector<std::shared_ptr<Output> > &outputs)
 {
     d->m_outputs = outputs;
 }
 
 void DecryptVerifyEMailController::setInformativeSenders(const std::vector<KMime::Types::Mailbox> &senders)
 {
     d->m_informativeSenders = senders;
 }
 
 void DecryptVerifyEMailController::setWizardShown(bool shown)
 {
     d->m_silent = !shown;
     if (d->m_wizard) {
         d->m_wizard->setVisible(shown);
     }
 }
 
 void DecryptVerifyEMailController::setOperation(DecryptVerifyOperation operation)
 {
     d->m_operation = operation;
 }
 
 void DecryptVerifyEMailController::setVerificationMode(VerificationMode vm)
 {
     d->m_verificationMode = vm;
 }
 
 void DecryptVerifyEMailController::setProtocol(Protocol prot)
 {
     d->m_protocol = prot;
 }
 
 void DecryptVerifyEMailController::setSessionId(unsigned int id)
 {
     qCDebug(KLEOPATRA_LOG) << "id = " << id;
     d->m_sessionId = id;
 }
 
 void DecryptVerifyEMailController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     try {
         if (d->m_wizard) {
             disconnect(d->m_wizard);
             d->m_wizard->close();
         }
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 void DecryptVerifyEMailController::Private::cancelAllTasks()
 {
 
     // we just kill all runnable tasks - this will not result in
     // signal emissions.
     m_runnableTasks.clear();
 
     // a cancel() will result in a call to
     if (m_runningTask) {
         m_runningTask->cancel();
     }
 }
 
 #include "decryptverifyemailcontroller.moc"
 #include "moc_decryptverifyemailcontroller.cpp"
diff --git a/src/crypto/gui/newresultpage.cpp b/src/crypto/gui/newresultpage.cpp
index a12d18544..b17890521 100644
--- a/src/crypto/gui/newresultpage.cpp
+++ b/src/crypto/gui/newresultpage.cpp
@@ -1,185 +1,186 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "newresultpage.h"
 
 #include "resultlistwidget.h"
 #include "resultitemwidget.h"
 
 #include <crypto/taskcollection.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 
 #include <QCheckBox>
 #include <QHash>
 #include <QLabel>
 #include <QProgressBar>
 #include <QVBoxLayout>
 #include <QTimer>
 
 
 static const int ProgressBarHideDelay = 2000; // 2 secs
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class NewResultPage::Private
 {
     NewResultPage *const q;
 public:
     explicit Private(NewResultPage *qq);
 
     void progress(const QString &msg, int progress, int total);
     void result(const std::shared_ptr<const Task::Result> &result);
     void started(const std::shared_ptr<Task> &result);
     void allDone();
     QLabel *labelForTag(const QString &tag);
 
     std::vector< std::shared_ptr<TaskCollection> > m_collections;
     QTimer m_hideProgressTimer;
     QProgressBar *m_progressBar;
     QHash<QString, QLabel *> m_progressLabelByTag;
     QVBoxLayout *m_progressLabelLayout;
     int m_lastErrorItemIndex;
     ResultListWidget *m_resultList;
 };
 
 NewResultPage::Private::Private(NewResultPage *qq) : q(qq), m_lastErrorItemIndex(0)
 {
     m_hideProgressTimer.setInterval(ProgressBarHideDelay);
     m_hideProgressTimer.setSingleShot(true);
 
     QBoxLayout *const layout = new QVBoxLayout(q);
     auto const labels = new QWidget;
     m_progressLabelLayout = new QVBoxLayout(labels);
     layout->addWidget(labels);
     m_progressBar = new QProgressBar;
     layout->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     connect(m_resultList, &ResultListWidget::linkActivated, q, &NewResultPage::linkActivated);
     layout->addWidget(m_resultList, 1);
 
     connect(&m_hideProgressTimer, &QTimer::timeout, m_progressBar, &QProgressBar::hide);
 }
 
 void NewResultPage::Private::progress(const QString &msg, int progress, int total)
 {
     Q_UNUSED(msg)
     Q_ASSERT(progress >= 0);
     Q_ASSERT(total >= 0);
     m_progressBar->setRange(0, total);
     m_progressBar->setValue(progress);
 }
 
 void NewResultPage::Private::allDone()
 {
     Q_ASSERT(!m_collections.empty());
     if (!m_resultList->isComplete()) {
         return;
     }
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     m_collections.clear();
-    Q_FOREACH (const QString &i, m_progressLabelByTag.keys()) {
+    const auto progressLabelByTagKeys{m_progressLabelByTag.keys()};
+    for (const QString &i : progressLabelByTagKeys) {
         if (!i.isEmpty()) {
             m_progressLabelByTag.value(i)->setText(i18n("%1: All operations completed.", i));
         } else {
             m_progressLabelByTag.value(i)->setText(i18n("All operations completed."));
         }
     }
     if (QAbstractButton *cancel = q->wizard()->button(QWizard::CancelButton)) {
         cancel->setEnabled(false);
     }
     Q_EMIT q->completeChanged();
     m_hideProgressTimer.start();
 }
 
 void NewResultPage::Private::result(const std::shared_ptr<const Task::Result> &)
 {
 }
 
 void NewResultPage::Private::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const QString tag = task->tag();
     QLabel *const label = labelForTag(tag);
     Q_ASSERT(label);
     if (tag.isEmpty()) {
         label->setText(i18nc("number, operation description", "Operation %1: %2", m_resultList->numberOfCompletedTasks() + 1, task->label()));
     } else {
         label->setText(i18nc(R"(tag( "OpenPGP" or "CMS"),  operation description)", "%1: %2", tag, task->label()));
     }
 }
 
 NewResultPage::NewResultPage(QWidget *parent) : QWizardPage(parent), d(new Private(this))
 {
     setTitle(i18n("<b>Results</b>"));
 }
 
 NewResultPage::~NewResultPage()
 {
 }
 
 void NewResultPage::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     //clear(); ### PENDING(marc) implement
     addTaskCollection(coll);
 }
 
 void NewResultPage::addTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     Q_ASSERT(coll);
     if (std::find(d->m_collections.cbegin(), d->m_collections.cend(), coll) != d->m_collections.cend()) {
         return;
     }
     d->m_hideProgressTimer.stop();
     d->m_progressBar->show();
     d->m_collections.push_back(coll);
     d->m_resultList->addTaskCollection(coll);
     connect(coll.get(), SIGNAL(progress(QString,int,int)),
             this, SLOT(progress(QString,int,int)));
     connect(coll.get(), SIGNAL(done()),
             this, SLOT(allDone()));
     connect(coll.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
             this, SLOT(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
     connect(coll.get(), SIGNAL(started(std::shared_ptr<Kleo::Crypto::Task>)),
             this, SLOT(started(std::shared_ptr<Kleo::Crypto::Task>)));
 
     Q_FOREACH (const std::shared_ptr<Task> &i, coll->tasks()) {    // create labels for all tags in collection
         Q_ASSERT(i);
         QLabel *l = d->labelForTag(i->tag());
         Q_ASSERT(l); (void)l;
     }
     Q_EMIT completeChanged();
 }
 
 QLabel *NewResultPage::Private::labelForTag(const QString &tag)
 {
     if (QLabel *const label = m_progressLabelByTag.value(tag)) {
         return label;
     }
     auto label = new QLabel;
     label->setTextFormat(Qt::RichText);
     label->setWordWrap(true);
     m_progressLabelLayout->addWidget(label);
     m_progressLabelByTag.insert(tag, label);
     return label;
 }
 
 bool NewResultPage::isComplete() const
 {
     return d->m_resultList->isComplete();
 }
 
 #include "moc_newresultpage.cpp"
diff --git a/src/crypto/gui/resolverecipientspage.cpp b/src/crypto/gui/resolverecipientspage.cpp
index aee4f295e..73685f530 100644
--- a/src/crypto/gui/resolverecipientspage.cpp
+++ b/src/crypto/gui/resolverecipientspage.cpp
@@ -1,695 +1,697 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resolverecipientspage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "resolverecipientspage.h"
 #include "resolverecipientspage_p.h"
 
 #include <dialogs/certificateselectiondialog.h>
 
 #include <crypto/certificateresolver.h>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <KMime/HeaderParsing>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QButtonGroup>
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QListWidget>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QToolButton>
 #include <QStringList>
 #include <QVBoxLayout>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace KMime::Types;
 
 ResolveRecipientsPage::ListWidget::ListWidget(QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), m_protocol(UnknownProtocol)
 {
     m_listWidget = new QListWidget;
     m_listWidget->setSelectionMode(QAbstractItemView::MultiSelection);
     auto const layout = new QVBoxLayout(this);
     layout->addWidget(m_listWidget);
     connect(m_listWidget, &QListWidget::itemSelectionChanged, this, &ListWidget::onSelectionChange);
 }
 
 ResolveRecipientsPage::ListWidget::~ListWidget()
 {
 }
 
 void ResolveRecipientsPage::ListWidget::onSelectionChange()
 {
     const auto widgetskeys = widgets.keys();
     for (const QString &i : widgetskeys) {
         Q_ASSERT(items.contains(i));
         widgets[i]->setSelected(items[i]->isSelected());
     }
     Q_EMIT selectionChanged();
 }
 
 void ResolveRecipientsPage::ListWidget::addEntry(const Mailbox &mbox)
 {
     addEntry(mbox.prettyAddress(), mbox.prettyAddress(), mbox);
 }
 
 void ResolveRecipientsPage::ListWidget::addEntry(const QString &id, const QString &name)
 {
     addEntry(id, name, Mailbox());
 }
 
 void ResolveRecipientsPage::ListWidget::addEntry(const QString &id, const QString &name, const Mailbox &mbox)
 {
     Q_ASSERT(!widgets.contains(id) && !items.contains(id));
     auto item = new QListWidgetItem;
     item->setData(IdRole, id);
     auto wid = new ItemWidget(id, name, mbox, this);
     connect(wid, &ItemWidget::changed, this, &ListWidget::completeChanged);
     wid->setProtocol(m_protocol);
     item->setSizeHint(wid->sizeHint());
     m_listWidget->addItem(item);
     m_listWidget->setItemWidget(item, wid);
     widgets[id] = wid;
     items[id] = item;
 }
 
 Mailbox ResolveRecipientsPage::ListWidget::mailbox(const QString &id) const
 {
     return widgets.contains(id) ? widgets[id]->mailbox() : Mailbox();
 }
 
 void ResolveRecipientsPage::ListWidget::setCertificates(const QString &id, const std::vector<Key> &pgp, const std::vector<Key> &cms)
 {
     Q_ASSERT(widgets.contains(id));
     widgets[id]->setCertificates(pgp, cms);
 }
 
 Key ResolveRecipientsPage::ListWidget::selectedCertificate(const QString &id) const
 {
     return widgets.contains(id) ? widgets[id]->selectedCertificate() : Key();
 }
 
 GpgME::Key ResolveRecipientsPage::ListWidget::selectedCertificate(const QString &id, GpgME::Protocol prot) const
 {
     return  widgets.contains(id) ? widgets[id]->selectedCertificate(prot) : Key();
 }
 
 QStringList ResolveRecipientsPage::ListWidget::identifiers() const
 {
     return widgets.keys();
 }
 
 void ResolveRecipientsPage::ListWidget::setProtocol(GpgME::Protocol prot)
 {
     if (m_protocol == prot) {
         return;
     }
     m_protocol = prot;
     for (ItemWidget *i : std::as_const(widgets)) {
         i->setProtocol(prot);
     }
 }
 
 void ResolveRecipientsPage::ListWidget::removeEntry(const QString &id)
 {
     if (!widgets.contains(id)) {
         return;
     }
     delete items[id];
     items.remove(id);
     delete widgets[id];
     widgets.remove(id);
 }
 
 void ResolveRecipientsPage::ListWidget::showSelectionDialog(const QString &id)
 {
     if (!widgets.contains(id)) {
         return;
     }
     widgets[id]->showSelectionDialog();
 }
 
 QStringList ResolveRecipientsPage::ListWidget::selectedEntries() const
 {
     QStringList entries;
     const QList<QListWidgetItem *> items = m_listWidget->selectedItems();
     entries.reserve(items.count());
     for (const QListWidgetItem *i : items) {
         entries.append(i->data(IdRole).toString());
     }
     return entries;
 }
 
 ResolveRecipientsPage::ItemWidget::ItemWidget(const QString &id, const QString &name, const Mailbox &mbox,
         QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), m_id(id), m_mailbox(mbox), m_protocol(UnknownProtocol), m_selected(false)
 {
     Q_ASSERT(!m_id.isEmpty());
     setAutoFillBackground(true);
     auto layout = new QHBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addSpacing(15);
     m_nameLabel = new QLabel;
     m_nameLabel->setText(name);
     layout->addWidget(m_nameLabel);
     layout->addStretch();
     m_certLabel = new QLabel;
     m_certLabel->setText(i18n("<i>No certificate selected</i>"));
     layout->addWidget(m_certLabel);
     m_certCombo = new QComboBox;
     connect(m_certCombo, SIGNAL(currentIndexChanged(int)),
             this, SIGNAL(changed()));
     layout->addWidget(m_certCombo);
     m_selectButton = new QToolButton;
     m_selectButton->setText(i18n("..."));
     connect(m_selectButton, &QAbstractButton::clicked,
             this, &ItemWidget::showSelectionDialog);
     layout->addWidget(m_selectButton);
     layout->addSpacing(15);
     setCertificates(std::vector<Key>(), std::vector<Key>());
 }
 
 void ResolveRecipientsPage::ItemWidget::updateVisibility()
 {
     m_certLabel->setVisible(m_certCombo->count() == 0);
     m_certCombo->setVisible(m_certCombo->count() > 0);
 }
 
 ResolveRecipientsPage::ItemWidget::~ItemWidget()
 {
 }
 
 QString ResolveRecipientsPage::ItemWidget::id() const
 {
     return m_id;
 }
 
 void ResolveRecipientsPage::ItemWidget::setSelected(bool selected)
 {
     if (m_selected == selected) {
         return;
     }
     m_selected = selected;
     setBackgroundRole(selected ? QPalette::Highlight : QPalette::Base);
     const QPalette::ColorRole foreground = selected ? QPalette::HighlightedText : QPalette::Text;
     setForegroundRole(foreground);
     m_nameLabel->setForegroundRole(foreground);
     m_certLabel->setForegroundRole(foreground);
 }
 
 bool ResolveRecipientsPage::ItemWidget::isSelected() const
 {
     return m_selected;
 }
 
 static CertificateSelectionDialog *createCertificateSelectionDialog(QWidget *parent, GpgME::Protocol prot)
 {
     auto const dlg = new CertificateSelectionDialog(parent);
     const CertificateSelectionDialog::Options options =
         CertificateSelectionDialog::SingleSelection |
         CertificateSelectionDialog::EncryptOnly |
         CertificateSelectionDialog::MultiSelection |
         CertificateSelectionDialog::optionsFromProtocol(prot);
     dlg->setOptions(options);
     return dlg;
 }
 
 void ResolveRecipientsPage::ItemWidget::showSelectionDialog()
 {
     QPointer<CertificateSelectionDialog> dlg = createCertificateSelectionDialog(this, m_protocol);
 
     if (dlg->exec() == QDialog::Accepted && dlg /* still with us? */) {
         const GpgME::Key cert = dlg->selectedCertificate();
         if (!cert.isNull()) {
             addCertificateToComboBox(cert);
             selectCertificateInComboBox(cert);
         }
     }
     delete dlg;
 }
 
 Mailbox ResolveRecipientsPage::ItemWidget::mailbox() const
 {
     return m_mailbox;
 }
 
 void ResolveRecipientsPage::ItemWidget::selectCertificateInComboBox(const Key &key)
 {
     m_certCombo->setCurrentIndex(m_certCombo->findData(QLatin1String(key.keyID())));
 }
 
 void ResolveRecipientsPage::ItemWidget::addCertificateToComboBox(const GpgME::Key &key)
 {
     m_certCombo->addItem(Formatting::formatForComboBox(key), QByteArray(key.keyID()));
     if (m_certCombo->count() == 1) {
         m_certCombo->setCurrentIndex(0);
     }
     updateVisibility();
 }
 
 void ResolveRecipientsPage::ItemWidget::resetCertificates()
 {
     std::vector<Key> certs;
     Key selected;
     switch (m_protocol) {
     case OpenPGP:
         certs = m_pgp;
         break;
     case CMS:
         certs = m_cms;
         break;
     case UnknownProtocol:
         certs = m_cms;
         certs.insert(certs.end(), m_pgp.begin(), m_pgp.end());
     }
 
     m_certCombo->clear();
     for (const Key &i : std::as_const(certs)) {
         addCertificateToComboBox(i);
     }
     if (!m_selectedCertificates[m_protocol].isNull()) {
         selectCertificateInComboBox(m_selectedCertificates[m_protocol]);
     } else if (m_certCombo->count() > 0) {
         m_certCombo->setCurrentIndex(0);
     }
     updateVisibility();
     Q_EMIT changed();
 }
 
 void ResolveRecipientsPage::ItemWidget::setProtocol(Protocol prot)
 {
     if (m_protocol == prot) {
         return;
     }
     m_selectedCertificates[m_protocol] = selectedCertificate();
     if (m_protocol != UnknownProtocol) {
         (m_protocol == OpenPGP ? m_pgp : m_cms) = certificates();
     }
     m_protocol = prot;
     resetCertificates();
 }
 
 void ResolveRecipientsPage::ItemWidget::setCertificates(const std::vector<Key> &pgp, const std::vector<Key> &cms)
 {
     m_pgp = pgp;
     m_cms = cms;
     resetCertificates();
 }
 
 Key ResolveRecipientsPage::ItemWidget::selectedCertificate() const
 {
     return KeyCache::instance()->findByKeyIDOrFingerprint(m_certCombo->itemData(m_certCombo->currentIndex(), ListWidget::IdRole).toString().toStdString());
 }
 
 GpgME::Key ResolveRecipientsPage::ItemWidget::selectedCertificate(GpgME::Protocol prot) const
 {
     return prot == m_protocol ? selectedCertificate() : m_selectedCertificates.value(prot);
 }
 
 std::vector<Key> ResolveRecipientsPage::ItemWidget::certificates() const
 {
     std::vector<Key> certs;
     for (int i = 0; i < m_certCombo->count(); ++i) {
         certs.push_back(KeyCache::instance()->findByKeyIDOrFingerprint(m_certCombo->itemData(i, ListWidget::IdRole).toString().toStdString()));
     }
     return certs;
 }
 
 class ResolveRecipientsPage::Private
 {
     friend class ::Kleo::Crypto::Gui::ResolveRecipientsPage;
     ResolveRecipientsPage *const q;
 public:
     explicit Private(ResolveRecipientsPage *qq);
     ~Private();
 
     void setSelectedProtocol(Protocol protocol);
     void selectionChanged();
     void removeSelectedEntries();
     void addRecipient();
     void addRecipient(const Mailbox &mbox);
     void addRecipient(const QString &id, const QString &name);
     void updateProtocolRBVisibility();
     void protocolSelected(int prot);
     void writeSelectedCertificatesToPreferences();
     void completeChangedInternal();
 
 private:
     ListWidget *m_listWidget;
     QPushButton *m_addButton;
     QPushButton *m_removeButton;
     QRadioButton *m_pgpRB;
     QRadioButton *m_cmsRB;
     QLabel *m_additionalRecipientsLabel;
     Protocol m_presetProtocol;
     Protocol m_selectedProtocol;
     bool m_multipleProtocolsAllowed;
     std::shared_ptr<RecipientPreferences> m_recipientPreferences;
 };
 
 ResolveRecipientsPage::Private::Private(ResolveRecipientsPage *qq)
     : q(qq), m_presetProtocol(UnknownProtocol), m_selectedProtocol(m_presetProtocol), m_multipleProtocolsAllowed(false), m_recipientPreferences()
 {
     connect(q, SIGNAL(completeChanged()), q, SLOT(completeChangedInternal()));
     q->setTitle(i18n("<b>Recipients</b>"));
     auto const layout = new QVBoxLayout(q);
     m_listWidget = new ListWidget;
     connect(m_listWidget, SIGNAL(selectionChanged()), q, SLOT(selectionChanged()));
     connect(m_listWidget, &ListWidget::completeChanged, q, &WizardPage::completeChanged);
     layout->addWidget(m_listWidget);
     m_additionalRecipientsLabel = new QLabel;
     m_additionalRecipientsLabel->setWordWrap(true);
     layout->addWidget(m_additionalRecipientsLabel);
     m_additionalRecipientsLabel->setVisible(false);
     auto buttonWidget = new QWidget;
     auto buttonLayout = new QHBoxLayout(buttonWidget);
     buttonLayout->setContentsMargins(0, 0, 0, 0);
     m_addButton = new QPushButton;
     connect(m_addButton, SIGNAL(clicked()), q, SLOT(addRecipient()));
     m_addButton->setText(i18n("Add Recipient..."));
     buttonLayout->addWidget(m_addButton);
     m_removeButton = new QPushButton;
     m_removeButton->setEnabled(false);
     m_removeButton->setText(i18n("Remove Selected"));
     connect(m_removeButton, SIGNAL(clicked()),
             q, SLOT(removeSelectedEntries()));
     buttonLayout->addWidget(m_removeButton);
     buttonLayout->addStretch();
     layout->addWidget(buttonWidget);
     auto protocolWidget = new QWidget;
     auto protocolLayout = new QHBoxLayout(protocolWidget);
     auto protocolGroup = new QButtonGroup(q);
     connect(protocolGroup, SIGNAL(buttonClicked(int)), q, SLOT(protocolSelected(int)));
     m_pgpRB = new QRadioButton;
     m_pgpRB->setText(i18n("OpenPGP"));
     protocolGroup->addButton(m_pgpRB, OpenPGP);
     protocolLayout->addWidget(m_pgpRB);
     m_cmsRB = new QRadioButton;
     m_cmsRB->setText(i18n("S/MIME"));
     protocolGroup->addButton(m_cmsRB, CMS);
     protocolLayout->addWidget(m_cmsRB);
     protocolLayout->addStretch();
     layout->addWidget(protocolWidget);
 }
 
 ResolveRecipientsPage::Private::~Private() {}
 
 void ResolveRecipientsPage::Private::completeChangedInternal()
 {
     const bool isComplete = q->isComplete();
     const std::vector<Key> keys = q->resolvedCertificates();
     const bool haveSecret = std::find_if(keys.begin(), keys.end(),
                                          [](const Key &key) {
                                              return key.hasSecret();
                                         }) != keys.end();
     if (isComplete && !haveSecret) {
         q->setExplanation(i18n("<b>Warning:</b> None of the selected certificates seem to be your own. You will not be able to decrypt the encrypted data again."));
     } else {
         q->setExplanation(QString());
     }
 }
 
 void ResolveRecipientsPage::Private::updateProtocolRBVisibility()
 {
     const bool visible = !m_multipleProtocolsAllowed && m_presetProtocol == UnknownProtocol;
     m_cmsRB->setVisible(visible);
     m_pgpRB->setVisible(visible);
     if (visible) {
         if (m_selectedProtocol == CMS) {
             m_cmsRB->click();
         } else {
             m_pgpRB->click();
         }
     }
 }
 
 bool ResolveRecipientsPage::isComplete() const
 {
     const QStringList ids = d->m_listWidget->identifiers();
     if (ids.isEmpty()) {
         return false;
     }
 
     for (const QString &i : ids) {
         if (d->m_listWidget->selectedCertificate(i).isNull()) {
             return false;
         }
     }
 
     return true;
 }
 
 ResolveRecipientsPage::ResolveRecipientsPage(QWidget *parent)
     : WizardPage(parent), d(new Private(this))
 {
 }
 
 ResolveRecipientsPage::~ResolveRecipientsPage() {}
 
 Protocol ResolveRecipientsPage::selectedProtocol() const
 {
     return d->m_selectedProtocol;
 }
 
 void ResolveRecipientsPage::Private::setSelectedProtocol(Protocol protocol)
 {
     if (m_selectedProtocol == protocol) {
         return;
     }
     m_selectedProtocol = protocol;
     m_listWidget->setProtocol(m_selectedProtocol);
     Q_EMIT q->selectedProtocolChanged();
 }
 
 void ResolveRecipientsPage::Private::protocolSelected(int p)
 {
     const auto protocol = static_cast<Protocol>(p);
     Q_ASSERT(protocol != UnknownProtocol);
     setSelectedProtocol(protocol);
 }
 
 void ResolveRecipientsPage::setPresetProtocol(Protocol prot)
 {
     if (d->m_presetProtocol == prot) {
         return;
     }
     d->m_presetProtocol = prot;
     d->setSelectedProtocol(prot);
     if (prot != UnknownProtocol) {
         d->m_multipleProtocolsAllowed = false;
     }
     d->updateProtocolRBVisibility();
 }
 
 Protocol ResolveRecipientsPage::presetProtocol() const
 {
     return d->m_presetProtocol;
 }
 
 bool ResolveRecipientsPage::multipleProtocolsAllowed() const
 {
     return d->m_multipleProtocolsAllowed;
 }
 
 void ResolveRecipientsPage::setMultipleProtocolsAllowed(bool allowed)
 {
     if (d->m_multipleProtocolsAllowed == allowed) {
         return;
     }
     d->m_multipleProtocolsAllowed = allowed;
     if (d->m_multipleProtocolsAllowed) {
         setPresetProtocol(UnknownProtocol);
         d->setSelectedProtocol(UnknownProtocol);
     }
     d->updateProtocolRBVisibility();
 }
 
 void ResolveRecipientsPage::Private::addRecipient(const QString &id, const QString &name)
 {
     m_listWidget->addEntry(id, name);
 }
 
 void ResolveRecipientsPage::Private::addRecipient(const Mailbox &mbox)
 {
     m_listWidget->addEntry(mbox);
 }
 
 void ResolveRecipientsPage::Private::addRecipient()
 {
     QPointer<CertificateSelectionDialog> dlg = createCertificateSelectionDialog(q, q->selectedProtocol());
     if (dlg->exec() != QDialog::Accepted || !dlg /*q already deleted*/) {
         return;
     }
     const std::vector<Key> keys = dlg->selectedCertificates();
 
     int i = 0;
     for (const Key &key : keys) {
         const QStringList existing = m_listWidget->identifiers();
         QString rec = i18n("Recipient");
         while (existing.contains(rec)) {
             rec = i18nc("%1 == number", "Recipient (%1)", ++i);
         }
         addRecipient(rec, rec);
         const std::vector<Key> pgp = key.protocol() == OpenPGP ? std::vector<Key>(1, key) : std::vector<Key>();
         const std::vector<Key> cms = key.protocol() == CMS ? std::vector<Key>(1, key) : std::vector<Key>();
         m_listWidget->setCertificates(rec, pgp, cms);
     }
     Q_EMIT q->completeChanged();
 }
 
 namespace
 {
 
 std::vector<Key> makeSuggestions(const std::shared_ptr<RecipientPreferences> &prefs, const Mailbox &mb, GpgME::Protocol prot)
 {
     std::vector<Key> suggestions;
     const Key remembered = prefs ? prefs->preferredCertificate(mb, prot) : Key();
     if (!remembered.isNull()) {
         suggestions.push_back(remembered);
     } else {
         suggestions = CertificateResolver::resolveRecipient(mb, prot);
     }
     return suggestions;
 }
 }
 
 static QString listKeysForInfo(const std::vector<Key> &keys)
 {
     QStringList list;
     std::transform(keys.begin(), keys.end(), list.begin(), &Formatting::formatKeyLink);
     return list.join(QLatin1String("<br/>"));
 }
 
 void ResolveRecipientsPage::setAdditionalRecipientsInfo(const std::vector<Key> &recipients)
 {
     d->m_additionalRecipientsLabel->setVisible(!recipients.empty());
     if (recipients.empty()) {
         return;
     }
     d->m_additionalRecipientsLabel->setText(
         i18n("<qt><p>Recipients predefined via GnuPG settings:</p>%1</qt>",
              listKeysForInfo(recipients)));
 }
 
 void ResolveRecipientsPage::setRecipients(const std::vector<Mailbox> &recipients, const std::vector<Mailbox> &encryptToSelfRecipients)
 {
     uint cmsCount = 0;
     uint pgpCount = 0;
     uint senders = 0;
     for (const Mailbox &mb : encryptToSelfRecipients) {
         const QString id = QLatin1String("sender-") + QString::number(++senders);
         d->m_listWidget->addEntry(id, i18n("Sender"), mb);
         const std::vector<Key> pgp = makeSuggestions(d->m_recipientPreferences, mb, OpenPGP);
         const std::vector<Key> cms = makeSuggestions(d->m_recipientPreferences, mb, CMS);
         pgpCount += !pgp.empty();
         cmsCount += !cms.empty();
         d->m_listWidget->setCertificates(id, pgp, cms);
     }
     for (const Mailbox &i : recipients) {
         //TODO:
         const QString address = i.prettyAddress();
         d->addRecipient(i);
         const std::vector<Key> pgp = makeSuggestions(d->m_recipientPreferences, i, OpenPGP);
         const std::vector<Key> cms = makeSuggestions(d->m_recipientPreferences, i, CMS);
         pgpCount += pgp.empty() ? 0 : 1;
         cmsCount += cms.empty() ? 0 : 1;
         d->m_listWidget->setCertificates(address, pgp, cms);
     }
     if (d->m_presetProtocol == UnknownProtocol && !d->m_multipleProtocolsAllowed) {
         (cmsCount > pgpCount ? d->m_cmsRB : d->m_pgpRB)->click();
     }
 }
 
 std::vector<Key> ResolveRecipientsPage::resolvedCertificates() const
 {
     std::vector<Key> certs;
     Q_FOREACH (const QString &i, d->m_listWidget->identifiers()) {
         const GpgME::Key cert = d->m_listWidget->selectedCertificate(i);
         if (!cert.isNull()) {
             certs.push_back(cert);
         }
     }
     return certs;
 }
 
 void ResolveRecipientsPage::Private::selectionChanged()
 {
     m_removeButton->setEnabled(!m_listWidget->selectedEntries().isEmpty());
 }
 
 void ResolveRecipientsPage::Private::removeSelectedEntries()
 {
-    Q_FOREACH (const QString &i, m_listWidget->selectedEntries()) {
+    const auto selectedEntries{m_listWidget->selectedEntries()};
+    for (const QString &i : selectedEntries) {
         m_listWidget->removeEntry(i);
     }
     Q_EMIT q->completeChanged();
 }
 
 void ResolveRecipientsPage::setRecipientsUserMutable(bool isMutable)
 {
     d->m_addButton->setVisible(isMutable);
     d->m_removeButton->setVisible(isMutable);
 }
 
 bool ResolveRecipientsPage::recipientsUserMutable() const
 {
     return d->m_addButton->isVisible();
 }
 
 std::shared_ptr<RecipientPreferences> ResolveRecipientsPage::recipientPreferences() const
 {
     return d->m_recipientPreferences;
 }
 
 void ResolveRecipientsPage::setRecipientPreferences(const std::shared_ptr<RecipientPreferences> &prefs)
 {
     d->m_recipientPreferences = prefs;
 }
 
 void ResolveRecipientsPage::Private::writeSelectedCertificatesToPreferences()
 {
     if (!m_recipientPreferences) {
         return;
     }
 
-    Q_FOREACH (const QString &i, m_listWidget->identifiers()) {
+    const auto identifiers{m_listWidget->identifiers()};
+    for (const QString &i : identifiers) {
         const Mailbox mbox = m_listWidget->mailbox(i);
         if (!mbox.hasAddress()) {
             continue;
         }
         const Key pgp = m_listWidget->selectedCertificate(i, OpenPGP);
         if (!pgp.isNull()) {
             m_recipientPreferences->setPreferredCertificate(mbox, OpenPGP, pgp);
         }
         const Key cms = m_listWidget->selectedCertificate(i, CMS);
         if (!cms.isNull()) {
             m_recipientPreferences->setPreferredCertificate(mbox, CMS, cms);
         }
     }
 }
 
 void ResolveRecipientsPage::onNext()
 {
     d->writeSelectedCertificatesToPreferences();
 }
 
 #include "moc_resolverecipientspage_p.cpp"
 #include "moc_resolverecipientspage.cpp"
diff --git a/src/crypto/gui/resultpage.cpp b/src/crypto/gui/resultpage.cpp
index ecc7e4bfd..fb18627d6 100644
--- a/src/crypto/gui/resultpage.cpp
+++ b/src/crypto/gui/resultpage.cpp
@@ -1,181 +1,182 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "resultpage.h"
 #include "resultlistwidget.h"
 #include "resultitemwidget.h"
 
 #include <crypto/taskcollection.h>
 
 #include <utils/scrollarea.h>
 
 #include <KLocalizedString>
 
 #include <QCheckBox>
 #include <QHash>
 #include <QLabel>
 #include <QProgressBar>
 #include <QVBoxLayout>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class ResultPage::Private
 {
     ResultPage *const q;
 public:
     explicit Private(ResultPage *qq);
 
     void progress(const QString &msg, int progress, int total);
     void result(const std::shared_ptr<const Task::Result> &result);
     void started(const std::shared_ptr<Task> &result);
     void allDone();
     void keepOpenWhenDone(bool keep);
     QLabel *labelForTag(const QString &tag);
 
     std::shared_ptr<TaskCollection> m_tasks;
     QProgressBar *m_progressBar;
     QHash<QString, QLabel *> m_progressLabelByTag;
     QVBoxLayout *m_progressLabelLayout;
     int m_lastErrorItemIndex = 0;
     ResultListWidget *m_resultList;
     QCheckBox *m_keepOpenCB;
 };
 
 ResultPage::Private::Private(ResultPage *qq) : q(qq)
 {
     QBoxLayout *const layout = new QVBoxLayout(q);
     auto const labels = new QWidget;
     m_progressLabelLayout = new QVBoxLayout(labels);
     layout->addWidget(labels);
     m_progressBar = new QProgressBar;
     layout->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     layout->addWidget(m_resultList);
     m_keepOpenCB = new QCheckBox;
     m_keepOpenCB->setText(i18n("Keep open after operation completed"));
     m_keepOpenCB->setChecked(true);
     connect(m_keepOpenCB, &QAbstractButton::toggled, q, &ResultPage::keepOpenWhenDone);
     layout->addWidget(m_keepOpenCB);
 }
 
 void ResultPage::Private::progress(const QString &msg, int progress, int total)
 {
     Q_UNUSED(msg)
     Q_ASSERT(progress >= 0);
     Q_ASSERT(total >= 0);
     m_progressBar->setRange(0, total);
     m_progressBar->setValue(progress);
 }
 
 void ResultPage::Private::keepOpenWhenDone(bool)
 {
 }
 
 void ResultPage::Private::allDone()
 {
     Q_ASSERT(m_tasks);
     q->setAutoAdvance(!m_keepOpenCB->isChecked() && !m_tasks->errorOccurred());
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     m_tasks.reset();
-    Q_FOREACH (const QString &i, m_progressLabelByTag.keys()) {
+    const auto progressLabelByTagKeys{m_progressLabelByTag.keys()};
+    for (const QString &i : progressLabelByTagKeys) {
         if (!i.isEmpty()) {
             m_progressLabelByTag.value(i)->setText(i18n("%1: All operations completed.", i));
         } else {
             m_progressLabelByTag.value(i)->setText(i18n("All operations completed."));
         }
     }
     Q_EMIT q->completeChanged();
 }
 
 void ResultPage::Private::result(const std::shared_ptr<const Task::Result> &)
 {
 }
 
 void ResultPage::Private::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const QString tag = task->tag();
     QLabel *const label = labelForTag(tag);
     Q_ASSERT(label);
     if (tag.isEmpty()) {
         label->setText(i18nc("number, operation description", "Operation %1: %2", m_tasks->numberOfCompletedTasks() + 1, task->label()));
     } else {
         label->setText(i18nc(R"(tag( "OpenPGP" or "CMS"),  operation description)", "%1: %2", tag, task->label()));
     }
 }
 
 ResultPage::ResultPage(QWidget *parent, Qt::WindowFlags flags) : WizardPage(parent, flags), d(new Private(this))
 {
     setTitle(i18n("<b>Results</b>"));
 }
 
 ResultPage::~ResultPage()
 {
 }
 
 bool ResultPage::keepOpenWhenDone() const
 {
     return d->m_keepOpenCB->isChecked();
 }
 
 void ResultPage::setKeepOpenWhenDone(bool keep)
 {
     d->m_keepOpenCB->setChecked(keep);
 }
 
 void ResultPage::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     Q_ASSERT(!d->m_tasks);
     if (d->m_tasks == coll) {
         return;
     }
     d->m_tasks = coll;
     Q_ASSERT(d->m_tasks);
     d->m_resultList->setTaskCollection(coll);
     connect(d->m_tasks.get(), SIGNAL(progress(QString,int,int)),
             this, SLOT(progress(QString,int,int)));
     connect(d->m_tasks.get(), SIGNAL(done()),
             this, SLOT(allDone()));
     connect(d->m_tasks.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
             this, SLOT(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
     connect(d->m_tasks.get(), SIGNAL(started(std::shared_ptr<Kleo::Crypto::Task>)),
             this, SLOT(started(std::shared_ptr<Kleo::Crypto::Task>)));
 
     Q_FOREACH (const std::shared_ptr<Task> &i, d->m_tasks->tasks()) {    // create labels for all tags in collection
         Q_ASSERT(i && d->labelForTag(i->tag()));
         Q_UNUSED(i)
     }
     Q_EMIT completeChanged();
 }
 
 QLabel *ResultPage::Private::labelForTag(const QString &tag)
 {
     if (QLabel *const label = m_progressLabelByTag.value(tag)) {
         return label;
     }
     auto label = new QLabel;
     label->setTextFormat(Qt::RichText);
     label->setWordWrap(true);
     m_progressLabelLayout->addWidget(label);
     m_progressLabelByTag.insert(tag, label);
     return label;
 }
 
 bool ResultPage::isComplete() const
 {
     return d->m_tasks ? d->m_tasks->allTasksCompleted() : true;
 }
 
 #include "moc_resultpage.cpp"
diff --git a/src/crypto/gui/signencryptemailconflictdialog.cpp b/src/crypto/gui/signencryptemailconflictdialog.cpp
index e9f1702b8..38fbf22f6 100644
--- a/src/crypto/gui/signencryptemailconflictdialog.cpp
+++ b/src/crypto/gui/signencryptemailconflictdialog.cpp
@@ -1,644 +1,644 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptemailconflictdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptemailconflictdialog.h"
 
 #include <crypto/sender.h>
 #include <crypto/recipient.h>
 
 #include "dialogs/certificateselectiondialog.h"
 #include "certificateselectionline.h"
 
 #include <Libkleo/GnuPG>
 #include "utils/gui-helper.h"
 #include "utils/kleo_assert.h"
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/key.h>
 
 #include <KMime/HeaderParsing>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 
 #include <QLabel>
 #include <QLayout>
 #include <QGroupBox>
 #include <QDialogButtonBox>
 #include <QCheckBox>
 #include <QRadioButton>
 #include <QPushButton>
 #include <QPointer>
 #include <QSignalBlocker>
 #include <QToolButton>
 
 #include <algorithm>
 #include <iterator>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 Q_DECLARE_METATYPE(GpgME::UserID)
 
 static CertificateSelectionDialog *
 create_certificate_selection_dialog(QWidget *parent, Protocol proto)
 {
     auto const dlg = new CertificateSelectionDialog(parent);
     dlg->setOptions(proto == OpenPGP ? CertificateSelectionDialog::OpenPGPFormat :
                     proto == CMS     ? CertificateSelectionDialog::CMSFormat : CertificateSelectionDialog::AnyFormat);
     return dlg;
 }
 
 static CertificateSelectionDialog *
 create_encryption_certificate_selection_dialog(QWidget *parent, Protocol proto, const QString &mailbox)
 {
     CertificateSelectionDialog *const dlg = create_certificate_selection_dialog(parent, proto);
     dlg->setCustomLabelText(i18n("Please select an encryption certificate for recipient \"%1\"", mailbox));
     dlg->setOptions(CertificateSelectionDialog::SingleSelection |
                     CertificateSelectionDialog::EncryptOnly |
                     dlg->options());
     return dlg;
 }
 
 static CertificateSelectionDialog *
 create_signing_certificate_selection_dialog(QWidget *parent, Protocol proto, const QString &mailbox)
 {
     CertificateSelectionDialog *const dlg = create_certificate_selection_dialog(parent, proto);
     dlg->setCustomLabelText(i18n("Please select a signing certificate for sender \"%1\"", mailbox));
     dlg->setOptions(CertificateSelectionDialog::SingleSelection |
                     CertificateSelectionDialog::SignOnly |
                     CertificateSelectionDialog::SecretKeys |
                     dlg->options());
     return dlg;
 }
 
 static QString make_top_label_conflict_text(bool sign, bool enc)
 {
     return
         sign && enc ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for all recipients/senders of the message.\n"
                            "Please select the correct certificates for each recipient:") :
         sign        ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for the sender of the message.\n"
                            "Please select the correct certificates for the sender:") :
         enc         ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for all recipients of the message.\n"
                            "Please select the correct certificates for each recipient:") :
         /* else */ (kleo_assert_fail(sign || enc), QString());
 }
 
 static QString make_top_label_quickmode_text(bool sign, bool enc)
 {
     return
         enc    ? i18n("Please verify that correct certificates have been selected for each recipient:") :
         sign   ? i18n("Please verify that the correct certificate has been selected for the sender:") :
         /*else*/ (kleo_assert_fail(sign || enc), QString());
 }
 
 class SignEncryptEMailConflictDialog::Private
 {
     friend class ::Kleo::Crypto::Gui::SignEncryptEMailConflictDialog;
     SignEncryptEMailConflictDialog *const q;
 public:
     explicit Private(SignEncryptEMailConflictDialog *qq)
         : q(qq),
           senders(),
           recipients(),
           sign(true),
           encrypt(true),
           presetProtocol(UnknownProtocol),
           ui(q)
     {
 
     }
 
 private:
     void updateTopLabelText()
     {
         ui.conflictTopLB.setText(make_top_label_conflict_text(sign, encrypt));
         ui.quickModeTopLB.setText(make_top_label_quickmode_text(sign, encrypt));
     }
 
     void showHideWidgets()
     {
         const Protocol proto = q->selectedProtocol();
         const bool quickMode = q->isQuickMode();
 
         const bool needProtocolSelection = presetProtocol == UnknownProtocol;
 
         const bool needShowAllRecipientsCB =
             quickMode             ? false :
             needProtocolSelection ? needShowAllRecipients(OpenPGP) || needShowAllRecipients(CMS) :
             /* else */              needShowAllRecipients(proto)
             ;
 
         ui.showAllRecipientsCB.setVisible(needShowAllRecipientsCB);
 
         ui.pgpRB.setVisible(needProtocolSelection);
         ui.cmsRB.setVisible(needProtocolSelection);
 
         const bool showAll = !needShowAllRecipientsCB || ui.showAllRecipientsCB.isChecked();
 
         bool first;
         first = true;
         for (const CertificateSelectionLine &line : std::as_const(ui.signers)) {
             line.showHide(proto, first, showAll, sign);
         }
         ui.selectSigningCertificatesGB.setVisible(sign && (showAll || !first));
 
         first = true;
         for (const CertificateSelectionLine &line : std::as_const(ui.recipients)) {
             line.showHide(proto, first, showAll, encrypt);
         }
         ui.selectEncryptionCertificatesGB.setVisible(encrypt && (showAll || !first));
     }
 
     bool needShowAllRecipients(Protocol proto) const
     {
         if (sign) {
             if (const unsigned int num = std::count_if(ui.signers.cbegin(), ui.signers.cend(),
                                                        [proto](const CertificateSelectionLine &l) {
                                                            return l.wasInitiallyAmbiguous(proto);
                                                        })) {
                 if (num != ui.signers.size()) {
                     return true;
                 }
             }
         }
         if (encrypt) {
             if (const unsigned int num = std::count_if(ui.recipients.cbegin(), ui.recipients.cend(),
                                                       [proto](const CertificateSelectionLine &l) {
                                                           return l.wasInitiallyAmbiguous(proto);
                                                       })) {
                 if (num != ui.recipients.size()) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     void createSendersAndRecipients()
     {
         ui.clearSendersAndRecipients();
 
         ui.addSelectSigningCertificatesGB();
         for (const Sender &s : std::as_const(senders)) {
             addSigner(s);
         }
 
         ui.addSelectEncryptionCertificatesGB();
         for (const Sender &s : std::as_const(senders)) {
             addRecipient(s);
         }
         for (const Recipient &r : std::as_const(recipients)) {
             addRecipient(r);
         }
     }
 
     void addSigner(const Sender &s)
     {
         ui.addSigner(s.mailbox().prettyAddress(),
                      s.signingCertificateCandidates(OpenPGP),
                      s.isSigningAmbiguous(OpenPGP),
                      s.signingCertificateCandidates(CMS),
                      s.isSigningAmbiguous(CMS),
                      q);
     }
 
     void addRecipient(const Sender &s)
     {
         ui.addRecipient(s.mailbox().prettyAddress(),
                         s.encryptToSelfCertificateCandidates(OpenPGP),
                         s.isEncryptionAmbiguous(OpenPGP),
                         s.encryptToSelfCertificateCandidates(CMS),
                         s.isEncryptionAmbiguous(CMS),
                         q);
     }
 
     void addRecipient(const Recipient &r)
     {
         ui.addRecipient(r.mailbox().prettyAddress(),
                         r.encryptionCertificateCandidates(OpenPGP),
                         r.isEncryptionAmbiguous(OpenPGP),
                         r.encryptionCertificateCandidates(CMS),
                         r.isEncryptionAmbiguous(CMS),
                         q);
     }
 
     bool isComplete(Protocol proto) const;
 
 private:
 
     void updateComplianceStatus()
     {
         if (q->selectedProtocol() == UnknownProtocol ||
             (q->resolvedSigningKeys().empty() && q->resolvedEncryptionKeys().empty())) {
             return;
         }
         // Handle compliance
         bool de_vs = true;
         for (const auto &key: q->resolvedSigningKeys()) {
             if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 de_vs = false;
                 break;
             }
         }
         if (de_vs) {
             for (const auto &key: q->resolvedEncryptionKeys()) {
                 if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                     de_vs = false;
                     break;
                 }
             }
         }
 
         auto btn = ui.buttonBox.button(QDialogButtonBox::Ok);
 
         btn->setIcon(QIcon::fromTheme(de_vs
                     ? QStringLiteral("security-high")
                     : QStringLiteral("security-medium")));
         btn->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                     ? KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                     : KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
         ui.complianceLB.setText(de_vs
                 ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                     "%1 communication possible.", Formatting::deVsString())
                 : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                     "%1 communication not possible.", Formatting::deVsString()));
         ui.complianceLB.setVisible(true);
     }
 
     void updateDialogStatus()
     {
         ui.setOkButtonEnabled(q->isComplete());
         if (Kleo::gpgComplianceP("de-vs")) {
             updateComplianceStatus();
         }
     }
     void slotCompleteChanged()
     {
         updateDialogStatus();
     }
     void slotShowAllRecipientsToggled(bool)
     {
         showHideWidgets();
     }
     void slotProtocolChanged()
     {
         showHideWidgets();
         updateDialogStatus();
     }
     void slotCertificateSelectionDialogRequested()
     {
         const QObject *const s = q->sender();
         const Protocol proto = q->selectedProtocol();
         QPointer<CertificateSelectionDialog> dlg;
-        Q_FOREACH (const CertificateSelectionLine &l, ui.signers)
+        for (const CertificateSelectionLine &l : std::as_const(ui.signers))
             if (s == l.toolButton()) {
                 dlg = create_signing_certificate_selection_dialog(q, proto, l.mailboxText());
                 if (dlg->exec()) {
                     l.addAndSelectCertificate(dlg->selectedCertificate());
                 }
                 // ### switch to key.protocol(), in case proto == UnknownProtocol
                 break;
             }
-        Q_FOREACH (const CertificateSelectionLine &l, ui.recipients)
+        for (const CertificateSelectionLine &l : std::as_const(ui.recipients))
             if (s == l.toolButton()) {
                 dlg = create_encryption_certificate_selection_dialog(q, proto, l.mailboxText());
                 if (dlg->exec()) {
                     l.addAndSelectCertificate(dlg->selectedCertificate());
                 }
                 // ### switch to key.protocol(), in case proto == UnknownProtocol
                 break;
             }
 #ifndef Q_OS_WIN
         // This leads to a crash on Windows. We don't really
         // leak memory here anyway because the destruction of the
         // dialog happens when the parent (q) is destroyed anyway.
         delete dlg;
 #endif
     }
 
 private:
     std::vector<Sender> senders;
     std::vector<Recipient> recipients;
 
     bool sign : 1;
     bool encrypt : 1;
     Protocol presetProtocol;
 
 private:
     struct Ui {
         QLabel conflictTopLB, quickModeTopLB;
         QCheckBox showAllRecipientsCB;
         QRadioButton pgpRB, cmsRB;
         QGroupBox selectSigningCertificatesGB;
         QGroupBox selectEncryptionCertificatesGB;
         QCheckBox quickModeCB;
         QDialogButtonBox buttonBox;
         QVBoxLayout vlay;
         QHBoxLayout  hlay;
         QHBoxLayout  hlay2;
         QGridLayout  glay;
         std::vector<CertificateSelectionLine> signers, recipients;
         QLabel complianceLB;
 
         void setOkButtonEnabled(bool enable)
         {
             return buttonBox.button(QDialogButtonBox::Ok)->setEnabled(enable);
         }
 
         explicit Ui(SignEncryptEMailConflictDialog *q)
             : conflictTopLB(make_top_label_conflict_text(true, true), q),
               quickModeTopLB(make_top_label_quickmode_text(true, true), q),
               showAllRecipientsCB(i18n("Show all recipients"), q),
               pgpRB(i18n("OpenPGP"), q),
               cmsRB(i18n("S/MIME"), q),
               selectSigningCertificatesGB(i18n("Select Signing Certificate"), q),
               selectEncryptionCertificatesGB(i18n("Select Encryption Certificate"), q),
               quickModeCB(i18n("Only show this dialog in case of conflicts (experimental)"), q),
               buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, q),
               vlay(q),
               hlay(),
               glay(),
               signers(),
               recipients()
         {
             KDAB_SET_OBJECT_NAME(conflictTopLB);
             KDAB_SET_OBJECT_NAME(quickModeTopLB);
             KDAB_SET_OBJECT_NAME(showAllRecipientsCB);
             KDAB_SET_OBJECT_NAME(pgpRB);
             KDAB_SET_OBJECT_NAME(cmsRB);
             KDAB_SET_OBJECT_NAME(selectSigningCertificatesGB);
             KDAB_SET_OBJECT_NAME(selectEncryptionCertificatesGB);
             KDAB_SET_OBJECT_NAME(quickModeCB);
             KDAB_SET_OBJECT_NAME(buttonBox);
             KDAB_SET_OBJECT_NAME(hlay);
             KDAB_SET_OBJECT_NAME(glay);
             KDAB_SET_OBJECT_NAME(vlay);
 
             q->setWindowTitle(i18nc("@title:window", "Select Certificates for Message"));
 
             conflictTopLB.hide();
 
             selectSigningCertificatesGB.setFlat(true);
             selectEncryptionCertificatesGB.setFlat(true);
             selectSigningCertificatesGB.setAlignment(Qt::AlignCenter);
             selectEncryptionCertificatesGB.setAlignment(Qt::AlignCenter);
 
             glay.setColumnStretch(2, 1);
             glay.setColumnStretch(3, 1);
 
             vlay.setSizeConstraint(QLayout::SetMinimumSize);
 
             vlay.addWidget(&conflictTopLB);
             vlay.addWidget(&quickModeTopLB);
 
             hlay.addWidget(&showAllRecipientsCB);
             hlay.addStretch(1);
             hlay.addWidget(&pgpRB);
             hlay.addWidget(&cmsRB);
             vlay.addLayout(&hlay);
 
             addSelectSigningCertificatesGB();
             addSelectEncryptionCertificatesGB();
             vlay.addLayout(&glay);
 
             vlay.addStretch(1);
 
             complianceLB.setVisible(false);
             hlay2.addStretch(1);
             hlay2.addWidget(&complianceLB, 0, Qt::AlignRight);
             hlay2.addWidget(&buttonBox, 0, Qt::AlignRight);
 
             vlay.addWidget(&quickModeCB, 0, Qt::AlignRight);
             vlay.addLayout(&hlay2);
 
 
             connect(&buttonBox, &QDialogButtonBox::accepted, q, &SignEncryptEMailConflictDialog::accept);
             connect(&buttonBox, &QDialogButtonBox::rejected, q, &SignEncryptEMailConflictDialog::reject);
 
             connect(&showAllRecipientsCB, SIGNAL(toggled(bool)), q, SLOT(slotShowAllRecipientsToggled(bool)));
             connect(&pgpRB, SIGNAL(toggled(bool)),
                     q, SLOT(slotProtocolChanged()));
             connect(&cmsRB, SIGNAL(toggled(bool)),
                     q, SLOT(slotProtocolChanged()));
         }
 
         void clearSendersAndRecipients()
         {
             std::vector<CertificateSelectionLine> sig, enc;
             sig.swap(signers);
             enc.swap(recipients);
             std::for_each(sig.begin(), sig.end(), std::mem_fn(&CertificateSelectionLine::kill));
             std::for_each(enc.begin(), enc.end(), std::mem_fn(&CertificateSelectionLine::kill));
             glay.removeWidget(&selectSigningCertificatesGB);
             glay.removeWidget(&selectEncryptionCertificatesGB);
         }
 
         void addSelectSigningCertificatesGB()
         {
             glay.addWidget(&selectSigningCertificatesGB,    glay.rowCount(), 0, 1, CertificateSelectionLine::NumColumns);
         }
         void addSelectEncryptionCertificatesGB()
         {
             glay.addWidget(&selectEncryptionCertificatesGB, glay.rowCount(), 0, 1, CertificateSelectionLine::NumColumns);
         }
 
         void addSigner(const QString &mailbox,
                        const std::vector<Key> &pgp, bool pgpAmbiguous,
                        const std::vector<Key> &cms, bool cmsAmbiguous, QWidget *q)
         {
             CertificateSelectionLine line(i18n("From:"), mailbox, pgp, pgpAmbiguous, cms, cmsAmbiguous, q, glay);
             signers.push_back(line);
         }
 
         void addRecipient(const QString &mailbox,
                           const std::vector<Key> &pgp, bool pgpAmbiguous,
                           const std::vector<Key> &cms, bool cmsAmbiguous, QWidget *q)
         {
             CertificateSelectionLine line(i18n("To:"), mailbox, pgp, pgpAmbiguous, cms, cmsAmbiguous, q, glay);
             recipients.push_back(line);
         }
 
     } ui;
 };
 
 SignEncryptEMailConflictDialog::SignEncryptEMailConflictDialog(QWidget *parent)
     : QDialog(parent), d(new Private(this))
 {
 
 }
 
 SignEncryptEMailConflictDialog::~SignEncryptEMailConflictDialog() {}
 
 void SignEncryptEMailConflictDialog::setPresetProtocol(Protocol p)
 {
     if (p == d->presetProtocol) {
         return;
     }
     const QSignalBlocker pgpBlocker(d->ui.pgpRB);
     const QSignalBlocker cmsBlocker(d->ui.cmsRB);
     really_check(d->ui.pgpRB, p == OpenPGP);
     really_check(d->ui.cmsRB, p == CMS);
     d->presetProtocol = p;
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 Protocol SignEncryptEMailConflictDialog::selectedProtocol() const
 {
     if (d->presetProtocol != UnknownProtocol) {
         return d->presetProtocol;
     }
     if (d->ui.pgpRB.isChecked()) {
         return OpenPGP;
     }
     if (d->ui.cmsRB.isChecked()) {
         return CMS;
     }
     return UnknownProtocol;
 }
 
 void SignEncryptEMailConflictDialog::setSubject(const QString &subject)
 {
     setWindowTitle(i18nc("@title:window", "Select Certificates for Message \"%1\"", subject));
 }
 
 void SignEncryptEMailConflictDialog::setSign(bool sign)
 {
     if (sign == d->sign) {
         return;
     }
     d->sign = sign;
     d->updateTopLabelText();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setEncrypt(bool encrypt)
 {
     if (encrypt == d->encrypt) {
         return;
     }
     d->encrypt = encrypt;
     d->updateTopLabelText();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setSenders(const std::vector<Sender> &senders)
 {
     if (senders == d->senders) {
         return;
     }
     d->senders = senders;
     d->createSendersAndRecipients();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setRecipients(const std::vector<Recipient> &recipients)
 {
     if (d->recipients == recipients) {
         return;
     }
     d->recipients = recipients;
     d->createSendersAndRecipients();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::pickProtocol()
 {
 
     if (selectedProtocol() != UnknownProtocol) {
         return;    // already picked
     }
 
     const bool pgp = d->isComplete(OpenPGP);
     const bool cms = d->isComplete(CMS);
 
     if (pgp && !cms) {
         d->ui.pgpRB.setChecked(true);
     } else if (cms && !pgp) {
         d->ui.cmsRB.setChecked(true);
     }
 }
 
 bool SignEncryptEMailConflictDialog::isComplete() const
 {
     const Protocol proto = selectedProtocol();
     return proto != UnknownProtocol && d->isComplete(proto);
 }
 
 bool SignEncryptEMailConflictDialog::Private::isComplete(Protocol proto) const
 {
     return (!sign || std::none_of(ui.signers.cbegin(), ui.signers.cend(),
                                   [proto](const CertificateSelectionLine &l) {
                                       return l.isStillAmbiguous(proto);
                                   }))
            && (!encrypt || std::none_of(ui.recipients.cbegin(), ui.recipients.cend(),
                                         [proto](const CertificateSelectionLine &l) {
                                             return l.isStillAmbiguous(proto);
                                         }));
 }
 
 static std::vector<Key> get_keys(const std::vector<CertificateSelectionLine> &lines, Protocol proto)
 {
     if (proto == UnknownProtocol) {
         return std::vector<Key>();
     }
     Q_ASSERT(proto == OpenPGP || proto == CMS);
 
     std::vector<Key> keys;
     keys.reserve(lines.size());
     std::transform(lines.cbegin(), lines.cend(), std::back_inserter(keys),
                    [proto](const CertificateSelectionLine &l) {
                        return l.key(proto);
                    });
     return keys;
 }
 
 std::vector<Key> SignEncryptEMailConflictDialog::resolvedSigningKeys() const
 {
     return d->sign    ? get_keys(d->ui.signers,    selectedProtocol()) : std::vector<Key>();
 }
 
 std::vector<Key> SignEncryptEMailConflictDialog::resolvedEncryptionKeys() const
 {
     return d->encrypt ? get_keys(d->ui.recipients, selectedProtocol()) : std::vector<Key>();
 }
 
 void SignEncryptEMailConflictDialog::setQuickMode(bool on)
 {
     d->ui.quickModeCB.setChecked(on);
 }
 
 bool SignEncryptEMailConflictDialog::isQuickMode() const
 {
     return d->ui.quickModeCB.isChecked();
 }
 
 void SignEncryptEMailConflictDialog::setConflict(bool conflict)
 {
     d->ui.conflictTopLB.setVisible(conflict);
     d->ui.quickModeTopLB.setVisible(!conflict);
 }
 
 #include "moc_signencryptemailconflictdialog.cpp"
diff --git a/src/crypto/verifychecksumscontroller.cpp b/src/crypto/verifychecksumscontroller.cpp
index c418bea03..41c4f6229 100644
--- a/src/crypto/verifychecksumscontroller.cpp
+++ b/src/crypto/verifychecksumscontroller.cpp
@@ -1,689 +1,689 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/verifychecksumscontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "verifychecksumscontroller.h"
 
 #ifndef QT_NO_DIRMODEL
 
 #include <crypto/gui/verifychecksumsdialog.h>
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/ChecksumDefinition>
 #include <Libkleo/Classify>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 #include <QPointer>
 #include <QFileInfo>
 #include <QThread>
 #include <QMutex>
 #include <QProgressDialog>
 #include <QDir>
 #include <QProcess>
 
 #include <gpg-error.h>
 
 #include <deque>
 #include <limits>
 #include <set>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 #ifdef Q_OS_UNIX
 static const bool HAVE_UNIX = true;
 #else
 static const bool HAVE_UNIX = false;
 #endif
 
 static const QLatin1String CHECKSUM_DEFINITION_ID_ENTRY("checksum-definition-id");
 
 static const Qt::CaseSensitivity fs_cs = HAVE_UNIX ? Qt::CaseSensitive : Qt::CaseInsensitive; // can we use QAbstractFileEngine::caseSensitive()?
 
 #if 0
 static QStringList fs_sort(QStringList l)
 {
     int (*QString_compare)(const QString &, const QString &, Qt::CaseSensitivity) = &QString::compare;
     std::sort(l.begin(), l.end(),
               [](const QString &lhs, const QString &rhs) {
                 return QString::compare(lhs, rhs, fs_cs) < 0;
               });
     return l;
 }
 
 static QStringList fs_intersect(QStringList l1, QStringList l2)
 {
     int (*QString_compare)(const QString &, const QString &, Qt::CaseSensitivity) = &QString::compare;
     fs_sort(l1);
     fs_sort(l2);
     QStringList result;
     std::set_intersection(l1.begin(), l1.end(),
                           l2.begin(), l2.end(),
                           std::back_inserter(result),
                           [](const QString &lhs, const QString &rhs) {
                             return QString::compare(lhs, rhs, fs_cs) < 0;
                           });
     return result;
 }
 #endif
 
 static QList<QRegExp> get_patterns(const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
     QList<QRegExp> result;
     for (const std::shared_ptr<ChecksumDefinition> &cd : checksumDefinitions)
         if (cd) {
             const auto patterns = cd->patterns();
             for (const QString &pattern : patterns) {
                 result.push_back(QRegExp(pattern, fs_cs));
             }
         }
     return result;
 }
 
 namespace
 {
 struct matches_any : std::unary_function<QString, bool> {
     const QList<QRegExp> m_regexps;
     explicit matches_any(const QList<QRegExp> &regexps) : m_regexps(regexps) {}
     bool operator()(const QString &s) const
     {
         return std::any_of(m_regexps.cbegin(), m_regexps.cend(),
                            [&s](const QRegExp &rx) { return rx.exactMatch(s); });
     }
 };
 struct matches_none_of : std::unary_function<QString, bool> {
     const QList<QRegExp> m_regexps;
     explicit matches_none_of(const QList<QRegExp> &regexps) : m_regexps(regexps) {}
     bool operator()(const QString &s) const
     {
         return std::none_of(m_regexps.cbegin(), m_regexps.cend(),
                             [&s](const QRegExp &rx) { return rx.exactMatch(s); });
     }
 };
 }
 
 class VerifyChecksumsController::Private : public QThread
 {
     Q_OBJECT
     friend class ::Kleo::Crypto::VerifyChecksumsController;
     VerifyChecksumsController *const q;
 public:
     explicit Private(VerifyChecksumsController *qq);
     ~Private() override;
 
 Q_SIGNALS:
     void baseDirectories(const QStringList &);
     void progress(int, int, const QString &);
     void status(const QString &file, Kleo::Crypto::Gui::VerifyChecksumsDialog::Status);
 
 private:
     void slotOperationFinished()
     {
         if (dialog) {
             dialog->setProgress(100, 100);
             dialog->setErrors(errors);
         }
 
         if (!errors.empty())
             q->setLastError(gpg_error(GPG_ERR_GENERAL),
                             errors.join(QLatin1Char('\n')));
         q->emitDoneOrError();
     }
 
 private:
     void run() override;
 
 private:
     QPointer<VerifyChecksumsDialog> dialog;
     mutable QMutex mutex;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions;
     QStringList files;
     QStringList errors;
     volatile bool canceled;
 };
 
 VerifyChecksumsController::Private::Private(VerifyChecksumsController *qq)
     : q(qq),
       dialog(),
       mutex(),
       checksumDefinitions(ChecksumDefinition::getChecksumDefinitions()),
       files(),
       errors(),
       canceled(false)
 {
     connect(this, &Private::progress,
             q, &Controller::progress);
     connect(this, SIGNAL(finished()),
             q, SLOT(slotOperationFinished()));
 }
 
 VerifyChecksumsController::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 VerifyChecksumsController::VerifyChecksumsController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 VerifyChecksumsController::VerifyChecksumsController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *p)
     : Controller(ctx, p), d(new Private(this))
 {
 
 }
 
 VerifyChecksumsController::~VerifyChecksumsController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void VerifyChecksumsController::setFiles(const QStringList &files)
 {
     kleo_assert(!d->isRunning());
     kleo_assert(!files.empty());
     const QMutexLocker locker(&d->mutex);
     d->files = files;
 }
 
 void VerifyChecksumsController::start()
 {
 
     {
         const QMutexLocker locker(&d->mutex);
 
         d->dialog = new VerifyChecksumsDialog;
         d->dialog->setAttribute(Qt::WA_DeleteOnClose);
         d->dialog->setWindowTitle(i18nc("@title:window", "Verify Checksum Results"));
 
         connect(d->dialog.data(), &VerifyChecksumsDialog::canceled,
                 this, &VerifyChecksumsController::cancel);
         connect(d.get(), &Private::baseDirectories,
                 d->dialog.data(), &VerifyChecksumsDialog::setBaseDirectories);
         connect(d.get(), &Private::progress,
                 d->dialog.data(), &VerifyChecksumsDialog::setProgress);
         connect(d.get(), &Private::status,
                 d->dialog.data(), &VerifyChecksumsDialog::setStatus);
 
         d->canceled = false;
         d->errors.clear();
     }
 
     d->start();
 
     d->dialog->show();
 
 }
 
 void VerifyChecksumsController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     const QMutexLocker locker(&d->mutex);
     d->canceled = true;
 }
 
 namespace
 {
 
 struct SumFile {
     QDir dir;
     QString sumFile;
     quint64 totalSize;
     std::shared_ptr<ChecksumDefinition> checksumDefinition;
 };
 
 }
 
 static QStringList filter_checksum_files(QStringList l, const QList<QRegExp> &rxs)
 {
     l.erase(std::remove_if(l.begin(), l.end(),
                            matches_none_of(rxs)),
             l.end());
     return l;
 }
 
 namespace
 {
 struct File {
     QString name;
     QByteArray checksum;
     bool binary;
 };
 }
 
 static QString decode(const QString &encoded)
 {
     QString decoded;
     decoded.reserve(encoded.size());
     bool shift = false;
     for (const QChar &ch : encoded)
         if (shift) {
             switch (ch.toLatin1()) {
             case '\\': decoded += QLatin1Char('\\'); break;
             case 'n':  decoded += QLatin1Char('\n'); break;
             default:
                 qCDebug(KLEOPATRA_LOG) << "invalid escape sequence" << '\\' << ch << "(interpreted as '" << ch << "')";
                 decoded += ch;
                 break;
             }
             shift = false;
         } else {
             if (ch == QLatin1Char('\\')) {
                 shift = true;
             } else {
                 decoded += ch;
             }
         }
     return decoded;
 }
 
 static std::vector<File> parse_sum_file(const QString &fileName)
 {
     std::vector<File> files;
     QFile f(fileName);
     if (f.open(QIODevice::ReadOnly)) {
         QTextStream s(&f);
         QRegExp rx(QLatin1String("(\\?)([a-f0-9A-F]+) ([ *])([^\n]+)\n*"));
         while (!s.atEnd()) {
             const QString line = s.readLine();
             if (rx.exactMatch(line)) {
                 Q_ASSERT(!rx.cap(4).endsWith(QLatin1Char('\n')));
                 const File file = {
                     rx.cap(1) == QLatin1String("\\") ? decode(rx.cap(4)) : rx.cap(4),
                     rx.cap(2).toLatin1(),
                     rx.cap(3) == QLatin1String("*"),
                 };
                 files.push_back(file);
             }
         }
     }
     return files;
 }
 
 static quint64 aggregate_size(const QDir &dir, const QStringList &files)
 {
     quint64 n = 0;
     for (const QString &file : files) {
         n += QFileInfo(dir.absoluteFilePath(file)).size();
     }
     return n;
 }
 
 static std::shared_ptr<ChecksumDefinition> filename2definition(const QString &fileName,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
     for (const std::shared_ptr<ChecksumDefinition> &cd : checksumDefinitions)
         if (cd) {
             const auto patterns = cd->patterns();
             for (const QString &pattern : patterns)
                 if (QRegExp(pattern, fs_cs).exactMatch(fileName)) {
                     return cd;
                 }
         }
     return std::shared_ptr<ChecksumDefinition>();
 }
 
 namespace
 {
 struct less_dir : std::binary_function<QDir, QDir, bool> {
     bool operator()(const QDir &lhs, const QDir &rhs) const
     {
         return QString::compare(lhs.absolutePath(), rhs.absolutePath(), fs_cs) < 0;
     }
 };
 struct less_file : std::binary_function<QString, QString, bool> {
     bool operator()(const QString &lhs, const QString &rhs) const
     {
         return QString::compare(lhs, rhs, fs_cs) < 0;
     }
 };
 struct sumfile_contains_file : std::unary_function<QString, bool> {
     const QDir dir;
     const QString fileName;
     sumfile_contains_file(const QDir &dir_, const QString &fileName_)
         : dir(dir_), fileName(fileName_) {}
     bool operator()(const QString &sumFile) const
     {
         const std::vector<File> files = parse_sum_file(dir.absoluteFilePath(sumFile));
         qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:      found " << files.size()
                                << " files listed in " << qPrintable(dir.absoluteFilePath(sumFile));
         for (const File &file : files) {
             const bool isSameFileName = (QString::compare(file.name, fileName, fs_cs) == 0);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:        "
                                    << qPrintable(file.name) << " == "
                                    << qPrintable(fileName)  << " ? "
                                    << isSameFileName;
             if (isSameFileName) {
                 return true;
             }
         }
         return false;
     }
 };
 
 }
 
 // IF is_dir(file)
 //   add all sumfiles \in dir(file)
 //   inputs.prepend( all dirs \in dir(file) )
 // ELSE IF is_sum_file(file)
 //   add
 // ELSE IF \exists sumfile in dir(file) \where sumfile \contains file
 //   add sumfile
 // ELSE
 //   error: no checksum found for "file"
 
 static QStringList find_base_directories(const QStringList &files)
 {
 
     // Step 1: find base dirs:
 
     std::set<QDir, less_dir> dirs;
     for (const QString &file : files) {
         const QFileInfo fi(file);
         const QDir dir = fi.isDir() ? QDir(file) : fi.dir();
         dirs.insert(dir);
     }
 
     // Step 1a: collapse direct child directories
 
     bool changed;
     do {
         changed = false;
         auto it = dirs.begin();
         while (it != dirs.end()) {
             QDir dir = *it;
             if (dir.cdUp() && dirs.count(dir)) {
                 dirs.erase(it++);
                 changed = true;
             } else {
                 ++it;
             }
         }
     } while (changed);
 
     QStringList rv;
     rv.reserve(dirs.size());
     std::transform(dirs.cbegin(), dirs.cend(), std::back_inserter(rv), std::mem_fn(&QDir::absolutePath));
     return rv;
 }
 
 static std::vector<SumFile> find_sums_by_input_files(const QStringList &files, QStringList &errors,
         const std::function<void(int)> &progress,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
     const QList<QRegExp> patterns = get_patterns(checksumDefinitions);
 
     const matches_any is_sum_file(patterns);
 
     std::map<QDir, std::set<QString, less_file>, less_dir> dirs2sums;
 
     // Step 1: find the sumfiles we need to check:
 
     std::deque<QString> inputs(files.begin(), files.end());
 
     int i = 0;
     while (!inputs.empty()) {
         const QString file = inputs.front();
         qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files: considering " << qPrintable(file);
         inputs.pop_front();
         const QFileInfo fi(file);
         const QString fileName = fi.fileName();
         if (fi.isDir()) {
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   it's a directory";
             QDir dir(file);
             const QStringList sumfiles = filter_checksum_files(dir.entryList(QDir::Files), patterns);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   found " << sumfiles.size()
                                    << " sum files: " << qPrintable(sumfiles.join(QLatin1String(", ")));
             dirs2sums[ dir ].insert(sumfiles.begin(), sumfiles.end());
             const QStringList dirs = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   found " << dirs.size()
                                    << " subdirs, prepending";
             std::transform(dirs.cbegin(), dirs.cend(),
                            std::inserter(inputs, inputs.begin()),
                            [&dir](const QString &path) {
                                return dir.absoluteFilePath(path);
                            });
         } else if (is_sum_file(fileName)) {
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   it's a sum file";
             dirs2sums[fi.dir()].insert(fileName);
         } else {
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   it's something else; checking whether we'll find a sumfile for it...";
             const QDir dir = fi.dir();
             const QStringList sumfiles = filter_checksum_files(dir.entryList(QDir::Files), patterns);
             qCDebug(KLEOPATRA_LOG) << "find_sums_by_input_files:   found " << sumfiles.size()
                                    << " potential sumfiles: " << qPrintable(sumfiles.join(QLatin1String(", ")));
             const auto it = std::find_if(sumfiles.cbegin(), sumfiles.cend(),
                                          sumfile_contains_file(dir, fileName));
             if (it == sumfiles.end()) {
                 errors.push_back(i18n("Cannot find checksums file for file %1", file));
             } else {
                 dirs2sums[dir].insert(*it);
             }
         }
         if (progress) {
             progress(++i);
         }
     }
 
     // Step 2: convert into vector<SumFile>:
 
     std::vector<SumFile> sumfiles;
     sumfiles.reserve(dirs2sums.size());
 
     for (auto it = dirs2sums.begin(), end = dirs2sums.end(); it != end; ++it) {
 
         if (it->second.empty()) {
             continue;
         }
 
         const QDir &dir = it->first;
 
         for (const QString &sumFileName : std::as_const(it->second)) {
 
             const std::vector<File> summedfiles = parse_sum_file(dir.absoluteFilePath(sumFileName));
             QStringList files;
             files.reserve(summedfiles.size());
             std::transform(summedfiles.cbegin(), summedfiles.cend(),
                            std::back_inserter(files), std::mem_fn(&File::name));
             const SumFile sumFile = {
                 it->first,
                 sumFileName,
                 aggregate_size(it->first, files),
                 filename2definition(sumFileName, checksumDefinitions),
             };
             sumfiles.push_back(sumFile);
 
         }
 
         if (progress) {
             progress(++i);
         }
 
     }
     return sumfiles;
 }
 
 static QStringList c_lang_environment()
 {
     QStringList env = QProcess::systemEnvironment();
     env.erase(std::remove_if(env.begin(), env.end(),
                              [](const QString &str) {
                                  return QRegExp(QLatin1String("^LANG=.*"), fs_cs).exactMatch(str);
                              }),
               env.end());
     env.push_back(QStringLiteral("LANG=C"));
     return env;
 }
 
 static const struct {
     const char *string;
     VerifyChecksumsDialog::Status status;
 } statusStrings[] = {
     { "OK",     VerifyChecksumsDialog::OK     },
     { "FAILED", VerifyChecksumsDialog::Failed },
 };
 static const size_t numStatusStrings = sizeof statusStrings / sizeof * statusStrings;
 
 static VerifyChecksumsDialog::Status string2status(const QByteArray &str)
 {
     for (unsigned int i = 0; i < numStatusStrings; ++i)
         if (str == statusStrings[i].string) {
             return statusStrings[i].status;
         }
     return VerifyChecksumsDialog::Unknown;
 }
 
 static QString process(const SumFile &sumFile, bool *fatal, const QStringList &env,
                        const std::function<void(const QString &, VerifyChecksumsDialog::Status)> &status)
 {
     QProcess p;
     p.setEnvironment(env);
     p.setWorkingDirectory(sumFile.dir.absolutePath());
     p.setReadChannel(QProcess::StandardOutput);
 
     const QString absFilePath = sumFile.dir.absoluteFilePath(sumFile.sumFile);
 
     const QString program = sumFile.checksumDefinition->verifyCommand();
     sumFile.checksumDefinition->startVerifyCommand(&p, QStringList(absFilePath));
 
     QByteArray remainder; // used for filenames with newlines in them
     while (p.state() != QProcess::NotRunning) {
         p.waitForReadyRead();
         while (p.canReadLine()) {
             const QByteArray line = p.readLine();
             const int colonIdx = line.lastIndexOf(':');
             if (colonIdx < 0) {
                 remainder += line; // no colon -> probably filename with a newline
                 continue;
             }
             const QString file = QFile::decodeName(remainder + line.left(colonIdx));
             remainder.clear();
             const VerifyChecksumsDialog::Status result = string2status(line.mid(colonIdx + 1).trimmed());
             status(sumFile.dir.absoluteFilePath(file), result);
         }
     }
     qCDebug(KLEOPATRA_LOG) << "[" << &p << "] Exit code " << p.exitCode();
 
     if (p.exitStatus() != QProcess::NormalExit || p.exitCode() != 0) {
         if (fatal && p.error() == QProcess::FailedToStart) {
             *fatal = true;
         }
         if (p.error() == QProcess::UnknownError)
             return i18n("Error while running %1: %2", program,
                         QString::fromLocal8Bit(p.readAllStandardError().trimmed().constData()));
         else {
             return i18n("Failed to execute %1: %2", program, p.errorString());
         }
     }
 
     return QString();
 }
 
 namespace
 {
 static QDebug operator<<(QDebug s, const SumFile &sum)
 {
     return s << "SumFile(" << sum.dir << "->" << sum.sumFile << "<-(" << sum.totalSize << ')' << ")\n";
 }
 }
 
 void VerifyChecksumsController::Private::run()
 {
 
     QMutexLocker locker(&mutex);
 
     const QStringList files = this->files;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions = this->checksumDefinitions;
 
     locker.unlock();
 
     QStringList errors;
 
     //
     // Step 0: find base directories:
     //
 
     Q_EMIT baseDirectories(find_base_directories(files));
 
     //
     // Step 1: build a list of work to do (no progress):
     //
 
     const QString scanning = i18n("Scanning directories...");
     Q_EMIT progress(0, 0, scanning);
 
     const auto progressCb = [this, scanning](int arg) { Q_EMIT progress(arg, 0, scanning); };
     const auto statusCb = [this](const QString &str, VerifyChecksumsDialog::Status st) { Q_EMIT status(str, st); };
 
     const std::vector<SumFile> sumfiles = find_sums_by_input_files(files, errors, progressCb, checksumDefinitions);
 
     for (const SumFile &sumfile : sumfiles) {
         qCDebug(KLEOPATRA_LOG) << sumfile;
     }
 
     if (!canceled) {
 
         Q_EMIT progress(0, 0, i18n("Calculating total size..."));
 
         const quint64 total
             = kdtools::accumulate_transform(sumfiles.cbegin(), sumfiles.cend(),
                                             std::mem_fn(&SumFile::totalSize), Q_UINT64_C(0));
 
         if (!canceled) {
 
             //
             // Step 2: perform work (with progress reporting):
             //
 
             const QStringList env = c_lang_environment();
 
             // re-scale 'total' to fit into ints (wish QProgressDialog would use quint64...)
             const quint64 factor = total / std::numeric_limits<int>::max() + 1;
 
             quint64 done = 0;
-            Q_FOREACH (const SumFile &sumFile, sumfiles) {
+            for (const SumFile &sumFile : sumfiles) {
                 Q_EMIT progress(done / factor, total / factor,
                                 i18n("Verifying checksums (%2) in %1", sumFile.checksumDefinition->label(), sumFile.dir.path()));
                 bool fatal = false;
                 const QString error = process(sumFile, &fatal, env, statusCb);
                 if (!error.isEmpty()) {
                     errors.push_back(error);
                 }
                 done += sumFile.totalSize;
                 if (fatal || canceled) {
                     break;
                 }
             }
             Q_EMIT progress(done / factor, total / factor, i18n("Done."));
 
         }
     }
 
     locker.relock();
 
     this->errors = errors;
 
     // mutex unlocked by QMutexLocker
 
 }
 
 #include "moc_verifychecksumscontroller.cpp"
 #include "verifychecksumscontroller.moc"
 
 #endif // QT_NO_DIRMODEL
diff --git a/src/uiserver/assuanserverconnection.cpp b/src/uiserver/assuanserverconnection.cpp
index 352c71346..bdc1af038 100644
--- a/src/uiserver/assuanserverconnection.cpp
+++ b/src/uiserver/assuanserverconnection.cpp
@@ -1,1690 +1,1690 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/assuanserverconnection.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #ifndef QT_NO_CAST_TO_ASCII
 # define QT_NO_CAST_TO_ASCII
 #endif
 #ifndef QT_NO_CAST_FROM_ASCII
 # define QT_NO_CAST_FROM_ASCII
 #endif
 
 #include <config-kleopatra.h>
 #include <version-kleopatra.h>
 
 #include "assuanserverconnection.h"
 #include "assuancommand.h"
 #include "sessiondata.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <Libkleo/GnuPG>
 #include <utils/detail_p.h>
 #include <utils/hex.h>
 #include <utils/log.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/data.h>
 #include <gpgme++/key.h>
 
 #include <KMime/HeaderParsing>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 #include <KWindowSystem>
 
 #include <QSocketNotifier>
 #include <QTimer>
 #include <QVariant>
 #include <QPointer>
 #include <QFileInfo>
 #include <QStringList>
 #include <QRegExp>
 #include <QWidget>
 #include <QCoreApplication>
 
 
 #include <map>
 #include <algorithm>
 #include <functional>
 #include <type_traits>
 
 #include <cerrno>
 
 #ifdef __GLIBCXX__
 # include <ext/algorithm> // for is_sorted
 #endif
 
 #ifdef Q_OS_WIN32
 # include <io.h>
 # include <process.h>
 #else
 # include <sys/types.h>
 # include <unistd.h>
 #endif
 using namespace Kleo;
 
 static const unsigned int INIT_SOCKET_FLAGS = 3; // says info assuan...
 //static int(*USE_DEFAULT_HANDLER)(assuan_context_t,char*) = 0;
 static const int FOR_READING = 0;
 static const unsigned int MAX_ACTIVE_FDS = 32;
 
 #ifdef HAVE_ASSUAN2
 static void my_assuan_release(assuan_context_t ctx)
 {
     if (ctx) {
         assuan_release(ctx);
     }
 }
 
 #endif
 // std::shared_ptr for assuan_context_t w/ deleter enforced to assuan_deinit_server:
 using AssuanContextBase = std::shared_ptr<std::remove_pointer<assuan_context_t>::type>;
 struct AssuanContext : AssuanContextBase {
     AssuanContext() : AssuanContextBase() {}
 #ifndef HAVE_ASSUAN2
     explicit AssuanContext(assuan_context_t ctx) : AssuanContextBase(ctx, &assuan_deinit_server) {}
 #else
     explicit AssuanContext(assuan_context_t ctx) : AssuanContextBase(ctx, &my_assuan_release) {}
 #endif
 
 #ifndef HAVE_ASSUAN2
     void reset(assuan_context_t ctx = 0)
     {
         AssuanContextBase::reset(ctx, &assuan_deinit_server);
     }
 #else
     void reset(assuan_context_t ctx = nullptr)
     {
         AssuanContextBase::reset(ctx, &my_assuan_release);
     }
 #endif
 };
 
 static inline gpg_error_t assuan_process_done_msg(assuan_context_t ctx, gpg_error_t err, const char *err_msg)
 {
     return assuan_process_done(ctx, assuan_set_error(ctx, err, err_msg));
 }
 
 static inline gpg_error_t assuan_process_done_msg(assuan_context_t ctx, gpg_error_t err, const std::string &err_msg)
 {
     return assuan_process_done_msg(ctx, err, err_msg.c_str());
 }
 
 static inline gpg_error_t assuan_process_done_msg(assuan_context_t ctx, gpg_error_t err, const QString &err_msg)
 {
     return assuan_process_done_msg(ctx, err, err_msg.toUtf8().constData());
 }
 
 static std::map<std::string, std::string> upcase_option(const char *option, std::map<std::string, std::string> options)
 {
     std::string value;
     bool value_found = false;
     auto it = options.begin();
     while (it != options.end())
         if (qstricmp(it->first.c_str(), option) == 0) {
             value = it->second;
             options.erase(it++);
             value_found = true;
         } else {
             ++it;
         }
     if (value_found) {
         options[option] = value;
     }
     return options;
 }
 
 static std::map<std::string, std::string> parse_commandline(const char *line)
 {
     std::map<std::string, std::string> result;
     if (line) {
         const char *begin = line;
         const char *lastEQ = nullptr;
         while (*line) {
             if (*line == ' ' || *line == '\t') {
                 if (begin != line) {
                     if (begin[0] == '-' && begin[1] == '-') {
                         begin += 2;    // skip initial "--"
                     }
                     if (lastEQ && lastEQ > begin) {
                         result[ std::string(begin, lastEQ - begin) ] = hexdecode(std::string(lastEQ + 1, line - (lastEQ + 1)));
                     } else {
                         result[ std::string(begin,  line  - begin) ] = std::string();
                     }
                 }
                 begin = line + 1;
             } else if (*line == '=') {
                 if (line == begin)
                     throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX),
                                     i18n("No option name given"));
                 else {
                     lastEQ = line;
                 }
             }
             ++line;
         }
         if (begin != line) {
             if (begin[0] == '-' && begin[1] == '-') {
                 begin += 2;    // skip initial "--"
             }
             if (lastEQ && lastEQ > begin) {
                 result[ std::string(begin, lastEQ - begin) ] = hexdecode(std::string(lastEQ + 1, line - (lastEQ + 1)));
             } else {
                 result[ begin ] = std::string();
             }
         }
     }
 
     return result;
 }
 
 static WId wid_from_string(const QString &winIdStr, bool *ok = nullptr)
 {
     return static_cast<WId>(winIdStr.toULongLong(ok, 16));
 }
 
 static void apply_window_id(QWidget *widget, const QString &winIdStr)
 {
     if (!widget || winIdStr.isEmpty()) {
         return;
     }
     bool ok = false;
     const WId wid = wid_from_string(winIdStr, &ok);
     if (!ok) {
         qCDebug(KLEOPATRA_LOG) << "window-id value" << wid << "doesn't look like a number";
         return;
     }
     if (QWidget *pw = QWidget::find(wid)) {
         widget->setParent(pw, widget->windowFlags());
     } else {
         widget->setAttribute(Qt::WA_NativeWindow, true);
         KWindowSystem::setMainWindow(widget->windowHandle(), wid);
     }
 }
 
 //
 //
 // AssuanServerConnection:
 //
 //
 
 class AssuanServerConnection::Private : public QObject
 {
     Q_OBJECT
     friend class ::Kleo::AssuanServerConnection;
     friend class ::Kleo::AssuanCommandFactory;
     friend class ::Kleo::AssuanCommand;
     AssuanServerConnection *const q;
 public:
     Private(assuan_fd_t fd_, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories_, AssuanServerConnection *qq);
     ~Private();
 
 Q_SIGNALS:
     void startKeyManager();
 
 public Q_SLOTS:
     void slotReadActivity(int)
     {
         Q_ASSERT(ctx);
 #ifndef HAVE_ASSUAN2
         if (const int err = assuan_process_next(ctx.get())) {
 #else
         int done = false;
         if (const int err = assuan_process_next(ctx.get(), &done) || done) {
 #endif
             //if ( err == -1 || gpg_err_code(err) == GPG_ERR_EOF ) {
             topHalfDeletion();
             if (nohupedCommands.empty()) {
                 bottomHalfDeletion();
             }
             //} else {
             //assuan_process_done( ctx.get(), err );
             //return;
             //}
         }
     }
 
     int startCommandBottomHalf();
 
 private:
     void nohupDone(AssuanCommand *cmd)
     {
         const auto it = std::find_if(nohupedCommands.begin(), nohupedCommands.end(),
                                      [cmd](const std::shared_ptr<AssuanCommand> &other) {
                                         return other.get() == cmd;
                                      });
         Q_ASSERT(it != nohupedCommands.end());
         nohupedCommands.erase(it);
         if (nohupedCommands.empty() && closed) {
             bottomHalfDeletion();
         }
     }
 
     void commandDone(AssuanCommand *cmd)
     {
         if (!cmd || cmd != currentCommand.get()) {
             return;
         }
         currentCommand.reset();
     }
 
     void topHalfDeletion()
     {
         if (currentCommand) {
             currentCommand->canceled();
         }
         if (fd != ASSUAN_INVALID_FD) {
 #if defined(Q_OS_WIN32)
             CloseHandle(fd);
 #else
             ::close(fd);
 #endif
         }
         notifiers.clear();
         closed = true;
     }
 
     void bottomHalfDeletion()
     {
         if (sessionId) {
             SessionDataHandler::instance()->exitSession(sessionId);
         }
         cleanup();
         const QPointer<Private> that = this;
         Q_EMIT q->closed(q);
         if (that) { // still there
             q->deleteLater();
         }
     }
 
 private:
 #ifndef HAVE_ASSUAN2
     static void reset_handler(assuan_context_t ctx_)
     {
 #else
     static gpg_error_t reset_handler(assuan_context_t ctx_, char *)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
 
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         conn.reset();
 #ifdef HAVE_ASSUAN2
 
         return 0;
 #endif
     }
 
 #ifndef HAVE_ASSUAN2
     static int option_handler(assuan_context_t ctx_, const char *key, const char *value)
     {
 #else
     static gpg_error_t option_handler(assuan_context_t ctx_, const char *key, const char *value)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
 
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (key && key[0] == '-' && key[1] == '-') {
             key += 2;    // skip "--"
         }
         conn.options[key] = QString::fromUtf8(value);
 
         return 0;
         //return gpg_error( GPG_ERR_UNKNOWN_OPTION );
     }
 
 #ifndef HAVE_ASSUAN2
     static int session_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t session_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         const QString str = QString::fromUtf8(line);
         QRegExp rx(QLatin1String("(\\d+)(?:\\s+(.*))?"));
         if (!rx.exactMatch(str)) {
             static const QString errorString = i18n("Parse error");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_SYNTAX), errorString);
         }
         bool ok = false;
         if (const qulonglong id = rx.cap(1).toULongLong(&ok)) {
             if (ok && id <= std::numeric_limits<unsigned int>::max()) {
                 SessionDataHandler::instance()->enterSession(id);
                 conn.sessionId = id;
             } else {
                 static const QString errorString = i18n("Parse error: numeric session id too large");
                 return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_SYNTAX), errorString);
             }
         }
         if (!rx.cap(2).isEmpty()) {
             conn.sessionTitle = rx.cap(2);
         }
         qCDebug(KLEOPATRA_LOG) << "session_handler: "
                                << "id=" << static_cast<unsigned long>(conn.sessionId)
                                << ", title=" << qPrintable(conn.sessionTitle);
         return assuan_process_done(ctx_, 0);
     }
 
 #ifndef HAVE_ASSUAN2
     static int capabilities_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t capabilities_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         if (!QByteArray(line).trimmed().isEmpty()) {
             static const QString errorString = i18n("CAPABILITIES does not take arguments");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
         static const char capabilities[] =
             "SENDER=info\n"
             "RECIPIENT=info\n"
             "SESSION\n"
             ;
         return assuan_process_done(ctx_, assuan_send_data(ctx_, capabilities, sizeof capabilities - 1));
     }
 
 #ifndef HAVE_ASSUAN2
     static int getinfo_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t getinfo_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (qstrcmp(line, "version") == 0) {
             static const char version[] = "Kleopatra " KLEOPATRA_VERSION_STRING;
             return assuan_process_done(ctx_, assuan_send_data(ctx_, version, sizeof version - 1));
         }
 
         QByteArray ba;
         if (qstrcmp(line, "pid") == 0) {
             ba = QByteArray::number(QCoreApplication::applicationPid());
         } else if (qstrcmp(line, "options") == 0) {
             ba = conn.dumpOptions();
         } else if (qstrcmp(line, "x-mementos") == 0) {
             ba = conn.dumpMementos();
         } else if (qstrcmp(line, "senders") == 0) {
             ba = conn.dumpSenders();
         } else if (qstrcmp(line, "recipients") == 0) {
             ba = conn.dumpRecipients();
         } else if (qstrcmp(line, "x-files") == 0) {
             ba = conn.dumpFiles();
         } else {
             static const QString errorString = i18n("Unknown value for WHAT");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
         return assuan_process_done(ctx_, assuan_send_data(ctx_, ba.constData(), ba.size()));
     }
 
 #ifndef HAVE_ASSUAN2
     static int start_keymanager_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t start_keymanager_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (line && *line) {
             static const QString errorString = i18n("START_KEYMANAGER does not take arguments");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
 
         Q_EMIT conn.q->startKeyManagerRequested();
 
         return assuan_process_done(ctx_, 0);
     }
 
 #ifndef HAVE_ASSUAN2
     static int start_confdialog_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t start_confdialog_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         if (line && *line) {
             static const QString errorString = i18n("START_CONFDIALOG does not take arguments");
             return assuan_process_done_msg(ctx_, gpg_error(GPG_ERR_ASS_PARAMETER), errorString);
         }
 
         Q_EMIT conn.q->startConfigDialogRequested();
 
         return assuan_process_done(ctx_, 0);
     }
 
     template <bool in>
     struct Input_or_Output : std::conditional<in, Input, Output> {};
 
     // format: TAG (FD|FD=\d+|FILE=...)
     template <bool in, typename T_memptr>
 #ifndef HAVE_ASSUAN2
     static int IO_handler(assuan_context_t ctx_, char *line_, T_memptr which)
     {
 #else
     static gpg_error_t IO_handler(assuan_context_t ctx_, char *line_, T_memptr which)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         char *binOpt = strstr(line_, "--binary");
 
         if (binOpt && !in) {
             /* Note there is also --armor and --base64 allowed but we don't need
              * to parse those because they are default.
              * We remove it here so that it is not parsed as an Option.*/
             memset(binOpt, ' ', 8);
         }
 
         try {
 
             /*const*/ std::map<std::string, std::string> options = upcase_option("FD", upcase_option("FILE", parse_commandline(line_)));
             if (options.size() < 1 || options.size() > 2) {
                 throw gpg_error(GPG_ERR_ASS_SYNTAX);
             }
 
             std::shared_ptr< typename Input_or_Output<in>::type > io;
 
             if (options.count("FD")) {
 
                 if (options.count("FILE")) {
                     throw gpg_error(GPG_ERR_CONFLICT);
                 }
 
                 assuan_fd_t fd = ASSUAN_INVALID_FD;
 
                 const std::string fdstr = options["FD"];
 
                 if (fdstr.empty()) {
                     if (const gpg_error_t err = assuan_receivefd(conn.ctx.get(), &fd)) {
                         throw err;
                     }
                 } else {
 #if defined(Q_OS_WIN32)
                     fd = (assuan_fd_t)std::stoi(fdstr);
 #else
                     fd = std::stoi(fdstr);
 #endif
                 }
 
                 io = Input_or_Output<in>::type::createFromPipeDevice(fd, in ? i18n("Message #%1", (conn.*which).size() + 1) : QString());
 
                 options.erase("FD");
 
             } else if (options.count("FILE")) {
 
                 if (options.count("FD")) {
                     throw gpg_error(GPG_ERR_CONFLICT);
                 }
 
                 const QString filePath = QFile::decodeName(options["FILE"].c_str());
                 if (filePath.isEmpty()) {
                     throw Exception(gpg_error(GPG_ERR_ASS_SYNTAX), i18n("Empty file path"));
                 }
                 const QFileInfo fi(filePath);
                 if (!fi.isAbsolute()) {
                     throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Only absolute file paths are allowed"));
                 }
                 if (!fi.isFile()) {
                     throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Only files are allowed in INPUT/OUTPUT FILE"));
                 } else {
                     io = Input_or_Output<in>::type::createFromFile(fi.absoluteFilePath(), true);
                 }
 
                 options.erase("FILE");
 
             } else {
 
                 throw gpg_error(GPG_ERR_ASS_PARAMETER);
 
             }
 
             if (options.size()) {
                 throw gpg_error(GPG_ERR_UNKNOWN_OPTION);
             }
 
             (conn.*which).push_back(io);
 
             if (binOpt && !in) {
                 auto out = reinterpret_cast <Output *>(io.get());
                 out->setBinaryOpt(true);
                 qCDebug(KLEOPATRA_LOG) << "Configured output for binary data";
             }
 
             qCDebug(KLEOPATRA_LOG) << "AssuanServerConnection: added" << io->label();
 
             return assuan_process_done(conn.ctx.get(), 0);
         } catch (const GpgME::Exception &e) {
             return assuan_process_done_msg(conn.ctx.get(), e.error().encodedError(), e.message().c_str());
         } catch (const std::exception &) {
             return assuan_process_done(conn.ctx.get(), gpg_error(GPG_ERR_ASS_SYNTAX));
         } catch (const gpg_error_t &e) {
             return assuan_process_done(conn.ctx.get(), e);
         } catch (...) {
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), "unknown exception caught");
         }
 
     }
 
 #ifndef HAVE_ASSUAN2
     static int input_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t input_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return IO_handler<true>(ctx, line, &Private::inputs);
     }
 
 #ifndef HAVE_ASSUAN2
     static int output_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t output_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return IO_handler<false>(ctx, line, &Private::outputs);
     }
 
 #ifndef HAVE_ASSUAN2
     static int message_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t message_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return IO_handler<true>(ctx, line, &Private::messages);
     }
 
 #ifndef HAVE_ASSUAN2
     static int file_handler(assuan_context_t ctx_, char *line)
     {
 #else
     static gpg_error_t file_handler(assuan_context_t ctx_, char *line)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx_));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx_));
 
         try {
             const QFileInfo fi(QFile::decodeName(hexdecode(line).c_str()));
             if (!fi.isAbsolute()) {
                 throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Only absolute file paths are allowed"));
             }
             if (!fi.exists()) {
                 throw gpg_error(GPG_ERR_ENOENT);
             }
             if (!fi.isReadable() || (fi.isDir() && !fi.isExecutable())) {
                 throw gpg_error(GPG_ERR_EPERM);
             }
 
             conn.files.push_back(fi.absoluteFilePath());
 
             return assuan_process_done(conn.ctx.get(), 0);
         } catch (const Exception &e) {
             return assuan_process_done_msg(conn.ctx.get(), e.error().encodedError(), e.message().toUtf8().constData());
         } catch (const gpg_error_t &e) {
             return assuan_process_done(conn.ctx.get(), e);
         } catch (...) {
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), i18n("unknown exception caught").toUtf8().constData());
         }
     }
 
     static bool parse_informative(const char *&begin, GpgME::Protocol &protocol)
     {
         protocol = GpgME::UnknownProtocol;
         bool informative = false;
         const char *pos = begin;
         while (true) {
             while (*pos == ' ' || *pos == '\t') {
                 ++pos;
             }
             if (qstrnicmp(pos, "--info", strlen("--info")) == 0) {
                 informative = true;
                 pos += strlen("--info");
                 if (*pos == '=') {
                     ++pos;
                     break;
                 }
             } else if (qstrnicmp(pos, "--protocol=", strlen("--protocol=")) == 0) {
                 pos += strlen("--protocol=");
                 if (qstrnicmp(pos, "OpenPGP", strlen("OpenPGP")) == 0) {
                     protocol = GpgME::OpenPGP;
                     pos += strlen("OpenPGP");
                 } else if (qstrnicmp(pos, "CMS", strlen("CMS")) == 0) {
                     protocol = GpgME::CMS;
                     pos += strlen("CMS");
                 } else {
                     ;
                 }
             } else if (qstrncmp(pos, "-- ", strlen("-- ")) == 0) {
                 pos += 3;
                 while (*pos == ' ' || *pos == '\t') {
                     ++pos;
                 }
                 break;
             } else {
                 break;
             }
         }
         begin = pos;
         return informative;
     }
 
     template <typename T_memptr, typename T_memptr2>
 #ifndef HAVE_ASSUAN2
     static int recipient_sender_handler(T_memptr mp, T_memptr2 info, assuan_context_t ctx, char *line, bool sender = false)
     {
 #else
     static gpg_error_t recipient_sender_handler(T_memptr mp, T_memptr2 info, assuan_context_t ctx, char *line, bool sender = false)
     {
 #endif
         Q_ASSERT(assuan_get_pointer(ctx));
         AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx));
 
         if (!line || !*line) {
             return assuan_process_done(conn.ctx.get(), gpg_error(GPG_ERR_INV_ARG));
         }
         const char *begin     = line;
         const char *const end = begin + qstrlen(line);
         GpgME::Protocol proto = GpgME::UnknownProtocol;
         const bool informative = parse_informative(begin, proto);
         if (!(conn.*mp).empty() && informative != (conn.*info))
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_CONFLICT),
                                            i18n("Cannot mix --info with non-info SENDER or RECIPIENT").toUtf8().constData());
         KMime::Types::Mailbox mb;
         if (!KMime::HeaderParsing::parseMailbox(begin, end, mb))
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_INV_ARG),
                                            i18n("Argument is not a valid RFC-2822 mailbox").toUtf8().constData());
         if (begin != end)
             return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_INV_ARG),
                                            i18n("Garbage after valid RFC-2822 mailbox detected").toUtf8().constData());
         (conn.*info) = informative;
         (conn.*mp).push_back(mb);
 
         const QString email = mb.addrSpec().asString();
         (void)assuan_write_line(conn.ctx.get(), qPrintable(QString::asprintf("# ok, parsed as \"%s\"", qPrintable(email))));
         if (sender && !informative) {
             return AssuanCommandFactory::_handle(conn.ctx.get(), line, "PREP_SIGN");
         } else {
             return assuan_process_done(ctx, 0);
         }
     }
 
 #ifndef HAVE_ASSUAN2
     static int recipient_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t recipient_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return recipient_sender_handler(&Private::recipients, &Private::informativeRecipients, ctx, line);
     }
 
 #ifndef HAVE_ASSUAN2
     static int sender_handler(assuan_context_t ctx, char *line)
     {
 #else
     static gpg_error_t sender_handler(assuan_context_t ctx, char *line)
     {
 #endif
         return recipient_sender_handler(&Private::senders, &Private::informativeSenders, ctx, line, true);
     }
 
     QByteArray dumpOptions() const
     {
         QByteArray result;
         for (auto it = options.begin(), end = options.end(); it != end; ++it) {
             result += it->first.c_str() + it->second.toString().toUtf8() + '\n';
         }
         return result;
     }
 
     static QByteArray dumpStringList(const QStringList &sl)
     {
         return sl.join(QLatin1Char('\n')).toUtf8();
     }
 
     template <typename T_container>
     static QByteArray dumpStringList(const T_container &c)
     {
         QStringList sl;
         std::copy(c.begin(), c.end(), std::back_inserter(sl));
         return dumpStringList(sl);
     }
 
     template <typename T_container>
     static QByteArray dumpMailboxes(const T_container &c)
     {
         QStringList sl;
         std::transform(c.begin(), c.end(),
                        std::back_inserter(sl),
                        [](typename T_container::const_reference val) {
                            return val.prettyAddress();
                        });
         return dumpStringList(sl);
     }
 
     QByteArray dumpSenders() const
     {
         return dumpMailboxes(senders);
     }
 
     QByteArray dumpRecipients() const
     {
         return dumpMailboxes(recipients);
     }
 
     QByteArray dumpMementos() const
     {
         QByteArray result;
         for (auto it = mementos.begin(), end = mementos.end(); it != end; ++it) {
             char buf[2 + 2 * sizeof(void *) + 2];
             sprintf(buf, "0x%p\n", (void *)it->second.get());
             buf[sizeof(buf) - 1] = '\0';
             result += it->first + QByteArray::fromRawData(buf, sizeof buf);
         }
         return result;
     }
 
     QByteArray dumpFiles() const
     {
         QStringList rv;
         rv.reserve(files.size());
         std::copy(files.cbegin(), files.cend(), std::back_inserter(rv));
         return dumpStringList(rv);
     }
 
     void cleanup();
     void reset()
     {
         options.clear();
         senders.clear();
         informativeSenders = false;
         recipients.clear();
         informativeRecipients = false;
         sessionTitle.clear();
         sessionId = 0;
         mementos.clear();
         files.clear();
         std::for_each(inputs.begin(), inputs.end(), std::mem_fn(&Input::finalize));
         inputs.clear();
         std::for_each(outputs.begin(), outputs.end(), std::mem_fn(&Output::finalize));
         outputs.clear();
         std::for_each(messages.begin(), messages.end(), std::mem_fn(&Input::finalize));
         messages.clear();
         bias = GpgME::UnknownProtocol;
     }
 
     assuan_fd_t fd;
     AssuanContext ctx;
     bool closed                : 1;
     bool cryptoCommandsEnabled : 1;
     bool commandWaitingForCryptoCommandsEnabled : 1;
     bool currentCommandIsNohup : 1;
     bool informativeSenders;    // address taken, so no : 1
     bool informativeRecipients; // address taken, so no : 1
     GpgME::Protocol bias;
     QString sessionTitle;
     unsigned int sessionId;
     std::vector< std::shared_ptr<QSocketNotifier> > notifiers;
     std::vector< std::shared_ptr<AssuanCommandFactory> > factories; // sorted: _detail::ByName<std::less>
     std::shared_ptr<AssuanCommand> currentCommand;
     std::vector< std::shared_ptr<AssuanCommand> > nohupedCommands;
     std::map<std::string, QVariant> options;
     std::vector<KMime::Types::Mailbox> senders, recipients;
     std::vector< std::shared_ptr<Input> > inputs, messages;
     std::vector< std::shared_ptr<Output> > outputs;
     std::vector<QString> files;
     std::map< QByteArray, std::shared_ptr<AssuanCommand::Memento> > mementos;
 };
 
 void AssuanServerConnection::Private::cleanup()
 {
     Q_ASSERT(nohupedCommands.empty());
     reset();
     currentCommand.reset();
     currentCommandIsNohup = false;
     commandWaitingForCryptoCommandsEnabled = false;
     notifiers.clear();
     ctx.reset();
     fd = ASSUAN_INVALID_FD;
 }
 
 AssuanServerConnection::Private::Private(assuan_fd_t fd_, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories_, AssuanServerConnection *qq)
     : QObject(),
       q(qq),
       fd(fd_),
       closed(false),
       cryptoCommandsEnabled(false),
       commandWaitingForCryptoCommandsEnabled(false),
       currentCommandIsNohup(false),
       informativeSenders(false),
       informativeRecipients(false),
       bias(GpgME::UnknownProtocol),
       sessionId(0),
       factories(factories_)
 {
 #ifdef __GLIBCXX__
     Q_ASSERT(__gnu_cxx::is_sorted(factories_.begin(), factories_.end(), _detail::ByName<std::less>()));
 #endif
 
     if (fd == ASSUAN_INVALID_FD) {
         throw Exception(gpg_error(GPG_ERR_INV_ARG), "pre-assuan_init_socket_server_ext");
     }
 
 #ifndef HAVE_ASSUAN2
     assuan_context_t naked_ctx = 0;
     if (const gpg_error_t err = assuan_init_socket_server_ext(&naked_ctx, fd, INIT_SOCKET_FLAGS))
 #else
     {
         assuan_context_t naked_ctx = nullptr;
         if (const gpg_error_t err = assuan_new(&naked_ctx)) {
             throw Exception(err, "assuan_new");
         }
         ctx.reset(naked_ctx);
     }
     if (const gpg_error_t err = assuan_init_socket_server(ctx.get(), fd, INIT_SOCKET_FLAGS))
 #endif
         throw Exception(err, "assuan_init_socket_server_ext");
 
 #ifndef HAVE_ASSUAN2
     ctx.reset(naked_ctx); naked_ctx = 0;
 #endif
 
     // for callbacks, associate the context with this connection:
     assuan_set_pointer(ctx.get(), this);
 
     FILE *const logFile = Log::instance()->logFile();
     assuan_set_log_stream(ctx.get(), logFile ? logFile : stderr);
 
     // register FDs with the event loop:
     assuan_fd_t fds[MAX_ACTIVE_FDS];
     const int numFDs = assuan_get_active_fds(ctx.get(), FOR_READING, fds, MAX_ACTIVE_FDS);
     Q_ASSERT(numFDs != -1);   // == 1
 
     if (!numFDs || fds[0] != fd) {
         const std::shared_ptr<QSocketNotifier> sn(new QSocketNotifier((intptr_t)fd, QSocketNotifier::Read), std::mem_fn(&QObject::deleteLater));
         connect(sn.get(), &QSocketNotifier::activated, this, &Private::slotReadActivity);
         notifiers.push_back(sn);
     }
 
     notifiers.reserve(notifiers.size() + numFDs);
     for (int i = 0; i < numFDs; ++i) {
         const std::shared_ptr<QSocketNotifier> sn(new QSocketNotifier((intptr_t)fds[i], QSocketNotifier::Read), std::mem_fn(&QObject::deleteLater));
         connect(sn.get(), &QSocketNotifier::activated, this, &Private::slotReadActivity);
         notifiers.push_back(sn);
     }
 
     // register our INPUT/OUTPUT/MESSGAE/FILE handlers:
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "INPUT",  input_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "INPUT",  input_handler, ""))
 #endif
         throw Exception(err, "register \"INPUT\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "MESSAGE",  message_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "MESSAGE",  message_handler, ""))
 #endif
         throw Exception(err, "register \"MESSAGE\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "OUTPUT", output_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "OUTPUT", output_handler, ""))
 #endif
         throw Exception(err, "register \"OUTPUT\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "FILE", file_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "FILE", file_handler, ""))
 #endif
         throw Exception(err, "register \"FILE\" handler");
 
     // register user-defined commands:
-    Q_FOREACH (std::shared_ptr<AssuanCommandFactory> fac, factories)
+    for (std::shared_ptr<AssuanCommandFactory> fac : std::as_const(factories))
 #ifndef HAVE_ASSUAN2
         if (const gpg_error_t err = assuan_register_command(ctx.get(), fac->name(), fac->_handler()))
 #else
         if (const gpg_error_t err = assuan_register_command(ctx.get(), fac->name(), fac->_handler(), ""))
 #endif
             throw Exception(err, std::string("register \"") + fac->name() + "\" handler");
 
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "GETINFO", getinfo_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "GETINFO", getinfo_handler, ""))
 #endif
         throw Exception(err, "register \"GETINFO\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_KEYMANAGER", start_keymanager_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_KEYMANAGER", start_keymanager_handler, ""))
 #endif
         throw Exception(err, "register \"START_KEYMANAGER\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_CONFDIALOG", start_confdialog_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "START_CONFDIALOG", start_confdialog_handler, ""))
 #endif
         throw Exception(err, "register \"START_CONFDIALOG\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "RECIPIENT", recipient_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "RECIPIENT", recipient_handler, ""))
 #endif
         throw Exception(err, "register \"RECIPIENT\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SENDER", sender_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SENDER", sender_handler, ""))
 #endif
         throw Exception(err, "register \"SENDER\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SESSION", session_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "SESSION", session_handler, ""))
 #endif
         throw Exception(err, "register \"SESSION\" handler");
 #ifndef HAVE_ASSUAN2
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "CAPABILITIES", capabilities_handler))
 #else
     if (const gpg_error_t err = assuan_register_command(ctx.get(), "CAPABILITIES", capabilities_handler, ""))
 #endif
         throw Exception(err, "register \"CAPABILITIES\" handler");
 
     assuan_set_hello_line(ctx.get(), "GPG UI server (Kleopatra/" KLEOPATRA_VERSION_STRING ") ready to serve");
     //assuan_set_hello_line( ctx.get(), GPG UI server (qApp->applicationName() + " v" + kapp->applicationVersion() + "ready to serve" )
 
     // some notifiers we're interested in:
     if (const gpg_error_t err = assuan_register_reset_notify(ctx.get(), reset_handler)) {
         throw Exception(err, "register reset notify");
     }
     if (const gpg_error_t err = assuan_register_option_handler(ctx.get(), option_handler)) {
         throw Exception(err, "register option handler");
     }
 
     // and last, we need to call assuan_accept, which doesn't block
     // (d/t INIT_SOCKET_FLAGS), but performs vital connection
     // establishing handling:
     if (const gpg_error_t err = assuan_accept(ctx.get())) {
         throw Exception(err, "assuan_accept");
     }
 }
 
 AssuanServerConnection::Private::~Private()
 {
     cleanup();
 }
 
 AssuanServerConnection::AssuanServerConnection(assuan_fd_t fd, const std::vector< std::shared_ptr<AssuanCommandFactory> > &factories, QObject *p)
     : QObject(p), d(new Private(fd, factories, this))
 {
 
 }
 
 AssuanServerConnection::~AssuanServerConnection() {}
 
 void AssuanServerConnection::enableCryptoCommands(bool on)
 {
     if (on == d->cryptoCommandsEnabled) {
         return;
     }
     d->cryptoCommandsEnabled = on;
     if (d->commandWaitingForCryptoCommandsEnabled) {
         QTimer::singleShot(0, d.get(), &Private::startCommandBottomHalf);
     }
 }
 
 //
 //
 // AssuanCommand:
 //
 //
 
 namespace Kleo
 {
 
 class InquiryHandler : public QObject
 {
     Q_OBJECT
 public:
 
 #if defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
     explicit InquiryHandler(const char *keyword_, QObject *p = nullptr)
         : QObject(p),
 # if !defined(HAVE_ASSUAN2) && !defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
           buffer(0),
           buflen(0),
 # endif
           keyword(keyword_)
     {
 
     }
 
 # if defined(HAVE_ASSUAN2) || defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
 #  ifndef HAVE_ASSUAN2
     static int handler(void *cb_data, int rc, unsigned char *buffer, size_t buflen)
 #  else
     static gpg_error_t handler(void *cb_data, gpg_error_t rc, unsigned char *buffer, size_t buflen)
 #  endif
     {
         Q_ASSERT(cb_data);
         auto this_ = static_cast<InquiryHandler *>(cb_data);
         Q_EMIT this_->signal(rc, QByteArray::fromRawData(reinterpret_cast<const char *>(buffer), buflen), this_->keyword);
         std::free(buffer);
         delete this_;
         return 0;
     }
 # else
     static int handler(void *cb_data, int rc)
     {
         Q_ASSERT(cb_data);
         InquiryHandler *this_ = static_cast<InquiryHandler *>(cb_data);
         Q_EMIT this_->signal(rc, QByteArray::fromRawData(reinterpret_cast<const char *>(this_->buffer), this_->buflen), this_->keyword);
         std::free(this_->buffer);
         delete this_;
         return 0;
     }
 # endif
 
 private:
 #if !defined(HAVE_ASSUAN2) && !defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
     friend class ::Kleo::AssuanCommand;
     unsigned char *buffer;
     size_t buflen;
 #endif
     const char *keyword;
 #endif // defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
 
 Q_SIGNALS:
     void signal(int rc, const QByteArray &data, const QByteArray &keyword);
 };
 
 } // namespace Kleo
 
 class AssuanCommand::Private
 {
 public:
     Private()
         : informativeRecipients(false),
           informativeSenders(false),
           bias(GpgME::UnknownProtocol),
           done(false),
           nohup(false)
     {
 
     }
 
     std::map<std::string, QVariant> options;
     std::vector< std::shared_ptr<Input> > inputs, messages;
     std::vector< std::shared_ptr<Output> > outputs;
     std::vector<QString> files;
     std::vector<KMime::Types::Mailbox> recipients, senders;
     bool informativeRecipients, informativeSenders;
     GpgME::Protocol bias;
     QString sessionTitle;
     unsigned int sessionId;
     QByteArray utf8ErrorKeepAlive;
     AssuanContext ctx;
     bool done;
     bool nohup;
 };
 
 AssuanCommand::AssuanCommand()
     : d(new Private)
 {
 
 }
 
 AssuanCommand::~AssuanCommand()
 {
 
 }
 
 int AssuanCommand::start()
 {
     try {
         if (const int err = doStart())
             if (!d->done) {
                 done(err);
             }
         return 0;
     } catch (const Exception &e) {
         if (!d->done) {
             done(e.error_code(), e.message());
         }
         return 0;
     } catch (const GpgME::Exception &e) {
         if (!d->done) {
             done(e.error(), QString::fromLocal8Bit(e.message().c_str()));
         }
         return 0;
     } catch (const std::exception &e) {
         if (!d->done) {
             done(makeError(GPG_ERR_INTERNAL), i18n("Caught unexpected exception: %1", QString::fromLocal8Bit(e.what())));
         }
         return 0;
     } catch (...) {
         if (!d->done) {
             done(makeError(GPG_ERR_INTERNAL), i18n("Caught unknown exception - please report this error to the developers."));
         }
         return 0;
     }
 }
 
 void AssuanCommand::canceled()
 {
     d->done = true;
     doCanceled();
 }
 
 // static
 int AssuanCommand::makeError(int code)
 {
     return makeGnuPGError(code);
 }
 
 bool AssuanCommand::hasOption(const char *opt) const
 {
     return d->options.count(opt);
 }
 
 QVariant AssuanCommand::option(const char *opt) const
 {
     const auto it = d->options.find(opt);
     if (it == d->options.end()) {
         return QVariant();
     } else {
         return it->second;
     }
 }
 
 const std::map<std::string, QVariant> &AssuanCommand::options() const
 {
     return d->options;
 }
 
 namespace
 {
 template <typename U, typename V>
 std::vector<U> keys(const std::map<U, V> &map)
 {
     std::vector<U> result;
     result.resize(map.size());
     for (typename std::map<U, V>::const_iterator it = map.begin(), end = map.end(); it != end; ++it) {
         result.push_back(it->first);
     }
     return result;
 }
 }
 
 const std::map< QByteArray, std::shared_ptr<AssuanCommand::Memento> > &AssuanCommand::mementos() const
 {
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     const AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
     return conn.mementos;
 }
 
 bool AssuanCommand::hasMemento(const QByteArray &tag) const
 {
     if (const unsigned int id = sessionId()) {
         return SessionDataHandler::instance()->sessionData(id)->mementos.count(tag) || mementos().count(tag);
     } else {
         return mementos().count(tag);
     }
 }
 
 std::shared_ptr<AssuanCommand::Memento> AssuanCommand::memento(const QByteArray &tag) const
 {
     if (const unsigned int id = sessionId()) {
         const std::shared_ptr<SessionDataHandler> sdh = SessionDataHandler::instance();
         const std::shared_ptr<SessionData> sd = sdh->sessionData(id);
         const auto it = sd->mementos.find(tag);
         if (it != sd->mementos.end()) {
             return it->second;
         }
     }
     const auto it = mementos().find(tag);
     if (it == mementos().end()) {
         return std::shared_ptr<Memento>();
     } else {
         return it->second;
     }
 }
 
 QByteArray AssuanCommand::registerMemento(const std::shared_ptr<Memento> &mem)
 {
     const QByteArray tag = QByteArray::number(reinterpret_cast<qulonglong>(mem.get()), 36);
     return registerMemento(tag, mem);
 }
 
 QByteArray AssuanCommand::registerMemento(const QByteArray &tag, const std::shared_ptr<Memento> &mem)
 {
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
 
     if (const unsigned int id = sessionId()) {
         SessionDataHandler::instance()->sessionData(id)->mementos[tag] = mem;
     } else {
         conn.mementos[tag] = mem;
     }
     return tag;
 }
 
 void AssuanCommand::removeMemento(const QByteArray &tag)
 {
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
 
     conn.mementos.erase(tag);
     if (const unsigned int id = sessionId()) {
         SessionDataHandler::instance()->sessionData(id)->mementos.erase(tag);
     }
 }
 
 const std::vector< std::shared_ptr<Input> > &AssuanCommand::inputs() const
 {
     return d->inputs;
 }
 
 const std::vector< std::shared_ptr<Input> > &AssuanCommand::messages() const
 {
     return d->messages;
 }
 
 const std::vector< std::shared_ptr<Output> > &AssuanCommand::outputs() const
 {
     return d->outputs;
 }
 
 QStringList AssuanCommand::fileNames() const
 {
     QStringList rv;
     rv.reserve(d->files.size());
     std::copy(d->files.cbegin(), d->files.cend(), std::back_inserter(rv));
     return rv;
 }
 
 unsigned int AssuanCommand::numFiles() const
 {
     return d->files.size();
 }
 
 void AssuanCommand::sendStatus(const char *keyword, const QString &text)
 {
     sendStatusEncoded(keyword, text.toUtf8().constData());
 }
 
 void AssuanCommand::sendStatusEncoded(const char *keyword, const std::string &text)
 {
     if (d->nohup) {
         return;
     }
     if (const int err = assuan_write_status(d->ctx.get(), keyword, text.c_str())) {
         throw Exception(err, i18n("Cannot send \"%1\" status", QString::fromLatin1(keyword)));
     }
 }
 
 void  AssuanCommand::sendData(const QByteArray &data, bool moreToCome)
 {
     if (d->nohup) {
         return;
     }
     if (const gpg_error_t err = assuan_send_data(d->ctx.get(), data.constData(), data.size())) {
         throw Exception(err, i18n("Cannot send data"));
     }
     if (!moreToCome)
         if (const gpg_error_t err = assuan_send_data(d->ctx.get(), nullptr, 0)) {   // flush
             throw Exception(err, i18n("Cannot flush data"));
         }
 }
 
 int AssuanCommand::inquire(const char *keyword, QObject *receiver, const char *slot, unsigned int maxSize)
 {
     Q_ASSERT(keyword);
     Q_ASSERT(receiver);
     Q_ASSERT(slot);
 
     if (d->nohup) {
         return makeError(GPG_ERR_INV_OP);
     }
 
 #if defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
     std::unique_ptr<InquiryHandler> ih(new InquiryHandler(keyword, receiver));
     receiver->connect(ih.get(), SIGNAL(signal(int,QByteArray,QByteArray)), slot);
     if (const gpg_error_t err = assuan_inquire_ext(d->ctx.get(), keyword,
 # if !defined(HAVE_ASSUAN2) && !defined(HAVE_NEW_STYLE_ASSUAN_INQUIRE_EXT)
                                 &ih->buffer, &ih->buflen,
 # endif
                                 maxSize, InquiryHandler::handler, ih.get())) {
         return err;
     }
     ih.release();
     return 0;
 #else
     return makeError(GPG_ERR_NOT_SUPPORTED);   // libassuan too old
 #endif // defined(HAVE_ASSUAN2) || defined(HAVE_ASSUAN_INQUIRE_EXT)
 }
 
 void AssuanCommand::done(const GpgME::Error &err, const QString &details)
 {
     if (d->ctx && !d->done && !details.isEmpty()) {
         qCDebug(KLEOPATRA_LOG) << "Error: " << details;
         d->utf8ErrorKeepAlive = details.toUtf8();
         if (!d->nohup) {
             assuan_set_error(d->ctx.get(), err.encodedError(), d->utf8ErrorKeepAlive.constData());
         }
     }
     done(err);
 }
 
 void AssuanCommand::done(const GpgME::Error &err)
 {
     if (!d->ctx) {
         qCDebug(KLEOPATRA_LOG) << err.asString() << ": called with NULL ctx.";
         return;
     }
     if (d->done) {
         qCDebug(KLEOPATRA_LOG) << err.asString() << ": called twice!";
         return;
     }
 
     d->done = true;
 
     std::for_each(d->messages.begin(), d->messages.end(), std::mem_fn(&Input::finalize));
     std::for_each(d->inputs.begin(), d->inputs.end(), std::mem_fn(&Input::finalize));
     std::for_each(d->outputs.begin(), d->outputs.end(), std::mem_fn(&Output::finalize));
     d->messages.clear();
     d->inputs.clear();
     d->outputs.clear();
     d->files.clear();
 
     // oh, hack :(
     Q_ASSERT(assuan_get_pointer(d->ctx.get()));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(d->ctx.get()));
 
     if (d->nohup) {
         conn.nohupDone(this);
         return;
     }
 
     const gpg_error_t rc = assuan_process_done(d->ctx.get(), err.encodedError());
     if (gpg_err_code(rc) != GPG_ERR_NO_ERROR)
         qFatal("AssuanCommand::done: assuan_process_done returned error %d (%s)",
                static_cast<int>(rc), gpg_strerror(rc));
 
     d->utf8ErrorKeepAlive.clear();
 
     conn.commandDone(this);
 }
 
 void AssuanCommand::setNohup(bool nohup)
 {
     d->nohup = nohup;
 }
 
 bool AssuanCommand::isNohup() const
 {
     return d->nohup;
 }
 
 bool AssuanCommand::isDone() const
 {
     return d->done;
 }
 
 QString AssuanCommand::sessionTitle() const
 {
     return d->sessionTitle;
 }
 
 unsigned int AssuanCommand::sessionId() const
 {
     return d->sessionId;
 }
 
 bool AssuanCommand::informativeSenders() const
 {
     return d->informativeSenders;
 }
 
 bool AssuanCommand::informativeRecipients() const
 {
     return d->informativeRecipients;
 }
 
 const std::vector<KMime::Types::Mailbox> &AssuanCommand::recipients() const
 {
     return d->recipients;
 }
 
 const std::vector<KMime::Types::Mailbox> &AssuanCommand::senders() const
 {
     return d->senders;
 }
 
 #ifndef HAVE_ASSUAN2
 int AssuanCommandFactory::_handle(assuan_context_t ctx, char *line, const char *commandName)
 {
 #else
 gpg_error_t AssuanCommandFactory::_handle(assuan_context_t ctx, char *line, const char *commandName)
 {
 #endif
     Q_ASSERT(assuan_get_pointer(ctx));
     AssuanServerConnection::Private &conn = *static_cast<AssuanServerConnection::Private *>(assuan_get_pointer(ctx));
 
     try {
 
         const auto it
             = std::lower_bound(conn.factories.begin(), conn.factories.end(), commandName, _detail::ByName<std::less>());
         kleo_assert(it != conn.factories.end());
         kleo_assert(*it);
         kleo_assert(qstricmp((*it)->name(), commandName) == 0);
 
         const std::shared_ptr<AssuanCommand> cmd = (*it)->create();
         kleo_assert(cmd);
 
         cmd->d->ctx     = conn.ctx;
         cmd->d->options = conn.options;
         cmd->d->inputs.swap(conn.inputs);     kleo_assert(conn.inputs.empty());
         cmd->d->messages.swap(conn.messages); kleo_assert(conn.messages.empty());
         cmd->d->outputs.swap(conn.outputs);   kleo_assert(conn.outputs.empty());
         cmd->d->files.swap(conn.files);       kleo_assert(conn.files.empty());
         cmd->d->senders.swap(conn.senders);   kleo_assert(conn.senders.empty());
         cmd->d->recipients.swap(conn.recipients); kleo_assert(conn.recipients.empty());
         cmd->d->informativeRecipients = conn.informativeRecipients;
         cmd->d->informativeSenders    = conn.informativeSenders;
         cmd->d->bias                  = conn.bias;
         cmd->d->sessionTitle          = conn.sessionTitle;
         cmd->d->sessionId             = conn.sessionId;
 
         const std::map<std::string, std::string> cmdline_options = parse_commandline(line);
         for (auto it = cmdline_options.begin(), end = cmdline_options.end(); it != end; ++it) {
             cmd->d->options[it->first] = QString::fromUtf8(it->second.c_str());
         }
 
         bool nohup = false;
         if (cmd->d->options.count("nohup")) {
             if (!cmd->d->options["nohup"].toString().isEmpty()) {
                 return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_ASS_PARAMETER), "--nohup takes no argument");
             }
             nohup = true;
             cmd->d->options.erase("nohup");
         }
 
         conn.currentCommand = cmd;
         conn.currentCommandIsNohup = nohup;
 
         QTimer::singleShot(0, &conn, &AssuanServerConnection::Private::startCommandBottomHalf);
 
         return 0;
 
     } catch (const Exception &e) {
         return assuan_process_done_msg(conn.ctx.get(), e.error_code(), e.message());
     } catch (const std::exception &e) {
         return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), e.what());
     } catch (...) {
         return assuan_process_done_msg(conn.ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), i18n("Caught unknown exception"));
     }
 }
 
 int AssuanServerConnection::Private::startCommandBottomHalf()
 {
 
     commandWaitingForCryptoCommandsEnabled = currentCommand && !cryptoCommandsEnabled;
 
     if (!cryptoCommandsEnabled) {
         return 0;
     }
 
     const std::shared_ptr<AssuanCommand> cmd = currentCommand;
     if (!cmd) {
         return 0;
     }
 
     currentCommand.reset();
 
     const bool nohup = currentCommandIsNohup;
     currentCommandIsNohup = false;
 
     try {
 
         if (const int err = cmd->start()) {
             if (cmd->isDone()) {
                 return err;
             } else {
                 return assuan_process_done(ctx.get(), err);
             }
         }
 
         if (cmd->isDone()) {
             return 0;
         }
 
         if (nohup) {
             cmd->setNohup(true);
             nohupedCommands.push_back(cmd);
             return assuan_process_done_msg(ctx.get(), 0, "Command put in the background to continue executing after connection end.");
         } else {
             currentCommand = cmd;
             return 0;
         }
 
     } catch (const Exception &e) {
         return assuan_process_done_msg(ctx.get(), e.error_code(), e.message());
     } catch (const std::exception &e) {
         return assuan_process_done_msg(ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), e.what());
     } catch (...) {
         return assuan_process_done_msg(ctx.get(), gpg_error(GPG_ERR_UNEXPECTED), i18n("Caught unknown exception"));
     }
 
 }
 
 //
 //
 // AssuanCommand convenience methods
 //
 //
 
 /*!
   Checks the \c --mode parameter.
 
   \returns The parameter as an AssuanCommand::Mode enum value.
 
   If no \c --mode was given, or it's value wasn't recognized, throws
   an Kleo::Exception.
 */
 AssuanCommand::Mode AssuanCommand::checkMode() const
 {
     if (!hasOption("mode")) {
         throw Exception(makeError(GPG_ERR_MISSING_VALUE), i18n("Required --mode option missing"));
     }
 
     const QString modeString = option("mode").toString().toLower();
     if (modeString == QLatin1String("filemanager")) {
         return FileManager;
     }
     if (modeString == QLatin1String("email")) {
         return EMail;
     }
     throw Exception(makeError(GPG_ERR_INV_ARG), i18n("invalid mode: \"%1\"", modeString));
 }
 
 /*!
   Checks the \c --protocol parameter.
 
   \returns The parameter as a GpgME::Protocol enum value.
 
   If \c --protocol was given, but has an invalid value, throws an
   Kleo::Exception.
 
   If no \c --protocol was given, checks the connection bias, if
   available, otherwise, in FileManager mode, returns
   GpgME::UnknownProtocol, but if \a mode == \c EMail, throws an
   Kleo::Exception instead.
 */
 GpgME::Protocol AssuanCommand::checkProtocol(Mode mode, int options) const
 {
     if (!hasOption("protocol"))
         if (d->bias != GpgME::UnknownProtocol) {
             return d->bias;
         } else if (mode == AssuanCommand::EMail && (options & AllowProtocolMissing) == 0) {
             throw Exception(makeError(GPG_ERR_MISSING_VALUE), i18n("Required --protocol option missing"));
         } else {
             return GpgME::UnknownProtocol;
         }
     else if (mode == AssuanCommand::FileManager) {
         throw Exception(makeError(GPG_ERR_INV_FLAG), i18n("--protocol is not allowed here"));
     }
 
     const QString protocolString = option("protocol").toString().toLower();
     if (protocolString == QLatin1String("openpgp")) {
         return GpgME::OpenPGP;
     }
     if (protocolString == QLatin1String("cms")) {
         return GpgME::CMS;
     }
     throw Exception(makeError(GPG_ERR_INV_ARG), i18n("invalid protocol \"%1\"", protocolString));
 }
 
 void AssuanCommand::doApplyWindowID(QWidget *widget) const
 {
     if (!widget || !hasOption("window-id")) {
         return;
     }
     apply_window_id(widget, option("window-id").toString());
 }
 
 WId AssuanCommand::parentWId() const
 {
     return wid_from_string(option("window-id").toString());
 }
 
 #include "assuanserverconnection.moc"
diff --git a/src/view/tabwidget.cpp b/src/view/tabwidget.cpp
index 699beea32..320efb65c 100644
--- a/src/view/tabwidget.cpp
+++ b/src/view/tabwidget.cpp
@@ -1,959 +1,960 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     view/tabwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "tabwidget.h"
 #include "keytreeview.h"
 #include "kleopatra_debug.h"
 
 #include <utils/action_data.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyFilterManager>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include <QTabWidget>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KConfig>
 #include <QAction>
 #include <KActionCollection>
 #include <QInputDialog>
 
 #include <QTreeView>
 #include <QToolButton>
 #include <QMenu>
 #include <QVBoxLayout>
 #include <QRegularExpression>
 #include <QAbstractProxyModel>
 
 #include <map>
 
 using namespace Kleo;
 using namespace GpgME;
 
 namespace
 {
 
 class Page : public Kleo::KeyTreeView
 {
     Q_OBJECT
     Page(const Page &other);
 public:
     Page(const QString &title, const QString &id, const QString &text, AbstractKeyListSortFilterProxyModel *proxy = nullptr, const QString &toolTip = QString(), QWidget *parent = nullptr, const KConfigGroup &group = KConfigGroup());
     Page(const KConfigGroup &group, QWidget *parent = nullptr);
     ~Page();
 
     void setTemporary(bool temporary);
     bool isTemporary() const
     {
         return m_isTemporary;
     }
 
     void setHierarchicalView(bool hierarchical) override;
     void setStringFilter(const QString &filter) override;
     void setKeyFilter(const std::shared_ptr<KeyFilter> &filter) override;
 
     QString title() const
     {
         return m_title.isEmpty() && keyFilter() ? keyFilter()->name() : m_title;
     }
     void setTitle(const QString &title);
 
     QString toolTip() const
     {
         return m_toolTip.isEmpty() ? title() : m_toolTip;
     }
     // not used void setToolTip(const QString &tip);
 
     bool canBeClosed() const
     {
         return m_canBeClosed;
     }
     bool canBeRenamed() const
     {
         return m_canBeRenamed;
     }
     bool canChangeStringFilter() const
     {
         return m_canChangeStringFilter;
     }
     bool canChangeKeyFilter() const
     {
         return m_canChangeKeyFilter && !m_isTemporary;
     }
     bool canChangeHierarchical() const
     {
         return m_canChangeHierarchical;
     }
 
     void saveTo(KConfigGroup &group) const;
 
     Page *clone() const override
     {
         return new Page(*this);
     }
 
     void liftAllRestrictions()
     {
         m_canBeClosed = m_canBeRenamed = m_canChangeStringFilter = m_canChangeKeyFilter = m_canChangeHierarchical = true;
     }
 
 Q_SIGNALS:
     void titleChanged(const QString &title);
 
 private:
     void init();
 
 private:
     QString m_title;
     QString m_toolTip;
     bool m_isTemporary : 1;
     bool m_canBeClosed : 1;
     bool m_canBeRenamed : 1;
     bool m_canChangeStringFilter : 1;
     bool m_canChangeKeyFilter : 1;
     bool m_canChangeHierarchical : 1;
 };
 } // anon namespace
 
 Page::Page(const Page &other)
     : KeyTreeView(other),
       m_title(other.m_title),
       m_toolTip(other.m_toolTip),
       m_isTemporary(other.m_isTemporary),
       m_canBeClosed(other.m_canBeClosed),
       m_canBeRenamed(other.m_canBeRenamed),
       m_canChangeStringFilter(other.m_canChangeStringFilter),
       m_canChangeKeyFilter(other.m_canChangeKeyFilter),
       m_canChangeHierarchical(other.m_canChangeHierarchical)
 {
     init();
 }
 
 Page::Page(const QString &title, const QString &id, const QString &text, AbstractKeyListSortFilterProxyModel *proxy, const QString &toolTip, QWidget *parent,
            const KConfigGroup &group)
     : KeyTreeView(text, KeyFilterManager::instance()->keyFilterByID(id), proxy, parent, group),
       m_title(title),
       m_toolTip(toolTip),
       m_isTemporary(false),
       m_canBeClosed(true),
       m_canBeRenamed(true),
       m_canChangeStringFilter(true),
       m_canChangeKeyFilter(true),
       m_canChangeHierarchical(true)
 {
     init();
 }
 
 static const char TITLE_ENTRY[] = "title";
 static const char STRING_FILTER_ENTRY[] = "string-filter";
 static const char KEY_FILTER_ENTRY[] = "key-filter";
 static const char HIERARCHICAL_VIEW_ENTRY[] = "hierarchical-view";
 static const char COLUMN_SIZES[] = "column-sizes";
 static const char SORT_COLUMN[] = "sort-column";
 static const char SORT_DESCENDING[] = "sort-descending";
 
 Page::Page(const KConfigGroup &group, QWidget *parent)
     : KeyTreeView(group.readEntry(STRING_FILTER_ENTRY),
                   KeyFilterManager::instance()->keyFilterByID(group.readEntry(KEY_FILTER_ENTRY)),
                   nullptr, parent, group),
       m_title(group.readEntry(TITLE_ENTRY)),
       m_toolTip(),
       m_isTemporary(false),
       m_canBeClosed(!group.isImmutable()),
       m_canBeRenamed(!group.isEntryImmutable(TITLE_ENTRY)),
       m_canChangeStringFilter(!group.isEntryImmutable(STRING_FILTER_ENTRY)),
       m_canChangeKeyFilter(!group.isEntryImmutable(KEY_FILTER_ENTRY)),
       m_canChangeHierarchical(!group.isEntryImmutable(HIERARCHICAL_VIEW_ENTRY))
 {
     init();
     setHierarchicalView(group.readEntry(HIERARCHICAL_VIEW_ENTRY, true));
     const QList<int> settings = group.readEntry(COLUMN_SIZES, QList<int>());
     std::vector<int> sizes;
     sizes.reserve(settings.size());
     std::copy(settings.cbegin(), settings.cend(), std::back_inserter(sizes));
     setColumnSizes(sizes);
     setSortColumn(group.readEntry(SORT_COLUMN, 0),
                   group.readEntry(SORT_DESCENDING, true) ? Qt::DescendingOrder : Qt::AscendingOrder);
 }
 
 void Page::init()
 {
 
 }
 
 Page::~Page() {}
 
 void Page::saveTo(KConfigGroup &group) const
 {
 
     group.writeEntry(TITLE_ENTRY,         m_title);
     group.writeEntry(STRING_FILTER_ENTRY, stringFilter());
     group.writeEntry(KEY_FILTER_ENTRY,    keyFilter() ? keyFilter()->id() : QString());
     group.writeEntry(HIERARCHICAL_VIEW_ENTRY, isHierarchicalView());
     QList<int> settings;
     const auto sizes = columnSizes();
     settings.reserve(sizes.size());
     std::copy(sizes.cbegin(), sizes.cend(), std::back_inserter(settings));
     group.writeEntry(COLUMN_SIZES,        settings);
     group.writeEntry(SORT_COLUMN,         sortColumn());
     group.writeEntry(SORT_DESCENDING,     sortOrder() == Qt::DescendingOrder);
 }
 
 void Page::setStringFilter(const QString &filter)
 {
     if (!m_canChangeStringFilter) {
         return;
     }
     KeyTreeView::setStringFilter(filter);
 }
 
 void Page::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     if (!canChangeKeyFilter()) {
         return;
     }
     const QString oldTitle = title();
     KeyTreeView::setKeyFilter(filter);
     const QString newTitle = title();
     if (oldTitle != newTitle) {
         Q_EMIT titleChanged(newTitle);
     }
 }
 
 void Page::setTitle(const QString &t)
 {
     if (t == m_title) {
         return;
     }
     if (!m_canBeRenamed) {
         return;
     }
     const QString oldTitle = title();
     m_title = t;
     const QString newTitle = title();
     if (oldTitle != newTitle) {
         Q_EMIT titleChanged(newTitle);
     }
 }
 
 #if 0 // not used
 void Page::setToolTip(const QString &tip)
 {
     if (tip == m_toolTip) {
         return;
     }
     if (!m_canBeRenamed) {
         return;
     }
     const QString oldTip = toolTip();
     m_toolTip = tip;
     const QString newTip = toolTip();
     if (oldTip != newTip) {
         Q_EMIT titleChanged(title());
     }
 }
 #endif
 
 void Page::setHierarchicalView(bool on)
 {
     if (!m_canChangeHierarchical) {
         return;
     }
     KeyTreeView::setHierarchicalView(on);
 }
 
 void Page::setTemporary(bool on)
 {
     if (on == m_isTemporary) {
         return;
     }
     m_isTemporary = on;
     if (on) {
         setKeyFilter(std::shared_ptr<KeyFilter>());
     }
 }
 
 //
 //
 // TabWidget
 //
 //
 
 class TabWidget::Private
 {
     friend class ::Kleo::TabWidget;
     TabWidget *const q;
 public:
     explicit Private(TabWidget *qq);
     ~Private() {}
 
 private:
     void slotContextMenu(const QPoint &p);
     void currentIndexChanged(int index);
     void slotPageTitleChanged(const QString &title);
     void slotPageKeyFilterChanged(const std::shared_ptr<KeyFilter> &filter);
     void slotPageStringFilterChanged(const QString &filter);
     void slotPageHierarchyChanged(bool on);
 
 #ifndef QT_NO_INPUTDIALOG
     void slotRenameCurrentTab()
     {
         renamePage(currentPage());
     }
 #endif // QT_NO_INPUTDIALOG
     void slotNewTab();
     void slotDuplicateCurrentTab()
     {
         duplicatePage(currentPage());
     }
     void slotCloseCurrentTab()
     {
         closePage(currentPage());
     }
     void slotMoveCurrentTabLeft()
     {
         movePageLeft(currentPage());
     }
     void slotMoveCurrentTabRight()
     {
         movePageRight(currentPage());
     }
     void slotToggleHierarchicalView(bool on)
     {
         toggleHierarchicalView(currentPage(), on);
     }
     void slotExpandAll()
     {
         expandAll(currentPage());
     }
     void slotCollapseAll()
     {
         collapseAll(currentPage());
     }
 
 #ifndef QT_NO_INPUTDIALOG
     void renamePage(Page *page);
 #endif
     void duplicatePage(Page *page);
     void closePage(Page *page);
     void movePageLeft(Page *page);
     void movePageRight(Page *page);
     void toggleHierarchicalView(Page *page, bool on);
     void expandAll(Page *page);
     void collapseAll(Page *page);
 
     void enableDisableCurrentPageActions();
     void enableDisablePageActions(const std::vector<QAction *> &actions, const Page *page);
 
     Page *currentPage() const
     {
         Q_ASSERT(!tabWidget.currentWidget() || qobject_cast<Page *>(tabWidget.currentWidget()));
         return static_cast<Page *>(tabWidget.currentWidget());
     }
     Page *page(unsigned int idx) const
     {
         Q_ASSERT(!tabWidget.widget(idx) || qobject_cast<Page *>(tabWidget.widget(idx)));
         return static_cast<Page *>(tabWidget.widget(idx));
     }
 
     Page *senderPage() const
     {
         QObject *const sender = q->sender();
         Q_ASSERT(!sender || qobject_cast<Page *>(sender));
         return static_cast<Page *>(sender);
     }
 
     bool isSenderCurrentPage() const
     {
         Page *const sp = senderPage();
         return sp && sp == currentPage();
     }
 
     QTreeView *addView(Page *page, Page *columnReference);
     void setCornerAction(QAction *action, Qt::Corner corner);
 
 private:
     AbstractKeyListModel *flatModel;
     AbstractKeyListModel *hierarchicalModel;
     QTabWidget tabWidget;
     QVBoxLayout layout;
     enum {
         Rename,
         Duplicate,
         Close,
         MoveLeft,
         MoveRight,
         Hierarchical,
         ExpandAll,
         CollapseAll,
 
         NumPageActions
     };
     QAction *newAction = nullptr;
     std::vector<QAction *> currentPageActions;
     std::vector<QAction *> otherPageActions;
     bool actionsCreated;
 };
 
 TabWidget::Private::Private(TabWidget *qq)
     : q(qq),
       flatModel(nullptr),
       hierarchicalModel(nullptr),
       tabWidget(q),
       layout(q),
       actionsCreated(false)
 {
     KDAB_SET_OBJECT_NAME(tabWidget);
     KDAB_SET_OBJECT_NAME(layout);
 
     layout.setContentsMargins(0, 0, 0, 0);
     layout.addWidget(&tabWidget);
 
     tabWidget.tabBar()->hide();
     tabWidget.setMovable(true);
 
     tabWidget.tabBar()->setContextMenuPolicy(Qt::CustomContextMenu);
 
     connect(&tabWidget, SIGNAL(currentChanged(int)), q, SLOT(currentIndexChanged(int)));
     connect(tabWidget.tabBar(), &QWidget::customContextMenuRequested, q, [this](const QPoint & p) {
         slotContextMenu(p);
     });
 
 }
 
 void TabWidget::Private::slotContextMenu(const QPoint &p)
 {
     const int tabUnderPos = tabWidget.tabBar()->tabAt(p);
     Page *const contextMenuPage = static_cast<Page *>(tabWidget.widget(tabUnderPos));
     const Page *const current = currentPage();
 
     const std::vector<QAction *> actions = contextMenuPage == current ? currentPageActions : otherPageActions;
 
     enableDisablePageActions(actions, contextMenuPage);
 
     QMenu menu;
     menu.addAction(actions[Rename]);
     menu.addSeparator();
     menu.addAction(newAction);
     menu.addAction(actions[Duplicate]);
     menu.addSeparator();
     menu.addAction(actions[MoveLeft]);
     menu.addAction(actions[MoveRight]);
     menu.addSeparator();
     menu.addAction(actions[Close]);
 
     const QAction *const action = menu.exec(tabWidget.tabBar()->mapToGlobal(p));
 
     if (contextMenuPage == current || action == newAction) {
         return;    // performed through signal/slot connections...
     }
 
 #ifndef QT_NO_INPUTDIALOG
     if (action == otherPageActions[Rename]) {
         renamePage(contextMenuPage);
     }
 #endif // QT_NO_INPUTDIALOG
     else if (action == otherPageActions[Duplicate]) {
         duplicatePage(contextMenuPage);
     } else if (action == otherPageActions[Close]) {
         closePage(contextMenuPage);
     } else if (action == otherPageActions[MoveLeft]) {
         movePageLeft(contextMenuPage);
     } else if (action == otherPageActions[MoveRight]) {
         movePageRight(contextMenuPage);
     }
 
 }
 
 void TabWidget::Private::currentIndexChanged(int index)
 {
     const Page *const page = this->page(index);
     Q_EMIT q->currentViewChanged(page ? page->view() : nullptr);
     Q_EMIT q->keyFilterChanged(page ? page->keyFilter() : std::shared_ptr<KeyFilter>());
     Q_EMIT q->stringFilterChanged(page ? page->stringFilter() : QString());
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::enableDisableCurrentPageActions()
 {
     const Page *const page = currentPage();
 
     Q_EMIT q->enableChangeStringFilter(page && page->canChangeStringFilter());
     Q_EMIT q->enableChangeKeyFilter(page && page->canChangeKeyFilter());
 
     enableDisablePageActions(currentPageActions, page);
 }
 
 void TabWidget::Private::enableDisablePageActions(const std::vector<QAction *> &actions, const Page *p)
 {
     actions[Rename]      ->setEnabled(p && p->canBeRenamed());
     actions[Duplicate]   ->setEnabled(p);
     actions[Close]       ->setEnabled(p && p->canBeClosed() && tabWidget.count() > 1);
     actions[MoveLeft]    ->setEnabled(p && tabWidget.indexOf(const_cast<Page *>(p)) != 0);
     actions[MoveRight]   ->setEnabled(p && tabWidget.indexOf(const_cast<Page *>(p)) != tabWidget.count() - 1);
     actions[Hierarchical]->setEnabled(p && p->canChangeHierarchical());
     actions[Hierarchical]->setChecked(p && p->isHierarchicalView());
     actions[ExpandAll]   ->setEnabled(p && p->isHierarchicalView());
     actions[CollapseAll] ->setEnabled(p && p->isHierarchicalView());
 
     if (tabWidget.count() < 2) {
         tabWidget.tabBar()->hide();
     } else {
         tabWidget.tabBar()->show();
     }
 }
 
 void TabWidget::Private::slotPageTitleChanged(const QString &)
 {
     if (Page *const page = senderPage()) {
         const int idx = tabWidget.indexOf(page);
         tabWidget.setTabText(idx, page->title());
         tabWidget.setTabToolTip(idx, page->toolTip());
     }
 }
 
 void TabWidget::Private::slotPageKeyFilterChanged(const std::shared_ptr<KeyFilter> &kf)
 {
     if (isSenderCurrentPage()) {
         Q_EMIT q->keyFilterChanged(kf);
     }
 }
 
 void TabWidget::Private::slotPageStringFilterChanged(const QString &filter)
 {
     if (isSenderCurrentPage()) {
         Q_EMIT q->stringFilterChanged(filter);
     }
 }
 
 void TabWidget::Private::slotPageHierarchyChanged(bool)
 {
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::slotNewTab()
 {
     const KConfigGroup group = KSharedConfig::openConfig()->group(QString::asprintf("View #%u", tabWidget.count()));
     Page *page = new Page(QString(), QStringLiteral("all-certificates"), QString(), nullptr, QString(), nullptr, group);
     addView(page, currentPage());
     tabWidget.setCurrentIndex(tabWidget.count() - 1);
 }
 
 void TabWidget::Private::renamePage(Page *page)
 {
     if (!page) {
         return;
     }
     bool ok;
     const QString text = QInputDialog::getText(q, i18n("Rename Tab"), i18n("New tab title:"), QLineEdit::Normal, page->title(), &ok);
     if (!ok) {
         return;
     }
     page->setTitle(text);
 }
 
 void TabWidget::Private::duplicatePage(Page *page)
 {
     if (!page) {
         return;
     }
     Page *const clone = page->clone();
     Q_ASSERT(clone);
     clone->liftAllRestrictions();
     addView(clone, page);
 }
 
 void TabWidget::Private::closePage(Page *page)
 {
     if (!page || !page->canBeClosed() || tabWidget.count() <= 1) {
         return;
     }
     Q_EMIT q->viewAboutToBeRemoved(page->view());
     tabWidget.removeTab(tabWidget.indexOf(page));
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::movePageLeft(Page *page)
 {
     if (!page) {
         return;
     }
     const int idx = tabWidget.indexOf(page);
     if (idx <= 0) {
         return;
     }
     tabWidget.tabBar()->moveTab(idx, idx - 1);
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::movePageRight(Page *page)
 {
     if (!page) {
         return;
     }
     const int idx = tabWidget.indexOf(page);
     if (idx < 0 || idx >= tabWidget.count() - 1) {
         return;
     }
     tabWidget.tabBar()->moveTab(idx, idx + 1);
     enableDisableCurrentPageActions();
 }
 
 void TabWidget::Private::toggleHierarchicalView(Page *page, bool on)
 {
     if (!page) {
         return;
     }
     page->setHierarchicalView(on);
 }
 
 void TabWidget::Private::expandAll(Page *page)
 {
     if (!page || !page->view()) {
         return;
     }
     page->view()->expandAll();
 }
 
 void TabWidget::Private::collapseAll(Page *page)
 {
     if (!page || !page->view()) {
         return;
     }
     page->view()->collapseAll();
 }
 
 TabWidget::TabWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f), d(new Private(this))
 {
 
 }
 
 TabWidget::~TabWidget() {
     saveViews(KSharedConfig::openConfig().data());
 }
 
 void TabWidget::setFlatModel(AbstractKeyListModel *model)
 {
     if (model == d->flatModel) {
         return;
     }
     d->flatModel = model;
     for (unsigned int i = 0, end = count(); i != end; ++i)
         if (Page *const page = d->page(i)) {
             page->setFlatModel(model);
         }
 }
 
 AbstractKeyListModel *TabWidget::flatModel() const
 {
     return d->flatModel;
 }
 
 void TabWidget::setHierarchicalModel(AbstractKeyListModel *model)
 {
     if (model == d->hierarchicalModel) {
         return;
     }
     d->hierarchicalModel = model;
     for (unsigned int i = 0, end = count(); i != end; ++i)
         if (Page *const page = d->page(i)) {
             page->setHierarchicalModel(model);
         }
 }
 
 AbstractKeyListModel *TabWidget::hierarchicalModel() const
 {
     return d->hierarchicalModel;
 }
 
 void TabWidget::Private::setCornerAction(QAction *action, Qt::Corner corner)
 {
     if (!action) {
         return;
     }
     auto b = new QToolButton;
     b->setDefaultAction(action);
     tabWidget.setCornerWidget(b, corner);
 }
 
 void TabWidget::setStringFilter(const QString &filter)
 {
     if (Page *const page = d->currentPage()) {
         page->setStringFilter(filter);
     }
 }
 
 void TabWidget::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     if (!filter) {
         qCDebug(KLEOPATRA_LOG) << "TabWidget::setKeyFilter() trial to set filter=NULL";
         return;
     }
 
     if (Page *const page = d->currentPage()) {
         page->setKeyFilter(filter);
     }
 }
 
 std::vector<QAbstractItemView *> TabWidget::views() const
 {
     std::vector<QAbstractItemView *> result;
     const unsigned int N = count();
     result.reserve(N);
     for (unsigned int i = 0; i != N; ++i)
         if (const Page *const p = d->page(i)) {
             result.push_back(p->view());
         }
     return result;
 }
 
 QAbstractItemView *TabWidget::currentView() const
 {
     if (Page *const page = d->currentPage()) {
         return page->view();
     } else {
         return nullptr;
     }
 }
 
 KeyListModelInterface *TabWidget::currentModel() const
 {
     const QAbstractItemView *const view = currentView();
     if (!view) {
         return nullptr;
     }
     auto const proxy = qobject_cast<QAbstractProxyModel *>(view->model());
     if (!proxy) {
         return nullptr;
     }
     return dynamic_cast<KeyListModelInterface *>(proxy);
 }
 
 unsigned int TabWidget::count() const
 {
     return d->tabWidget.count();
 }
 
 void TabWidget::setMultiSelection(bool on)
 {
     for (unsigned int i = 0, end = count(); i != end; ++i)
         if (const Page *const p = d->page(i))
             if (QTreeView *const view = p->view()) {
                 view->setSelectionMode(on ? QAbstractItemView::ExtendedSelection : QAbstractItemView::SingleSelection);
             }
 }
 
 void TabWidget::createActions(KActionCollection *coll)
 {
     if (!coll) {
         return;
     }
     const action_data actionDataNew = {
         "window_new_tab", i18n("New Tab"), i18n("Open a new tab"),
         "tab-new-background", this, SLOT(slotNewTab()), QStringLiteral("CTRL+SHIFT+N"), false, true
     };
 
     d->newAction = make_action_from_data(actionDataNew, coll);
 
     struct action_data actionData[] = {
         {
             "window_rename_tab", i18n("Rename Tab..."), i18n("Rename this tab"),
             "edit-rename", this, SLOT(slotRenameCurrentTab()), QStringLiteral("CTRL+SHIFT+R"), false, false
         },
         {
             "window_duplicate_tab", i18n("Duplicate Tab"), i18n("Duplicate this tab"),
             "tab-duplicate", this, SLOT(slotDuplicateCurrentTab()), QStringLiteral("CTRL+SHIFT+D"), false, true
         },
         {
             "window_close_tab", i18n("Close Tab"), i18n("Close this tab"),
             "tab-close", this, SLOT(slotCloseCurrentTab()), QStringLiteral("CTRL+SHIFT+W"), false, false
         }, // ### CTRL-W when available
         {
             "window_move_tab_left", i18n("Move Tab Left"), i18n("Move this tab left"),
             nullptr, this, SLOT(slotMoveCurrentTabLeft()), QStringLiteral("CTRL+SHIFT+LEFT"), false, false
         },
         {
             "window_move_tab_right", i18n("Move Tab Right"), i18n("Move this tab right"),
             nullptr, this, SLOT(slotMoveCurrentTabRight()), QStringLiteral("CTRL+SHIFT+RIGHT"), false, false
         },
         {
             "window_view_hierarchical", i18n("Hierarchical Certificate List"), QString(),
             nullptr, this, SLOT(slotToggleHierarchicalView(bool)), QString(), true, false
         },
         {
             "window_expand_all", i18n("Expand All"), QString(),
             nullptr, this, SLOT(slotExpandAll()), QStringLiteral("CTRL+."), false, false
         },
         {
             "window_collapse_all", i18n("Collapse All"), QString(),
             nullptr, this, SLOT(slotCollapseAll()), QStringLiteral("CTRL+,"), false, false
         },
     };
 
     d->currentPageActions.reserve(d->NumPageActions);
     for (int i = 0; i < d->NumPageActions; ++i) {
         d->currentPageActions.push_back(make_action_from_data(actionData[i], coll));
     }
 
     d->otherPageActions.reserve(d->NumPageActions);
     for (int i = 0; i < d->NumPageActions; ++i) {
         // create actions for the context menu of the currently not active tabs,
         // but do not add those actions to the action collection
         const action_data ad = actionData[i];
         auto action = new QAction(ad.text, coll);
         if (ad.icon) {
             action->setIcon(QIcon::fromTheme(QLatin1String(ad.icon)));
         }
         action->setEnabled(ad.enabled);
         d->otherPageActions.push_back(action);
     }
 
     d->setCornerAction(d->newAction,                 Qt::TopLeftCorner);
     d->setCornerAction(d->currentPageActions[d->Close], Qt::TopRightCorner);
     d->actionsCreated = true;
 }
 
 QAbstractItemView *TabWidget::addView(const QString &title, const QString &id, const QString &text)
 {
     const KConfigGroup group = KSharedConfig::openConfig()->group(QString::asprintf("View #%u", d->tabWidget.count()));
     Page *page = new Page(title, id, text, nullptr, QString(), nullptr, group);
     return d->addView(page, d->currentPage());
 }
 
 QAbstractItemView *TabWidget::addView(const KConfigGroup &group)
 {
     return d->addView(new Page(group), nullptr);
 }
 
 QAbstractItemView *TabWidget::addTemporaryView(const QString &title, AbstractKeyListSortFilterProxyModel *proxy, const QString &tabToolTip)
 {
     const KConfigGroup group = KSharedConfig::openConfig()->group("KeyTreeView_default");
     Page *const page = new Page(title, QString(), QString(), proxy, tabToolTip, nullptr, group);
     page->setTemporary(true);
     QAbstractItemView *v = d->addView(page, d->currentPage());
     d->tabWidget.setCurrentIndex(d->tabWidget.count() - 1);
     return v;
 }
 
 QTreeView *TabWidget::Private::addView(Page *page, Page *columnReference)
 {
     if (!page) {
         return nullptr;
     }
 
     if (!actionsCreated) {
         auto coll = new KActionCollection(q);
         q->createActions(coll);
     }
 
     page->setFlatModel(flatModel);
     page->setHierarchicalModel(hierarchicalModel);
 
     connect(page, SIGNAL(titleChanged(QString)), q, SLOT(slotPageTitleChanged(QString)));
     connect(page, SIGNAL(keyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)), q, SLOT(slotPageKeyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)));
     connect(page, SIGNAL(stringFilterChanged(QString)), q, SLOT(slotPageStringFilterChanged(QString)));
     connect(page, SIGNAL(hierarchicalChanged(bool)), q, SLOT(slotPageHierarchyChanged(bool)));
 
     if (columnReference) {
         page->setColumnSizes(columnReference->columnSizes());
         page->setSortColumn(columnReference->sortColumn(), columnReference->sortOrder());
     }
 
     QAbstractItemView *const previous = q->currentView();
     const int tabIndex = tabWidget.addTab(page, page->title());
     tabWidget.setTabToolTip(tabIndex, page->toolTip());
     // work around a bug in QTabWidget (tested with 4.3.2) not emitting currentChanged() when the first widget is inserted
     QAbstractItemView *const current = q->currentView();
     if (previous != current) {
         currentIndexChanged(tabWidget.currentIndex());
     }
     enableDisableCurrentPageActions();
     QTreeView *view = page->view();
     Q_EMIT q->viewAdded(view);
     return view;
 }
 
 static QStringList extractViewGroups(const KConfig *config)
 {
     return config ? config->groupList().filter(QRegularExpression(QStringLiteral("^View #\\d+$"))) : QStringList();
 }
 
 // work around deleteGroup() not deleting groups out of groupList():
 static const bool KCONFIG_DELETEGROUP_BROKEN = true;
 
 void TabWidget::loadViews(const KConfig *config)
 {
     if (config) {
         QStringList groupList = extractViewGroups(config);
         groupList.sort();
         for (const QString &group : std::as_const(groupList)) {
             const KConfigGroup kcg(config, group);
             if (!KCONFIG_DELETEGROUP_BROKEN || kcg.readEntry("magic", 0U) == 0xFA1AFE1U) {
                 addView(kcg);
             }
         }
     }
     if (!count()) {
         // add default view:
         addView(QString(), QStringLiteral("all-certificates"));
     }
 }
 
 void TabWidget::saveViews(KConfig *config) const
 {
     if (!config) {
         return;
     }
-    Q_FOREACH (const QString &group, extractViewGroups(config)) {
+    const auto extraView{extractViewGroups(config)};
+    for (const QString &group : extraView) {
         config->deleteGroup(group);
     }
     unsigned int vg = 0;
     for (unsigned int i = 0, end = count(); i != end; ++i) {
         if (const Page *const p = d->page(i)) {
             if (p->isTemporary()) {
                 continue;
             }
             KConfigGroup group(config, QString::asprintf("View #%u", vg++));
             p->saveTo(group);
             if (KCONFIG_DELETEGROUP_BROKEN) {
                 group.writeEntry("magic", 0xFA1AFE1U);
             }
         }
     }
 }
 
 static void xconnect(const QObject *o1, const char *signal, const QObject *o2, const char *slot)
 {
     QObject::connect(o1, signal, o2, slot);
     QObject::connect(o2, signal, o1, slot);
 }
 
 void TabWidget::connectSearchBar(QObject *sb)
 {
     xconnect(sb, SIGNAL(stringFilterChanged(QString)),
              this, SLOT(setStringFilter(QString)));
     xconnect(sb, SIGNAL(keyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)),
              this, SLOT(setKeyFilter(std::shared_ptr<Kleo::KeyFilter>)));
     connect(this, SIGNAL(enableChangeStringFilter(bool)),
             sb, SLOT(setChangeStringFilterEnabled(bool)));
     connect(this, SIGNAL(enableChangeKeyFilter(bool)),
             sb, SLOT(setChangeKeyFilterEnabled(bool)));
 }
 
 #include "moc_tabwidget.cpp"
 #include "tabwidget.moc"