diff --git a/src/commands/certifycertificatecommand.cpp b/src/commands/certifycertificatecommand.cpp
index 1734e3db8..74b70e7d5 100644
--- a/src/commands/certifycertificatecommand.cpp
+++ b/src/commands/certifycertificatecommand.cpp
@@ -1,350 +1,350 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/signcertificatecommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2019 g10code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "certifycertificatecommand.h"
 #include "newcertificatecommand.h"
 
 #include "command_p.h"
 
 #include "exportopenpgpcertstoservercommand.h"
 #include "dialogs/certifycertificatedialog.h"
 #include "utils/tags.h"
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignKeyJob>
 
 #include <QEventLoop>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 using namespace QGpgME;
 
 class CertifyCertificateCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::CertifyCertificateCommand;
     CertifyCertificateCommand *q_func() const
     {
         return static_cast<CertifyCertificateCommand *>(q);
     }
 public:
     explicit Private(CertifyCertificateCommand *qq, KeyListController *c);
     ~Private();
 
     void init();
 
 private:
     void slotDialogRejected();
     void slotResult(const Error &err);
     void slotCertificationPrepared();
 
 private:
     void ensureDialogCreated();
     void createJob();
 
 private:
     std::vector<UserID> uids;
     QPointer<CertifyCertificateDialog> dialog;
     QPointer<QGpgME::SignKeyJob> job;
 };
 
 CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const CertifyCertificateCommand::Private *CertifyCertificateCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 CertifyCertificateCommand::Private::Private(CertifyCertificateCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       uids(),
       dialog(),
       job()
 {
 
 }
 
 CertifyCertificateCommand::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
     if (dialog) {
         delete dialog;
         dialog = nullptr;
     }
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(KeyListController *c)
     : Command(new Private(this, c))
 {
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(QAbstractItemView *v, KeyListController *c)
     : Command(v, new Private(this, c))
 {
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::Key &key)
     : Command(key, new Private(this, nullptr))
 {
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(const GpgME::UserID &uid)
     : Command(uid.parent(), new Private(this, nullptr))
 {
     std::vector<UserID>(1, uid).swap(d->uids);
     d->init();
 }
 
 CertifyCertificateCommand::CertifyCertificateCommand(const std::vector<GpgME::UserID> &uids)
     : Command(uids.empty() ? Key() : uids.front().parent(), new Private(this, nullptr))
 {
     d->uids = uids;
     d->init();
 }
 
 void CertifyCertificateCommand::Private::init()
 {
 
 }
 
 CertifyCertificateCommand::~CertifyCertificateCommand()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void CertifyCertificateCommand::setCertificationExportable(bool on)
 {
     Q_UNUSED(on)
 }
 
 void CertifyCertificateCommand::setCertificationRevocable(bool on)
 {
     Q_UNUSED(on)
 }
 
 void CertifyCertificateCommand::setCertifyingKey(const Key &signer)
 {
     Q_UNUSED(signer)
 }
 
 void CertifyCertificateCommand::setUserIDs(const std::vector<UserID> &uids)
 {
     d->uids = uids;
     if (!uids.empty() && d->key().isNull()) {
         setKey(uids.front().parent());
     }
 }
 
 void CertifyCertificateCommand::setUserID(const UserID &uid)
 {
     setUserIDs(std::vector<UserID>(1, uid));
 }
 
 void CertifyCertificateCommand::doStart()
 {
 
     const std::vector<Key> keys = d->keys();
     if (keys.size() != 1 ||
             keys.front().protocol() != GpgME::OpenPGP) {
         d->finished();
         return;
     }
 
     std::vector<Key> secKeys;
     Q_FOREACH (const Key &secKey, KeyCache::instance()->secretKeys()) {
         // Only include usable keys.
         if (secKey.canCertify() && secKey.protocol() == OpenPGP && !secKey.isRevoked() &&
             !secKey.isExpired() && !secKey.isInvalid()) {
             secKeys.push_back(secKey);
         }
     }
 
     if (secKeys.empty()) {
         auto sel = KMessageBox::questionYesNo(d->parentWidgetOrView(),
                     xi18nc("@info", "To certify other certificates, you first need to create an OpenPGP certificate for yourself.") +
                     QStringLiteral("<br><br>") +
                     i18n("Do you wish to create one now?"),
                     i18n("Certification Not Possible"));
         if (sel == KMessageBox::Yes) {
             QEventLoop loop;
             auto cmd = new Commands::NewCertificateCommand();
             cmd->setParentWidget(d->parentWidgetOrView());
             cmd->setProtocol(GpgME::OpenPGP);
             loop.connect(cmd, SIGNAL(finished()), SLOT(quit()));
             QMetaObject::invokeMethod(cmd, &Commands::NewCertificateCommand::start, Qt::QueuedConnection);
             loop.exec();
         } else {
             Q_EMIT(canceled());
             d->finished();
             return;
         }
         Q_FOREACH (const Key &secKey, KeyCache::instance()->secretKeys()) {
             // Check again for secret keys
             if (secKey.canCertify() && secKey.protocol() == OpenPGP && !secKey.isRevoked() &&
                 !secKey.isExpired() && !secKey.isInvalid()) {
                 secKeys.push_back(secKey);
             }
         }
         if (secKeys.empty()) {
             qCDebug(KLEOPATRA_LOG) << "Sec Keys still empty after keygen.";
             Q_EMIT(canceled());
             d->finished();
             return;
         }
     }
     const Key &key = keys.front();
 
     for (const UserID &uid : qAsConst(d->uids))
         if (qstricmp(uid.parent().primaryFingerprint(), key.primaryFingerprint()) != 0) {
             qCWarning(KLEOPATRA_LOG) << "User-ID <-> Key mismatch!";
             d->finished();
             return;
         }
 
     d->ensureDialogCreated();
     Q_ASSERT(d->dialog);
 
     Key target = d->key();
 #ifdef GPGME_HAS_REMARKS
     if (!(target.keyListMode() & GpgME::SignatureNotations)) {
         target.update();
     }
 #endif
     d->dialog->setCertificateToCertify(target);
     if (d->uids.size()) {
         d->dialog->setSelectedUserIDs(d->uids);
     }
     d->dialog->show();
 }
 
 void CertifyCertificateCommand::Private::slotDialogRejected()
 {
     Q_EMIT q->canceled();
     finished();
 }
 
 void CertifyCertificateCommand::Private::slotResult(const Error &err)
 {
     if (!err && !err.isCanceled() && dialog && dialog->exportableCertificationSelected() && dialog->sendToServer()) {
-        ExportOpenPGPCertsToServerCommand *const cmd = new ExportOpenPGPCertsToServerCommand(key());
+        auto const cmd = new ExportOpenPGPCertsToServerCommand(key());
         cmd->start();
     } else if (!err) {
         information(i18n("Certification successful."),
                     i18n("Certification Succeeded"));
     } else {
         error(i18n("<p>An error occurred while trying to certify<br/><br/>"
                    "<b>%1</b>:</p><p>\t%2</p>",
               Formatting::formatForComboBox(key()),
               QString::fromUtf8(err.asString())),
               i18n("Certification Error"));
     }
     if (!dialog->tags().isEmpty()) {
         Tags::enableTags();
     }
 
     finished();
 }
 
 void CertifyCertificateCommand::Private::slotCertificationPrepared()
 {
     Q_ASSERT(dialog);
 
     createJob();
     Q_ASSERT(job);
     job->setExportable(dialog->exportableCertificationSelected());
     job->setNonRevocable(dialog->nonRevocableCertificationSelected());
     job->setUserIDsToSign(dialog->selectedUserIDs());
     job->setSigningKey(dialog->selectedSecretKey());
     job->setCheckLevel(dialog->selectedCheckLevel());
 #ifdef GPGME_HAS_REMARKS
     if (!dialog->tags().isEmpty()) {
         // do not set an empty remark to avoid an empty signature notation (GnuPG bug T5142)
         job->setRemark(dialog->tags());
     }
     // This also came with 1.14.0
     job->setDupeOk(true);
 #endif
 
     if (const Error err = job->start(key())) {
         slotResult(err);
     }
 }
 
 void CertifyCertificateCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG);
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 void CertifyCertificateCommand::Private::ensureDialogCreated()
 {
     if (dialog) {
         return;
     }
 
     dialog = new CertifyCertificateDialog;
     applyWindowID(dialog);
 
     connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
     connect(dialog, SIGNAL(accepted()), q, SLOT(slotCertificationPrepared()));
 }
 
 void CertifyCertificateCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     Q_ASSERT(key().protocol() == OpenPGP);
     const auto backend = QGpgME::openpgp();
     if (!backend) {
         return;
     }
 
     SignKeyJob *const j = backend->signKeyJob();
     if (!j) {
         return;
     }
 
     connect(j, &Job::progress,
             q, &Command::progress);
     connect(j, SIGNAL(result(GpgME::Error)),
             q, SLOT(slotResult(GpgME::Error)));
 
     job = j;
 }
 
 #undef d
 #undef q
 
 #include "moc_certifycertificatecommand.cpp"
diff --git a/src/commands/detailscommand.cpp b/src/commands/detailscommand.cpp
index a87da6882..b03d357fd 100644
--- a/src/commands/detailscommand.cpp
+++ b/src/commands/detailscommand.cpp
@@ -1,162 +1,162 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/detailscommand.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 "detailscommand.h"
 #include "command_p.h"
 
 #include <dialogs/certificatedetailswidget.h>
 
 #include "kleopatra_debug.h"
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 class DetailsCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::DetailsCommand;
     DetailsCommand *q_func() const
     {
         return static_cast<DetailsCommand *>(q);
     }
 public:
     explicit Private(DetailsCommand *qq, KeyListController *c);
     ~Private();
 
 private:
     void ensureDialogCreated()
     {
         if (dialog) {
             return;
         }
 
-        CertificateDetailsDialog *dlg = new CertificateDetailsDialog;
+        auto dlg = new CertificateDetailsDialog;
         applyWindowID(dlg);
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         connect(dlg, &QDialog::finished, q_func(), [this] (int) {
                 slotDialogClosed();
             });
 
         dialog = dlg;
     }
 
     void ensureDialogVisible()
     {
         ensureDialogCreated();
         if (dialog->isVisible()) {
             dialog->raise();
         } else {
             dialog->show();
         }
     }
 
     void init()
     {
         q->setWarnWhenRunningAtShutdown(false);
     }
 
 private:
     void slotDialogClosed();
 
 private:
     QPointer<CertificateDetailsDialog> dialog;
 };
 
 DetailsCommand::Private *DetailsCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const DetailsCommand::Private *DetailsCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define q q_func()
 #define d d_func()
 
 DetailsCommand::Private::Private(DetailsCommand *qq, KeyListController *c)
     : Command::Private(qq, c),
       dialog()
 {
 
 }
 
 DetailsCommand::Private::~Private() {}
 
 DetailsCommand::DetailsCommand(KeyListController *p)
     : Command(new Private(this, p))
 {
     d->init();
 }
 
 DetailsCommand::DetailsCommand(QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
     d->init();
 }
 
 DetailsCommand::DetailsCommand(const Key &key, KeyListController *p)
     : Command(new Private(this, p))
 {
     Q_ASSERT(!key.isNull());
     d->init();
     setKey(key);
 }
 
 DetailsCommand::DetailsCommand(const Key &key, QAbstractItemView *v, KeyListController *p)
     : Command(v, new Private(this, p))
 {
     Q_ASSERT(!key.isNull());
     d->init();
     setKey(key);
 }
 
 DetailsCommand::~DetailsCommand() {}
 
 void DetailsCommand::doStart()
 {
     const std::vector<Key> keys = d->keys();
     Key key;
     if (keys.size() == 1) {
         key = keys.front();
     } else {
         qCWarning(KLEOPATRA_LOG) << "can only work with one certificate at a time";
     }
 
     if (key.isNull()) {
         d->finished();
         return;
     }
 
     d->ensureDialogCreated();
 
     d->dialog->setKey(key);
 
     d->ensureDialogVisible();
 }
 
 void DetailsCommand::doCancel()
 {
     if (d->dialog) {
         d->dialog->close();
     }
 }
 
 void DetailsCommand::Private::slotDialogClosed()
 {
     finished();
 }
 
 #undef q_func
 #undef d_func
 
 #include "moc_detailscommand.cpp"
diff --git a/src/commands/lookupcertificatescommand.cpp b/src/commands/lookupcertificatescommand.cpp
index 8719c7f41..31ab1dead 100644
--- a/src/commands/lookupcertificatescommand.cpp
+++ b/src/commands/lookupcertificatescommand.cpp
@@ -1,404 +1,404 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/lookupcertificatescommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008, 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "lookupcertificatescommand.h"
 
 #include "importcertificatescommand_p.h"
 
 #include "detailscommand.h"
 
 #include <Libkleo/Compat>
 #include <Libkleo/GnuPG>
 
 #include <dialogs/lookupcertificatesdialog.h>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 #include <QGpgME/KeyListJob>
 #include <QGpgME/ImportFromKeyserverJob>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/importresult.h>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include "kleopatra_debug.h"
 
 #include <QRegExp>
 
 #include <vector>
 #include <map>
 #include <algorithm>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 using namespace QGpgME;
 
 class LookupCertificatesCommand::Private : public ImportCertificatesCommand::Private
 {
     friend class ::Kleo::Commands::LookupCertificatesCommand;
     LookupCertificatesCommand *q_func() const
     {
         return static_cast<LookupCertificatesCommand *>(q);
     }
 public:
     explicit Private(LookupCertificatesCommand *qq, KeyListController *c);
     ~Private();
 
     QString query;
     void init();
 
 private:
     void slotSearchTextChanged(const QString &str);
     void slotNextKey(const Key &key)
     {
         keyListing.keys.push_back(key);
     }
     void slotKeyListResult(const KeyListResult &result);
     void slotImportRequested(const std::vector<Key> &keys);
     void slotDetailsRequested(const Key &key);
     void slotSaveAsRequested(const std::vector<Key> &keys);
     void slotDialogRejected()
     {
         canceled();
     }
 
 private:
     using ImportCertificatesCommand::Private::showError;
     void showError(QWidget *parent, const KeyListResult &result);
     void showResult(QWidget *parent, const KeyListResult &result);
     void createDialog();
     KeyListJob *createKeyListJob(GpgME::Protocol proto) const
     {
         const auto cbp = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
         return cbp ? cbp->keyListJob(true) : nullptr;
     }
     ImportFromKeyserverJob *createImportJob(GpgME::Protocol proto) const
     {
         const auto cbp = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
         return cbp ? cbp->importFromKeyserverJob() : nullptr;
     }
     void startKeyListJob(GpgME::Protocol proto, const QString &str);
     bool checkConfig() const;
 
     QWidget *dialogOrParentWidgetOrView() const
     {
         if (dialog) {
             return dialog;
         } else {
             return parentWidgetOrView();
         }
     }
 
 private:
     QPointer<LookupCertificatesDialog> dialog;
     struct KeyListingVariables {
         QPointer<KeyListJob> cms, openpgp;
         KeyListResult result;
         std::vector<Key> keys;
 
         void reset()
         {
             *this = KeyListingVariables();
         }
     } keyListing;
 };
 
 LookupCertificatesCommand::Private *LookupCertificatesCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const LookupCertificatesCommand::Private *LookupCertificatesCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 LookupCertificatesCommand::Private::Private(LookupCertificatesCommand *qq, KeyListController *c)
     : ImportCertificatesCommand::Private(qq, c),
       dialog()
 {
 
 }
 
 LookupCertificatesCommand::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
     delete dialog;
 }
 
 LookupCertificatesCommand::LookupCertificatesCommand(KeyListController *c)
     : ImportCertificatesCommand(new Private(this, c))
 {
     d->init();
 }
 
 LookupCertificatesCommand::LookupCertificatesCommand(const QString &query, KeyListController *c)
     : ImportCertificatesCommand(new Private(this, c))
 {
     d->init();
     d->query = query;
 }
 
 LookupCertificatesCommand::LookupCertificatesCommand(QAbstractItemView *v, KeyListController *c)
     : ImportCertificatesCommand(v, new Private(this, c))
 {
     d->init();
 }
 
 void LookupCertificatesCommand::Private::init()
 {
 
 }
 
 LookupCertificatesCommand::~LookupCertificatesCommand()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void LookupCertificatesCommand::doStart()
 {
 
     if (!d->checkConfig()) {
         d->finished();
         return;
     }
 
     d->createDialog();
     Q_ASSERT(d->dialog);
 
     // if we have a prespecified query, load it into find field
     // and start the search
     if (!d->query.isEmpty()) {
         d->dialog->setSearchText(d->query);
         d->slotSearchTextChanged(d->query);
     } else {
         d->dialog->setPassive(false);
     }
 
     d->dialog->show();
 
 }
 
 void LookupCertificatesCommand::Private::createDialog()
 {
     if (dialog) {
         return;
     }
     dialog = new LookupCertificatesDialog;
     applyWindowID(dialog);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
     connect(dialog, SIGNAL(searchTextChanged(QString)),
             q, SLOT(slotSearchTextChanged(QString)));
     connect(dialog, SIGNAL(saveAsRequested(std::vector<GpgME::Key>)),
             q, SLOT(slotSaveAsRequested(std::vector<GpgME::Key>)));
     connect(dialog, SIGNAL(importRequested(std::vector<GpgME::Key>)),
             q, SLOT(slotImportRequested(std::vector<GpgME::Key>)));
     connect(dialog, SIGNAL(detailsRequested(GpgME::Key)),
             q, SLOT(slotDetailsRequested(GpgME::Key)));
     connect(dialog, SIGNAL(rejected()),
             q, SLOT(slotDialogRejected()));
 }
 
 void LookupCertificatesCommand::Private::slotSearchTextChanged(const QString &str)
 {
     // pressing return might trigger both search and dialog destruction (search focused and default key set)
     // On Windows, the dialog is then destroyed before this slot is called
     if (dialog) {   //thus test
         dialog->setPassive(true);
         dialog->setCertificates(std::vector<Key>());
     }
 
     query = str;
 
     startKeyListJob(CMS,     str);
 
     const QRegExp rx(QLatin1String("(?:0x|0X)?[0-9a-fA-F]{6,}"));
     if (rx.exactMatch(query) && !str.startsWith(QLatin1String("0x"), Qt::CaseInsensitive)) {
         qCDebug(KLEOPATRA_LOG) << "Adding 0x prefix to query";
         startKeyListJob(OpenPGP, QStringLiteral("0x") + str);
     } else {
         startKeyListJob(OpenPGP, str);
     }
 }
 
 void LookupCertificatesCommand::Private::startKeyListJob(GpgME::Protocol proto, const QString &str)
 {
     KeyListJob *const klj = createKeyListJob(proto);
     if (!klj) {
         return;
     }
     connect(klj, SIGNAL(result(GpgME::KeyListResult)),
             q, SLOT(slotKeyListResult(GpgME::KeyListResult)));
     connect(klj, SIGNAL(nextKey(GpgME::Key)),
             q, SLOT(slotNextKey(GpgME::Key)));
     if (const Error err = klj->start(QStringList(str))) {
         keyListing.result.mergeWith(KeyListResult(err));
     } else if (proto == CMS) {
         keyListing.cms     = klj;
     } else {
         keyListing.openpgp = klj;
     }
 }
 
 void LookupCertificatesCommand::Private::slotKeyListResult(const KeyListResult &r)
 {
 
     if (q->sender() == keyListing.cms) {
         keyListing.cms = nullptr;
     } else if (q->sender() == keyListing.openpgp) {
         keyListing.openpgp = nullptr;
     } else {
         qCDebug(KLEOPATRA_LOG) << "unknown sender()" << q->sender();
     }
 
     keyListing.result.mergeWith(r);
     if (keyListing.cms || keyListing.openpgp) { // still waiting for jobs to complete
         return;
     }
 
     if (keyListing.result.error() && !keyListing.result.error().isCanceled()) {
         showError(dialog, keyListing.result);
     }
 
     if (keyListing.result.isTruncated()) {
         showResult(dialog, keyListing.result);
     }
 
     if (dialog) {
         dialog->setPassive(false);
         dialog->setCertificates(keyListing.keys);
     } else {
         finished();
     }
 
     keyListing.reset();
 }
 
 void LookupCertificatesCommand::Private::slotImportRequested(const std::vector<Key> &keys)
 {
     dialog = nullptr;
 
     Q_ASSERT(!keys.empty());
     Q_ASSERT(std::none_of(keys.cbegin(), keys.cend(), [](const Key &key) { return key.isNull(); }));
 
     std::vector<Key> pgp, cms;
     pgp.reserve(keys.size());
     cms.reserve(keys.size());
     kdtools::separate_if(keys.begin(), keys.end(),
                          std::back_inserter(pgp),
                          std::back_inserter(cms),
                          [](const Key &key) {
                              return key.protocol() == GpgME::OpenPGP;
                          });
 
     setWaitForMoreJobs(true);
     if (!pgp.empty())
         startImport(OpenPGP, pgp,
-                    i18nc("@title %1:\"OpenPGP\" or \"CMS\"",
+                    i18nc(R"(@title %1:"OpenPGP" or "CMS")",
                           "%1 Certificate Server",
                           Formatting::displayName(OpenPGP)));
     if (!cms.empty())
         startImport(CMS, cms,
-                    i18nc("@title %1:\"OpenPGP\" or \"CMS\"",
+                    i18nc(R"(@title %1:"OpenPGP" or "CMS")",
                           "%1 Certificate Server",
                           Formatting::displayName(CMS)));
     setWaitForMoreJobs(false);
 }
 
 void LookupCertificatesCommand::Private::slotSaveAsRequested(const std::vector<Key> &keys)
 {
     Q_UNUSED(keys)
     qCDebug(KLEOPATRA_LOG) << "not implemented";
 }
 
 void LookupCertificatesCommand::Private::slotDetailsRequested(const Key &key)
 {
     Command *const cmd = new DetailsCommand(key, view(), controller());
     cmd->setParentWidget(dialogOrParentWidgetOrView());
     cmd->start();
 }
 
 void LookupCertificatesCommand::doCancel()
 {
     ImportCertificatesCommand::doCancel();
     if (QDialog *const dlg = d->dialog) {
         d->dialog = nullptr;
         dlg->close();
     }
 }
 
 void LookupCertificatesCommand::Private::showError(QWidget *parent, const KeyListResult &result)
 {
     if (!result.error()) {
         return;
     }
     KMessageBox::information(parent, i18nc("@info",
                                            "Failed to search on certificate server. The error returned was:\n%1",
                                            QString::fromLocal8Bit(result.error().asString())));
 }
 
 void LookupCertificatesCommand::Private::showResult(QWidget *parent, const KeyListResult &result)
 {
     if (result.isTruncated())
         KMessageBox::information(parent,
                                  xi18nc("@info",
                                         "<para>The query result has been truncated.</para>"
                                         "<para>Either the local or a remote limit on "
                                         "the maximum number of returned hits has "
                                         "been exceeded.</para>"
                                         "<para>You can try to increase the local limit "
                                         "in the configuration dialog, but if one "
                                         "of the configured servers is the limiting "
                                         "factor, you have to refine your search.</para>"),
                                  i18nc("@title", "Result Truncated"),
                                  QStringLiteral("lookup-certificates-truncated-result"));
 }
 
 static bool haveX509DirectoryServerConfigured()
 {
     const QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         return false;
     }
     const QGpgME::CryptoConfigEntry *entry = getCryptoConfigEntry(config, "dirmngr", "LDAP Server");
     bool entriesExist = entry && !entry->urlValueList().empty();
     entry = getCryptoConfigEntry(config, "gpgsm", "keyserver");
     entriesExist |= entry && !entry->urlValueList().empty();
     return entriesExist;
 }
 
 bool LookupCertificatesCommand::Private::checkConfig() const
 {
     const bool ok = haveKeyserverConfigured() || haveX509DirectoryServerConfigured();
     if (!ok)
         information(xi18nc("@info",
                            "<para>You do not have any directory servers configured.</para>"
                            "<para>You need to configure at least one directory server to "
                            "search on one.</para>"
                            "<para>You can configure directory servers here: "
                            "<interface>Settings->Configure Kleopatra</interface>.</para>"),
                     i18nc("@title", "No Directory Servers Configured"));
     return ok;
 }
 
 #undef d
 #undef q
 
 #include "moc_lookupcertificatescommand.cpp"
diff --git a/src/commands/revokecertificationcommand.cpp b/src/commands/revokecertificationcommand.cpp
index e59c31c60..a77ff69c0 100644
--- a/src/commands/revokecertificationcommand.cpp
+++ b/src/commands/revokecertificationcommand.cpp
@@ -1,254 +1,254 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/revokecertificationcommand.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "revokecertificationcommand.h"
 
 #include "command_p.h"
 
 #include "exportopenpgpcertstoservercommand.h"
 #include "dialogs/revokecertificationdialog.h"
 
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyCache>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/QuickJob>
 
 #include <gpgme++/engineinfo.h>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E01 // 1.14.1
 # define GPGME_HAS_REVSIG
 #endif
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 using namespace QGpgME;
 
 class RevokeCertificationCommand::Private : public Command::Private
 {
     friend class ::Kleo::Commands::RevokeCertificationCommand;
     RevokeCertificationCommand *q_func() const
     {
         return static_cast<RevokeCertificationCommand *>(q);
     }
 public:
     explicit Private(RevokeCertificationCommand *qq, KeyListController *c);
     ~Private();
 
     void init();
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
     void slotResult(const Error &err);
 
 private:
     void ensureDialogCreated();
     void createJob();
 
 private:
     Key certificationKey;
     Key certificationTarget;
     std::vector<UserID> uids;
     QPointer<RevokeCertificationDialog> dialog;
     QPointer<QGpgME::QuickJob> job;
 };
 
 RevokeCertificationCommand::Private *RevokeCertificationCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const RevokeCertificationCommand::Private *RevokeCertificationCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define d d_func()
 #define q q_func()
 
 RevokeCertificationCommand::Private::Private(RevokeCertificationCommand *qq, KeyListController *c)
     : Command::Private(qq, c)
 {
 }
 
 RevokeCertificationCommand::Private::~Private()
 {
 }
 
 void RevokeCertificationCommand::Private::init()
 {
     const std::vector<Key> keys_ = keys();
     if (keys_.size() != 1) {
         qCWarning(KLEOPATRA_LOG) << "RevokeCertificationCommand::Private::init: Expected exactly one key, but got" << keys_.size();
         return;
     }
     if (keys_.front().protocol() != GpgME::OpenPGP) {
         qCWarning(KLEOPATRA_LOG) << "RevokeCertificationCommand::Private::init: Expected OpenPGP key, but got" << keys_.front().protocolAsString();
         return;
     }
     certificationTarget = keys_.front();
 }
 
 void RevokeCertificationCommand::Private::slotDialogAccepted()
 {
     createJob();
 
 #ifdef GPGME_HAS_REVSIG
     job->startRevokeSignature(certificationTarget, dialog->selectedCertificationKey(), dialog->selectedUserIDs());
 #endif
 }
 
 void RevokeCertificationCommand::Private::slotDialogRejected()
 {
     canceled();
 }
 
 void RevokeCertificationCommand::Private::slotResult(const Error &err)
 {
     if (err.isCanceled()) {
         // do nothing
     } else if (err) {
         error(i18n("<p>An error occurred while trying to revoke the certification of<br/><br/>"
                    "<b>%1</b>:</p><p>\t%2</p>",
                    Formatting::formatForComboBox(certificationTarget),
                    QString::fromUtf8(err.asString())),
               i18n("Revocation Error"));
     } else {
         information(i18n("Revocation successful."),
                     i18n("Revocation Succeeded"));
         if (dialog && dialog->sendToServer()) {
-            ExportOpenPGPCertsToServerCommand *const cmd = new ExportOpenPGPCertsToServerCommand(certificationTarget);
+            auto const cmd = new ExportOpenPGPCertsToServerCommand(certificationTarget);
             cmd->start();
         }
     }
 
     finished();
 }
 
 void RevokeCertificationCommand::Private::ensureDialogCreated()
 {
     if (dialog) {
         return;
     }
 
     dialog = new RevokeCertificationDialog;
     applyWindowID(dialog);
     dialog->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(dialog, SIGNAL(accepted()), q, SLOT(slotDialogAccepted()));
     connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
 }
 
 void RevokeCertificationCommand::Private::createJob()
 {
     Q_ASSERT(!job);
 
     Q_ASSERT(certificationTarget.protocol() == OpenPGP);
     const auto backend = QGpgME::openpgp();
     if (!backend) {
         return;
     }
 
     QuickJob *const j = backend->quickJob();
     if (!j) {
         return;
     }
 
     connect(j, &Job::progress,
             q, &Command::progress);
     connect(j, SIGNAL(result(GpgME::Error)),
             q, SLOT(slotResult(GpgME::Error)));
 
     job = j;
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(QAbstractItemView *v, KeyListController *c)
     : Command(v, new Private(this, c))
 {
     d->init();
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::UserID &uid)
     : Command(uid.parent(), new Private(this, nullptr))
 {
     std::vector<UserID>(1, uid).swap(d->uids);
     d->init();
 }
 
 RevokeCertificationCommand::RevokeCertificationCommand(const GpgME::UserID::Signature &signature)
     : Command(signature.parent().parent(), new Private(this, nullptr))
 {
     std::vector<UserID>(1, signature.parent()).swap(d->uids);
     d->certificationKey = KeyCache::instance()->findByKeyIDOrFingerprint(signature.signerKeyID());
     d->init();
 }
 
 RevokeCertificationCommand::~RevokeCertificationCommand()
 {
     qCDebug(KLEOPATRA_LOG) << "~RevokeCertificationCommand()";
 }
 
 // static
 bool RevokeCertificationCommand::isSupported()
 {
 #ifdef GPGME_HAS_REVSIG
     return engineInfo(GpgEngine).engineVersion() >= "2.2.24";
 #else
     return false;
 #endif
 }
 
 void RevokeCertificationCommand::doStart()
 {
     if (d->certificationTarget.isNull()) {
         d->finished();
         return;
     }
 
     for (const UserID &uid : qAsConst(d->uids))
         if (qstricmp(uid.parent().primaryFingerprint(), d->certificationTarget.primaryFingerprint()) != 0) {
             qCWarning(KLEOPATRA_LOG) << "User-ID <-> Key mismatch!";
             d->finished();
             return;
         }
 
     d->ensureDialogCreated();
     Q_ASSERT(d->dialog);
 
     d->dialog->setCertificateToRevoke(d->certificationTarget);
     if (!d->uids.empty()) {
         d->dialog->setSelectedUserIDs(d->uids);
     }
     if (!d->certificationKey.isNull()) {
         d->dialog->setSelectedCertificationKey(d->certificationKey);
     }
     d->dialog->show();
 }
 
 void RevokeCertificationCommand::doCancel()
 {
     qCDebug(KLEOPATRA_LOG) << "RevokeCertificationCommand::doCancel()";
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 #undef d
 #undef q
 
 #include "moc_revokecertificationcommand.cpp"
diff --git a/src/commands/setinitialpincommand.cpp b/src/commands/setinitialpincommand.cpp
index 9b54bbd39..c687bcc11 100644
--- a/src/commands/setinitialpincommand.cpp
+++ b/src/commands/setinitialpincommand.cpp
@@ -1,178 +1,178 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     commands/setinitialpincommand.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 "setinitialpincommand.h"
 #include "cardcommand_p.h"
 
 #include "dialogs/setinitialpindialog.h"
 
 #include "smartcard/netkeycard.h"
 #include "smartcard/readerstatus.h"
 
 #include <KLocalizedString>
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 using namespace Kleo::SmartCard;
 using namespace GpgME;
 
 class SetInitialPinCommand::Private : public CardCommand::Private
 {
     friend class ::Kleo::Commands::SetInitialPinCommand;
     SetInitialPinCommand *q_func() const
     {
         return static_cast<SetInitialPinCommand *>(q);
     }
 public:
     explicit Private(SetInitialPinCommand *qq, const std::string &serialNumber);
     ~Private();
 
 private:
     void init()
     {
     }
 
     void ensureDialogCreated() const
     {
         if (dialog) {
             return;
         }
 
-        SetInitialPinDialog *dlg = new SetInitialPinDialog;
+        auto dlg = new SetInitialPinDialog;
         applyWindowID(dlg);
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         dlg->setWindowTitle(i18nc("@title:window", "Set Initial Pin"));
 
         connect(dlg, SIGNAL(nksPinRequested()), q_func(), SLOT(slotNksPinRequested()));
         connect(dlg, SIGNAL(sigGPinRequested()), q_func(), SLOT(slotSigGPinRequested()));
         connect(dlg, SIGNAL(rejected()), q_func(), SLOT(slotDialogRejected()));
         connect(dlg, SIGNAL(accepted()), q_func(), SLOT(slotDialogAccepted()));
 
         dialog = dlg;
     }
 
     void ensureDialogVisible()
     {
         ensureDialogCreated();
         if (dialog->isVisible()) {
             dialog->raise();
         } else {
             dialog->show();
         }
     }
 
 private:
     void setInitialPin(const char *pinRef, const char *resultSlot)
     {
         const auto nksCard = ReaderStatus::instance()->getCard<NetKeyCard>(serialNumber());
         if (!nksCard) {
             error(i18n("Failed to find the NetKey card with the serial number: %1", QString::fromStdString(serialNumber())));
             return;
         }
 
         const QByteArray command = QByteArray("SCD PASSWD --nullpin ") + pinRef;
         ReaderStatus::mutableInstance()->startSimpleTransaction(nksCard, command, dialog, resultSlot);
     }
 
     void slotNksPinRequested()
     {
         setInitialPin("PW1.CH", "setNksPinSettingResult");
     }
 
     void slotSigGPinRequested()
     {
         setInitialPin("PW1.CH.SIG", "setSigGPinSettingResult");
     }
 
     void slotDialogRejected()
     {
         if (dialog->isComplete()) {
             slotDialogAccepted();
         } else {
             canceled();
         }
     }
     void slotDialogAccepted()
     {
         ReaderStatus::mutableInstance()->updateStatus();
         finished();
     }
 
 private:
     mutable QPointer<SetInitialPinDialog> dialog;
 };
 
 SetInitialPinCommand::Private *SetInitialPinCommand::d_func()
 {
     return static_cast<Private *>(d.get());
 }
 const SetInitialPinCommand::Private *SetInitialPinCommand::d_func() const
 {
     return static_cast<const Private *>(d.get());
 }
 
 #define q q_func()
 #define d d_func()
 
 SetInitialPinCommand::Private::Private(SetInitialPinCommand *qq, const std::string &serialNumber)
     : CardCommand::Private(qq, serialNumber, nullptr),
       dialog()
 {
 }
 
 SetInitialPinCommand::Private::~Private() {}
 
 SetInitialPinCommand::SetInitialPinCommand(const std::string &serialNumber)
     : CardCommand(new Private(this, serialNumber))
 {
     d->init();
 }
 
 SetInitialPinCommand::~SetInitialPinCommand() {}
 
 QDialog *SetInitialPinCommand::dialog() const
 {
     d->ensureDialogCreated();
     return d->dialog;
 }
 
 void SetInitialPinCommand::doStart()
 {
     d->ensureDialogCreated();
 
     const auto nksCard = ReaderStatus::instance()->getCard<NetKeyCard>(d->serialNumber());
     if (!nksCard) {
         d->error(i18n("Failed to find the NetKey card with the serial number: %1", QString::fromStdString(d->serialNumber())));
         d->dialog->close();
         finished();
         return;
     }
 
     const std::vector<Card::PinState> pinStates = nksCard->pinStates();
     d->dialog->setNksPinPresent(pinStates.size() >= 1 && pinStates[0] != Card::NullPin);
     d->dialog->setSigGPinPresent(pinStates.size() >= 3 && pinStates[2] != Card::NullPin);
 
     d->ensureDialogVisible();
 }
 
 void SetInitialPinCommand::doCancel()
 {
     if (d->dialog) {
         d->dialog->close();
     }
 }
 
 #undef q_func
 #undef d_func
 
 #include "moc_setinitialpincommand.cpp"
diff --git a/src/conf/appearanceconfigpage.cpp b/src/conf/appearanceconfigpage.cpp
index f43f368f1..57ffc6237 100644
--- a/src/conf/appearanceconfigpage.cpp
+++ b/src/conf/appearanceconfigpage.cpp
@@ -1,59 +1,59 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/appearanceconfigpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2004, 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 #include "appearanceconfigpage.h"
 
 #include "appearanceconfigwidget.h"
 
 
 #include <QVBoxLayout>
 
 using namespace Kleo;
 using namespace Kleo::Config;
 
 AppearanceConfigurationPage::AppearanceConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
-    QVBoxLayout *lay = new QVBoxLayout(this);
+    auto lay = new QVBoxLayout(this);
     mWidget = new AppearanceConfigWidget(this);
     lay->addWidget(mWidget);
 
     connect(mWidget, &AppearanceConfigWidget::changed, this, &Kleo::Config::AppearanceConfigurationPage::markAsChanged);
 
     load();
 }
 
 void AppearanceConfigurationPage::load()
 {
     mWidget->load();
 }
 
 void AppearanceConfigurationPage::save()
 {
     mWidget->save();
 
 }
 
 void AppearanceConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C"
 {
     Q_DECL_EXPORT KCModule *create_kleopatra_config_appear(QWidget *parent = nullptr, const QVariantList &args = QVariantList())
     {
-        AppearanceConfigurationPage *page =
+        auto page =
             new AppearanceConfigurationPage(parent, args);
         page->setObjectName(QStringLiteral("kleopatra_config_appear"));
         return page;
     }
 }
 
diff --git a/src/conf/appearanceconfigwidget.cpp b/src/conf/appearanceconfigwidget.cpp
index d1b1664ba..8d4f99638 100644
--- a/src/conf/appearanceconfigwidget.cpp
+++ b/src/conf/appearanceconfigwidget.cpp
@@ -1,631 +1,631 @@
 /*
     appearanceconfigwidget.cpp
 
     This file is part of kleopatra, the KDE key manager
     SPDX-FileCopyrightText: 2002, 2004, 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2002, 2003 Marc Mutz <mutz@kde.org>
 
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include <config-kleopatra.h>
 
 #include "appearanceconfigwidget.h"
 #include "ui_appearanceconfigwidget.h"
 
 #include "tagspreferences.h"
 #include "tooltippreferences.h"
 
 #include <QGpgME/Protocol>
 #include <Libkleo/KeyFilterManager>
 #include <Libkleo/Dn>
 #include <Libkleo/DNAttributeOrderConfigWidget>
 
 #include <KIconDialog>
 #include <QIcon>
 
 #include <KConfig>
 #include <KLocalizedString>
 #include <KConfigGroup>
 
 #include <QColor>
 #include <QFont>
 #include <QString>
 #include <QRegularExpression>
 #include <QApplication>
 #include <QColorDialog>
 #include <QFontDialog>
 
 #include <algorithm>
 
 using namespace Kleo;
 using namespace Kleo::Config;
 
 enum {
     HasNameRole = Qt::UserRole + 0x1234, /*!< Records that the user has assigned a name (to avoid comparing with i18n-strings) */
     HasFontRole,                         /*!< Records that the user has chosen  completely different font (as opposed to italic/bold/strikeout) */
     IconNameRole,                        /*!< Records the name of the icon (since QIcon won't give it out again, once set) */
     MayChangeNameRole,
     MayChangeForegroundRole,
     MayChangeBackgroundRole,
     MayChangeFontRole,
     MayChangeItalicRole,
     MayChangeBoldRole,
     MayChangeStrikeOutRole,
     MayChangeIconRole,
 
     EndDummy
 };
 
 static QFont tryToFindFontFor(const QListWidgetItem *item)
 {
     if (item)
         if (const QListWidget *const lw = item->listWidget()) {
             return lw->font();
         }
     return QApplication::font("QListWidget");
 }
 
 static bool is(const QListWidgetItem *item, bool (QFont::*func)() const)
 {
     if (!item) {
         return false;
     }
     const QVariant v = item->data(Qt::FontRole);
     if (!v.isValid() || v.type() != QVariant::Font) {
         return false;
     }
     return (v.value<QFont>().*func)();
 }
 
 static bool is_italic(const QListWidgetItem *item)
 {
     return is(item, &QFont::italic);
 }
 static bool is_bold(const QListWidgetItem *item)
 {
     return is(item, &QFont::bold);
 }
 static bool is_strikeout(const QListWidgetItem *item)
 {
     return is(item, &QFont::strikeOut);
 }
 
 static void set(QListWidgetItem *item, bool on, void (QFont::*func)(bool))
 {
     if (!item) {
         return;
     }
     const QVariant v = item->data(Qt::FontRole);
     QFont font = v.isValid() && v.type() == QVariant::Font ? v.value<QFont>() : tryToFindFontFor(item);
     (font.*func)(on);
     item->setData(Qt::FontRole, font);
 }
 
 static void set_italic(QListWidgetItem *item, bool on)
 {
     set(item, on, &QFont::setItalic);
 }
 static void set_bold(QListWidgetItem *item, bool on)
 {
     set(item, on, &QFont::setBold);
 }
 static void set_strikeout(QListWidgetItem *item, bool on)
 {
     set(item, on, &QFont::setStrikeOut);
 }
 
 static void apply_config(const KConfigGroup &group, QListWidgetItem *item)
 {
     if (!item) {
         return;
     }
 
     const QString name = group.readEntry("Name");
     item->setText(name.isEmpty() ? i18nc("Key filter without user-assigned name", "<unnamed>") : name);
     item->setData(HasNameRole, !name.isEmpty());
     item->setData(MayChangeNameRole, !group.isEntryImmutable("Name"));
 
     const QColor fg = group.readEntry("foreground-color", QColor());
     item->setData(Qt::ForegroundRole, fg.isValid() ? QBrush(fg) : QVariant());
     item->setData(MayChangeForegroundRole, !group.isEntryImmutable("foreground-color"));
 
     const QColor bg = group.readEntry("background-color", QColor());
     item->setData(Qt::BackgroundRole, bg.isValid() ? QBrush(bg) : QVariant());
     item->setData(MayChangeBackgroundRole, !group.isEntryImmutable("background-color"));
 
     const QFont defaultFont = tryToFindFontFor(item);
     if (group.hasKey("font")) {
         const QFont font = group.readEntry("font", defaultFont);
         item->setData(Qt::FontRole, font != defaultFont ? font : QVariant());
         item->setData(HasFontRole,  font != defaultFont);
     } else {
         QFont font = defaultFont;
         font.setStrikeOut(group.readEntry("font-strikeout", false));
         font.setItalic(group.readEntry("font-italic", false));
         font.setBold(group.readEntry("font-bold", false));
         item->setData(Qt::FontRole, font);
         item->setData(HasFontRole, false);
     }
     item->setData(MayChangeFontRole, !group.isEntryImmutable("font"));
     item->setData(MayChangeItalicRole, !group.isEntryImmutable("font-italic"));
     item->setData(MayChangeBoldRole, !group.isEntryImmutable("font-bold"));
     item->setData(MayChangeStrikeOutRole, !group.isEntryImmutable("font-strikeout"));
 
     const QString iconName = group.readEntry("icon");
     item->setData(Qt::DecorationRole, iconName.isEmpty() ? QVariant() : QIcon::fromTheme(iconName));
     item->setData(IconNameRole, iconName.isEmpty() ? QVariant() : iconName);
     item->setData(MayChangeIconRole, !group.isEntryImmutable("icon"));
 }
 
 static void erase_if_allowed(QListWidgetItem *item, int role, int allowRole)
 {
     if (item && item->data(allowRole).toBool()) {
         item->setData(role, QVariant());
     }
 }
 
 #if 0
 static void erase_if_allowed(QListWidgetItem *item, const int role[], size_t numRoles, int allowRole)
 {
     if (item && item->data(allowRole).toBool())
         for (unsigned int i = 0; i < numRoles; ++i) {
             item->setData(role[i], QVariant());
         }
 }
 
 static void erase_if_allowed(QListWidgetItem *item, int role, const int allowRole[], size_t numAllowRoles)
 {
     if (!item) {
         return;
     }
     for (unsigned int i = 0; i < numAllowRoles; ++i)
         if (!item->data(allowRole[i]).toBool()) {
             return;
         }
     item->setData(role, QVariant());
 }
 #endif
 
 static void erase_if_allowed(QListWidgetItem *item, const int role[], size_t numRoles, const int allowRole[], size_t numAllowRoles)
 {
     if (!item) {
         return;
     }
     for (unsigned int i = 0; i < numAllowRoles; ++i)
         if (!item->data(allowRole[i]).toBool()) {
             return;
         }
     for (unsigned int i = 0; i < numRoles; ++i) {
         item->setData(role[i], QVariant());
     }
 }
 
 static void set_default_appearance(QListWidgetItem *item)
 {
     if (!item) {
         return;
     }
     erase_if_allowed(item, Qt::ForegroundRole, MayChangeForegroundRole);
     erase_if_allowed(item, Qt::BackgroundRole, MayChangeBackgroundRole);
     erase_if_allowed(item, Qt::DecorationRole, MayChangeIconRole);
     static const int fontRoles[] = { Qt::FontRole, HasFontRole };
     static const int fontAllowRoles[] = {
         MayChangeFontRole,
         MayChangeItalicRole,
         MayChangeBoldRole,
         MayChangeStrikeOutRole,
     };
     erase_if_allowed(item, fontRoles, sizeof(fontRoles) / sizeof(int), fontAllowRoles, sizeof(fontAllowRoles) / sizeof(int));
 }
 
 static void writeOrDelete(KConfigGroup &group, const char *key, const QVariant &value)
 {
     if (value.isValid()) {
         group.writeEntry(key, value);
     } else {
         group.deleteEntry(key);
     }
 }
 
 static QVariant brush2color(const QVariant &v)
 {
     if (v.isValid()) {
         if (v.type() == QVariant::Color) {
             return v;
         } else if (v.type() == QVariant::Brush) {
             return v.value<QBrush>().color();
         }
     }
     return QVariant();
 }
 
 static void save_to_config(const QListWidgetItem *item, KConfigGroup &group)
 {
     if (!item) {
         return;
     }
     writeOrDelete(group, "Name", item->data(HasNameRole).toBool() ? item->text() : QVariant());
     writeOrDelete(group, "foreground-color", brush2color(item->data(Qt::ForegroundRole)));
     writeOrDelete(group, "background-color", brush2color(item->data(Qt::BackgroundRole)));
     writeOrDelete(group, "icon", item->data(IconNameRole));
 
     group.deleteEntry("font");
     group.deleteEntry("font-strikeout");
     group.deleteEntry("font-italic");
     group.deleteEntry("font-bold");
 
     if (item->data(HasFontRole).toBool()) {
         writeOrDelete(group, "font", item->data(Qt::FontRole));
         return;
     }
 
     if (is_strikeout(item)) {
         group.writeEntry("font-strikeout", true);
     }
     if (is_italic(item)) {
         group.writeEntry("font-italic", true);
     }
     if (is_bold(item)) {
         group.writeEntry("font-bold", true);
     }
 }
 
 static void kiosk_enable(QWidget *w, const QListWidgetItem *item, int allowRole)
 {
     if (!w) {
         return;
     }
     if (item && !item->data(allowRole).toBool()) {
         w->setEnabled(false);
         w->setToolTip(i18n("This parameter has been locked down by the system administrator."));
     } else {
         w->setEnabled(item);
         w->setToolTip(QString());
     }
 }
 
 class AppearanceConfigWidget::Private : public Ui_AppearanceConfigWidget
 {
     friend class ::Kleo::Config::AppearanceConfigWidget;
     AppearanceConfigWidget *const q;
 public:
     explicit Private(AppearanceConfigWidget *qq)
         : Ui_AppearanceConfigWidget(),
           q(qq),
           dnOrderWidget(nullptr)
     {
         setupUi(q);
 
         if (QLayout *const l = q->layout()) {
             l->setContentsMargins(0, 0, 0, 0);
         }
 
-        QWidget *w = new QWidget;
+        auto w = new QWidget;
         dnOrderWidget = Kleo::DNAttributeMapper::instance()->configWidget(w);
         dnOrderWidget->setObjectName(QStringLiteral("dnOrderWidget"));
         (new QVBoxLayout(w))->addWidget(dnOrderWidget);
 
         tabWidget->addTab(w, i18n("DN-Attribute Order"));
 
         connect(dnOrderWidget, &DNAttributeOrderConfigWidget::changed, q, &AppearanceConfigWidget::changed);
 
         connect(iconButton, SIGNAL(clicked()), q, SLOT(slotIconClicked()));
 #ifndef QT_NO_COLORDIALOG
         connect(foregroundButton, SIGNAL(clicked()), q, SLOT(slotForegroundClicked()));
         connect(backgroundButton, SIGNAL(clicked()), q, SLOT(slotBackgroundClicked()));
 #else
         foregroundButton->hide();
         backgroundButton->hide();
 #endif
 #ifndef QT_NO_FONTDIALOG
         connect(fontButton, SIGNAL(clicked()), q, SLOT(slotFontClicked()));
 #else
         fontButton->hide();
 #endif
         connect(categoriesLV, SIGNAL(itemSelectionChanged()), q, SLOT(slotSelectionChanged()));
         connect(defaultLookPB, SIGNAL(clicked()), q, SLOT(slotDefaultClicked()));
         connect(italicCB, SIGNAL(toggled(bool)), q, SLOT(slotItalicToggled(bool)));
         connect(boldCB, SIGNAL(toggled(bool)), q, SLOT(slotBoldToggled(bool)));
         connect(strikeoutCB, SIGNAL(toggled(bool)), q, SLOT(slotStrikeOutToggled(bool)));
         connect(tooltipValidityCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipValidityChanged(bool)));
         connect(tooltipOwnerCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipOwnerChanged(bool)));
         connect(tooltipDetailsCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotTooltipDetailsChanged(bool)));
         connect(useTagsCheckBox, SIGNAL(toggled(bool)), q, SLOT(slotUseTagsChanged(bool)));
     }
 
 private:
     void enableDisableActions(QListWidgetItem *item);
     QListWidgetItem *selectedItem() const;
 
 private:
     void slotIconClicked();
 #ifndef QT_NO_COLORDIALOG
     void slotForegroundClicked();
     void slotBackgroundClicked();
 #endif
 #ifndef QT_NO_FONTDIALOG
     void slotFontClicked();
 #endif
     void slotSelectionChanged();
     void slotDefaultClicked();
     void slotItalicToggled(bool);
     void slotBoldToggled(bool);
     void slotStrikeOutToggled(bool);
     void slotTooltipValidityChanged(bool);
     void slotTooltipOwnerChanged(bool);
     void slotTooltipDetailsChanged(bool);
     void slotUseTagsChanged(bool);
 
 private:
     Kleo::DNAttributeOrderConfigWidget *dnOrderWidget;
 };
 
 AppearanceConfigWidget::AppearanceConfigWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f), d(new Private(this))
 {
 //    load();
 }
 
 AppearanceConfigWidget::~AppearanceConfigWidget() {}
 
 void AppearanceConfigWidget::Private::slotSelectionChanged()
 {
     enableDisableActions(selectedItem());
 }
 
 QListWidgetItem *AppearanceConfigWidget::Private::selectedItem() const
 {
     const QList<QListWidgetItem *> items = categoriesLV->selectedItems();
     return items.empty() ? nullptr : items.front();
 }
 
 void AppearanceConfigWidget::Private::enableDisableActions(QListWidgetItem *item)
 {
     kiosk_enable(iconButton, item, MayChangeIconRole);
 #ifndef QT_NO_COLORDIALOG
     kiosk_enable(foregroundButton, item, MayChangeForegroundRole);
     kiosk_enable(backgroundButton, item, MayChangeBackgroundRole);
 #endif
 #ifndef QT_NO_FONTDIALOG
     kiosk_enable(fontButton, item, MayChangeFontRole);
 #endif
     kiosk_enable(italicCB, item, MayChangeItalicRole);
     kiosk_enable(boldCB, item, MayChangeBoldRole);
     kiosk_enable(strikeoutCB, item, MayChangeStrikeOutRole);
 
     defaultLookPB->setEnabled(item);
 
     italicCB->setChecked(is_italic(item));
     boldCB->setChecked(is_bold(item));
     strikeoutCB->setChecked(is_strikeout(item));
 }
 
 void AppearanceConfigWidget::Private::slotDefaultClicked()
 {
 
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     set_default_appearance(item);
     enableDisableActions(item);
 
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::defaults()
 {
 
     // This simply means "default look for every category"
     for (int i = 0, end = d->categoriesLV->count(); i != end; ++i) {
         set_default_appearance(d->categoriesLV->item(i));
     }
     d->tooltipValidityCheckBox->setChecked(true);
     d->tooltipOwnerCheckBox->setChecked(false);
     d->tooltipDetailsCheckBox->setChecked(false);
 
     d->dnOrderWidget->defaults();
 
     Q_EMIT changed();
 }
 
 void AppearanceConfigWidget::load()
 {
 
     d->dnOrderWidget->load();
 
     d->categoriesLV->clear();
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
     if (!config) {
         return;
     }
     const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
     for (const QString &group : groups) {
         //QListWidgetItem * item = new QListWidgetItem( d->categoriesLV );
         apply_config(KConfigGroup(config, group), new QListWidgetItem(d->categoriesLV));
     }
 
     const TooltipPreferences prefs;
     d->tooltipValidityCheckBox->setChecked(prefs.showValidity());
     d->tooltipOwnerCheckBox->setChecked(prefs.showOwnerInformation());
     d->tooltipDetailsCheckBox->setChecked(prefs.showCertificateDetails());
 
     const TagsPreferences tagsPrefs;
     d->useTagsCheckBox->setChecked(tagsPrefs.useTags());
 }
 
 void AppearanceConfigWidget::save()
 {
 
     d->dnOrderWidget->save();
 
     TooltipPreferences prefs;
     prefs.setShowValidity(d->tooltipValidityCheckBox->isChecked());
     prefs.setShowOwnerInformation(d->tooltipOwnerCheckBox->isChecked());
     prefs.setShowCertificateDetails(d->tooltipDetailsCheckBox->isChecked());
     prefs.save();
 
     KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"));
     if (!config) {
         return;
     }
     // We know (assume) that the groups in the config object haven't changed,
     // so we just iterate over them and over the listviewitems, and map one-to-one.
     const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Key Filter #\\d+$")));
 #if 0
     if (groups.isEmpty()) {
         // If we created the default categories ourselves just now, then we need to make up their list
         Q3ListViewItemIterator lvit(categoriesLV);
         for (; lvit.current(); ++lvit) {
             groups << lvit.current()->text(0);
         }
     }
 #endif
     for (int i = 0, end = std::min(groups.size(), d->categoriesLV->count()); i != end; ++i) {
         const QListWidgetItem *const item = d->categoriesLV->item(i);
         Q_ASSERT(item);
         KConfigGroup group(config, groups[i]);
         save_to_config(item, group);
     }
 
     TagsPreferences tagsPrefs;
     tagsPrefs.setUseTags(d->useTagsCheckBox->isChecked());
 
     config->sync();
     KeyFilterManager::instance()->reload();
 }
 
 void AppearanceConfigWidget::Private::slotIconClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QString iconName = KIconDialog::getIcon( /* repeating default arguments begin */
                                  KIconLoader::Desktop, KIconLoader::Application, false, 0, false,
                                  /* repeating default arguments end */
                                  q);
     if (iconName.isEmpty()) {
         return;
     }
 
     item->setIcon(QIcon::fromTheme(iconName));
     item->setData(IconNameRole, iconName);
     Q_EMIT q->changed();
 }
 
 #ifndef QT_NO_COLORDIALOG
 void AppearanceConfigWidget::Private::slotForegroundClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QVariant v = brush2color(item->data(Qt::ForegroundRole));
 
     const QColor initial = v.isValid() ? v.value<QColor>() : categoriesLV->palette().color(QPalette::Normal, QPalette::Text);
     const QColor c = QColorDialog::getColor(initial, q);
 
     if (c.isValid()) {
         item->setData(Qt::ForegroundRole, QBrush(c));
         Q_EMIT q->changed();
     }
 }
 
 void AppearanceConfigWidget::Private::slotBackgroundClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QVariant v = brush2color(item->data(Qt::BackgroundRole));
 
     const QColor initial = v.isValid() ? v.value<QColor>() : categoriesLV->palette().color(QPalette::Normal, QPalette::Base);
     const QColor c = QColorDialog::getColor(initial, q);
 
     if (c.isValid()) {
         item->setData(Qt::BackgroundRole, QBrush(c));
         Q_EMIT q->changed();
     }
 }
 #endif // QT_NO_COLORDIALOG
 
 #ifndef QT_NO_FONTDIALOG
 void AppearanceConfigWidget::Private::slotFontClicked()
 {
     QListWidgetItem *const item = selectedItem();
     if (!item) {
         return;
     }
 
     const QVariant v = item->data(Qt::FontRole);
 
     bool ok = false;
     const QFont defaultFont = tryToFindFontFor(item);
     const QFont initial = v.isValid() && v.type() == QVariant::Font ? v.value<QFont>() : defaultFont;
     QFont f = QFontDialog::getFont(&ok, initial, q);
     if (!ok) {
         return;
     }
 
     // disallow circumventing KIOSK:
     if (!item->data(MayChangeItalicRole).toBool()) {
         f.setItalic(initial.italic());
     }
     if (!item->data(MayChangeBoldRole).toBool()) {
         f.setBold(initial.bold());
     }
     if (!item->data(MayChangeStrikeOutRole).toBool()) {
         f.setStrikeOut(initial.strikeOut());
     }
 
     item->setData(Qt::FontRole, f != defaultFont ? f : QVariant());
     item->setData(HasFontRole, true);
     Q_EMIT q->changed();
 }
 #endif // QT_NO_FONTDIALOG
 
 void AppearanceConfigWidget::Private::slotItalicToggled(bool on)
 {
     set_italic(selectedItem(), on);
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotBoldToggled(bool on)
 {
     set_bold(selectedItem(), on);
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotStrikeOutToggled(bool on)
 {
     set_strikeout(selectedItem(), on);
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotTooltipValidityChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotTooltipOwnerChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotTooltipDetailsChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 void AppearanceConfigWidget::Private::slotUseTagsChanged(bool)
 {
     Q_EMIT q->changed();
 }
 
 #include "moc_appearanceconfigwidget.cpp"
diff --git a/src/conf/cryptooperationsconfigpage.cpp b/src/conf/cryptooperationsconfigpage.cpp
index d2200c66b..5571d4c75 100644
--- a/src/conf/cryptooperationsconfigpage.cpp
+++ b/src/conf/cryptooperationsconfigpage.cpp
@@ -1,58 +1,58 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/cryptooperationsconfigpage.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 "cryptooperationsconfigpage.h"
 
 #include "cryptooperationsconfigwidget.h"
 
 #include <QVBoxLayout>
 
 using namespace Kleo;
 using namespace Kleo::Config;
 
 CryptoOperationsConfigurationPage::CryptoOperationsConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
-    QVBoxLayout *lay = new QVBoxLayout(this);
+    auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
     mWidget = new CryptoOperationsConfigWidget(this);
     lay->addWidget(mWidget);
     connect(mWidget, &CryptoOperationsConfigWidget::changed, this, &Kleo::Config::CryptoOperationsConfigurationPage::markAsChanged);
     load();
 }
 
 void CryptoOperationsConfigurationPage::load()
 {
     mWidget->load();
 }
 
 void CryptoOperationsConfigurationPage::save()
 {
     mWidget->save();
 
 }
 
 void CryptoOperationsConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C"
 {
     Q_DECL_EXPORT KCModule *create_kleopatra_config_cryptooperations(QWidget *parent = nullptr, const QVariantList &args = QVariantList())
     {
-        CryptoOperationsConfigurationPage *page =
+        auto page =
             new CryptoOperationsConfigurationPage(parent, args);
         page->setObjectName(QStringLiteral("kleopatra_config_cryptooperations"));
         return page;
     }
 }
 
diff --git a/src/conf/cryptooperationsconfigwidget.cpp b/src/conf/cryptooperationsconfigwidget.cpp
index da6860636..38bce2e88 100644
--- a/src/conf/cryptooperationsconfigwidget.cpp
+++ b/src/conf/cryptooperationsconfigwidget.cpp
@@ -1,385 +1,385 @@
 /*
     cryptooperationsconfigwidget.cpp
 
     This file is part of kleopatra, the KDE key manager
     SPDX-FileCopyrightText: 2010 Klarälvdalens Datakonsult AB
     2016 by Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
  */
 
 #include <config-kleopatra.h>
 
 #include "cryptooperationsconfigwidget.h"
 #include "kleopatra_debug.h"
 
 #include "emailoperationspreferences.h"
 #include "fileoperationspreferences.h"
 
 #include <Libkleo/ChecksumDefinition>
 #include <Libkleo/KeyFilterManager>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/CryptoConfig>
 
 #include <gpgme++/context.h>
 #include <gpgme++/engineinfo.h>
 
 #include <KConfig>
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KMessageBox>
 
 #include <QCheckBox>
 #include <QComboBox>
 #include <QDir>
 #include <QGroupBox>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QProcess>
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QRegularExpression>
 
 #include <memory>
 
 using namespace Kleo;
 using namespace Kleo::Config;
 
 CryptoOperationsConfigWidget::CryptoOperationsConfigWidget(QWidget *p, Qt::WindowFlags f)
     : QWidget(p, f),
       mApplyBtn(nullptr)
 {
     setupGui();
 }
 
 static void resetDefaults()
 {
     auto config = QGpgME::cryptoConfig();
 
     if (!config) {
         qCWarning(KLEOPATRA_LOG) << "Failed to obtain config";
         return;
     }
 
     const QStringList componentList = config->componentList();
     for (const auto &compName: componentList) {
         auto comp = config->component(compName);
         if (!comp) {
             qCWarning(KLEOPATRA_LOG) << "Failed to find component:" << comp;
             return;
         }
         const QStringList groupList = comp->groupList();
         for (const auto &grpName: groupList) {
             auto grp = comp->group(grpName);
             if (!grp) {
                 qCWarning(KLEOPATRA_LOG) << "Failed to find group:" << grp << "in component:" << compName;
                 return;
             }
             const QStringList entries = grp->entryList();
             for (const auto &entryName: entries) {
                 auto entry = grp->entry(entryName);
                 if (!entry) {
                     qCWarning(KLEOPATRA_LOG) << "Failed to find entry:" << entry << "in group:"<< grp << "in component:" << compName;
                     return;
                 }
                 entry->resetToDefault();
             }
         }
     }
     config->sync(true);
     return;
 }
 
 void CryptoOperationsConfigWidget::applyProfile(const QString &profile)
 {
     if (profile.isEmpty()) {
         return;
     }
     qCDebug(KLEOPATRA_LOG) << "Applying profile " << profile;
 
     if (profile == i18n("default")) {
         if (KMessageBox::warningYesNo(
                           this,
                           i18n("This means that every configuration option of the GnuPG System will be reset to its default."),
                           i18n("Apply profile"),
                           KStandardGuiItem::apply(),
                           KStandardGuiItem::no()) != KMessageBox::Yes) {
             return;
         }
         resetDefaults();
         KeyFilterManager::instance()->reload();
         return;
     }
 
     mApplyBtn->setEnabled(false);
 
     QDir datadir(QString::fromLocal8Bit(GpgME::dirInfo("datadir")) + QStringLiteral("/../doc/gnupg/examples"));
     const auto path = datadir.filePath(profile + QStringLiteral(".prf"));
 
     auto gpgconf = new QProcess;
     const auto ei = GpgME::engineInfo(GpgME::GpgConfEngine);
     Q_ASSERT (ei.fileName());
     gpgconf->setProgram(QFile::decodeName(ei.fileName()));
     gpgconf->setProcessChannelMode(QProcess::MergedChannels);
     gpgconf->setArguments(QStringList() << QStringLiteral("--runtime")
                                         << QStringLiteral("--apply-profile")
                                         << path);
 
     qDebug() << "Starting" << ei.fileName() << "with args" << gpgconf->arguments();
 
     connect(gpgconf, static_cast<void(QProcess::*)(int, QProcess::ExitStatus)>(&QProcess::finished),
             this, [this, gpgconf, profile] () {
         mApplyBtn->setEnabled(true);
         if (gpgconf->exitStatus() != QProcess::NormalExit) {
             KMessageBox::error(this, QStringLiteral("<pre>%1</pre>").arg(QString::fromLocal8Bit(gpgconf->readAll())));
             delete gpgconf;
             return;
         }
         delete gpgconf;
         KMessageBox::information(this,
                          i18nc("%1 is the name of the profile",
                                "The configuration profile \"%1\" was applied.", profile),
                          i18n("GnuPG Profile - Kleopatra"));
         auto config = QGpgME::cryptoConfig();
         if (config) {
             config->clear();
         }
         KeyFilterManager::instance()->reload();
     });
     gpgconf->start();
 }
 
 // Get a list of available profile files and add a configuration
 // group if there are any.
 void CryptoOperationsConfigWidget::setupProfileGui(QBoxLayout *layout)
 {
     qCDebug(KLEOPATRA_LOG) << "Engine version ";
     if (GpgME::engineInfo(GpgME::GpgEngine).engineVersion() < "2.1.20" || !layout) {
         //  Profile support is new in 2.1.20
         qCDebug(KLEOPATRA_LOG) << "Engine version false";
         return;
     }
     QDir datadir(QString::fromLocal8Bit(GpgME::dirInfo("datadir")) + QStringLiteral("/../doc/gnupg/examples"));
 
     if (!datadir.exists()) {
         qCDebug(KLEOPATRA_LOG) << "Failed to find gnupg's example profile directory" << datadir.path();
         return;
     }
 
     const auto profiles = datadir.entryInfoList(QStringList() << QStringLiteral("*.prf"), QDir::Readable | QDir::Files, QDir::Name);
 
     if (profiles.isEmpty()) {
         qCDebug(KLEOPATRA_LOG) << "Failed to find any profiles in: " << datadir.path();
         return;
     }
 
 
     auto genGrp = new QGroupBox(i18nc("@title", "General Operations"));
     auto profLayout = new QHBoxLayout;
     genGrp->setLayout(profLayout);
     layout->addWidget(genGrp);
     auto profLabel = new QLabel(i18n("Activate GnuPG Profile:"));
     profLabel->setToolTip(i18n("A profile consists of various settings that can apply to multiple components of the GnuPG system."));
 
     auto combo = new QComboBox;
     profLabel->setBuddy(combo);
 
     // Add an empty Item to avoid the impression that this GUI element
     // shows the currently selected profile.
     combo->addItem(QString());
 
     // We don't translate "default" here because the other profile names are
     // also not translated as they are taken directly from file.
     combo->addItem(i18n("default"));
     for (const auto &profile: profiles) {
         combo->addItem(profile.baseName());
     }
 
     mApplyBtn = new QPushButton(i18n("Apply"));
 
     mApplyBtn->setEnabled(false);
 
     profLayout->addWidget(profLabel);
     profLayout->addWidget(combo);
     profLayout->addWidget(mApplyBtn);
     profLayout->addStretch(1);
 
     connect(mApplyBtn, &QPushButton::clicked, this, [this, combo] () {
         applyProfile(combo->currentText());
     });
 
     connect(combo, QOverload<const QString &>::of(&QComboBox::currentTextChanged), this, [this] (const QString &text) {
         mApplyBtn->setEnabled(!text.isEmpty());
     });
 }
 
 void CryptoOperationsConfigWidget::setupGui()
 {
-    QVBoxLayout *baseLay = new QVBoxLayout(this);
+    auto baseLay = new QVBoxLayout(this);
     baseLay->setContentsMargins(0, 0, 0, 0);
 
-    QGroupBox *mailGrp = new QGroupBox(i18n("EMail Operations"));
-    QVBoxLayout *mailGrpLayout = new QVBoxLayout;
+    auto mailGrp = new QGroupBox(i18n("EMail Operations"));
+    auto mailGrpLayout = new QVBoxLayout;
     mQuickSignCB = new QCheckBox(i18n("Don't confirm signing certificate if there is only one valid certificate for the identity"));
     mQuickEncryptCB = new QCheckBox(i18n("Don't confirm encryption certificates if there is exactly one valid certificate for each recipient"));
     mailGrpLayout->addWidget(mQuickSignCB);
     mailGrpLayout->addWidget(mQuickEncryptCB);
     mailGrp->setLayout(mailGrpLayout);
     baseLay->addWidget(mailGrp);
 
-    QGroupBox *fileGrp = new QGroupBox(i18n("File Operations"));
-    QVBoxLayout *fileGrpLay = new QVBoxLayout;
-    mPGPFileExtCB = new QCheckBox(i18n("Create OpenPGP encrypted files with \".pgp\" file extensions instead of \".gpg\""));
+    auto fileGrp = new QGroupBox(i18n("File Operations"));
+    auto fileGrpLay = new QVBoxLayout;
+    mPGPFileExtCB = new QCheckBox(i18n(R"(Create OpenPGP encrypted files with ".pgp" file extensions instead of ".gpg")"));
     mASCIIArmorCB = new QCheckBox(i18n("Create signed or encrypted files as text files."));
     mASCIIArmorCB->setToolTip(i18nc("@info", "Set this option to encode encrypted or signed files as base64 encoded text. "
                                              "So that they can be opened with an editor or sent in a mail body. "
                                              "This will increase file size by one third."));
     mAutoDecryptVerifyCB = new QCheckBox(i18n("Automatically start operation based on input detection for decrypt/verify."));
     mTmpDirCB = new QCheckBox(i18n("Create temporary decrypted files in the folder of the encrypted file."));
     mTmpDirCB->setToolTip(i18nc("@info", "Set this option to avoid using the users temporary directory."));
 
     fileGrpLay->addWidget(mPGPFileExtCB);
     fileGrpLay->addWidget(mAutoDecryptVerifyCB);
     fileGrpLay->addWidget(mASCIIArmorCB);
     fileGrpLay->addWidget(mTmpDirCB);
 
-    QGridLayout *comboLay = new QGridLayout;
-    QLabel *chkLabel = new QLabel(i18n("Checksum program to use when creating checksum files:"));
+    auto comboLay = new QGridLayout;
+    auto chkLabel = new QLabel(i18n("Checksum program to use when creating checksum files:"));
     comboLay->addWidget(chkLabel, 0, 0);
     mChecksumDefinitionCB = new QComboBox;
     comboLay->addWidget(mChecksumDefinitionCB, 0, 1);
 
-    QLabel *archLabel = new QLabel(i18n("Archive command to use when archiving files:"));
+    auto archLabel = new QLabel(i18n("Archive command to use when archiving files:"));
     comboLay->addWidget(archLabel, 1, 0);
     mArchiveDefinitionCB = new QComboBox;
     comboLay->addWidget(mArchiveDefinitionCB, 1, 1);
     fileGrpLay->addLayout(comboLay);
 
 
     fileGrp->setLayout(fileGrpLay);
     baseLay->addWidget(fileGrp);
 
     setupProfileGui(baseLay);
 
     baseLay->addStretch(1);
 
 
     if (!GpgME::hasFeature(0, GpgME::BinaryAndFineGrainedIdentify)) {
         /* Auto handling requires a working identify in GpgME.
          * so that classify in kleoaptra can correctly detect the input.*/
         mAutoDecryptVerifyCB->setVisible(false);
     }
 
     connect(mQuickSignCB, &QCheckBox::toggled, this, &CryptoOperationsConfigWidget::changed);
     connect(mQuickEncryptCB, &QCheckBox::toggled, this, &CryptoOperationsConfigWidget::changed);
     connect(mChecksumDefinitionCB, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
             this, &CryptoOperationsConfigWidget::changed);
     connect(mArchiveDefinitionCB, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged),
             this, &CryptoOperationsConfigWidget::changed);
     connect(mPGPFileExtCB, &QCheckBox::toggled, this, &CryptoOperationsConfigWidget::changed);
     connect(mAutoDecryptVerifyCB, &QCheckBox::toggled, this, &CryptoOperationsConfigWidget::changed);
     connect(mASCIIArmorCB, &QCheckBox::toggled, this, &CryptoOperationsConfigWidget::changed);
     connect(mTmpDirCB, &QCheckBox::toggled, this, &CryptoOperationsConfigWidget::changed);
 }
 
 CryptoOperationsConfigWidget::~CryptoOperationsConfigWidget() {}
 
 void CryptoOperationsConfigWidget::defaults()
 {
     EMailOperationsPreferences emailPrefs;
     emailPrefs.setDefaults();
     mQuickSignCB->setChecked(emailPrefs.quickSignEMail());
     mQuickEncryptCB->setChecked(emailPrefs.quickEncryptEMail());
 
     FileOperationsPreferences filePrefs;
     filePrefs.setDefaults();
     mPGPFileExtCB->setChecked(filePrefs.usePGPFileExt());
     mAutoDecryptVerifyCB->setChecked(filePrefs.autoDecryptVerify());
 
     if (mChecksumDefinitionCB->count()) {
         mChecksumDefinitionCB->setCurrentIndex(0);
     }
 
     if (mArchiveDefinitionCB->count()) {
         mArchiveDefinitionCB->setCurrentIndex(0);
     }
 }
 
 Q_DECLARE_METATYPE(std::shared_ptr<Kleo::ChecksumDefinition>)
 
 void CryptoOperationsConfigWidget::load()
 {
 
     const EMailOperationsPreferences emailPrefs;
     mQuickSignCB   ->setChecked(emailPrefs.quickSignEMail());
     mQuickEncryptCB->setChecked(emailPrefs.quickEncryptEMail());
 
     const FileOperationsPreferences filePrefs;
     mPGPFileExtCB->setChecked(filePrefs.usePGPFileExt());
     mAutoDecryptVerifyCB->setChecked(filePrefs.autoDecryptVerify());
     mASCIIArmorCB->setChecked(filePrefs.addASCIIArmor());
     mTmpDirCB->setChecked(filePrefs.dontUseTmpDir());
 
     const std::vector< std::shared_ptr<ChecksumDefinition> > cds = ChecksumDefinition::getChecksumDefinitions();
     const std::shared_ptr<ChecksumDefinition> default_cd = ChecksumDefinition::getDefaultChecksumDefinition(cds);
 
     mChecksumDefinitionCB->clear();
     mArchiveDefinitionCB->clear();
 
     for (const std::shared_ptr<ChecksumDefinition> &cd : cds) {
         mChecksumDefinitionCB->addItem(cd->label(), QVariant::fromValue(cd));
         if (cd == default_cd) {
             mChecksumDefinitionCB->setCurrentIndex(mChecksumDefinitionCB->count() - 1);
         }
     }
 
     const QString ad_default_id = filePrefs.archiveCommand();
 
     // This is a weird hack but because we are a KCM we can't link
     // against ArchiveDefinition which pulls in loads of other classes.
     // So we do the parsing which archive definitions exist here ourself.
     if (KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("libkleopatrarc"))) {
         const QStringList groups = config->groupList().filter(QRegularExpression(QStringLiteral("^Archive Definition #")));
         for (const QString &group : groups) {
             const KConfigGroup cGroup(config, group);
             const QString id = cGroup.readEntryUntranslated(QStringLiteral("id"));
             const QString name = cGroup.readEntry("Name");
             mArchiveDefinitionCB->addItem(name, QVariant(id));
             if (id == ad_default_id) {
                 mArchiveDefinitionCB->setCurrentIndex(mArchiveDefinitionCB->count() - 1);
             }
         }
 
     }
 }
 
 void CryptoOperationsConfigWidget::save()
 {
 
     EMailOperationsPreferences emailPrefs;
     emailPrefs.setQuickSignEMail(mQuickSignCB   ->isChecked());
     emailPrefs.setQuickEncryptEMail(mQuickEncryptCB->isChecked());
     emailPrefs.save();
 
     FileOperationsPreferences filePrefs;
     filePrefs.setUsePGPFileExt(mPGPFileExtCB->isChecked());
     filePrefs.setAutoDecryptVerify(mAutoDecryptVerifyCB->isChecked());
     filePrefs.setAddASCIIArmor(mASCIIArmorCB->isChecked());
     filePrefs.setDontUseTmpDir(mTmpDirCB->isChecked());
 
     const int idx = mChecksumDefinitionCB->currentIndex();
     if (idx >= 0) {
-        const std::shared_ptr<ChecksumDefinition> cd = qvariant_cast< std::shared_ptr<ChecksumDefinition> >(mChecksumDefinitionCB->itemData(idx));
+        const auto cd = qvariant_cast< std::shared_ptr<ChecksumDefinition> >(mChecksumDefinitionCB->itemData(idx));
         ChecksumDefinition::setDefaultChecksumDefinition(cd);
     }
 
     const int aidx = mArchiveDefinitionCB->currentIndex();
     if (aidx >= 0) {
         const QString id = mArchiveDefinitionCB->itemData(aidx).toString();
         filePrefs.setArchiveCommand(id);
     }
     filePrefs.save();
 }
diff --git a/src/conf/dirservconfigpage.cpp b/src/conf/dirservconfigpage.cpp
index 8f937fc44..6414ec983 100644
--- a/src/conf/dirservconfigpage.cpp
+++ b/src/conf/dirservconfigpage.cpp
@@ -1,414 +1,414 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/dirservconfigpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2004, 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "dirservconfigpage.h"
 
 #include <Libkleo/Compat>
 #include <Libkleo/DirectoryServicesWidget>
 #include <Libkleo/CryptoConfigModule>
 
 #include <QGpgME/Protocol>
 
 #include <KMessageBox>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 #include <KConfig>
 #include <QSpinBox>
 
 #include <QLabel>
 #include <QCheckBox>
 #include <QLayout>
 #include <QTimeEdit>
 
 using namespace Kleo;
 using namespace QGpgME;
 
 #if 0 // disabled, since it is apparently confusing
 // For sync'ing kabldaprc
 class KABSynchronizer
 {
 public:
     KABSynchronizer()
         : mConfig("kabldaprc")
     {
         mConfig.setGroup("LDAP");
     }
 
     KUrl::List readCurrentList() const
     {
 
         KUrl::List lst;
         // stolen from kabc/ldapclient.cpp
         const uint numHosts = mConfig.readEntry("NumSelectedHosts");
         for (uint j = 0; j < numHosts; j++) {
             const QString num = QString::number(j);
 
             KUrl url;
             url.setProtocol("ldap");
             url.setPath("/");   // workaround KUrl parsing bug
             const QString host = mConfig.readEntry(QString("SelectedHost") + num).trimmed();
             url.setHost(host);
 
             const int port = mConfig.readEntry(QString("SelectedPort") + num);
             if (port != 0) {
                 url.setPort(port);
             }
 
             const QString base = mConfig.readEntry(QString("SelectedBase") + num).trimmed();
             url.setQuery(base);
 
             const QString bindDN = mConfig.readEntry(QString("SelectedBind") + num).trimmed();
             url.setUser(bindDN);
 
             const QString pwdBindDN = mConfig.readEntry(QString("SelectedPwdBind") + num).trimmed();
             url.setPass(pwdBindDN);
             lst.append(url);
         }
         return lst;
     }
 
     void writeList(const KUrl::List &lst)
     {
 
         mConfig.writeEntry("NumSelectedHosts", lst.count());
 
         KUrl::List::const_iterator it = lst.begin();
         KUrl::List::const_iterator end = lst.end();
         unsigned j = 0;
         for (; it != end; ++it, ++j) {
             const QString num = QString::number(j);
             KUrl url = *it;
 
             Q_ASSERT(url.scheme() == "ldap");
             mConfig.writeEntry(QString("SelectedHost") + num, url.host());
             mConfig.writeEntry(QString("SelectedPort") + num, url.port());
 
             // KUrl automatically encoded the query (e.g. for spaces inside it),
             // so decode it before writing it out
             const QString base = KUrl::decode_string(url.query().mid(1));
             mConfig.writeEntry(QString("SelectedBase") + num, base);
             mConfig.writeEntry(QString("SelectedBind") + num, url.user());
             mConfig.writeEntry(QString("SelectedPwdBind") + num, url.pass());
         }
         mConfig.sync();
     }
 
 private:
     KConfig mConfig;
 };
 
 #endif
 
 static const char s_x509services_componentName[] = "gpgsm";
 static const char s_x509services_entryName[] = "keyserver";
 
 static const char s_x509services_legacy_componentName[] = "dirmngr";
 static const char s_x509services_legacy_entryName[] = "LDAP Server";
 
 static const char s_pgpservice_componentName[] = "dirmngr";
 static const char s_pgpservice_entryName[] = "keyserver";
 
 // legacy config entry used until GnuPG 2.2
 static const char s_pgpservice_legacy_componentName[] = "gpg";
 static const char s_pgpservice_legacy_entryName[] = "keyserver";
 
 static const char s_timeout_componentName[] = "dirmngr";
 static const char s_timeout_entryName[] = "ldaptimeout";
 
 static const char s_maxitems_componentName[] = "dirmngr";
 static const char s_maxitems_entryName[] = "max-replies";
 
 #ifdef NOT_USEFUL_CURRENTLY
 static const char s_addnewservers_componentName[] = "dirmngr";
 static const char s_addnewservers_entryName[] = "add-servers";
 #endif
 
 DirectoryServicesConfigurationPage::DirectoryServicesConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
     mConfig = QGpgME::cryptoConfig();
-    QGridLayout *glay = new QGridLayout(this);
+    auto glay = new QGridLayout(this);
     glay->setContentsMargins(0, 0, 0, 0);
 
     int row = 0;
     mWidget = new Kleo::DirectoryServicesWidget(this);
     if (QLayout *l = mWidget->layout()) {
         l->setContentsMargins(0, 0, 0, 0);
     }
     glay->addWidget(mWidget, row, 0, 1, 3);
     connect(mWidget, SIGNAL(changed()), this, SLOT(changed()));
 
     // LDAP timeout
     ++row;
-    QLabel *label = new QLabel(i18n("LDAP &timeout (minutes:seconds):"), this);
+    auto label = new QLabel(i18n("LDAP &timeout (minutes:seconds):"), this);
     mTimeout = new QTimeEdit(this);
     mTimeout->setDisplayFormat(QStringLiteral("mm:ss"));
     connect(mTimeout, SIGNAL(timeChanged(QTime)), this, SLOT(changed()));
     label->setBuddy(mTimeout);
     glay->addWidget(label, row, 0);
     glay->addWidget(mTimeout, row, 1);
 
     // Max number of items returned by queries
     ++row;
     mMaxItemsLabel = new QLabel(i18n("&Maximum number of items returned by query:"), this);
     mMaxItems = new QSpinBox(this);
     mMaxItems->setMinimum(0);
     mMaxItemsLabel->setBuddy(mMaxItems);
     connect(mMaxItems, SIGNAL(valueChanged(int)), this, SLOT(changed()));
     glay->addWidget(mMaxItemsLabel, row, 0);
     glay->addWidget(mMaxItems, row, 1);
 
 #ifdef NOT_USEFUL_CURRENTLY
     ++row
     mAddNewServersCB = new QCheckBox(i18n("Automatically add &new servers discovered in CRL distribution points"), this);
     connect(mAddNewServersCB, SIGNAL(clicked()), this, SLOT(changed()));
     glay->addWidget(mAddNewServersCB, row, 0, 1, 3);
 #endif
 
     glay->setRowStretch(++row, 1);
     glay->setColumnStretch(2, 1);
 
     load();
 }
 
 static QList<QUrl> string2urls(const QString &str)
 {
     QList<QUrl> ret;
     if (str.isEmpty()) {
         return ret;
     }
     ret << QUrl::fromEncoded(str.toLocal8Bit());
     return ret;
 }
 
 void DirectoryServicesConfigurationPage::load()
 {
     mWidget->clear();
 
     // gpgsm's keyserver option is not provided by very old gpgconf versions
     if ((mX509ServicesEntry = configEntry(s_x509services_componentName, s_x509services_entryName,
                                           CryptoConfigEntry::ArgType_LDAPURL, ListValue, DoNotShowError))) {
         mWidget->addX509Services(mX509ServicesEntry->urlValueList());
     } else if ((mX509ServicesEntry = configEntry(s_x509services_legacy_componentName, s_x509services_legacy_entryName,
                                                  CryptoConfigEntry::ArgType_LDAPURL, ListValue, DoShowError))) {
         mWidget->addX509Services(mX509ServicesEntry->urlValueList());
     }
     mWidget->setX509ReadOnly(mX509ServicesEntry && mX509ServicesEntry->isReadOnly());
 
     {
-        auto *const newEntry = configEntry(s_pgpservice_componentName, s_pgpservice_entryName,
+        auto const newEntry = configEntry(s_pgpservice_componentName, s_pgpservice_entryName,
                                            CryptoConfigEntry::ArgType_String, SingleValue, DoNotShowError);
-        auto *const legacyEntry = configEntry(s_pgpservice_legacy_componentName, s_pgpservice_legacy_entryName,
+        auto const legacyEntry = configEntry(s_pgpservice_legacy_componentName, s_pgpservice_legacy_entryName,
                                               CryptoConfigEntry::ArgType_String, SingleValue, DoNotShowError);
         mOpenPGPServiceEntry = newEntry ? newEntry : legacyEntry;
 
         QString stringValue;
         if (newEntry && legacyEntry && !newEntry->isSet() && legacyEntry->isSet()) {
             // use value of legacy entry if value of new entry is unset
             qCDebug(KLEOPATRA_LOG) << "Using value of legacy entry for config entry"
                 << s_pgpservice_componentName << "/" << s_pgpservice_entryName;
             stringValue = legacyEntry->stringValue();
         } else if (mOpenPGPServiceEntry) {
             stringValue = mOpenPGPServiceEntry->stringValue();
         } else {
             qCWarning(KLEOPATRA_LOG) << "Unknown or wrong typed config entry"
                 << s_pgpservice_componentName << "/" << s_pgpservice_entryName;
         }
         mWidget->addOpenPGPServices(string2urls(parseKeyserver(stringValue).url));
         mWidget->setOpenPGPReadOnly(mOpenPGPServiceEntry && mOpenPGPServiceEntry->isReadOnly());
     }
 
     if (mX509ServicesEntry)
         if (mOpenPGPServiceEntry) {
             mWidget->setAllowedProtocols(DirectoryServicesWidget::AllProtocols);
         } else {
             mWidget->setAllowedProtocols(DirectoryServicesWidget::X509Protocol);
         }
     else if (mOpenPGPServiceEntry) {
         mWidget->setAllowedProtocols(DirectoryServicesWidget::OpenPGPProtocol);
     } else {
         mWidget->setDisabled(true);
     }
 
     DirectoryServicesWidget::Protocols readOnlyProtocols;
     if (mX509ServicesEntry && mX509ServicesEntry->isReadOnly()) {
         readOnlyProtocols = DirectoryServicesWidget::X509Protocol;
     }
 
     // read LDAP timeout
     // first try to read the config entry as int (GnuPG 2.3)
     mTimeoutConfigEntry = configEntry(s_timeout_componentName, s_timeout_entryName, CryptoConfigEntry::ArgType_Int, SingleValue, DoNotShowError);
     if (!mTimeoutConfigEntry) {
         // if this fails, then try to read the config entry as unsigned int (GnuPG <= 2.2)
         mTimeoutConfigEntry = configEntry(s_timeout_componentName, s_timeout_entryName, CryptoConfigEntry::ArgType_UInt, SingleValue, DoShowError);
     }
     if (mTimeoutConfigEntry) {
         const int ldapTimeout = mTimeoutConfigEntry->argType() == CryptoConfigEntry::ArgType_Int ?
                                 mTimeoutConfigEntry->intValue() :
                                 static_cast<int>(mTimeoutConfigEntry->uintValue());
         const QTime time = QTime(0, 0, 0, 0).addSecs(ldapTimeout);
         //qCDebug(KLEOPATRA_LOG) <<"timeout:" << mTimeoutConfigEntry->uintValue() <<"  ->" << time;
         mTimeout->setTime(time);
     }
 
     // read max-replies config entry
     // first try to read the config entry as int (GnuPG 2.3)
     mMaxItemsConfigEntry = configEntry(s_maxitems_componentName, s_maxitems_entryName, CryptoConfigEntry::ArgType_Int, SingleValue, DoNotShowError);
     if (!mMaxItemsConfigEntry) {
         // if this fails, then try to read the config entry as unsigned int (GnuPG <= 2.2)
         mMaxItemsConfigEntry = configEntry(s_maxitems_componentName, s_maxitems_entryName, CryptoConfigEntry::ArgType_UInt, SingleValue, DoShowError);
     }
     if (mMaxItemsConfigEntry) {
         const int value = mMaxItemsConfigEntry->argType() == CryptoConfigEntry::ArgType_Int ?
                           mMaxItemsConfigEntry->intValue() :
                           static_cast<int>(mMaxItemsConfigEntry->uintValue());
         mMaxItems->blockSignals(true);   // KNumInput emits valueChanged from setValue!
         mMaxItems->setValue(value);
         mMaxItems->blockSignals(false);
     }
     const bool maxItemsEnabled = mMaxItemsConfigEntry && !mMaxItemsConfigEntry->isReadOnly();
     mMaxItems->setEnabled(maxItemsEnabled);
     mMaxItemsLabel->setEnabled(maxItemsEnabled);
 
 #ifdef NOT_USEFUL_CURRENTLY
     mAddNewServersConfigEntry = configEntry(s_addnewservers_componentName, s_addnewservers_groupName, s_addnewservers_entryName, CryptoConfigEntry::ArgType_None, SingleValue, DoShowError);
     if (mAddNewServersConfigEntry) {
         mAddNewServersCB->setChecked(mAddNewServersConfigEntry->boolValue());
     }
 #endif
 }
 
 namespace
 {
 void updateIntegerConfigEntry(QGpgME::CryptoConfigEntry *configEntry, int value) {
     if (!configEntry) {
         return;
     }
     if (configEntry->argType() == CryptoConfigEntry::ArgType_Int) {
         if (configEntry->intValue() != value) {
             configEntry->setIntValue(value);
         }
     } else {
-        const unsigned int newValue = static_cast<unsigned>(value);
+        const auto newValue = static_cast<unsigned>(value);
         if (configEntry->uintValue() != newValue) {
             configEntry->setUIntValue(newValue);
         }
     }
 }
 }
 
 void DirectoryServicesConfigurationPage::save()
 {
     if (mX509ServicesEntry) {
         mX509ServicesEntry->setURLValueList(mWidget->x509Services());
     }
 
     if (mOpenPGPServiceEntry) {
         const QList<QUrl> serv = mWidget->openPGPServices();
         if (serv.empty()) {
             mOpenPGPServiceEntry->setStringValue(QString());
         } else {
             ParsedKeyserver pks = parseKeyserver(mOpenPGPServiceEntry->stringValue());
             pks.url = serv.front().url();
             mOpenPGPServiceEntry->setStringValue(assembleKeyserver(pks));
         }
     }
 
     const QTime time{mTimeout->time()};
     updateIntegerConfigEntry(mTimeoutConfigEntry, time.minute() * 60 + time.second());
 
     updateIntegerConfigEntry(mMaxItemsConfigEntry, mMaxItems->value());
 
 #ifdef NOT_USEFUL_CURRENTLY
     if (mAddNewServersConfigEntry && mAddNewServersConfigEntry->boolValue() != mAddNewServersCB->isChecked()) {
         mAddNewServersConfigEntry->setBoolValue(mAddNewServersCB->isChecked());
     }
 #endif
 
     mConfig->sync(true);
 
 #if 0
     // Also write the LDAP URLs to kabldaprc so that they are used by kaddressbook
     KABSynchronizer sync;
     const KUrl::List toAdd = mWidget->urlList();
     KUrl::List currentList = sync.readCurrentList();
 
     KUrl::List::const_iterator it = toAdd.begin();
     KUrl::List::const_iterator end = toAdd.end();
     for (; it != end; ++it) {
         // check if the URL is already in currentList
         if (currentList.find(*it) == currentList.end())
             // if not, add it
         {
             currentList.append(*it);
         }
     }
     sync.writeList(currentList);
 #endif
 }
 
 void DirectoryServicesConfigurationPage::defaults()
 {
     // these guys don't have a default, to clear them:
     if (mX509ServicesEntry) {
         mX509ServicesEntry->setURLValueList(QList<QUrl>());
     }
     if (mOpenPGPServiceEntry) {
         mOpenPGPServiceEntry->setStringValue(QString());
     }
     // these presumably have a default, use that one:
     if (mTimeoutConfigEntry) {
         mTimeoutConfigEntry->resetToDefault();
     }
     if (mMaxItemsConfigEntry) {
         mMaxItemsConfigEntry->resetToDefault();
     }
 #ifdef NOT_USEFUL_CURRENTLY
     if (mAddNewServersConfigEntry) {
         mAddNewServersConfigEntry->resetToDefault();
     }
 #endif
     load();
 }
 
 extern "C"
 {
     Q_DECL_EXPORT KCModule *create_kleopatra_config_dirserv(QWidget *parent = nullptr, const QVariantList &args = QVariantList())
     {
-        DirectoryServicesConfigurationPage *page =
+        auto page =
             new DirectoryServicesConfigurationPage(parent, args);
         page->setObjectName(QStringLiteral("kleopatra_config_dirserv"));
         return page;
     }
 }
 
 // Find config entry for ldap servers. Implements runtime checks on the configuration option.
 CryptoConfigEntry *DirectoryServicesConfigurationPage::configEntry(const char *componentName,
         const char *entryName,
         CryptoConfigEntry::ArgType argType,
         EntryMultiplicity multiplicity,
         ShowError showError)
 {
     CryptoConfigEntry *const entry = Kleo::getCryptoConfigEntry(mConfig, componentName, entryName);
     if (!entry) {
         if (showError == DoShowError) {
             KMessageBox::error(this, i18n("Backend error: gpgconf does not seem to know the entry for %1/%2", QLatin1String(componentName), QLatin1String(entryName)));
         }
         return nullptr;
     }
     if (entry->argType() != argType || entry->isList() != bool(multiplicity)) {
         if (showError == DoShowError) {
             KMessageBox::error(this, i18n("Backend error: gpgconf has wrong type for %1/%2: %3 %4", QLatin1String(componentName), QLatin1String(entryName), entry->argType(), entry->isList()));
         }
         return nullptr;
     }
     return entry;
 }
diff --git a/src/conf/gnupgsystemconfigurationpage.cpp b/src/conf/gnupgsystemconfigurationpage.cpp
index bb3934bb5..43e9e75ec 100644
--- a/src/conf/gnupgsystemconfigurationpage.cpp
+++ b/src/conf/gnupgsystemconfigurationpage.cpp
@@ -1,76 +1,76 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/gnupgsystemconfigurationpage.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 "gnupgsystemconfigurationpage.h"
 
 #include <Libkleo/CryptoConfigModule>
 #include <QGpgME/Protocol>
 #include <QGpgME/CryptoConfig>
 
 #include <QVBoxLayout>
 
 using namespace Kleo::Config;
 
 GnuPGSystemConfigurationPage::GnuPGSystemConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
-    QVBoxLayout *lay = new QVBoxLayout(this);
+    auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
 
     mWidget = new CryptoConfigModule(config,
                                      CryptoConfigModule::TabbedLayout,
                                      this);
     lay->addWidget(mWidget);
 
 
     connect(mWidget, &CryptoConfigModule::changed, this, &Kleo::Config::GnuPGSystemConfigurationPage::markAsChanged);
 
     load();
 }
 
 GnuPGSystemConfigurationPage::~GnuPGSystemConfigurationPage()
 {
     // ### correct here?
     if (QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig()) {
         config->clear();
     }
 }
 
 void GnuPGSystemConfigurationPage::load()
 {
     mWidget->reset();
 }
 
 void GnuPGSystemConfigurationPage::save()
 {
     mWidget->save();
 #if 0
     // Tell other apps (e.g. kmail) that the gpgconf data might have changed
     QDBusMessage message =
         QDBusMessage::createSignal(QString(), "org.kde.kleo.CryptoConfig", "changed");
     QDBusConnection::sessionBus().send(message);
 #endif
 }
 
 void GnuPGSystemConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C" Q_DECL_EXPORT KCModule *create_kleopatra_config_gnupgsystem(QWidget *parent, const QVariantList &args)
 {
-    GnuPGSystemConfigurationPage *page =
+    auto page =
         new GnuPGSystemConfigurationPage(parent, args);
     page->setObjectName(QStringLiteral("kleopatra_config_gnupgsystem"));
     return page;
 }
 
diff --git a/src/conf/groupsconfigpage.cpp b/src/conf/groupsconfigpage.cpp
index 1ecf057aa..af99da3b6 100644
--- a/src/conf/groupsconfigpage.cpp
+++ b/src/conf/groupsconfigpage.cpp
@@ -1,76 +1,76 @@
 /*
     conf/groupsconfigpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "groupsconfigpage.h"
 
 #include "groupsconfigwidget.h"
 
 #include <Libkleo/Debug>
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyGroup>
 
 #include <QVBoxLayout>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 
 class GroupsConfigPage::Private
 {
     friend class ::GroupsConfigPage;
     GroupsConfigPage *const q;
 
     Private(GroupsConfigPage *qq);
 public:
     ~Private() = default;
 
 private:
     GroupsConfigWidget *widget = nullptr;
 };
 
 GroupsConfigPage::Private::Private(GroupsConfigPage *qq)
     : q(qq)
 {
 }
 
 GroupsConfigPage::GroupsConfigPage(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
-    QVBoxLayout *layout = new QVBoxLayout(this);
+    auto layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
 
     d->widget = new Kleo::GroupsConfigWidget(this);
     if (QLayout *l = d->widget->layout()) {
         l->setContentsMargins(0, 0, 0, 0);
     }
 
     layout->addWidget(d->widget);
 
     connect(d->widget, &GroupsConfigWidget::changed, this, [this] () { Q_EMIT changed(true); });
 }
 
 GroupsConfigPage::~GroupsConfigPage() = default;
 
 void GroupsConfigPage::load()
 {
     d->widget->setGroups(KeyCache::instance()->configurableGroups());
     Q_EMIT changed(false);
 }
 
 void GroupsConfigPage::save()
 {
     KeyCache::mutableInstance()->saveConfigurableGroups(d->widget->groups());
 
     // reload after saving to ensure that the groups reflect the saved groups (e.g. in case of immutable entries)
     load();
 }
diff --git a/src/conf/smimevalidationconfigurationpage.cpp b/src/conf/smimevalidationconfigurationpage.cpp
index 13da2bb01..049f480b8 100644
--- a/src/conf/smimevalidationconfigurationpage.cpp
+++ b/src/conf/smimevalidationconfigurationpage.cpp
@@ -1,54 +1,54 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     conf/smimevalidationconfigurationpage.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 "smimevalidationconfigurationpage.h"
 #include "smimevalidationconfigurationwidget.h"
 
 #include <QVBoxLayout>
 
 using namespace Kleo::Config;
 
 SMimeValidationConfigurationPage::SMimeValidationConfigurationPage(QWidget *parent, const QVariantList &args)
     : KCModule(parent, args)
 {
-    QVBoxLayout *lay = new QVBoxLayout(this);
+    auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     mWidget = new SMimeValidationConfigurationWidget(this);
     lay->addWidget(mWidget);
 
     connect(mWidget, &SMimeValidationConfigurationWidget::changed, this, &Kleo::Config::SMimeValidationConfigurationPage::markAsChanged);
     load();
 }
 
 void SMimeValidationConfigurationPage::load()
 {
     mWidget->load();
 }
 
 void SMimeValidationConfigurationPage::save()
 {
     mWidget->save();
 
 }
 
 void SMimeValidationConfigurationPage::defaults()
 {
     mWidget->defaults();
 }
 
 extern "C" Q_DECL_EXPORT KCModule *create_kleopatra_config_smimevalidation(QWidget *parent, const QVariantList &args)
 {
-    SMimeValidationConfigurationPage *page =
+    auto page =
         new SMimeValidationConfigurationPage(parent, args);
     page->setObjectName(QStringLiteral("kleopatra_config_smimevalidation"));
     return page;
 }
 
diff --git a/src/crypto/createchecksumscontroller.cpp b/src/crypto/createchecksumscontroller.cpp
index c794415b9..dee5aa2b3 100644
--- a/src/crypto/createchecksumscontroller.cpp
+++ b/src/crypto/createchecksumscontroller.cpp
@@ -1,719 +1,719 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/createchecksumscontroller.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 "createchecksumscontroller.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 <QTemporaryFile>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <QDialog>
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QListWidget>
 #include <QVBoxLayout>
 
 #include <QPointer>
 #include <QFileInfo>
 #include <QThread>
 #include <QMutex>
 #include <QProgressDialog>
 #include <QDir>
 #include <QProcess>
 
 #include <gpg-error.h>
 
 #include <deque>
 #include <map>
 #include <limits>
 #include <functional>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 namespace
 {
 
 class ResultDialog : public QDialog
 {
     Q_OBJECT
 public:
     ResultDialog(const QStringList &created, const QStringList &errors, QWidget *parent = nullptr, Qt::WindowFlags f = {})
         : QDialog(parent, f),
           createdLB(created.empty()
                     ? i18nc("@info", "No checksum files have been created.")
                     : i18nc("@info", "These checksum files have been successfully created:"), this),
           createdLW(this),
           errorsLB(errors.empty()
                    ? i18nc("@info", "There were no errors.")
                    : i18nc("@info", "The following errors were encountered:"), this),
           errorsLW(this),
           buttonBox(QDialogButtonBox::Ok, Qt::Horizontal, this),
           vlay(this)
     {
         KDAB_SET_OBJECT_NAME(createdLB);
         KDAB_SET_OBJECT_NAME(createdLW);
         KDAB_SET_OBJECT_NAME(errorsLB);
         KDAB_SET_OBJECT_NAME(errorsLW);
         KDAB_SET_OBJECT_NAME(buttonBox);
         KDAB_SET_OBJECT_NAME(vlay);
 
         createdLW.addItems(created);
         QRect r;
         for (int i = 0; i < created.size(); ++i) {
             r = r.united(createdLW.visualRect(createdLW.model()->index(0, i)));
         }
         createdLW.setMinimumWidth(qMin(1024, r.width() + 4 * createdLW.frameWidth()));
 
         errorsLW.addItems(errors);
 
         vlay.addWidget(&createdLB);
         vlay.addWidget(&createdLW, 1);
         vlay.addWidget(&errorsLB);
         vlay.addWidget(&errorsLW, 1);
         vlay.addWidget(&buttonBox);
 
         if (created.empty()) {
             createdLW.hide();
         }
         if (errors.empty()) {
             errorsLW.hide();
         }
 
         connect(&buttonBox, &QDialogButtonBox::accepted, this, &ResultDialog::accept);
         connect(&buttonBox, &QDialogButtonBox::rejected, this, &ResultDialog::reject);
         readConfig();
     }
     ~ResultDialog()
     {
         writeConfig();
     }
 
     void readConfig()
     {
         KConfigGroup dialog(KSharedConfig::openStateConfig(), "ResultDialog");
         const QSize size = dialog.readEntry("Size", QSize(600, 400));
         if (size.isValid()) {
             resize(size);
         }
     }
     void writeConfig()
     {
         KConfigGroup dialog(KSharedConfig::openStateConfig(), "ResultDialog");
         dialog.writeEntry("Size", size());
         dialog.sync();
     }
 
 private:
     QLabel createdLB;
     QListWidget createdLW;
     QLabel errorsLB;
     QListWidget errorsLW;
     QDialogButtonBox buttonBox;
     QVBoxLayout vlay;
 };
 
 }
 
 #ifdef Q_OS_UNIX
 static const bool HAVE_UNIX = true;
 #else
 static const bool HAVE_UNIX = false;
 #endif
 
 static const Qt::CaseSensitivity fs_cs = HAVE_UNIX ? Qt::CaseSensitive : Qt::CaseInsensitive; // can we use QAbstractFileEngine::caseSensitive()?
 
 static QStringList fs_sort(QStringList l)
 {
     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)
 {
     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;
 }
 
 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); });
     }
 };
 }
 
 class CreateChecksumsController::Private : public QThread
 {
     Q_OBJECT
     friend class ::Kleo::Crypto::CreateChecksumsController;
     CreateChecksumsController *const q;
 public:
     explicit Private(CreateChecksumsController *qq);
     ~Private() override;
 
 Q_SIGNALS:
     void progress(int, int, const QString &);
 
 private:
     void slotOperationFinished()
     {
 #ifndef QT_NO_PROGRESSDIALOG
         if (progressDialog) {
             progressDialog->setValue(progressDialog->maximum());
             progressDialog->close();
         }
 #endif // QT_NO_PROGRESSDIALOG
-        ResultDialog *const dlg = new ResultDialog(created, errors);
+        auto const dlg = new ResultDialog(created, errors);
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         q->bringToForeground(dlg);
         if (!errors.empty())
             q->setLastError(gpg_error(GPG_ERR_GENERAL),
                             errors.join(QLatin1Char('\n')));
         q->emitDoneOrError();
     }
     void slotProgress(int current, int total, const QString &what)
     {
         qCDebug(KLEOPATRA_LOG) << "progress: " << current << "/" << total << ": " << qPrintable(what);
 #ifndef QT_NO_PROGRESSDIALOG
         if (!progressDialog) {
             return;
         }
         progressDialog->setMaximum(total);
         progressDialog->setValue(current);
         progressDialog->setLabelText(what);
 #endif // QT_NO_PROGRESSDIALOG
     }
 
 private:
     void run() override;
 
 private:
 #ifndef QT_NO_PROGRESSDIALOG
     QPointer<QProgressDialog> progressDialog;
 #endif
     mutable QMutex mutex;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions;
     std::shared_ptr<ChecksumDefinition> checksumDefinition;
     QStringList files;
     QStringList errors, created;
     bool allowAddition;
     volatile bool canceled;
 };
 
 CreateChecksumsController::Private::Private(CreateChecksumsController *qq)
     : q(qq),
 #ifndef QT_NO_PROGRESSDIALOG
       progressDialog(),
 #endif
       mutex(),
       checksumDefinitions(ChecksumDefinition::getChecksumDefinitions()),
       checksumDefinition(ChecksumDefinition::getDefaultChecksumDefinition(checksumDefinitions)),
       files(),
       errors(),
       created(),
       allowAddition(false),
       canceled(false)
 {
     connect(this, SIGNAL(progress(int,int,QString)),
             q, SLOT(slotProgress(int,int,QString)));
     connect(this, &Private::progress,
             q, &Controller::progress);
     connect(this, SIGNAL(finished()),
             q, SLOT(slotOperationFinished()));
 }
 
 CreateChecksumsController::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 CreateChecksumsController::CreateChecksumsController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 CreateChecksumsController::CreateChecksumsController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *p)
     : Controller(ctx, p), d(new Private(this))
 {
 
 }
 
 CreateChecksumsController::~CreateChecksumsController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void CreateChecksumsController::setFiles(const QStringList &files)
 {
     kleo_assert(!d->isRunning());
     kleo_assert(!files.empty());
     const QList<QRegExp> patterns = get_patterns(d->checksumDefinitions);
     if (!std::all_of(files.cbegin(), files.cend(), matches_any(patterns)) &&
             !std::none_of(files.cbegin(), files.cend(), matches_any(patterns))) {
         throw Exception(gpg_error(GPG_ERR_INV_ARG), i18n("Create Checksums: input files must be either all checksum files or all files to be checksummed, not a mixture of both."));
     }
     const QMutexLocker locker(&d->mutex);
     d->files = files;
 }
 
 void CreateChecksumsController::setAllowAddition(bool allow)
 {
     kleo_assert(!d->isRunning());
     const QMutexLocker locker(&d->mutex);
     d->allowAddition = allow;
 }
 
 bool CreateChecksumsController::allowAddition() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->allowAddition;
 }
 
 void CreateChecksumsController::start()
 {
 
     {
         const QMutexLocker locker(&d->mutex);
 
 #ifndef QT_NO_PROGRESSDIALOG
         d->progressDialog = new QProgressDialog(i18n("Initializing..."), i18n("Cancel"), 0, 0);
         applyWindowID(d->progressDialog);
         d->progressDialog->setAttribute(Qt::WA_DeleteOnClose);
         d->progressDialog->setMinimumDuration(1000);
         d->progressDialog->setWindowTitle(i18nc("@title:window", "Create Checksum Progress"));
         connect(d->progressDialog.data(), &QProgressDialog::canceled, this, &CreateChecksumsController::cancel);
 #endif // QT_NO_PROGRESSDIALOG
 
         d->canceled = false;
         d->errors.clear();
         d->created.clear();
     }
 
     d->start();
 
 }
 
 void CreateChecksumsController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     const QMutexLocker locker(&d->mutex);
     d->canceled = true;
 }
 
 namespace
 {
 
 struct Dir {
     QDir dir;
     QString sumFile;
     QStringList inputFiles;
     quint64 totalSize;
     std::shared_ptr<ChecksumDefinition> checksumDefinition;
 };
 
 }
 
 static QStringList remove_checksum_files(QStringList l, const QList<QRegExp> &rxs)
 {
     QStringList::iterator end = l.end();
     for (const QRegExp &rx : rxs) {
         end = std::remove_if(l.begin(), end,
                              [rx](const QString &str) { 
                                 return rx.exactMatch(str);
                              });
     }
     l.erase(end, 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 (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>();
 }
 
 static std::vector<Dir> find_dirs_by_sum_files(const QStringList &files, bool allowAddition,
         const std::function<void(int)> &progress,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
 
     const QList<QRegExp> patterns = get_patterns(checksumDefinitions);
 
     std::vector<Dir> dirs;
     dirs.reserve(files.size());
 
     int i = 0;
 
     for (const QString &file : files) {
 
         const QFileInfo fi(file);
         const QDir dir = fi.dir();
         const QStringList entries = remove_checksum_files(dir.entryList(QDir::Files), patterns);
 
         QStringList inputFiles;
         if (allowAddition) {
             inputFiles = entries;
         } else {
             const std::vector<File> parsed = parse_sum_file(fi.absoluteFilePath());
             QStringList oldInputFiles;
             oldInputFiles.reserve(parsed.size());
             std::transform(parsed.cbegin(), parsed.cend(), std::back_inserter(oldInputFiles),
                            std::mem_fn(&File::name));
             inputFiles = fs_intersect(oldInputFiles, entries);
         }
 
         const Dir item = {
             dir,
             fi.fileName(),
             inputFiles,
             aggregate_size(dir, inputFiles),
             filename2definition(fi.fileName(), checksumDefinitions)
         };
 
         dirs.push_back(item);
 
         if (progress) {
             progress(++i);
         }
 
     }
     return dirs;
 }
 
 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;
     }
 };
 }
 
 static std::vector<Dir> find_dirs_by_input_files(const QStringList &files, const std::shared_ptr<ChecksumDefinition> &checksumDefinition, bool allowAddition,
         const std::function<void(int)> &progress,
         const std::vector< std::shared_ptr<ChecksumDefinition> > &checksumDefinitions)
 {
     Q_UNUSED(allowAddition)
     if (!checksumDefinition) {
         return std::vector<Dir>();
     }
 
     const QList<QRegExp> patterns = get_patterns(checksumDefinitions);
 
     std::map<QDir, QStringList, less_dir> dirs2files;
 
     // Step 1: sort files by the dir they're contained in:
 
     std::deque<QString> inputs(files.begin(), files.end());
 
     int i = 0;
     while (!inputs.empty()) {
         const QString file = inputs.front();
         inputs.pop_front();
         const QFileInfo fi(file);
         if (fi.isDir()) {
             QDir dir(file);
             dirs2files[ dir ] = remove_checksum_files(dir.entryList(QDir::Files), patterns);
             const auto entryList = dir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
             std::transform(entryList.cbegin(), entryList.cend(),
                            std::inserter(inputs, inputs.begin()),
                            [&dir](const QString &entry) {
                                return dir.absoluteFilePath(entry);
                            });
         } else {
             dirs2files[fi.dir()].push_back(file);
         }
         if (progress) {
             progress(++i);
         }
     }
 
     // Step 2: convert into vector<Dir>:
 
     std::vector<Dir> dirs;
     dirs.reserve(dirs2files.size());
 
-    for (std::map<QDir, QStringList, less_dir>::const_iterator it = dirs2files.begin(), end = dirs2files.end(); it != end; ++it) {
+    for (auto it = dirs2files.begin(), end = dirs2files.end(); it != end; ++it) {
 
         const QStringList inputFiles = remove_checksum_files(it->second, patterns);
         if (inputFiles.empty()) {
             continue;
         }
 
         const Dir dir = {
             it->first,
             checksumDefinition->outputFileName(),
             inputFiles,
             aggregate_size(it->first, inputFiles),
             checksumDefinition
         };
         dirs.push_back(dir);
 
         if (progress) {
             progress(++i);
         }
 
     }
     return dirs;
 }
 
 static QString process(const Dir &dir, bool *fatal)
 {
     const QString absFilePath = dir.dir.absoluteFilePath(dir.sumFile);
     QTemporaryFile out;
     QProcess p;
     if (!out.open()) {
         return QStringLiteral("Failed to open Temporary file.");
     }
     p.setWorkingDirectory(dir.dir.absolutePath());
     p.setStandardOutputFile(out.fileName());
     const QString program = dir.checksumDefinition->createCommand();
     dir.checksumDefinition->startCreateCommand(&p, dir.inputFiles);
     p.waitForFinished();
     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());
         }
     }
 
     QFileInfo fi(absFilePath);
     if (!(fi.exists() && !QFile::remove(absFilePath)) && QFile::copy(out.fileName(), absFilePath)) {
         return QString();
     }
 
     return xi18n("Failed to overwrite <filename>%1</filename>.", dir.sumFile);
 }
 
 namespace
 {
 static QDebug operator<<(QDebug s, const Dir &dir)
 {
     return s << "Dir(" << dir.dir << "->" << dir.sumFile << "<-(" << dir.totalSize << ')' << dir.inputFiles << ")\n";
 }
 }
 
 void CreateChecksumsController::Private::run()
 {
 
     QMutexLocker locker(&mutex);
 
     const QStringList files = this->files;
     const std::vector< std::shared_ptr<ChecksumDefinition> > checksumDefinitions = this->checksumDefinitions;
     const std::shared_ptr<ChecksumDefinition> checksumDefinition = this->checksumDefinition;
     const bool allowAddition = this->allowAddition;
 
     locker.unlock();
 
     QStringList errors;
     QStringList created;
 
     if (!checksumDefinition) {
         errors.push_back(i18n("No checksum programs defined."));
         locker.relock();
         this->errors = errors;
         return;
     } else {
         qCDebug(KLEOPATRA_LOG) << "using checksum-definition" << checksumDefinition->id();
     }
 
     //
     // Step 1: build a list of work to do (no progress):
     //
 
     const QString scanning = i18n("Scanning directories...");
     Q_EMIT progress(0, 0, scanning);
 
     const bool haveSumFiles = std::all_of(files.cbegin(), files.cend(), matches_any(get_patterns(checksumDefinitions)));
     const auto progressCb = [this, &scanning](int c) { Q_EMIT progress(c, 0, scanning); };
     const std::vector<Dir> dirs = haveSumFiles
                                   ? find_dirs_by_sum_files(files, allowAddition, progressCb, checksumDefinitions)
                                   : find_dirs_by_input_files(files, checksumDefinition, allowAddition, progressCb, checksumDefinitions);
 
     for (const Dir &dir : dirs) {
         qCDebug(KLEOPATRA_LOG) << dir;
     }
 
     if (!canceled) {
 
         Q_EMIT progress(0, 0, i18n("Calculating total size..."));
 
         const quint64 total = kdtools::accumulate_transform(dirs.cbegin(), dirs.cend(),
                                                             std::mem_fn(&Dir::totalSize),
                                                             Q_UINT64_C(0));
 
         if (!canceled) {
 
             //
             // Step 2: perform work (with progress reporting):
             //
 
             // 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;
             for (const Dir &dir : dirs) {
                 Q_EMIT progress(done / factor, total / factor,
                                 i18n("Checksumming (%2) in %1", dir.checksumDefinition->label(), dir.dir.path()));
                 bool fatal = false;
                 const QString error = process(dir, &fatal);
                 if (!error.isEmpty()) {
                     errors.push_back(error);
                 } else {
                     created.push_back(dir.dir.absoluteFilePath(dir.sumFile));
                 }
                 done += dir.totalSize;
                 if (fatal || canceled) {
                     break;
                 }
             }
             Q_EMIT progress(done / factor, total / factor, i18n("Done."));
 
         }
     }
 
     locker.relock();
 
     this->errors = errors;
     this->created = created;
 
     // mutex unlocked by QMutexLocker
 
 }
 
 #include "moc_createchecksumscontroller.cpp"
 #include "createchecksumscontroller.moc"
diff --git a/src/crypto/decryptverifyemailcontroller.cpp b/src/crypto/decryptverifyemailcontroller.cpp
index 7332f66fd..c7bfd38a4 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/kmime_header_parsing.h>
 
 #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 : qAsConst(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)
 {
-    typename C::iterator it = c.begin();
+    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 std::map<unsigned int, QPointer<DecryptVerifyEMailWizard> >::const_iterator it
+        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;
         }
 
     }
 
-    DecryptVerifyEMailWizard *w = new DecryptVerifyEMailWizard;
+    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) {
         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/decryptverifyfilescontroller.cpp b/src/crypto/decryptverifyfilescontroller.cpp
index ab8c45697..55bebbbfd 100644
--- a/src/crypto/decryptverifyfilescontroller.cpp
+++ b/src/crypto/decryptverifyfilescontroller.cpp
@@ -1,443 +1,443 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifyfilescontroller.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 "decryptverifyfilescontroller.h"
 
 #include <crypto/gui/decryptverifyoperationwidget.h>
 #include <crypto/gui/decryptverifyfileswizard.h>
 #include <crypto/decryptverifytask.h>
 #include <crypto/taskcollection.h>
 
 #include <Libkleo/GnuPG>
 #include <utils/path-helper.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <utils/archivedefinition.h>
 
 #include <Libkleo/Classify>
 
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <QDir>
 #include <QFile>
 #include <QFileInfo>
 #include <QPointer>
 #include <QTimer>
 
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class DecryptVerifyFilesController::Private
 {
     DecryptVerifyFilesController *const q;
 public:
 
     static std::shared_ptr<AbstractDecryptVerifyTask> taskFromOperationWidget(const DecryptVerifyOperationWidget *w, const QString &fileName, const QDir &outDir, const std::shared_ptr<OverwritePolicy> &overwritePolicy);
 
     explicit Private(DecryptVerifyFilesController *qq);
 
     void slotWizardOperationPrepared();
     void slotWizardCanceled();
     void schedule();
 
     void prepareWizardFromPassedFiles();
     std::vector<std::shared_ptr<Task> > buildTasks(const QStringList &, const std::shared_ptr<OverwritePolicy> &);
 
     void ensureWizardCreated();
     void ensureWizardVisible();
     void reportError(int err, const QString &details)
     {
         q->setLastError(err, details);
         q->emitDoneOrError();
     }
     void cancelAllTasks();
 
     QStringList m_passedFiles, m_filesAfterPreparation;
     QPointer<DecryptVerifyFilesWizard> m_wizard;
     std::vector<std::shared_ptr<const DecryptVerifyResult> > m_results;
     std::vector<std::shared_ptr<Task> > m_runnableTasks, m_completedTasks;
     std::shared_ptr<Task> m_runningTask;
     bool m_errorDetected;
     DecryptVerifyOperation m_operation;
 };
 
 // static
 std::shared_ptr<AbstractDecryptVerifyTask> DecryptVerifyFilesController::Private::taskFromOperationWidget(const DecryptVerifyOperationWidget *w, const QString &fileName, const QDir &outDir, const std::shared_ptr<OverwritePolicy> &overwritePolicy)
 {
 
     kleo_assert(w);
 
     std::shared_ptr<AbstractDecryptVerifyTask> task;
 
     switch (w->mode()) {
     case DecryptVerifyOperationWidget::VerifyDetachedWithSignature: {
 
         std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
         t->setInput(Input::createFromFile(fileName));
         t->setSignedData(Input::createFromFile(w->signedDataFileName()));
         task = t;
 
         kleo_assert(fileName == w->inputFileName());
     }
     break;
     case DecryptVerifyOperationWidget::VerifyDetachedWithSignedData: {
         std::shared_ptr<VerifyDetachedTask> t(new VerifyDetachedTask);
         t->setInput(Input::createFromFile(w->inputFileName()));
         t->setSignedData(Input::createFromFile(fileName));
         task = t;
 
         kleo_assert(fileName == w->signedDataFileName());
     }
     break;
     case DecryptVerifyOperationWidget::DecryptVerifyOpaque: {
         const unsigned int classification = classify(fileName);
         qCDebug(KLEOPATRA_LOG) << "classified" << fileName << "as" << printableClassification(classification);
 
         const std::shared_ptr<ArchiveDefinition> ad = w->selectedArchiveDefinition();
 
         const Protocol proto =
             isOpenPGP(classification) ? OpenPGP :
             isCMS(classification)     ? CMS :
             ad /* _needs_ the info */   ? throw Exception(gpg_error(GPG_ERR_CONFLICT), i18n("Cannot determine whether input data is OpenPGP or CMS")) :
             /* else we don't care */      UnknownProtocol;
 
         const std::shared_ptr<Input> input = Input::createFromFile(fileName);
         const std::shared_ptr<Output> output =
             ad       ? ad->createOutputFromUnpackCommand(proto, fileName, outDir) :
             /*else*/   Output::createFromFile(outDir.absoluteFilePath(outputFileName(QFileInfo(fileName).fileName())), overwritePolicy);
 
         if (mayBeCipherText(classification)) {
             qCDebug(KLEOPATRA_LOG) << "creating a DecryptVerifyTask";
             std::shared_ptr<DecryptVerifyTask> t(new DecryptVerifyTask);
             t->setInput(input);
             t->setOutput(output);
             task = t;
         } else {
             qCDebug(KLEOPATRA_LOG) << "creating a VerifyOpaqueTask";
             std::shared_ptr<VerifyOpaqueTask> t(new VerifyOpaqueTask);
             t->setInput(input);
             t->setOutput(output);
             task = t;
         }
 
         kleo_assert(fileName == w->inputFileName());
     }
     break;
     }
 
     task->autodetectProtocolFromInput();
     return task;
 }
 
 DecryptVerifyFilesController::Private::Private(DecryptVerifyFilesController *qq) : q(qq), m_errorDetected(false), m_operation(DecryptVerify)
 {
     qRegisterMetaType<VerificationResult>();
 }
 
 void DecryptVerifyFilesController::Private::slotWizardOperationPrepared()
 {
     ensureWizardCreated();
     std::vector<std::shared_ptr<Task> > tasks = buildTasks(m_filesAfterPreparation, std::shared_ptr<OverwritePolicy>(new OverwritePolicy(m_wizard)));
     if (tasks.empty()) {
         reportError(makeGnuPGError(GPG_ERR_ASS_NO_INPUT), i18n("No usable inputs found"));
     }
     kleo_assert(m_runnableTasks.empty());
     m_runnableTasks.swap(tasks);
 
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     for (const auto &i: m_runnableTasks) {
         q->connectTask(i);
     }
     coll->setTasks(m_runnableTasks);
     m_wizard->setTaskCollection(coll);
 
     QTimer::singleShot(0, q, SLOT(schedule()));
 }
 
 void DecryptVerifyFilesController::Private::slotWizardCanceled()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void DecryptVerifyFilesController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(task);
     Q_UNUSED(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
 
     d->m_completedTasks.push_back(d->m_runningTask);
     d->m_runningTask.reset();
 
     if (const std::shared_ptr<const DecryptVerifyResult> &dvr = std::dynamic_pointer_cast<const DecryptVerifyResult>(result)) {
         d->m_results.push_back(dvr);
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 void DecryptVerifyFilesController::Private::schedule()
 {
     if (!m_runningTask && !m_runnableTasks.empty()) {
         const std::shared_ptr<Task> t = m_runnableTasks.back();
         m_runnableTasks.pop_back();
         t->start();
         m_runningTask = t;
     }
     if (!m_runningTask) {
         kleo_assert(m_runnableTasks.empty());
         for (const auto &i: m_results) {
             Q_EMIT q->verificationResult(i->verificationResult());
         }
         q->emitDoneOrError();
     }
 }
 
 void DecryptVerifyFilesController::Private::ensureWizardCreated()
 {
     if (m_wizard) {
         return;
     }
 
     std::unique_ptr<DecryptVerifyFilesWizard> w(new DecryptVerifyFilesWizard);
     w->setWindowTitle(i18nc("@title:window", "Decrypt/Verify Files"));
     w->setAttribute(Qt::WA_DeleteOnClose);
 
     connect(w.get(), SIGNAL(operationPrepared()), q, SLOT(slotWizardOperationPrepared()), Qt::QueuedConnection);
     connect(w.get(), SIGNAL(canceled()), q, SLOT(slotWizardCanceled()), Qt::QueuedConnection);
     m_wizard = w.release();
 
 }
 
 namespace
 {
 struct FindExtension : std::unary_function<std::shared_ptr<ArchiveDefinition>, bool> {
     const QString ext;
     const Protocol proto;
     FindExtension(const QString &ext, Protocol proto) : ext(ext), proto(proto) {}
     bool operator()(const std::shared_ptr<ArchiveDefinition> &ad) const
     {
         qCDebug(KLEOPATRA_LOG) << "   considering" << (ad ? ad->label() : QStringLiteral("<null>")) << "for" << ext;
         bool result;
         if (proto == UnknownProtocol) {
             result = ad && (ad->extensions(OpenPGP).contains(ext, Qt::CaseInsensitive) || ad->extensions(CMS).contains(ext, Qt::CaseInsensitive));
         } else {
             result = ad && ad->extensions(proto).contains(ext, Qt::CaseInsensitive);
         }
         qCDebug(KLEOPATRA_LOG) << (result ? "   -> matches" : "   -> doesn't match");
         return result;
     }
 };
 }
 
 std::shared_ptr<ArchiveDefinition> DecryptVerifyFilesController::pick_archive_definition(GpgME::Protocol proto, const std::vector< std::shared_ptr<ArchiveDefinition> > &ads, const QString &filename)
 {
     const QFileInfo fi(outputFileName(filename));
     QString extension = fi.completeSuffix();
 
     if (extension == QLatin1String("out")) { // added by outputFileName() -> useless
         return std::shared_ptr<ArchiveDefinition>();
     }
 
     if (extension.endsWith(QLatin1String(".out"))) {     // added by outputFileName() -> remove
         extension.chop(4);
     }
 
     for (;;) {
-        const std::vector<std::shared_ptr<ArchiveDefinition> >::const_iterator it
+        const auto it
             = std::find_if(ads.begin(), ads.end(), FindExtension(extension, proto));
         if (it != ads.end()) {
             return *it;
         }
         const int idx = extension.indexOf(QLatin1Char('.'));
         if (idx < 0) {
             return std::shared_ptr<ArchiveDefinition>();
         }
         extension = extension.mid(idx + 1);
     }
 }
 
 void DecryptVerifyFilesController::Private::prepareWizardFromPassedFiles()
 {
     ensureWizardCreated();
     const std::vector< std::shared_ptr<ArchiveDefinition> > archiveDefinitions = ArchiveDefinition::getArchiveDefinitions();
 
     unsigned int counter = 0;
     for (const auto &fname: qAsConst(m_passedFiles)) {
         kleo_assert(!fname.isEmpty());
 
         const unsigned int classification = classify(fname);
         const Protocol proto = findProtocol(classification);
 
         if (mayBeOpaqueSignature(classification) || mayBeCipherText(classification) || mayBeDetachedSignature(classification)) {
 
             DecryptVerifyOperationWidget *const op = m_wizard->operationWidget(counter++);
             kleo_assert(op != nullptr);
 
             op->setArchiveDefinitions(archiveDefinitions);
 
             const QString signedDataFileName = findSignedData(fname);
 
             // this breaks opaque signatures whose source files still
             // happen to exist in the same directory. Until we have
             // content-based classification, this is the most unlikely
             // case, so that's the case we break. ### FIXME remove when content-classify is done
             if (mayBeDetachedSignature(classification) && !signedDataFileName.isEmpty()) {
                 op->setMode(DecryptVerifyOperationWidget::VerifyDetachedWithSignature);
             }
             // ### end FIXME
             else if (mayBeOpaqueSignature(classification) || mayBeCipherText(classification)) {
                 op->setMode(DecryptVerifyOperationWidget::DecryptVerifyOpaque, q->pick_archive_definition(proto, archiveDefinitions, fname));
             } else {
                 op->setMode(DecryptVerifyOperationWidget::VerifyDetachedWithSignature);
             }
 
             op->setInputFileName(fname);
             op->setSignedDataFileName(signedDataFileName);
 
             m_filesAfterPreparation << fname;
 
         } else {
 
             // probably the signed data file was selected:
             const QStringList signatures = findSignatures(fname);
 
             if (signatures.empty()) {
                 // We are assuming this is a detached signature file, but
                 // there were no signature files for it. Let's guess it's encrypted after all.
                 // ### FIXME once we have a proper heuristic for this, this should move into
                 // classify() and/or classifyContent()
                 DecryptVerifyOperationWidget *const op = m_wizard->operationWidget(counter++);
                 kleo_assert(op != nullptr);
                 op->setArchiveDefinitions(archiveDefinitions);
                 op->setMode(DecryptVerifyOperationWidget::DecryptVerifyOpaque, q->pick_archive_definition(proto, archiveDefinitions, fname));
                 op->setInputFileName(fname);
                 m_filesAfterPreparation << fname;
             } else {
                 for (const auto &s: signatures) {
                     DecryptVerifyOperationWidget *op = m_wizard->operationWidget(counter++);
                     kleo_assert(op != nullptr);
 
                     op->setArchiveDefinitions(archiveDefinitions);
                     op->setMode(DecryptVerifyOperationWidget::VerifyDetachedWithSignedData);
                     op->setInputFileName(s);
                     op->setSignedDataFileName(fname);
 
                     m_filesAfterPreparation << fname;
                 }
 
             }
         }
     }
 
     m_wizard->setOutputDirectory(heuristicBaseDirectory(m_passedFiles));
     return;
 }
 
 std::vector< std::shared_ptr<Task> > DecryptVerifyFilesController::Private::buildTasks(const QStringList &fileNames, const std::shared_ptr<OverwritePolicy> &overwritePolicy)
 {
     const bool useOutDir = m_wizard->useOutputDirectory();
     const QFileInfo outDirInfo(m_wizard->outputDirectory());
 
     kleo_assert(!useOutDir || outDirInfo.isDir());
 
     const QDir outDir(outDirInfo.absoluteFilePath());
     kleo_assert(!useOutDir || outDir.exists());
 
     std::vector<std::shared_ptr<Task> > tasks;
     for (int i = 0, end  = fileNames.size(); i != end; ++i)
         try {
             const QDir fileDir = QFileInfo(fileNames[i]).absoluteDir();
             kleo_assert(fileDir.exists());
             tasks.push_back(taskFromOperationWidget(m_wizard->operationWidget(static_cast<unsigned int>(i)), fileNames[i], useOutDir ? outDir : fileDir, overwritePolicy));
         } catch (const GpgME::Exception &e) {
             tasks.push_back(Task::makeErrorTask(e.error().code(), QString::fromLocal8Bit(e.what()), fileNames[i]));
         }
 
     return tasks;
 }
 
 void DecryptVerifyFilesController::setFiles(const QStringList &files)
 {
     d->m_passedFiles = files;
 }
 
 void DecryptVerifyFilesController::Private::ensureWizardVisible()
 {
     ensureWizardCreated();
     q->bringToForeground(m_wizard);
 }
 
 DecryptVerifyFilesController::DecryptVerifyFilesController(QObject *parent) : Controller(parent), d(new Private(this))
 {
 }
 
 DecryptVerifyFilesController::DecryptVerifyFilesController(const std::shared_ptr<const ExecutionContext> &ctx, QObject *parent) : Controller(ctx, parent), d(new Private(this))
 {
 }
 
 DecryptVerifyFilesController::~DecryptVerifyFilesController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void DecryptVerifyFilesController::start()
 {
     d->prepareWizardFromPassedFiles();
     d->ensureWizardVisible();
 }
 
 void DecryptVerifyFilesController::setOperation(DecryptVerifyOperation op)
 {
     d->m_operation = op;
 }
 
 DecryptVerifyOperation DecryptVerifyFilesController::operation() const
 {
     return d->m_operation;
 }
 
 void DecryptVerifyFilesController::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();
     }
 }
 
 void DecryptVerifyFilesController::cancel()
 {
     qCDebug(KLEOPATRA_LOG);
     try {
         d->m_errorDetected = true;
         if (d->m_wizard) {
             d->m_wizard->close();
         }
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 #include "moc_decryptverifyfilescontroller.cpp"
diff --git a/src/crypto/encryptemailtask.cpp b/src/crypto/encryptemailtask.cpp
index aaae1df54..65c96364d 100644
--- a/src/crypto/encryptemailtask.cpp
+++ b/src/crypto/encryptemailtask.cpp
@@ -1,232 +1,232 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/encryptemailtask.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 "encryptemailtask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 
 #include <Libkleo/Stl_Util>
 #include <QGpgME/Protocol>
 #include <QGpgME/EncryptJob>
 
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class EncryptEMailResult : public Task::Result
 {
     const EncryptionResult m_result;
     const AuditLog m_auditLog;
 public:
     EncryptEMailResult(const EncryptionResult &r, const AuditLog &auditLog)
         : Task::Result(), m_result(r), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLog auditLog() const override;
 };
 
 QString makeResultString(const EncryptionResult &res)
 {
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed: %1", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     return i18n("Encryption succeeded.");
 }
 
 }
 
 class EncryptEMailTask::Private
 {
     friend class ::Kleo::Crypto::EncryptEMailTask;
     EncryptEMailTask *const q;
 public:
     explicit Private(EncryptEMailTask *qq);
 
 private:
     std::unique_ptr<QGpgME::EncryptJob> createJob(GpgME::Protocol proto);
 
 private:
     void slotResult(const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     std::vector<Key> recipients;
 
     QPointer<QGpgME::EncryptJob> job;
 };
 
 EncryptEMailTask::Private::Private(EncryptEMailTask *qq)
     : q(qq),
       input(),
       output(),
       job(nullptr)
 {
 
 }
 
 EncryptEMailTask::EncryptEMailTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 EncryptEMailTask::~EncryptEMailTask() {}
 
 void EncryptEMailTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void EncryptEMailTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void EncryptEMailTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     kleo_assert(!recipients.empty());
     d->recipients = recipients;
 }
 
 Protocol EncryptEMailTask::protocol() const
 {
     kleo_assert(!d->recipients.empty());
     return d->recipients.front().protocol();
 }
 
 QString EncryptEMailTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 unsigned long long EncryptEMailTask::inputSize() const
 {
     return d->input ? d->input->size() : 0;
 }
 
 void EncryptEMailTask::doStart()
 {
     kleo_assert(!d->job);
     kleo_assert(d->input);
     kleo_assert(d->output);
     kleo_assert(!d->recipients.empty());
 
     std::unique_ptr<QGpgME::EncryptJob> job = d->createJob(protocol());
     kleo_assert(job.get());
 
     job->start(d->recipients,
                d->input->ioDevice(), d->output->ioDevice(),
                /*alwaysTrust=*/true);
 
     d->job = job.release();
 }
 
 void EncryptEMailTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::EncryptJob> EncryptEMailTask::Private::createJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     bool shouldArmor = (proto == OpenPGP || q->asciiArmor()) && !output->binaryOpt();
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(shouldArmor, /*textmode=*/false));
     kleo_assert(encryptJob.get());
     if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
         encryptJob->setOutputIsBase64Encoded(true);
     }
     connect(encryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 void EncryptEMailTask::Private::slotResult(const EncryptionResult &result)
 {
-    const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
+    const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     if (result.error().code()) {
         output->cancel();
     } else {
         output->finalize();
     }
     q->emitResult(std::shared_ptr<Result>(new EncryptEMailResult(result, AuditLog::fromJob(job))));
 }
 
 QString EncryptEMailResult::overview() const
 {
     return makeOverview(makeResultString(m_result));
 }
 
 QString EncryptEMailResult::details() const
 {
     return QString();
 }
 
 int EncryptEMailResult::errorCode() const
 {
     return m_result.error().encodedError();
 }
 
 QString EncryptEMailResult::errorString() const
 {
     return hasError() ? makeResultString(m_result) : QString();
 }
 
 AuditLog EncryptEMailResult::auditLog() const
 {
     return m_auditLog;
 }
 
 Task::Result::VisualCode EncryptEMailResult::code() const
 {
     if (m_result.error().isCanceled()) {
         return Warning;
     }
     return m_result.error().code() ? NeutralError : NeutralSuccess;
 }
 
 #include "moc_encryptemailtask.cpp"
 
diff --git a/src/crypto/gui/certificatelineedit.cpp b/src/crypto/gui/certificatelineedit.cpp
index 83d6f120f..0564454dc 100644
--- a/src/crypto/gui/certificatelineedit.cpp
+++ b/src/crypto/gui/certificatelineedit.cpp
@@ -1,329 +1,329 @@
 /*  crypto/gui/certificatelineedit.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "certificatelineedit.h"
 
 #include <QCompleter>
 #include <QPushButton>
 #include <QAction>
 #include <QSignalBlocker>
 
 #include "kleopatra_debug.h"
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 
 #include <gpgme++/key.h>
 
 #include <QGpgME/KeyForMailboxJob>
 #include <QGpgME/Protocol>
 
 using namespace Kleo;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 Q_DECLARE_METATYPE(KeyGroup)
 
 static QStringList s_lookedUpKeys;
 
 namespace
 {
 class ProxyModel : public KeyListSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     ProxyModel(QObject *parent = nullptr)
         : KeyListSortFilterProxyModel(parent)
     {
     }
 
     QVariant data(const QModelIndex &index, int role) const override
     {
         if (!index.isValid()) {
             return QVariant();
         }
 
         switch (role) {
         case Qt::DecorationRole: {
             const auto key = KeyListSortFilterProxyModel::data(index, KeyList::KeyRole).value<GpgME::Key>();
             if (!key.isNull()) {
                 return Kleo::Formatting::iconForUid(key.userID(0));
             }
 
             const auto group = KeyListSortFilterProxyModel::data(index, KeyList::GroupRole).value<KeyGroup>();
             if (!group.isNull()) {
                 return QIcon::fromTheme(QStringLiteral("group"));
             }
 
             Q_ASSERT(!key.isNull() || !group.isNull());
             return QVariant();
         }
         default:
             return KeyListSortFilterProxyModel::data(index, role);
         }
     }
 };
 } // namespace
 
 CertificateLineEdit::CertificateLineEdit(AbstractKeyListModel *model,
                                          QWidget *parent,
                                          KeyFilter *filter)
     : QLineEdit(parent),
       mFilterModel(new KeyListSortFilterProxyModel(this)),
       mCompleterFilterModel(new ProxyModel(this)),
       mCompleter(new QCompleter(this)),
       mFilter(std::shared_ptr<KeyFilter>(filter)),
       mLineAction(new QAction(this))
 {
     setPlaceholderText(i18n("Please enter a name or email address..."));
     setClearButtonEnabled(true);
     addAction(mLineAction, QLineEdit::LeadingPosition);
 
     mCompleterFilterModel->setKeyFilter(mFilter);
     mCompleterFilterModel->setSourceModel(model);
     mCompleter->setModel(mCompleterFilterModel);
     mCompleter->setCompletionColumn(KeyList::Summary);
     mCompleter->setFilterMode(Qt::MatchContains);
     mCompleter->setCaseSensitivity(Qt::CaseInsensitive);
     setCompleter(mCompleter);
     mFilterModel->setSourceModel(model);
     mFilterModel->setFilterKeyColumn(KeyList::Summary);
     if (filter) {
         mFilterModel->setKeyFilter(mFilter);
     }
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keyListingDone,
             this, &CertificateLineEdit::updateKey);
     connect(KeyCache::instance().get(), &Kleo::KeyCache::groupUpdated,
             this, [this] (const KeyGroup &group) {
                 if (!mGroup.isNull() && mGroup.source() == group.source() && mGroup.id() == group.id()) {
                     QSignalBlocker blocky(this);
                     setText(Formatting::summaryLine(group));
                     // queue the update to ensure that the model has been updated
                     QMetaObject::invokeMethod(this, &CertificateLineEdit::updateKey, Qt::QueuedConnection);
                 }
             });
     connect(KeyCache::instance().get(), &Kleo::KeyCache::groupRemoved,
             this, [this] (const KeyGroup &group) {
                 if (!mGroup.isNull() && mGroup.source() == group.source() && mGroup.id() == group.id()) {
                     mGroup = KeyGroup();
                     QSignalBlocker blocky(this);
                     clear();
                     // queue the update to ensure that the model has been updated
                     QMetaObject::invokeMethod(this, &CertificateLineEdit::updateKey, Qt::QueuedConnection);
                 }
             });
     connect(this, &QLineEdit::editingFinished,
             this, [this] () {
                 // queue the call of editFinished() to ensure that QCompleter::activated is handled first
                 QMetaObject::invokeMethod(this, &CertificateLineEdit::editFinished, Qt::QueuedConnection);
             });
     connect(this, &QLineEdit::textChanged,
             this, &CertificateLineEdit::editChanged);
     connect(mLineAction, &QAction::triggered,
             this, &CertificateLineEdit::dialogRequested);
     connect(mCompleter, QOverload<const QModelIndex &>::of(&QCompleter::activated),
             this, [this] (const QModelIndex &index) {
                 Key key = mCompleter->completionModel()->data(index, KeyList::KeyRole).value<Key>();
-                KeyGroup group = mCompleter->completionModel()->data(index, KeyList::GroupRole).value<KeyGroup>();
+                auto group = mCompleter->completionModel()->data(index, KeyList::GroupRole).value<KeyGroup>();
                 if (!key.isNull()) {
                     setKey(key);
                 } else if (!group.isNull()) {
                     setGroup(group);
                 } else {
                     qCDebug(KLEOPATRA_LOG) << "Activated item is neither key nor group";
                 }
             });
     updateKey();
 
     /* Take ownership of the model to prevent double deletion when the
      * filter models are deleted */
     model->setParent(parent ? parent : this);
 }
 
 void CertificateLineEdit::editChanged()
 {
     updateKey();
     if (!mEditStarted) {
         Q_EMIT editingStarted();
         mEditStarted = true;
     }
     mEditFinished = false;
 }
 
 void CertificateLineEdit::editFinished()
 {
     mEditStarted = false;
     mEditFinished = true;
     updateKey();
     checkLocate();
 }
 
 void CertificateLineEdit::checkLocate()
 {
     if (!key().isNull() || !group().isNull()) {
         // Already have a key or group
         return;
     }
 
     // Only check once per mailbox
     const auto mailText = text();
     if (s_lookedUpKeys.contains(mailText)) {
         return;
     }
     s_lookedUpKeys << mailText;
     qCDebug(KLEOPATRA_LOG) << "Lookup job for" << mailText;
     QGpgME::KeyForMailboxJob *job = QGpgME::openpgp()->keyForMailboxJob();
     job->start(mailText);
 }
 
 void CertificateLineEdit::updateKey()
 {
     static const _detail::ByFingerprint<std::equal_to> keysHaveSameFingerprint;
 
     const auto mailText = text();
     auto newKey = Key();
     auto newGroup = KeyGroup();
     if (mailText.isEmpty()) {
         mLineAction->setIcon(QIcon::fromTheme(QStringLiteral("resource-group-new")));
         mLineAction->setToolTip(i18n("Open selection dialog."));
     } else {
         mFilterModel->setFilterFixedString(mailText);
         if (mFilterModel->rowCount() > 1) {
             // keep current key or group if they still match
             if (!mKey.isNull()) {
                 for (int row = 0; row < mFilterModel->rowCount(); ++row) {
                     const QModelIndex index = mFilterModel->index(row, 0);
                     Key key = mFilterModel->key(index);
                     if (!key.isNull() && keysHaveSameFingerprint(key, mKey)) {
                         newKey = mKey;
                         break;
                     }
                 }
             } else if (!mGroup.isNull()) {
                 newGroup = mGroup;
                 for (int row = 0; row < mFilterModel->rowCount(); ++row) {
                     const QModelIndex index = mFilterModel->index(row, 0);
                     KeyGroup group = mFilterModel->group(index);
                     if (!group.isNull() && group.source() == mGroup.source() && group.id() == mGroup.id()) {
                         newGroup = mGroup;
                         break;
                     }
                 }
             }
             if (newKey.isNull() && newGroup.isNull()) {
                 if (mEditFinished) {
                     mLineAction->setIcon(QIcon::fromTheme(QStringLiteral("question")));
                     mLineAction->setToolTip(i18n("Multiple certificates"));
                 } else {
                     mLineAction->setIcon(QIcon::fromTheme(QStringLiteral("resource-group-new")));
                     mLineAction->setToolTip(i18n("Open selection dialog."));
                 }
             }
         } else if (mFilterModel->rowCount() == 1) {
             const auto index = mFilterModel->index(0, 0);
             newKey = mFilterModel->data(index, KeyList::KeyRole).value<Key>();
             newGroup = mFilterModel->data(index, KeyList::GroupRole).value<KeyGroup>();
             Q_ASSERT(!newKey.isNull() || !newGroup.isNull());
             if (newKey.isNull() && newGroup.isNull()) {
                 mLineAction->setIcon(QIcon::fromTheme(QStringLiteral("emblem-error")));
                 mLineAction->setToolTip(i18n("No matching certificates found.<br/>Click here to import a certificate."));
             }
         } else {
             mLineAction->setIcon(QIcon::fromTheme(QStringLiteral("emblem-error")));
             mLineAction->setToolTip(i18n("No matching certificates found.<br/>Click here to import a certificate."));
         }
     }
     mKey = newKey;
     mGroup = newGroup;
 
     if (!mKey.isNull()) {
         /* FIXME: This needs to be solved by a multiple UID supporting model */
         mLineAction->setIcon(Formatting::iconForUid(mKey.userID(0)));
         mLineAction->setToolTip(Formatting::validity(mKey.userID(0)) +
                                 QLatin1String("<br/>") + i18n("Click for details."));
         setToolTip(Formatting::toolTip(mKey, Formatting::ToolTipOption::AllOptions));
     } else if (!mGroup.isNull()) {
         mLineAction->setIcon(Formatting::validityIcon(mGroup));
         mLineAction->setToolTip(Formatting::validity(mGroup) +
                                 QLatin1String("<br/>") + i18n("Click for details."));
         setToolTip(Formatting::toolTip(mGroup, Formatting::ToolTipOption::AllOptions));
     } else {
         setToolTip(QString());
     }
 
     Q_EMIT keyChanged();
 
     if (mailText.isEmpty()) {
         Q_EMIT wantsRemoval(this);
     }
 }
 
 Key CertificateLineEdit::key() const
 {
     if (isEnabled()) {
         return mKey;
     } else {
         return Key();
     }
 }
 
 KeyGroup CertificateLineEdit::group() const
 {
     if (isEnabled()) {
         return mGroup;
     } else {
         return KeyGroup();
     }
 }
 
 void CertificateLineEdit::setKey(const Key &key)
 {
     mKey = key;
     mGroup = KeyGroup();
     QSignalBlocker blocky(this);
     qCDebug(KLEOPATRA_LOG) << "Setting Key. " << Formatting::summaryLine(key);
     setText(Formatting::summaryLine(key));
     updateKey();
 }
 
 void CertificateLineEdit::setGroup(const KeyGroup &group)
 {
     mGroup = group;
     mKey = Key();
     QSignalBlocker blocky(this);
     const QString summary = Formatting::summaryLine(group);
     qCDebug(KLEOPATRA_LOG) << "Setting KeyGroup. " << summary;
     setText(summary);
     updateKey();
 }
 
 bool CertificateLineEdit::isEmpty() const
 {
     return text().isEmpty();
 }
 
 void CertificateLineEdit::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     mFilter = filter;
     mFilterModel->setKeyFilter(filter);
     mCompleterFilterModel->setKeyFilter(mFilter);
     updateKey();
 }
 
 #include "certificatelineedit.moc"
diff --git a/src/crypto/gui/decryptverifyfilesdialog.cpp b/src/crypto/gui/decryptverifyfilesdialog.cpp
index 7ec5553cd..9c908dd66 100644
--- a/src/crypto/gui/decryptverifyfilesdialog.cpp
+++ b/src/crypto/gui/decryptverifyfilesdialog.cpp
@@ -1,244 +1,244 @@
 /* crypto/gui/decryptverifyfilesdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 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 "decryptverifyfilesdialog.h"
 
 #include "kleopatra_debug.h"
 
 #include "crypto/taskcollection.h"
 #include "crypto/decryptverifytask.h"
 #include "crypto/gui/resultpage.h"
 #include "crypto/gui/resultlistwidget.h"
 
 #include <Libkleo/FileNameRequester>
 
 #include <QWindow>
 #include <QVBoxLayout>
 #include <QProgressBar>
 #include <QLabel>
 #include <QPushButton>
 
 #include <vector>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 DecryptVerifyFilesDialog::DecryptVerifyFilesDialog(const std::shared_ptr<TaskCollection> &coll, QWidget *parent)
     : QDialog(parent), m_tasks(coll), m_buttonBox(new QDialogButtonBox)
 {
     readConfig();
     auto vLay = new QVBoxLayout(this);
     auto labels = new QWidget;
     auto outputLayout = new QHBoxLayout;
 
     m_outputLocationFNR = new FileNameRequester;
     auto outLabel = new QLabel(i18n("&Output folder:"));
     outLabel->setBuddy(m_outputLocationFNR);
     outputLayout->addWidget(outLabel);
     outputLayout->addWidget(m_outputLocationFNR);
     m_outputLocationFNR->setFilter(QDir::Dirs);
 
     vLay->addLayout(outputLayout);
 
     m_progressLabelLayout = new QVBoxLayout(labels);
     vLay->addWidget(labels);
     m_progressBar = new QProgressBar;
     vLay->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     vLay->addWidget(m_resultList);
 
     m_tasks = coll;
     Q_ASSERT(m_tasks);
     m_resultList->setTaskCollection(coll);
     connect(m_tasks.get(), &TaskCollection::progress, this, &DecryptVerifyFilesDialog::progress);
     connect(m_tasks.get(), &TaskCollection::done, this, &DecryptVerifyFilesDialog::allDone);
     connect(m_tasks.get(), &TaskCollection::result, this, &DecryptVerifyFilesDialog::result);
     connect(m_tasks.get(), &TaskCollection::started, this, &DecryptVerifyFilesDialog::started);
 
     connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
     connect(m_buttonBox, &QDialogButtonBox::clicked, this, &DecryptVerifyFilesDialog::btnClicked);
 
     layout()->addWidget(m_buttonBox);
 
     bool hasOutputs = false;
     for (const auto &t: coll->tasks()) {
         if (!qobject_cast<VerifyDetachedTask *>(t.get())) {
             hasOutputs = true;
             break;
         }
     }
     if (hasOutputs) {
         setWindowTitle(i18nc("@title:window", "Decrypt/Verify Files"));
         m_saveButton = QDialogButtonBox::SaveAll;
         m_buttonBox->addButton(QDialogButtonBox::Discard);
         connect(m_buttonBox, &QDialogButtonBox::accepted, this, &DecryptVerifyFilesDialog::checkAccept);
     } else {
         outLabel->setVisible(false);
         m_outputLocationFNR->setVisible(false);
         setWindowTitle(i18nc("@title:window", "Verify Files"));
         m_buttonBox->addButton(QDialogButtonBox::Close);
         connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     }
     if (m_saveButton) {
         m_buttonBox->addButton(m_saveButton);
         m_buttonBox->button(m_saveButton)->setEnabled(false);
     }
 }
 
 DecryptVerifyFilesDialog::~DecryptVerifyFilesDialog()
 {
     qCDebug(KLEOPATRA_LOG);
     writeConfig();
 }
 
 void DecryptVerifyFilesDialog::allDone()
 {
     qCDebug(KLEOPATRA_LOG) << "All done";
     Q_ASSERT(m_tasks);
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     for (const auto &i: m_progressLabelByTag.keys()) {
         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 (m_tasks->allTasksHaveErrors()) {
         return;
     }
     if (m_saveButton != QDialogButtonBox::NoButton) {
         m_buttonBox->button(m_saveButton)->setEnabled(true);
     } else {
         m_buttonBox->removeButton(m_buttonBox->button(QDialogButtonBox::Close));
         m_buttonBox->addButton(QDialogButtonBox::Ok);
     }
 }
 
 void DecryptVerifyFilesDialog::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const auto tag = task->tag();
     auto 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("tag( \"OpenPGP\" or \"CMS\"),  operation description", "%1: %2", tag, task->label()));
+        label->setText(i18nc(R"(tag( "OpenPGP" or "CMS"),  operation description)", "%1: %2", tag, task->label()));
     }
     if (m_saveButton != QDialogButtonBox::NoButton) {
         m_buttonBox->button(m_saveButton)->setEnabled(false);
     } else if (m_buttonBox->button(QDialogButtonBox::Ok)) {
         m_buttonBox->removeButton(m_buttonBox->button(QDialogButtonBox::Ok));
         m_buttonBox->addButton(QDialogButtonBox::Close);
     }
 }
 
 QLabel *DecryptVerifyFilesDialog::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;
 }
 
 void DecryptVerifyFilesDialog::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 DecryptVerifyFilesDialog::setOutputLocation(const QString &dir)
 {
     m_outputLocationFNR->setFileName(dir);
 }
 
 QString DecryptVerifyFilesDialog::outputLocation() const
 {
     return m_outputLocationFNR->fileName();
 }
 
 void DecryptVerifyFilesDialog::btnClicked(QAbstractButton *btn)
 {
     if (m_buttonBox->buttonRole(btn) == QDialogButtonBox::DestructiveRole) {
         close();
     }
 }
 
 void DecryptVerifyFilesDialog::checkAccept() {
     const auto outLoc = outputLocation();
     if (outLoc.isEmpty()) {
         KMessageBox::information(this, i18n("Please select an output folder."),
                                  i18n("No output folder."));
         return;
     }
     const QFileInfo fi(outLoc);
 
     if (fi.exists() && fi.isDir() && fi.isWritable()) {
         accept();
         return;
     }
 
     if (!fi.exists()) {
         qCDebug(KLEOPATRA_LOG) << "Output dir does not exist. Trying to create.";
         const QDir dir(outLoc);
         if (!dir.mkdir(outLoc)) {
             KMessageBox::information(this, i18n("Please select a different output folder."),
                                      i18n("Failed to create output folder."));
             return;
         } else {
             accept();
             return;
         }
     }
 
     KMessageBox::information(this, i18n("Please select a different output folder."),
                              i18n("Invalid output folder."));
 }
 
 void DecryptVerifyFilesDialog::readConfig()
 {
     winId(); // ensure there's a window created
 
     // set default window size
     windowHandle()->resize(640, 480);
 
     // restore size from config file
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "DecryptVerifyFilesDialog");
     KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
 
     // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
     // window was created -> QTBUG-40584. We therefore copy the size here.
     // TODO: remove once this was resolved in QWidget QPA
     resize(windowHandle()->size());
 }
 
 void DecryptVerifyFilesDialog::writeConfig()
 {
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "DecryptVerifyFilesDialog");
     KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
     cfgGroup.sync();
 }
diff --git a/src/crypto/gui/decryptverifyfileswizard.cpp b/src/crypto/gui/decryptverifyfileswizard.cpp
index 263bda89e..540a85853 100644
--- a/src/crypto/gui/decryptverifyfileswizard.cpp
+++ b/src/crypto/gui/decryptverifyfileswizard.cpp
@@ -1,253 +1,253 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/decryptverifywizard.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 "decryptverifyfileswizard.h"
 
 #include "decryptverifyoperationwidget.h"
 
 #include <crypto/gui/resultpage.h>
 #include <crypto/gui/wizardpage.h>
 
 #include <crypto/task.h>
 #include <crypto/taskcollection.h>
 
 #include <utils/scrollarea.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/FileNameRequester>
 
 #include <KLocalizedString>
 #include <KGuiItem>
 
 #include <QBoxLayout>
 #include <QCheckBox>
 #include <QLabel>
 #include <QTimer>
 #include <QTreeView>
 
 #include <vector>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 namespace
 {
 
 class HLine : public QFrame
 {
     Q_OBJECT
 public:
     explicit HLine(QWidget *p = nullptr, Qt::WindowFlags f = {})
         : QFrame(p, f)
     {
         setFrameStyle(QFrame::HLine | QFrame::Sunken);
     }
 };
 
 class OperationsWidget : public WizardPage
 {
     Q_OBJECT
 public:
     explicit OperationsWidget(QWidget *p = nullptr);
     ~OperationsWidget() override;
 
     void setOutputDirectory(const QString &dir)
     {
         m_ui.outputDirectoryFNR.setFileName(dir);
     }
 
     QString outputDirectory() const
     {
         return m_ui.outputDirectoryFNR.fileName();
     }
 
     bool useOutputDirectory() const
     {
         return m_ui.useOutputDirectoryCB.isChecked();
     }
 
     void ensureIndexAvailable(unsigned int idx);
 
     DecryptVerifyOperationWidget *widget(unsigned int idx)
     {
         return m_widgets.at(idx);
     }
 
     bool isComplete() const override
     {
         return true;
     }
 private:
     std::vector<DecryptVerifyOperationWidget *> m_widgets;
 
     struct UI {
         QCheckBox useOutputDirectoryCB;
         QLabel            outputDirectoryLB;
         FileNameRequester outputDirectoryFNR;
         ScrollArea       scrollArea; // ### replace with KDScrollArea when done
         QVBoxLayout     vlay;
         QHBoxLayout      hlay;
 
         explicit UI(OperationsWidget *q);
     } m_ui;
 };
 }
 
 class DecryptVerifyFilesWizard::Private
 {
     friend class ::Kleo::Crypto::Gui::DecryptVerifyFilesWizard;
     DecryptVerifyFilesWizard *const q;
 public:
     Private(DecryptVerifyFilesWizard *qq);
     ~Private();
 
     void ensureIndexAvailable(unsigned int idx)
     {
         operationsPage.ensureIndexAvailable(idx);
     }
 
 private:
     OperationsWidget operationsPage;
     Gui::ResultPage resultPage;
 };
 
 DecryptVerifyFilesWizard::DecryptVerifyFilesWizard(QWidget *p, Qt::WindowFlags f)
     : Wizard(p, f), d(new Private(this))
 {
 
 }
 
 DecryptVerifyFilesWizard::~DecryptVerifyFilesWizard() {}
 
 void DecryptVerifyFilesWizard::setOutputDirectory(const QString &dir)
 {
     d->operationsPage.setOutputDirectory(dir);
 }
 
 QString DecryptVerifyFilesWizard::outputDirectory() const
 {
     return d->operationsPage.outputDirectory();
 }
 
 bool DecryptVerifyFilesWizard::useOutputDirectory() const
 {
     return d->operationsPage.useOutputDirectory();
 }
 
 DecryptVerifyOperationWidget *DecryptVerifyFilesWizard::operationWidget(unsigned int idx)
 {
     d->ensureIndexAvailable(idx);
     return d->operationsPage.widget(idx);
 }
 
 void DecryptVerifyFilesWizard::onNext(int id)
 {
     if (id == OperationsPage) {
         QTimer::singleShot(0, this, &DecryptVerifyFilesWizard::operationPrepared);
     }
     Wizard::onNext(id);
 }
 
 void DecryptVerifyFilesWizard::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     kleo_assert(coll);
     d->resultPage.setTaskCollection(coll);
 }
 
 DecryptVerifyFilesWizard::Private::Private(DecryptVerifyFilesWizard *qq)
     : q(qq),
       operationsPage(q),
       resultPage(q)
 {
     q->setPage(DecryptVerifyFilesWizard::OperationsPage, &operationsPage);
     q->setPage(DecryptVerifyFilesWizard::ResultPage, &resultPage);
 
     std::vector<int> order;
     order.push_back(DecryptVerifyFilesWizard::OperationsPage);
     order.push_back(DecryptVerifyFilesWizard::ResultPage);
     q->setPageOrder(order);
     operationsPage.setCommitPage(true);
 }
 
 DecryptVerifyFilesWizard::Private::~Private() {}
 
 OperationsWidget::OperationsWidget(QWidget *p)
     : WizardPage(p), m_widgets(), m_ui(this)
 {
     setTitle(i18n("<b>Choose operations to be performed</b>"));
     setSubTitle(i18n("Here you can check and, if needed, override "
                      "the operations Kleopatra detected for the input given."));
     setCommitPage(true);
     setCustomNextButton(KGuiItem(i18n("&Decrypt/Verify")));
 }
 
 OperationsWidget::~OperationsWidget() {}
 
 OperationsWidget::UI::UI(OperationsWidget *q)
     : useOutputDirectoryCB(i18n("Create all output files in a single folder"), q),
       outputDirectoryLB(i18n("&Output folder:"), q),
       outputDirectoryFNR(q),
       scrollArea(q),
       vlay(q),
       hlay()
 {
     KDAB_SET_OBJECT_NAME(useOutputDirectoryCB);
     KDAB_SET_OBJECT_NAME(outputDirectoryLB);
     KDAB_SET_OBJECT_NAME(outputDirectoryFNR);
     KDAB_SET_OBJECT_NAME(scrollArea);
 
     KDAB_SET_OBJECT_NAME(vlay);
     KDAB_SET_OBJECT_NAME(hlay);
 
     outputDirectoryFNR.setFilter(QDir::Dirs);
 
     useOutputDirectoryCB.setChecked(true);
     connect(&useOutputDirectoryCB, &QCheckBox::toggled, &outputDirectoryLB, &QLabel::setEnabled);
     connect(&useOutputDirectoryCB, &QCheckBox::toggled, &outputDirectoryFNR, &FileNameRequester::setEnabled);
 
     Q_ASSERT(qobject_cast<QBoxLayout *>(scrollArea.widget()->layout()));
     static_cast<QBoxLayout *>(scrollArea.widget()->layout())->addStretch(1);
     outputDirectoryLB.setBuddy(&outputDirectoryFNR);
 
     hlay.setContentsMargins(0, 0, 0, 0);
 
     vlay.addWidget(&scrollArea, 1);
     vlay.addWidget(&useOutputDirectoryCB);
     vlay.addLayout(&hlay);
     hlay.addWidget(&outputDirectoryLB);
     hlay.addWidget(&outputDirectoryFNR);
 }
 
 void OperationsWidget::ensureIndexAvailable(unsigned int idx)
 {
 
     if (idx < m_widgets.size()) {
         return;
     }
 
     Q_ASSERT(m_ui.scrollArea.widget());
     Q_ASSERT(qobject_cast<QBoxLayout *>(m_ui.scrollArea.widget()->layout()));
     QBoxLayout &blay = *static_cast<QBoxLayout *>(m_ui.scrollArea.widget()->layout());
 
     for (unsigned int i = m_widgets.size(); i < idx + 1; ++i) {
         if (i) {
             blay.insertWidget(blay.count() - 1, new HLine(m_ui.scrollArea.widget()));
         }
-        DecryptVerifyOperationWidget *w = new DecryptVerifyOperationWidget(m_ui.scrollArea.widget());
+        auto w = new DecryptVerifyOperationWidget(m_ui.scrollArea.widget());
         blay.insertWidget(blay.count() - 1, w);
         w->show();
         m_widgets.push_back(w);
     }
 }
 
 #include "decryptverifyfileswizard.moc"
diff --git a/src/crypto/gui/newresultpage.cpp b/src/crypto/gui/newresultpage.cpp
index f40907b7c..a12d18544 100644
--- a/src/crypto/gui/newresultpage.cpp
+++ b/src/crypto/gui/newresultpage.cpp
@@ -1,185 +1,185 @@
 /* -*- 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);
-    QWidget *const labels = new QWidget;
+    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()) {
         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("tag( \"OpenPGP\" or \"CMS\"),  operation description", "%1: %2", tag, task->label()));
+        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;
     }
-    QLabel *label = new QLabel;
+    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/objectspage.cpp b/src/crypto/gui/objectspage.cpp
index 0d8797853..97bb900c1 100644
--- a/src/crypto/gui/objectspage.cpp
+++ b/src/crypto/gui/objectspage.cpp
@@ -1,144 +1,144 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/objectspage.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 "objectspage.h"
 
 #include <utils/filedialog.h>
 
 #include <QIcon>
 #include <KLocalizedString>
 
 #include <QFileInfo>
 #include <QListWidget>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QStringList>
 #include <QVBoxLayout>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 class ObjectsPage::Private
 {
     friend class ::Kleo::Crypto::Gui::ObjectsPage;
     ObjectsPage *const q;
 public:
     explicit Private(ObjectsPage *qq);
     ~Private();
     void add();
     void addFile(const QFileInfo &i);
     void remove();
     void listSelectionChanged();
     enum Role {
         AbsoluteFilePathRole = Qt::UserRole
     };
 
 private:
     QListWidget *fileListWidget;
     QPushButton *removeButton;
 };
 
 ObjectsPage::Private::Private(ObjectsPage *qq)
     : q(qq)
 {
     q->setTitle(i18n("<b>Objects</b>"));
-    QVBoxLayout *const top = new QVBoxLayout(q);
+    auto const top = new QVBoxLayout(q);
     fileListWidget = new QListWidget;
     fileListWidget->setSelectionMode(QAbstractItemView::MultiSelection);
     connect(fileListWidget, SIGNAL(itemSelectionChanged()), q, SLOT(listSelectionChanged()));
     top->addWidget(fileListWidget);
-    QWidget *const buttonWidget = new QWidget;
-    QHBoxLayout *const buttonLayout = new QHBoxLayout(buttonWidget);
+    auto const buttonWidget = new QWidget;
+    auto const buttonLayout = new QHBoxLayout(buttonWidget);
     removeButton = new QPushButton;
     removeButton->setText(i18n("Remove Selected"));
     connect(removeButton, SIGNAL(clicked()), q, SLOT(remove()));
     buttonLayout->addWidget(removeButton);
     buttonLayout->addStretch();
     top->addWidget(buttonWidget);
     listSelectionChanged();
 }
 
 ObjectsPage::Private::~Private() {}
 
 void ObjectsPage::Private::add()
 {
     const QString fname = FileDialog::getOpenFileName(q, i18n("Select File"), QStringLiteral("enc"));
     if (fname.isEmpty()) {
         return;
     }
     addFile(QFileInfo(fname));
     Q_EMIT q->completeChanged();
 }
 
 void ObjectsPage::Private::remove()
 {
     const QList<QListWidgetItem *> selected = fileListWidget->selectedItems();
     Q_ASSERT(!selected.isEmpty());
     for (QListWidgetItem *const i : selected) {
         delete i;
     }
     Q_EMIT q->completeChanged();
 }
 
 void ObjectsPage::Private::listSelectionChanged()
 {
     removeButton->setEnabled(!fileListWidget->selectedItems().isEmpty());
 }
 
 ObjectsPage::ObjectsPage(QWidget *parent, Qt::WindowFlags f)
     : WizardPage(parent, f), d(new Private(this))
 {
 
 }
 
 ObjectsPage::~ObjectsPage()
 {
 
 }
 
 void ObjectsPage::setFiles(const QStringList &list)
 {
     d->fileListWidget->clear();
     for (const QString &i : list) {
         d->addFile(QFileInfo(i));
     }
     Q_EMIT completeChanged();
 }
 
 void ObjectsPage::Private::addFile(const QFileInfo &info)
 {
-    QListWidgetItem *const item = new QListWidgetItem;
+    auto const item = new QListWidgetItem;
     if (info.isDir()) {
         item->setIcon(QIcon::fromTheme(QStringLiteral("folder")));
     }
     item->setText(info.fileName());
     item->setData(AbsoluteFilePathRole, info.absoluteFilePath());
     fileListWidget->addItem(item);
 }
 
 QStringList ObjectsPage::files() const
 {
     QStringList list;
     for (int i = 0; i < d->fileListWidget->count(); ++i) {
         const QListWidgetItem *const item = d->fileListWidget->item(i);
         list.push_back(item->data(Private::AbsoluteFilePathRole).toString());
     }
     return list;
 }
 
 bool ObjectsPage::isComplete() const
 {
     return d->fileListWidget->count() > 0;
 }
 
 #include "moc_objectspage.cpp"
 
diff --git a/src/crypto/gui/resolverecipientspage.cpp b/src/crypto/gui/resolverecipientspage.cpp
index ad8d7baa0..455ed698b 100644
--- a/src/crypto/gui/resolverecipientspage.cpp
+++ b/src/crypto/gui/resolverecipientspage.cpp
@@ -1,695 +1,695 @@
 /* -*- 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/kmime_header_parsing.h>
 
 #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);
-    QVBoxLayout *const layout = new QVBoxLayout(this);
+    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));
-    QListWidgetItem *item = new QListWidgetItem;
+    auto item = new QListWidgetItem;
     item->setData(IdRole, id);
-    ItemWidget *wid = new ItemWidget(id, name, mbox, this);
+    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 : qAsConst(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);
-    QHBoxLayout *layout = new QHBoxLayout(this);
+    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)
 {
-    CertificateSelectionDialog *const dlg = new CertificateSelectionDialog(parent);
+    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 : qAsConst(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>"));
-    QVBoxLayout *const layout = new QVBoxLayout(q);
+    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);
-    QWidget *buttonWidget = new QWidget;
-    QHBoxLayout *buttonLayout = new QHBoxLayout(buttonWidget);
+    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);
-    QWidget *protocolWidget = new QWidget;
-    QHBoxLayout *protocolLayout = new QHBoxLayout(protocolWidget);
-    QButtonGroup *protocolGroup = new QButtonGroup(q);
+    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 Protocol protocol = static_cast<Protocol>(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()) {
         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 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/resultitemwidget.cpp b/src/crypto/gui/resultitemwidget.cpp
index 416183101..8aa8c7189 100644
--- a/src/crypto/gui/resultitemwidget.cpp
+++ b/src/crypto/gui/resultitemwidget.cpp
@@ -1,356 +1,356 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultitemwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 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 "resultitemwidget.h"
 
 #include "utils/auditlog.h"
 #include "commands/command.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "crypto/decryptverifytask.h"
 
 #include <Libkleo/MessageBox>
 #include <Libkleo/Classify>
 
 #include <gpgme++/key.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <KLocalizedString>
 #include <QPushButton>
 #include <KStandardGuiItem>
 #include "kleopatra_debug.h"
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QUrl>
 #include <QVBoxLayout>
 #include <KGuiItem>
 #include <KColorScheme>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 namespace
 {
 // TODO move out of here
 static QColor colorForVisualCode(Task::Result::VisualCode code)
 {
     switch (code) {
     case Task::Result::AllGood:
         return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color();
     case Task::Result::NeutralError:
     case Task::Result::Warning:
         return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NormalBackground).color();
     case Task::Result::Danger:
         return KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color();
     case Task::Result::NeutralSuccess:
     default:
         return QColor(0x00, 0x80, 0xFF); // light blue
     }
 }
 static QColor txtColorForVisualCode(Task::Result::VisualCode code)
 {
     switch (code) {
     case Task::Result::AllGood:
         return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::PositiveText).color();
     case Task::Result::NeutralError:
     case Task::Result::Warning:
         return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::NormalText).color();
     case Task::Result::Danger:
         return KColorScheme(QPalette::Active, KColorScheme::View).foreground(KColorScheme::NegativeText).color();
     case Task::Result::NeutralSuccess:
     default:
         return QColor(0xFF, 0xFF, 0xFF); // white
     }
 }
 }
 
 class ResultItemWidget::Private
 {
     ResultItemWidget *const q;
 public:
     explicit Private(const std::shared_ptr<const Task::Result> &result, ResultItemWidget *qq) : q(qq), m_result(result)
     {
         Q_ASSERT(m_result);
     }
 
     void slotLinkActivated(const QString &);
     void updateShowDetailsLabel();
 
     void addKeyImportButton(QBoxLayout *lay, bool search);
     void addIgnoreMDCButton(QBoxLayout *lay);
 
     void oneImportFinished();
 
     const std::shared_ptr<const Task::Result> m_result;
     QLabel *m_detailsLabel = nullptr;
     QLabel *m_actionsLabel = nullptr;
     QPushButton *m_closeButton = nullptr;
     bool m_importCanceled = false;
 };
 
 void ResultItemWidget::Private::oneImportFinished()
 {
     if (m_importCanceled) {
         return;
     }
     if (m_result->parentTask()) {
         m_result->parentTask()->start();
     }
     q->setVisible(false);
 }
 
 void ResultItemWidget::Private::addIgnoreMDCButton(QBoxLayout *lay)
 {
     if (!m_result || !lay) {
         return;
     }
 
     const auto dvResult = dynamic_cast<const DecryptVerifyResult *>(m_result.get());
     if (!dvResult) {
         return;
     }
     const auto decResult = dvResult->decryptionResult();
 
     if (decResult.isNull() || !decResult.error() || !decResult.isLegacyCipherNoMDC())
     {
         return;
     }
 
     auto btn = new QPushButton(i18n("Force decryption"));
     btn->setFixedSize(btn->sizeHint());
 
     connect (btn, &QPushButton::clicked, q, [this] () {
         if (m_result->parentTask()) {
             const auto dvTask = dynamic_cast<DecryptVerifyTask*>(m_result->parentTask().data());
             dvTask->setIgnoreMDCError(true);
             dvTask->start();
             q->setVisible(false);
         } else {
             qCWarning(KLEOPATRA_LOG) << "Failed to get parent task";
         }
     });
     lay->addWidget(btn);
 }
 
 void ResultItemWidget::Private::addKeyImportButton(QBoxLayout *lay, bool search)
 {
     if (!m_result || !lay) {
         return;
     }
 
     const auto dvResult = dynamic_cast<const DecryptVerifyResult *>(m_result.get());
     if (!dvResult) {
         return;
     }
     const auto verifyResult = dvResult->verificationResult();
 
     if (verifyResult.isNull()) {
         return;
     }
 
     for (const auto &sig: verifyResult.signatures()) {
         if (!(sig.summary() & GpgME::Signature::KeyMissing)) {
             continue;
         }
 
         auto btn = new QPushButton;
         QString suffix;
         const auto keyid = QLatin1String(sig.fingerprint());
         if (verifyResult.numSignatures() > 1) {
             suffix = QLatin1Char(' ') + keyid;
         }
         btn = new QPushButton(search ? i18nc("1 is optional keyid. No space is intended as it can be empty.",
                                        "Search%1", suffix)
                                      : i18nc("1 is optional keyid. No space is intended as it can be empty.",
                                        "Import%1", suffix));
 
         if (search) {
             btn->setIcon(QIcon::fromTheme(QStringLiteral("edit-find")));
             connect (btn, &QPushButton::clicked, q, [this, btn, keyid] () {
                 btn->setEnabled(false);
                 m_importCanceled = false;
                 auto cmd = new Kleo::Commands::LookupCertificatesCommand(keyid, nullptr);
                 connect(cmd, &Kleo::Commands::LookupCertificatesCommand::canceled,
                         q, [this]() { m_importCanceled = true; });
                 connect(cmd, &Kleo::Commands::LookupCertificatesCommand::finished,
                         q, [this, btn]() {
                     btn->setEnabled(true);
                     oneImportFinished();
                 });
                 cmd->setParentWidget(q);
                 cmd->start();
             });
         } else {
             btn->setIcon(QIcon::fromTheme(QStringLiteral("view-certificate-import")));
             connect (btn, &QPushButton::clicked, q, [this, btn] () {
                 btn->setEnabled(false);
                 m_importCanceled = false;
                 auto cmd = new Kleo::ImportCertificateFromFileCommand();
                 connect(cmd, &Kleo::ImportCertificateFromFileCommand::canceled,
                         q, [this]() { m_importCanceled = true; });
                 connect(cmd, &Kleo::ImportCertificateFromFileCommand::finished,
                         q, [this, btn]() {
                     btn->setEnabled(true);
                     oneImportFinished();
                 });
                 cmd->setParentWidget(q);
                 cmd->start();
             });
         }
         btn->setFixedSize(btn->sizeHint());
         lay->addWidget(btn);
     }
 }
 
 static QUrl auditlog_url_template()
 {
     QUrl url(QStringLiteral("kleoresultitem://showauditlog"));
     return url;
 }
 
 void ResultItemWidget::Private::updateShowDetailsLabel()
 {
     if (!m_actionsLabel || !m_detailsLabel) {
         return;
     }
 
     const auto parentTask = m_result->parentTask();
     QString auditLogLink;
     if (m_result->hasError()) {
         auditLogLink = m_result->auditLog().formatLink(auditlog_url_template(), i18n("Diagnostics"));
     } else {
         auditLogLink = m_result->auditLog().formatLink(auditlog_url_template());
     }
     m_actionsLabel->setText(auditLogLink);
 }
 
 ResultItemWidget::ResultItemWidget(const std::shared_ptr<const Task::Result> &result, QWidget *parent, Qt::WindowFlags flags) : QWidget(parent, flags), d(new Private(result, this))
 {
     const QColor color = colorForVisualCode(d->m_result->code());
     const QColor txtColor = txtColorForVisualCode(d->m_result->code());
     const QString styleSheet = QStringLiteral("QFrame,QLabel { background-color: %1; margin: 0px; }"
                                               "QFrame#resultFrame{ border-color: %2; border-style: solid; border-radius: 3px; border-width: 1px }"
                                               "QLabel { color: %3; padding: 5px; border-radius: 3px }").arg(color.name()).arg(color.darker(150).name()).arg(txtColor.name());
-    QVBoxLayout *topLayout = new QVBoxLayout(this);
-    QFrame *frame = new QFrame;
+    auto topLayout = new QVBoxLayout(this);
+    auto frame = new QFrame;
     frame->setObjectName(QStringLiteral("resultFrame"));
     frame->setStyleSheet(styleSheet);
     topLayout->addWidget(frame);
-    QHBoxLayout *layout = new QHBoxLayout(frame);
-    QVBoxLayout *vlay = new QVBoxLayout();
-    QLabel *overview = new QLabel;
+    auto layout = new QHBoxLayout(frame);
+    auto vlay = new QVBoxLayout();
+    auto overview = new QLabel;
     overview->setWordWrap(true);
     overview->setTextFormat(Qt::RichText);
     overview->setText(d->m_result->overview());
     overview->setFocusPolicy(Qt::StrongFocus);
     overview->setStyleSheet(styleSheet);
     connect(overview, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
 
     vlay->addWidget(overview);
     layout->addLayout(vlay);
 
     const QString details = d->m_result->details();
 
-    QVBoxLayout *actionLayout = new QVBoxLayout;
+    auto actionLayout = new QVBoxLayout;
     layout->addLayout(actionLayout);
 
     d->addKeyImportButton(actionLayout, false);
     // TODO: Only show if auto-key-retrieve is not set.
     d->addKeyImportButton(actionLayout, true);
 
     d->addIgnoreMDCButton(actionLayout);
 
     d->m_actionsLabel = new QLabel;
     connect(d->m_actionsLabel, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
     actionLayout->addWidget(d->m_actionsLabel);
     d->m_actionsLabel->setFocusPolicy(Qt::StrongFocus);
     d->m_actionsLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     d->m_actionsLabel->setStyleSheet(styleSheet);
 
     d->m_detailsLabel = new QLabel;
     d->m_detailsLabel->setWordWrap(true);
     d->m_detailsLabel->setTextFormat(Qt::RichText);
     d->m_detailsLabel->setText(details);
     d->m_detailsLabel->setFocusPolicy(Qt::StrongFocus);
     d->m_detailsLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
     d->m_detailsLabel->setStyleSheet(styleSheet);
 
     connect(d->m_detailsLabel, SIGNAL(linkActivated(QString)), this, SLOT(slotLinkActivated(QString)));
     vlay->addWidget(d->m_detailsLabel);
 
     d->m_closeButton = new QPushButton;
     KGuiItem::assign(d->m_closeButton, KStandardGuiItem::close());
     d->m_closeButton->setFixedSize(d->m_closeButton->sizeHint());
     connect(d->m_closeButton, &QAbstractButton::clicked, this, &ResultItemWidget::closeButtonClicked);
     actionLayout->addWidget(d->m_closeButton);
     d->m_closeButton->setVisible(false);
 
     layout->setStretch(0, 1);
     actionLayout->addStretch(-1);
     vlay->addStretch(-1);
 
     d->updateShowDetailsLabel();
     setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Maximum);
 }
 
 ResultItemWidget::~ResultItemWidget()
 {
 }
 
 void ResultItemWidget::showCloseButton(bool show)
 {
     d->m_closeButton->setVisible(show);
 }
 
 bool ResultItemWidget::hasErrorResult() const
 {
     return d->m_result->hasError();
 }
 
 void ResultItemWidget::Private::slotLinkActivated(const QString &link)
 {
     Q_ASSERT(m_result);
     qCDebug(KLEOPATRA_LOG) << "Link activated: " << link;
     if (link.startsWith(QLatin1String("key:"))) {
         auto split = link.split(QLatin1Char(':'));
         auto fpr = split.value(1);
         if (split.size() == 2 && isFingerprint(fpr)) {
             /* There might be a security consideration here if somehow
              * a short keyid is used in a link and it collides with another.
              * So we additionally check that it really is a fingerprint. */
             auto cmd = Command::commandForQuery(fpr);
             cmd->setParentWId(q->effectiveWinId());
             cmd->start();
         } else {
             qCWarning(KLEOPATRA_LOG) << "key link invalid " << link;
         }
         return;
     }
 
     const QUrl url(link);
 
     if (url.host() == QLatin1String("showauditlog")) {
         q->showAuditLog();
         return;
     }
     qCWarning(KLEOPATRA_LOG) << "Unexpected link scheme: " << link;
 }
 
 void ResultItemWidget::showAuditLog()
 {
     MessageBox::auditLog(parentWidget(), d->m_result->auditLog().text());
 }
 
 #include "moc_resultitemwidget.cpp"
diff --git a/src/crypto/gui/resultlistwidget.cpp b/src/crypto/gui/resultlistwidget.cpp
index 8325113bd..f5f63d4cc 100644
--- a/src/crypto/gui/resultlistwidget.cpp
+++ b/src/crypto/gui/resultlistwidget.cpp
@@ -1,212 +1,212 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultlistwidget.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 "resultlistwidget.h"
 
 #include "emailoperationspreferences.h"
 
 #include <crypto/gui/resultitemwidget.h>
 
 #include <utils/scrollarea.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 #include <QPushButton>
 #include <KStandardGuiItem>
 
 #include <QLabel>
 #include <QVBoxLayout>
 
 #include <KGuiItem>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class ResultListWidget::Private
 {
     ResultListWidget *const q;
 public:
     explicit Private(ResultListWidget *qq);
 
     void result(const std::shared_ptr<const Task::Result> &result);
     void started(const std::shared_ptr<Task> &task);
     void allTasksDone();
 
     void addResultWidget(ResultItemWidget *widget);
     void setupSingle();
     void setupMulti();
     void resizeIfStandalone();
 
     std::vector< std::shared_ptr<TaskCollection> > m_collections;
     bool m_standaloneMode = false;
     int m_lastErrorItemIndex = 0;
     ScrollArea *m_scrollArea = nullptr;
     QPushButton *m_closeButton = nullptr;
     QVBoxLayout *m_layout = nullptr;
     QLabel *m_progressLabel = nullptr;
 };
 
 ResultListWidget::Private::Private(ResultListWidget *qq)
     : q(qq),
       m_collections()
 {
     m_layout = new QVBoxLayout(q);
     m_layout->setContentsMargins(0, 0, 0, 0);
     m_layout->setSpacing(0);
     m_progressLabel = new QLabel;
     m_progressLabel->setWordWrap(true);
     m_layout->addWidget(m_progressLabel);
     m_progressLabel->setVisible(false);
 
     m_closeButton = new QPushButton;
     KGuiItem::assign(m_closeButton, KStandardGuiItem::close());
     q->connect(m_closeButton, &QPushButton::clicked, q, &ResultListWidget::close);
     m_layout->addWidget(m_closeButton);
     m_closeButton->setVisible(false);
 }
 
 ResultListWidget::ResultListWidget(QWidget *parent, Qt::WindowFlags f) : QWidget(parent, f), d(new Private(this))
 {
 }
 
 ResultListWidget::~ResultListWidget()
 {
     if (!d->m_standaloneMode) {
         return;
     }
     EMailOperationsPreferences prefs;
     prefs.setDecryptVerifyPopupGeometry(geometry());
     prefs.save();
 }
 
 void ResultListWidget::Private::setupSingle()
 {
     m_layout->addStretch();
 }
 
 void ResultListWidget::Private::resizeIfStandalone()
 {
     if (m_standaloneMode) {
         q->resize(q->size().expandedTo(q->sizeHint()));
     }
 }
 
 void ResultListWidget::Private::setupMulti()
 {
     if (m_scrollArea) {
         return;    // already been here...
     }
 
     m_scrollArea = new ScrollArea;
     m_scrollArea->setFocusPolicy(Qt::NoFocus);
     Q_ASSERT(qobject_cast<QBoxLayout *>(m_scrollArea->widget()->layout()));
     static_cast<QBoxLayout *>(m_scrollArea->widget()->layout())->setContentsMargins(0, 0, 0, 0);
     static_cast<QBoxLayout *>(m_scrollArea->widget()->layout())->setSpacing(2);
     static_cast<QBoxLayout *>(m_scrollArea->widget()->layout())->addStretch();
     m_layout->insertWidget(0, m_scrollArea);
 }
 
 void ResultListWidget::Private::addResultWidget(ResultItemWidget *widget)
 {
     Q_ASSERT(widget);
     Q_ASSERT(std::any_of(m_collections.cbegin(), m_collections.cend(),
                        [](const std::shared_ptr<TaskCollection> &t) { return !t->isEmpty(); }));
 
     Q_ASSERT(m_scrollArea);
     Q_ASSERT(m_scrollArea->widget());
     Q_ASSERT(qobject_cast<QBoxLayout *>(m_scrollArea->widget()->layout()));
     QBoxLayout &blay = *static_cast<QBoxLayout *>(m_scrollArea->widget()->layout());
     blay.insertWidget(widget->hasErrorResult() ? m_lastErrorItemIndex++ : (blay.count() - 1), widget);
 
     widget->show();
     resizeIfStandalone();
 }
 
 void ResultListWidget::Private::allTasksDone()
 {
     if (!q->isComplete()) {
         return;
     }
     m_progressLabel->setVisible(false);
     resizeIfStandalone();
     Q_EMIT q->completeChanged();
 }
 
 void ResultListWidget::Private::result(const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(result);
     Q_ASSERT(std::any_of(m_collections.cbegin(), m_collections.cend(),
                        [](const std::shared_ptr<TaskCollection> &t) { return !t->isEmpty(); }));
-    ResultItemWidget *wid = new ResultItemWidget(result);
+    auto wid = new ResultItemWidget(result);
     q->connect(wid, &ResultItemWidget::linkActivated, q, &ResultListWidget::linkActivated);
     q->connect(wid, &ResultItemWidget::closeButtonClicked, q, &ResultListWidget::close);
     addResultWidget(wid);
 }
 
 bool ResultListWidget::isComplete() const
 {
     return std::all_of(d->m_collections.cbegin(), d->m_collections.cend(),
                        std::mem_fn(&TaskCollection::allTasksCompleted));
 }
 
 unsigned int ResultListWidget::totalNumberOfTasks() const
 {
     return kdtools::accumulate_transform(d->m_collections.cbegin(),
                                          d->m_collections.cend(),
                                          std::mem_fn(&TaskCollection::size), 0U);
 }
 
 unsigned int ResultListWidget::numberOfCompletedTasks() const
 {
     return kdtools::accumulate_transform(d->m_collections.cbegin(), d->m_collections.cend(),
                                          std::mem_fn(&TaskCollection::numberOfCompletedTasks), 0U);
 }
 
 void ResultListWidget::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     //clear(); ### PENDING(marc) implement
     addTaskCollection(coll);
 }
 
 void ResultListWidget::addTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     Q_ASSERT(coll); Q_ASSERT(!coll->isEmpty());
     d->m_collections.push_back(coll);
     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>)));
     connect(coll.get(), SIGNAL(done()), this, SLOT(allTasksDone()));
     d->setupMulti();
     setStandaloneMode(d->m_standaloneMode);
 }
 
 void ResultListWidget::Private::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     Q_ASSERT(m_progressLabel);
     m_progressLabel->setText(i18nc("number, operation description", "Operation %1: %2", q->numberOfCompletedTasks() + 1, task->label()));
     resizeIfStandalone();
 }
 
 void ResultListWidget::setStandaloneMode(bool standalone)
 {
     d->m_standaloneMode = standalone;
     if (totalNumberOfTasks() == 0) {
         return;
     }
     d->m_closeButton->setVisible(standalone);
     d->m_progressLabel->setVisible(standalone);
 }
 
 #include "moc_resultlistwidget.cpp"
diff --git a/src/crypto/gui/resultpage.cpp b/src/crypto/gui/resultpage.cpp
index 8a563babb..ecc7e4bfd 100644
--- a/src/crypto/gui/resultpage.cpp
+++ b/src/crypto/gui/resultpage.cpp
@@ -1,181 +1,181 @@
 /* -*- 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);
-    QWidget *const labels = new QWidget;
+    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()) {
         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("tag( \"OpenPGP\" or \"CMS\"),  operation description", "%1: %2", tag, task->label()));
+        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;
     }
-    QLabel *label = new QLabel;
+    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 e32b758f6..22474745f 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/kmime_header_parsing.h>
 
 #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)
 {
-    CertificateSelectionDialog *const dlg = new CertificateSelectionDialog(parent);
+    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 : qAsConst(ui.signers)) {
             line.showHide(proto, first, showAll, sign);
         }
         ui.selectSigningCertificatesGB.setVisible(sign && (showAll || !first));
 
         first = true;
         for (const CertificateSelectionLine &line : qAsConst(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 : qAsConst(senders)) {
             addSigner(s);
         }
 
         ui.addSelectEncryptionCertificatesGB();
         for (const Sender &s : qAsConst(senders)) {
             addRecipient(s);
         }
         for (const Recipient &r : qAsConst(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)
             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)
             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/gui/signencryptfileswizard.cpp b/src/crypto/gui/signencryptfileswizard.cpp
index 7c91a7b8f..b33fde63b 100644
--- a/src/crypto/gui/signencryptfileswizard.cpp
+++ b/src/crypto/gui/signencryptfileswizard.cpp
@@ -1,518 +1,518 @@
 /*  crypto/gui/signencryptfileswizard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 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 "signencryptfileswizard.h"
 #include "signencryptwidget.h"
 
 #include "newresultpage.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KColorScheme>
 #include <KConfigGroup>
 #include <KWindowConfig>
 
 #include <KMessageBox>
 
 #include "kleopatra_debug.h"
 #include <Libkleo/GnuPG>
 #include <Libkleo/Formatting>
 
 #include <Libkleo/FileNameRequester>
 #include <QWindow>
 #include <QVBoxLayout>
 #include <QWizardPage>
 #include <QGroupBox>
 #include <QLabel>
 #include <QIcon>
 #include <QCheckBox>
 
 
 #include <gpgme++/key.h>
 
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 enum Page {
     SigEncPageId,
     ResultPageId,
 
     NumPages
 };
 
 class SigEncPage: public QWizardPage
 {
     Q_OBJECT
 
 public:
     explicit SigEncPage(QWidget *parent = nullptr)
         : QWizardPage(parent),
           mParent((SignEncryptFilesWizard *) parent),
           mWidget(new SignEncryptWidget),
           mOutLayout(new QVBoxLayout),
           mArchive(false),
           mUseOutputDir(false)
     {
         setTitle(i18nc("@title", "Sign / Encrypt Files"));
         auto vLay = new QVBoxLayout(this);
         vLay->setContentsMargins(0, 0, 0, 0);
         vLay->addWidget(mWidget);
         connect(mWidget, &SignEncryptWidget::operationChanged, this,
                 &SigEncPage::updateCommitButton);
         connect(mWidget, &SignEncryptWidget::keysChanged, this,
                 &SigEncPage::updateFileWidgets);
         updateCommitButton(mWidget->currentOp());
 
         auto outputGrp = new QGroupBox(i18n("Output"));
         outputGrp->setLayout(mOutLayout);
 
         mPlaceholderWidget = new QLabel(i18n("Please select an action."));
         mOutLayout->addWidget(mPlaceholderWidget);
 
         mUseOutputDirChk = new QCheckBox(i18n("Encrypt / Sign each file separately."));
         mUseOutputDirChk->setToolTip(i18nc("@info",
                                             "Keep each file separate instead of creating an archive for all."));
 
         mOutLayout->addWidget(mUseOutputDirChk);
         connect (mUseOutputDirChk, &QCheckBox::toggled, this, [this] (bool state) {
                     mUseOutputDir = state;
                     mArchive = !mUseOutputDir;
                     updateFileWidgets();
                 });
 
         vLay->addWidget(outputGrp);
         setMinimumHeight(300);
     }
 
     void setEncryptionPreset(bool value)
     {
         mWidget->setEncryptionChecked(value);
     }
 
     void setSigningPreset(bool value)
     {
         mWidget->setSigningChecked(value);
     }
 
     bool isComplete() const override
     {
         return !mWidget->currentOp().isNull();
     }
 
     int nextId() const override
     {
         return ResultPageId;
     }
 
     void initializePage() override
     {
         setCommitPage(true);
     }
 
     void setArchiveForced(bool archive)
     {
         mArchive = archive;
         setArchiveMutable(!archive);
     }
 
     void setArchiveMutable(bool archive)
     {
         mUseOutputDirChk->setVisible(archive);
         if (archive) {
             const KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             mUseOutputDirChk->setChecked(archCfg.readEntry("LastUseOutputDir", false));
         } else {
             mUseOutputDirChk->setChecked(false);
         }
     }
 
     bool validatePage() override
     {
         bool sign = !mWidget->signKey().isNull();
         bool encrypt = !mWidget->selfKey().isNull() || !mWidget->recipients().empty();
         if (!mWidget->validate()) {
             return false;
         }
         mWidget->saveOwnKeys();
         if (mUseOutputDirChk->isVisible()) {
             KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             archCfg.writeEntry("LastUseOutputDir", mUseOutputDir);
         }
 
         if (sign && !encrypt && mArchive) {
             return KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>Archiving in combination with sign-only currently requires what are known as opaque signatures - "
             "unlike detached ones, these embed the content in the signature.</para>"
             "<para>This format is rather unusual. You might want to archive the files separately, "
             "and then sign the archive as one file with Kleopatra.</para>"
             "<para>Future versions of Kleopatra are expected to also support detached signatures in this case.</para>"),
             i18nc("@title:window", "Unusual Signature Warning"),
             KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
             QStringLiteral("signencryptfileswizard-archive+sign-only-warning"))
             == KMessageBox::Continue;
         } else if (sign && !encrypt) {
             return true;
         }
 
         if (!mWidget->selfKey().isNull()) {
             return true;
         }
         bool hasSecret = false;
         Q_FOREACH (const Key k, mWidget->recipients()) {
             if (k.hasSecret()) {
                 hasSecret = true;
                 break;
             }
         }
         if (!hasSecret && !mWidget->encryptSymmetric()) {
             if (KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>None of the recipients you are encrypting to seems to be your own.</para>"
             "<para>This means that you will not be able to decrypt the data anymore, once encrypted.</para>"
             "<para>Do you want to continue, or cancel to change the recipient selection?</para>"),
             i18nc("@title:window", "Encrypt-To-Self Warning"),
             KStandardGuiItem::cont(),
             KStandardGuiItem::cancel(),
             QStringLiteral("warn-encrypt-to-non-self"), KMessageBox::Notify | KMessageBox::Dangerous)
             == KMessageBox::Cancel) {
                 return false;
             }
         }
         return true;
     }
 
     std::vector<Key> recipients() const
     {
         return mWidget->recipients();
     }
 
     /* In the future we might find a usecase for multiple
      * signers */
     std::vector<Key> signers() const
     {
         const Key k = mWidget->signKey();
         if (!k.isNull()) {
             return {k};
         }
         return {};
     }
 
 private:
     QWidget *createRequester(int forKind, QBoxLayout *lay) {
         static const QMap <int, QString> icons = {
             { SignEncryptFilesWizard::SignatureCMS, QStringLiteral("document-sign") },
             { SignEncryptFilesWizard::SignaturePGP, QStringLiteral("document-sign") },
             { SignEncryptFilesWizard::CombinedPGP,  QStringLiteral("document-edit-sign-encrypt") },
             { SignEncryptFilesWizard::EncryptedPGP, QStringLiteral("document-encrypt") },
             { SignEncryptFilesWizard::EncryptedCMS, QStringLiteral("document-encrypt") },
             { SignEncryptFilesWizard::Directory,    QStringLiteral("folder") }
         };
         static const QMap <int, QString> toolTips = {
             { SignEncryptFilesWizard::SignatureCMS, i18n("The S/MIME signature.") },
             { SignEncryptFilesWizard::SignaturePGP, i18n("The signature.") },
             { SignEncryptFilesWizard::CombinedPGP,  i18n("The signed and encrypted file.") },
             { SignEncryptFilesWizard::EncryptedPGP, i18n("The encrypted file.") },
             { SignEncryptFilesWizard::EncryptedCMS, i18n("The S/MIME encrypted file.") },
             { SignEncryptFilesWizard::Directory,    i18n("Output directory.") }
         };
 
-        FileNameRequester *req = new FileNameRequester(forKind == SignEncryptFilesWizard::Directory ?
+        auto req = new FileNameRequester(forKind == SignEncryptFilesWizard::Directory ?
                                                        QDir::Dirs : QDir::Files, this);
         req->setFileName(mOutNames[forKind]);
-        QHBoxLayout *hLay = new QHBoxLayout;
-        QLabel *iconLabel = new QLabel;
-        QWidget *ret = new QWidget;
+        auto hLay = new QHBoxLayout;
+        auto iconLabel = new QLabel;
+        auto ret = new QWidget;
         iconLabel->setPixmap(QIcon::fromTheme(icons[forKind]).pixmap(32,32));
         hLay->addWidget(iconLabel);
         iconLabel->setToolTip(toolTips[forKind]);
         req->setToolTip(toolTips[forKind]);
         hLay->addWidget(req);
         ret->setLayout(hLay);
         lay->addWidget(ret);
 
         connect (req, &FileNameRequester::fileNameChanged, this,
                  [this, forKind](const QString &newName) {
                     mOutNames[forKind] = newName;
                  });
         return ret;
     }
 
 public:
     void setOutputNames(const QMap<int, QString> &names) {
         Q_ASSERT(mOutNames.isEmpty());
         mOutNames = names;
         const auto keys = mOutNames.keys();
         for (int i : keys) {
             mRequester[i] = createRequester(i, mOutLayout);
         }
         updateFileWidgets();
     }
 
     QMap <int, QString> outputNames() const {
         if (!mUseOutputDir) {
             auto ret = mOutNames;
             ret.remove(SignEncryptFilesWizard::Directory);
             return ret;
         }
         return mOutNames;
     }
 
     bool encryptSymmetric() const
     {
         return mWidget->encryptSymmetric();
     }
 
 private Q_SLOTS:
     void updateCommitButton(const QString &label)
     {
         auto btn = mParent->button(QWizard::CommitButton);
         if (!label.isEmpty()) {
             btn->setText(label);
             if (Kleo::gpgComplianceP("de-vs")) {
                 bool de_vs = mWidget->isDeVsAndValid();
                 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()));
                 mParent->setLabelText(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()));
             }
         } else {
             btn->setText(i18n("Next"));
             btn->setIcon(QIcon());
             btn->setStyleSheet(QString());
         }
         Q_EMIT completeChanged();
     }
 
     void updateFileWidgets()
     {
         if (mRequester.isEmpty()) {
             return;
         }
         const std::vector<Key> recipients = mWidget->recipients();
         const Key sigKey = mWidget->signKey();
         bool pgp = mWidget->encryptSymmetric();
         bool cms = false;
 
         for (const Key &k : recipients) {
             if (pgp && cms) {
                 break;
             }
             if (k.protocol() == Protocol::OpenPGP) {
                 pgp = true;
             } else {
                 cms = true;
             }
         }
         mOutLayout->setEnabled(false);
         mPlaceholderWidget->setVisible(!cms && !pgp && sigKey.isNull());
         mRequester[SignEncryptFilesWizard::SignatureCMS]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::CMS);
         mRequester[SignEncryptFilesWizard::EncryptedCMS]->setVisible(!mUseOutputDir && cms);
         mRequester[SignEncryptFilesWizard::CombinedPGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && pgp);
         mRequester[SignEncryptFilesWizard::EncryptedPGP]->setVisible(!mUseOutputDir && pgp && sigKey.protocol() != Protocol::OpenPGP);
         mRequester[SignEncryptFilesWizard::SignaturePGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && !pgp);
         mRequester[SignEncryptFilesWizard::Directory]->setVisible(mUseOutputDir && !mPlaceholderWidget->isVisible());
         mOutLayout->setEnabled(true);
     }
 
 private:
     SignEncryptFilesWizard *mParent;
     SignEncryptWidget *mWidget;
     QMap <int, QString> mOutNames;
     QMap <int, QWidget *> mRequester;
     QVBoxLayout *mOutLayout;
     QWidget *mPlaceholderWidget;
     QCheckBox *mUseOutputDirChk;
     bool mArchive;
     bool mUseOutputDir;
 };
 
 class ResultPage : public NewResultPage
 {
     Q_OBJECT
 
 public:
     explicit ResultPage(QWidget *parent = nullptr)
         : NewResultPage(parent),
           mParent((SignEncryptFilesWizard *) parent)
     {
         setTitle(i18nc("@title", "Results"));
         setSubTitle(i18nc("@title",
                           "Status and progress of the crypto operations is shown here."));
     }
 
     void initializePage() override
     {
         mParent->setLabelText(QString());
     }
 
 private:
     SignEncryptFilesWizard *mParent;
 };
 
 SignEncryptFilesWizard::SignEncryptFilesWizard(QWidget *parent, Qt::WindowFlags f)
     : QWizard(parent, f)
 {
     readConfig();
 
     bool de_vs = Kleo::gpgComplianceP("de-vs");
 #ifdef Q_OS_WIN
     // Enforce modern style to avoid vista style ugliness.
     setWizardStyle(QWizard::ModernStyle);
 #endif
     mSigEncPage = new SigEncPage(this);
     mResultPage = new ResultPage(this);
 
     connect(this, &QWizard::currentIdChanged, this,
             &SignEncryptFilesWizard::slotCurrentIdChanged);
     setPage(SigEncPageId, mSigEncPage);
     setPage(ResultPageId, mResultPage);
     setOptions(QWizard::IndependentPages |
                (de_vs ? QWizard::HaveCustomButton1 : (QWizard::WizardOption) 0) |
                QWizard::NoBackButtonOnLastPage |
                QWizard::NoBackButtonOnStartPage);
 
     if (de_vs) {
         /* We use a custom button to display a label next to the
            buttons.  */
         mLabel = button(QWizard::CustomButton1);
         /* We style the button so that it looks and acts like a
            label.  */
         mLabel->setStyleSheet(QStringLiteral("border: none"));
         mLabel->setFocusPolicy(Qt::NoFocus);
     } else {
         mLabel = nullptr;
     }
 }
 
 void SignEncryptFilesWizard::setLabelText(const QString &label) const
 {
     if (mLabel) {
         mLabel->setText(label);
     }
 }
 
 void SignEncryptFilesWizard::slotCurrentIdChanged(int id)
 {
     if (id == ResultPageId) {
         Q_EMIT operationPrepared();
     }
 }
 
 SignEncryptFilesWizard::~SignEncryptFilesWizard()
 {
     qCDebug(KLEOPATRA_LOG);
     writeConfig();
 }
 
 void SignEncryptFilesWizard::setSigningPreset(bool preset)
 {
     mSigEncPage->setSigningPreset(preset);
 }
 
 void SignEncryptFilesWizard::setSigningUserMutable(bool mut)
 {
     if (mut == mSigningUserMutable) {
         return;
     }
     mSigningUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setEncryptionPreset(bool preset)
 {
     mSigEncPage->setEncryptionPreset(preset);
 }
 
 void SignEncryptFilesWizard::setEncryptionUserMutable(bool mut)
 {
     if (mut == mEncryptionUserMutable) {
         return;
     }
     mEncryptionUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setArchiveForced(bool archive)
 {
     mSigEncPage->setArchiveForced(archive);
 }
 
 void SignEncryptFilesWizard::setArchiveMutable(bool archive)
 {
     mSigEncPage->setArchiveMutable(archive);
 }
 
 std::vector<Key> SignEncryptFilesWizard::resolvedRecipients() const
 {
     return mSigEncPage->recipients();
 }
 
 std::vector<Key> SignEncryptFilesWizard::resolvedSigners() const
 {
     return mSigEncPage->signers();
 }
 
 void SignEncryptFilesWizard::setTaskCollection(const std::shared_ptr<Kleo::Crypto::TaskCollection> &coll)
 {
     mResultPage->setTaskCollection(coll);
 }
 
 void SignEncryptFilesWizard::setOutputNames(const QMap<int, QString> &map) const
 {
     mSigEncPage->setOutputNames(map);
 }
 
 QMap<int, QString> SignEncryptFilesWizard::outputNames() const
 {
     return mSigEncPage->outputNames();
 }
 
 bool SignEncryptFilesWizard::encryptSymmetric() const
 {
     return mSigEncPage->encryptSymmetric();
 }
 
 void SignEncryptFilesWizard::readConfig()
 {
     winId(); // ensure there's a window created
 
     // set default window size
     windowHandle()->resize(640, 480);
 
     // restore size from config file
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
     KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
 
     // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
     // window was created -> QTBUG-40584. We therefore copy the size here.
     // TODO: remove once this was resolved in QWidget QPA
     resize(windowHandle()->size());
 }
 
 void SignEncryptFilesWizard::writeConfig()
 {
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
     KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
     cfgGroup.sync();
 }
 
 
 #include "signencryptfileswizard.moc"
diff --git a/src/crypto/gui/signencryptwidget.cpp b/src/crypto/gui/signencryptwidget.cpp
index 604c6c33f..d7dbc0c24 100644
--- a/src/crypto/gui/signencryptwidget.cpp
+++ b/src/crypto/gui/signencryptwidget.cpp
@@ -1,612 +1,612 @@
 /*  crypto/gui/signencryptwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "signencryptwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include "certificatelineedit.h"
 #include "settings.h"
 #include "unknownrecipientwidget.h"
 
 #include "commands/detailscommand.h"
 
 #include "dialogs/certificateselectiondialog.h"
 #include "dialogs/groupdetailsdialog.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QScrollArea>
 #include <QScrollBar>
 
 #include <Libkleo/DefaultKeyFilter>
 #include <Libkleo/KeyCache>
 #include <Libkleo/KeyGroup>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeySelectionCombo>
 #include <Libkleo/KeyListSortFilterProxyModel>
 
 #include <Libkleo/GnuPG>
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KMessageBox>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 namespace {
 class SignCertificateFilter: public DefaultKeyFilter
 {
 public:
     SignCertificateFilter(GpgME::Protocol proto) : DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setHasSecret(DefaultKeyFilter::Set);
         setCanSign(DefaultKeyFilter::Set);
 
         if (proto == GpgME::OpenPGP) {
             setIsOpenPGP(DefaultKeyFilter::Set);
         } else if (proto == GpgME::CMS) {
             setIsOpenPGP(DefaultKeyFilter::NotSet);
         }
     }
 };
 class EncryptCertificateFilter: public DefaultKeyFilter
 {
 public:
     EncryptCertificateFilter(GpgME::Protocol proto): DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
 
         if (proto == GpgME::OpenPGP) {
             setIsOpenPGP(DefaultKeyFilter::Set);
         } else if (proto == GpgME::CMS) {
             setIsOpenPGP(DefaultKeyFilter::NotSet);
         }
     }
 };
 class EncryptSelfCertificateFilter: public EncryptCertificateFilter
 {
 public:
     EncryptSelfCertificateFilter(GpgME::Protocol proto): EncryptCertificateFilter(proto)
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setCanEncrypt(DefaultKeyFilter::Set);
         setHasSecret(DefaultKeyFilter::Set);
     }
 };
 }
 
 SignEncryptWidget::SignEncryptWidget(QWidget *parent, bool sigEncExclusive)
     : QWidget(parent),
       mModel(AbstractKeyListModel::createFlatKeyListModel(this)),
       mRecpRowCount(2),
       mIsExclusive(sigEncExclusive)
 {
-    QVBoxLayout *lay = new QVBoxLayout(this);
+    auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     mModel->useKeyCache(true, KeyList::IncludeGroups);
 
     /* The signature selection */
-    QHBoxLayout *sigLay = new QHBoxLayout;
-    QGroupBox *sigGrp = new QGroupBox(i18n("Prove authenticity (sign)"));
+    auto sigLay = new QHBoxLayout;
+    auto sigGrp = new QGroupBox(i18n("Prove authenticity (sign)"));
     mSigChk = new QCheckBox(i18n("Sign as:"));
     mSigChk->setChecked(true);
 
     mSigSelect = new KeySelectionCombo();
 
     sigLay->addWidget(mSigChk);
     sigLay->addWidget(mSigSelect, 1);
     sigGrp->setLayout(sigLay);
     lay->addWidget(sigGrp);
 
     connect(mSigChk, &QCheckBox::toggled, mSigSelect, &QWidget::setEnabled);
     connect(mSigChk, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSigSelect, &KeySelectionCombo::currentKeyChanged,
             this, &SignEncryptWidget::updateOp);
 
     // Recipient selection
     mRecpLayout = new QGridLayout;
     mRecpLayout->setAlignment(Qt::AlignTop);
-    QVBoxLayout *encBoxLay = new QVBoxLayout;
-    QGroupBox *encBox = new QGroupBox(i18nc("@action", "Encrypt"));
+    auto encBoxLay = new QVBoxLayout;
+    auto encBox = new QGroupBox(i18nc("@action", "Encrypt"));
     encBox->setLayout(encBoxLay);
     encBox->setAlignment(Qt::AlignLeft);
 
     // Own key
     mSelfSelect = new KeySelectionCombo();
     mEncSelfChk = new QCheckBox(i18n("Encrypt for me:"));
     mEncSelfChk->setChecked(true);
     mRecpLayout->addWidget(mEncSelfChk, 0, 0);
     mRecpLayout->addWidget(mSelfSelect, 0, 1);
 
     // Checkbox for other keys
     mEncOtherChk = new QCheckBox(i18n("Encrypt for others:"));
     mRecpLayout->addWidget(mEncOtherChk, 1, 0);
     mEncOtherChk->setChecked(true);
     connect(mEncOtherChk, &QCheckBox::toggled, this,
         [this](bool toggled) {
             for (CertificateLineEdit *edit : qAsConst(mRecpWidgets)) {
                 edit->setEnabled(toggled);
             }
             updateOp();
         });
 
     // Scroll area for other keys
-    QWidget *recipientWidget = new QWidget;
-    QScrollArea *recipientScroll = new QScrollArea;
+    auto recipientWidget = new QWidget;
+    auto recipientScroll = new QScrollArea;
     recipientWidget->setLayout(mRecpLayout);
     recipientScroll->setWidget(recipientWidget);
     recipientScroll->setWidgetResizable(true);
     recipientScroll->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
     recipientScroll->setFrameStyle(QFrame::NoFrame);
     mRecpLayout->setContentsMargins(0, 0, 0, 0);
     encBoxLay->addWidget(recipientScroll, 1);
 
     auto bar = recipientScroll->verticalScrollBar();
     connect (bar, &QScrollBar::rangeChanged, this, [bar] (int, int max) {
             bar->setValue(max);
         });
 
 
     // Checkbox for password
     mSymmetric = new QCheckBox(i18n("Encrypt with password. Anyone you share the password with can read the data."));
     mSymmetric->setToolTip(i18nc("Tooltip information for symetric encryption",
                                  "Additionally to the keys of the recipients you can encrypt your data with a password. "
                                  "Anyone who has the password can read the data without any secret key. "
                                  "Using a password is <b>less secure</b> then public key cryptography. Even if you pick a very strong password."));
     encBoxLay->addWidget(mSymmetric);
 
     // Connect it
     connect(encBox, &QGroupBox::toggled, recipientWidget, &QWidget::setEnabled);
     connect(encBox, &QGroupBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mEncSelfChk, &QCheckBox::toggled, mSelfSelect, &QWidget::setEnabled);
     connect(mEncSelfChk, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSymmetric, &QCheckBox::toggled, this, &SignEncryptWidget::updateOp);
     connect(mSelfSelect, &KeySelectionCombo::currentKeyChanged,
             this, &SignEncryptWidget::updateOp);
 
     if (mIsExclusive) {
         connect(mEncOtherChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mSigChk->setChecked(false);
             }
         });
         connect(mEncSelfChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mSigChk->setChecked(false);
             }
         });
         connect(mSigChk, &QCheckBox::toggled, this, [this](bool value) {
             if (mCurrentProto != GpgME::CMS) {
                 return;
             }
             if (value) {
                 mEncSelfChk->setChecked(false);
                 mEncOtherChk->setChecked(false);
             }
         });
     }
 
     // Ensure that the mSigChk is aligned togehter with the encryption check boxes.
     mSigChk->setMinimumWidth(qMax(mEncOtherChk->width(), mEncSelfChk->width()));
 
     lay->addWidget(encBox);
 
     loadKeys();
     setProtocol(GpgME::UnknownProtocol);
     addRecipientWidget();
     updateOp();
 }
 
 CertificateLineEdit *SignEncryptWidget::addRecipientWidget()
 {
-    CertificateLineEdit *certSel = new CertificateLineEdit(mModel, this,
+    auto certSel = new CertificateLineEdit(mModel, this,
                                                            new EncryptCertificateFilter(mCurrentProto));
     mRecpWidgets << certSel;
 
     if (!mRecpLayout->itemAtPosition(mRecpRowCount - 1, 1)) {
         // First widget. Should align with the row above that
         // contains the encrypt for others checkbox.
         mRecpLayout->addWidget(certSel, mRecpRowCount - 1, 1);
     } else {
         mRecpLayout->addWidget(certSel, mRecpRowCount++, 1);
     }
 
     connect(certSel, &CertificateLineEdit::keyChanged,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::wantsRemoval,
             this, &SignEncryptWidget::recpRemovalRequested);
     connect(certSel, &CertificateLineEdit::editingStarted,
             this, [this] () { addRecipientWidget(); });
     connect(certSel, &CertificateLineEdit::dialogRequested,
             this, [this, certSel] () { dialogRequested(certSel); });
 
     return certSel;
 }
 
 void SignEncryptWidget::addRecipient(const Key &key)
 {
     CertificateLineEdit *certSel = addRecipientWidget();
     if (!key.isNull()) {
         certSel->setKey(key);
         mAddedKeys << key;
     }
 }
 
 void SignEncryptWidget::addRecipient(const KeyGroup &group)
 {
     CertificateLineEdit *certSel = addRecipientWidget();
     if (!group.isNull()) {
         certSel->setGroup(group);
         mAddedGroups << group;
     }
 }
 
 void SignEncryptWidget::dialogRequested(CertificateLineEdit *certificateLineEdit)
 {
     if (!certificateLineEdit->key().isNull()) {
         auto cmd = new Commands::DetailsCommand(certificateLineEdit->key(), nullptr);
         cmd->start();
         return;
     }
     if (!certificateLineEdit->group().isNull()) {
-        GroupDetailsDialog *dlg = new GroupDetailsDialog;
+        auto dlg = new GroupDetailsDialog;
         dlg->setAttribute(Qt::WA_DeleteOnClose);
         dlg->setGroup(certificateLineEdit->group());
         dlg->show();
         return;
     }
 
-    CertificateSelectionDialog *const dlg = new CertificateSelectionDialog(this);
+    auto const dlg = new CertificateSelectionDialog(this);
 
     dlg->setOptions(CertificateSelectionDialog::Options(
         CertificateSelectionDialog::MultiSelection |
         CertificateSelectionDialog::EncryptOnly |
         CertificateSelectionDialog::optionsFromProtocol(mCurrentProto) |
         CertificateSelectionDialog::IncludeGroups));
 
     if (dlg->exec()) {
         const std::vector<Key> keys = dlg->selectedCertificates();
         const std::vector<KeyGroup> groups = dlg->selectedGroups();
         if (keys.size() == 0 && groups.size() == 0) {
             return;
         }
         bool isFirstItem = true;
         for (const Key &key : keys) {
             if (isFirstItem) {
                 certificateLineEdit->setKey(key);
                 isFirstItem = false;
             } else {
                 addRecipient(key);
             }
         }
         for (const KeyGroup &group : groups) {
             if (isFirstItem) {
                 certificateLineEdit->setGroup(group);
                 isFirstItem = false;
             } else {
                 addRecipient(group);
             }
         }
     }
     delete dlg;
     recipientsChanged();
 }
 
 void SignEncryptWidget::clearAddedRecipients()
 {
     for (auto w: qAsConst(mUnknownWidgets)) {
         mRecpLayout->removeWidget(w);
         delete w;
     }
 
     for (auto &key: qAsConst(mAddedKeys)) {
         removeRecipient(key);
     }
 
     for (auto &group: qAsConst(mAddedGroups)) {
         removeRecipient(group);
     }
 }
 
 void SignEncryptWidget::addUnknownRecipient(const char *keyID)
 {
     auto unknownWidget = new UnknownRecipientWidget(keyID);
     mUnknownWidgets << unknownWidget;
 
     if (!mRecpLayout->itemAtPosition(mRecpRowCount - 1, 1)) {
         // First widget. Should align with the row above that
         // contains the encrypt for others checkbox.
         mRecpLayout->addWidget(unknownWidget, mRecpRowCount - 1, 1);
     } else {
         mRecpLayout->addWidget(unknownWidget, mRecpRowCount++, 1);
     }
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, [this] () {
         // Check if any unknown recipient can now be found.
         for (auto w: mUnknownWidgets) {
             auto key = KeyCache::instance()->findByKeyIDOrFingerprint(w->keyID().toLatin1().constData());
             if (key.isNull()) {
                 std::vector<std::string> subids;
                 subids.push_back(std::string(w->keyID().toLatin1().constData()));
                 for (const auto &subkey: KeyCache::instance()->findSubkeysByKeyID(subids)) {
                     key = subkey.parent();
                 }
             }
             if (key.isNull()) {
                 continue;
             }
             // Key is now available replace by line edit.
             qCDebug(KLEOPATRA_LOG) << "Removing widget for keyid: " << w->keyID();
             mRecpLayout->removeWidget(w);
             mUnknownWidgets.removeAll(w);
             delete w;
             addRecipient(key);
         }
     });
 }
 
 void SignEncryptWidget::recipientsChanged()
 {
     bool oneEmpty = false;
     for (const CertificateLineEdit *w : qAsConst(mRecpWidgets)) {
         if (w->key().isNull() && w->group().isNull()) {
             oneEmpty = true;
             break;
         }
     }
     if (!oneEmpty) {
         addRecipientWidget();
     }
     updateOp();
 }
 
 Key SignEncryptWidget::signKey() const
 {
     if (mSigSelect->isEnabled()) {
         return mSigSelect->currentKey();
     }
     return Key();
 }
 
 Key SignEncryptWidget::selfKey() const
 {
     if (mSelfSelect->isEnabled()) {
         return mSelfSelect->currentKey();
     }
     return Key();
 }
 
 std::vector<Key> SignEncryptWidget::recipients() const
 {
     std::vector<Key> ret;
     for (const CertificateLineEdit *w : qAsConst(mRecpWidgets)) {
         if (!w->isEnabled()) {
             // If one is disabled, all are disabled.
             break;
         }
         const Key k = w->key();
         const KeyGroup g = w->group();
         if (!k.isNull()) {
             ret.push_back(k);
         } else if (!g.isNull()) {
             const auto keys = g.keys();
             std::copy(keys.begin(), keys.end(), std::back_inserter(ret));
         }
     }
     const Key k = selfKey();
     if (!k.isNull()) {
         ret.push_back(k);
     }
     return ret;
 }
 
 bool SignEncryptWidget::isDeVsAndValid() const
 {
     if (!signKey().isNull()
         && (!IS_DE_VS(signKey()) || keyValidity(signKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     if (!selfKey().isNull()
         && (!IS_DE_VS(selfKey()) || keyValidity(selfKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     for (const auto &key: recipients()) {
         if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
             return false;
         }
     }
 
     return true;
 }
 
 void SignEncryptWidget::updateOp()
 {
     const Key sigKey = signKey();
     const std::vector<Key> recp = recipients();
 
     QString newOp;
     if (!sigKey.isNull() && (!recp.empty() || encryptSymmetric())) {
         newOp = i18nc("@action", "Sign / Encrypt");
     } else if (!recp.empty() || encryptSymmetric()) {
         newOp = i18nc("@action", "Encrypt");
     } else if (!sigKey.isNull()) {
         newOp = i18nc("@action", "Sign");
     } else {
         newOp = QString();
     }
     mOp = newOp;
     Q_EMIT operationChanged(mOp);
     Q_EMIT keysChanged();
 }
 
 QString SignEncryptWidget::currentOp() const
 {
     return mOp;
 }
 
 void SignEncryptWidget::recpRemovalRequested(CertificateLineEdit *w)
 {
     if (!w) {
         return;
     }
     int emptyEdits = 0;
     for (const CertificateLineEdit *edit : qAsConst(mRecpWidgets)) {
         if (edit->isEmpty()) {
             emptyEdits++;
         }
         if (emptyEdits > 1) {
             int row, col, rspan, cspan;
             mRecpLayout->getItemPosition(mRecpLayout->indexOf(w), &row, &col, &rspan, &cspan);
             mRecpLayout->removeWidget(w);
             mRecpWidgets.removeAll(w);
             // The row count of the grid layout does not reflect the actual
             // items so we keep our internal count.
             mRecpRowCount--;
             for (int i = row + 1; i <= mRecpRowCount; i++) {
                 // move widgets one up
                 auto item = mRecpLayout->itemAtPosition(i, 1);
                 if (!item) {
                     break;
                 }
                 mRecpLayout->removeItem(item);
                 mRecpLayout->addItem(item, i - 1, 1);
             }
             w->deleteLater();
             return;
         }
     }
 }
 
 void SignEncryptWidget::removeRecipient(const GpgME::Key &key)
 {
     for (CertificateLineEdit *edit: qAsConst(mRecpWidgets)) {
         const auto editKey = edit->key();
         if (key.isNull() && editKey.isNull()) {
             recpRemovalRequested(edit);
             return;
         }
         if (editKey.primaryFingerprint() &&
             key.primaryFingerprint() &&
             !strcmp(editKey.primaryFingerprint(), key.primaryFingerprint())) {
             recpRemovalRequested(edit);
             return;
         }
     }
 }
 
 void SignEncryptWidget::removeRecipient(const KeyGroup &group)
 {
     for (CertificateLineEdit *edit: qAsConst(mRecpWidgets)) {
         const auto editGroup = edit->group();
         if (group.isNull() && editGroup.isNull()) {
             recpRemovalRequested(edit);
             return;
         }
         if (editGroup.name() == group.name()) {
             recpRemovalRequested(edit);
             return;
         }
     }
 }
 
 bool SignEncryptWidget::encryptSymmetric() const
 {
     return mSymmetric->isChecked();
 }
 
 void SignEncryptWidget::loadKeys()
 {
     KConfigGroup keys(KSharedConfig::openConfig(), "SignEncryptKeys");
     auto cache = KeyCache::instance();
     mSigSelect->setDefaultKey(keys.readEntry("SigningKey", QString()));
     mSelfSelect->setDefaultKey(keys.readEntry("EncryptKey", QString()));
 }
 
 void SignEncryptWidget::saveOwnKeys() const
 {
     KConfigGroup keys(KSharedConfig::openConfig(), "SignEncryptKeys");
     auto sigKey = mSigSelect->currentKey();
     auto encKey = mSelfSelect->currentKey();
     if (!sigKey.isNull()) {
         keys.writeEntry("SigningKey", sigKey.primaryFingerprint());
     }
     if (!encKey.isNull()) {
         keys.writeEntry("EncryptKey", encKey.primaryFingerprint());
     }
 }
 
 void SignEncryptWidget::setSigningChecked(bool value)
 {
     mSigChk->setChecked(value);
 }
 
 void SignEncryptWidget::setEncryptionChecked(bool value)
 {
     mEncSelfChk->setChecked(value);
     mEncOtherChk->setChecked(value);
 }
 
 void SignEncryptWidget::setProtocol(GpgME::Protocol proto)
 {
     if (mCurrentProto == proto) {
         return;
     }
     mCurrentProto = proto;
     mSigSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new SignCertificateFilter(proto)));
     mSelfSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new EncryptSelfCertificateFilter(proto)));
     const auto encFilter = std::shared_ptr<KeyFilter>(new EncryptCertificateFilter(proto));
     for (CertificateLineEdit *edit : qAsConst(mRecpWidgets)) {
         edit->setKeyFilter(encFilter);
     }
 
     if (mIsExclusive) {
         mSymmetric->setDisabled(proto == GpgME::CMS);
         if (mSymmetric->isChecked() && proto == GpgME::CMS) {
             mSymmetric->setChecked(false);
         }
         if (mSigChk->isChecked() && proto == GpgME::CMS &&
                 (mEncSelfChk->isChecked() || mEncOtherChk->isChecked())) {
             mSigChk->setChecked(false);
         }
     }
 }
 
 bool SignEncryptWidget::validate()
 {
     for (const auto edit: qAsConst(mRecpWidgets)) {
         if (!edit->isEmpty() && edit->key().isNull() && edit->group().isNull()) {
             KMessageBox::error(this, i18nc("%1 is user input that could not be found",
                         "Could not find a key for '%1'", edit->text().toHtmlEscaped()),
                     i18n("Failed to find recipient"), KMessageBox::Notify);
             return false;
         }
     }
     return true;
 }
diff --git a/src/crypto/gui/signencryptwizard.h b/src/crypto/gui/signencryptwizard.h
index ffe4aa545..10d967cda 100644
--- a/src/crypto/gui/signencryptwizard.h
+++ b/src/crypto/gui/signencryptwizard.h
@@ -1,138 +1,138 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptwizard.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <crypto/gui/wizard.h>
 
 #include <crypto/gui/signerresolvepage.h>
 
 #include <utils/pimpl_ptr.h>
 
 #include <gpgme++/global.h>
 #include <kmime/kmime_header_parsing.h>
 
 #include <memory>
 #include <vector>
 
 namespace GpgME
 {
 class Key;
 }
 
 class QFileInfo;
 template <typename T> class QList;
-typedef QList<QFileInfo> QFileInfoList;
+using QFileInfoList = QList<QFileInfo>;
 
 namespace Kleo
 {
 namespace Crypto
 {
 
 class Task;
 class TaskCollection;
 
 namespace Gui
 {
 
 class ObjectsPage;
 class ResolveRecipientsPage;
 class ResultPage;
 class SignerResolvePage;
 
 class SignEncryptWizard : public Wizard
 {
     Q_OBJECT
 public:
     explicit SignEncryptWizard(QWidget *parent = nullptr, Qt::WindowFlags f = {});
     ~SignEncryptWizard() override;
 
     enum Page {
         ResolveSignerPage = 0,
         ObjectsPage,
         ResolveRecipientsPage,
         ResultPage
     };
 
     void setCommitPage(Page);
 
     GpgME::Protocol presetProtocol() const;
     void setPresetProtocol(GpgME::Protocol proto);
 
     GpgME::Protocol selectedProtocol() const;
 
     /// SignOrEncryptFiles mode subinterface
     //@{
 
     QFileInfoList resolvedFiles() const;
     void setFiles(const QStringList &files);
 
     bool signingSelected() const;
     void setSigningSelected(bool selected);
 
     bool encryptionSelected() const;
     void setEncryptionSelected(bool selected);
 
     bool isSigningUserMutable() const;
     void setSigningUserMutable(bool isMutable);
 
     bool isEncryptionUserMutable() const;
     void setEncryptionUserMutable(bool isMutable);
 
     bool isMultipleProtocolsAllowed() const;
     void setMultipleProtocolsAllowed(bool allowed);
 
     //@}
 
     void setRecipients(const std::vector<KMime::Types::Mailbox> &recipients, const std::vector<KMime::Types::Mailbox> &encryptoToSelfRecipients);
 
     /** if true, the user is allowed to remove/add recipients via the UI.
      * Defaults to @p false.
      */
     bool recipientsUserMutable() const;
     void setRecipientsUserMutable(bool isMutable);
 
     void setSignersAndCandidates(const std::vector<KMime::Types::Mailbox> &signers, const std::vector< std::vector<GpgME::Key> > &keys);
 
     void setTaskCollection(const std::shared_ptr<TaskCollection> &tasks);
 
     std::vector<GpgME::Key> resolvedCertificates() const;
     std::vector<GpgME::Key> resolvedSigners() const;
 
     bool isAsciiArmorEnabled() const;
     void setAsciiArmorEnabled(bool enabled);
 
     bool keepResultPageOpenWhenDone() const;
     void setKeepResultPageOpenWhenDone(bool keep);
 
     void onNext(int currentId) override;
 
 Q_SIGNALS:
     void signersResolved();
     void objectsResolved();
     void recipientsResolved();
 
 protected:
     Gui::SignerResolvePage *signerResolvePage();
     const Gui::SignerResolvePage *signerResolvePage() const;
     Gui::ObjectsPage *objectsPage();
     Gui::ResultPage *resultPage();
     Gui::ResolveRecipientsPage *resolveRecipientsPage();
 
     void setSignerResolvePageValidator(const std::shared_ptr<SignerResolvePage::Validator> &validator);
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 }
 }
 }
 
diff --git a/src/crypto/gui/signerresolvepage.cpp b/src/crypto/gui/signerresolvepage.cpp
index a2d2a7f1e..96f339e07 100644
--- a/src/crypto/gui/signerresolvepage.cpp
+++ b/src/crypto/gui/signerresolvepage.cpp
@@ -1,666 +1,666 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signerresolvepage.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 "signerresolvepage.h"
 #include "signerresolvepage_p.h"
 
 #include "signingcertificateselectiondialog.h"
 
 #include <crypto/certificateresolver.h>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <utils/kleo_assert.h>
 
 
 #include <gpgme++/key.h>
 
 #include <QDialog>
 #include <KLocalizedString>
 
 #include <QButtonGroup>
 #include <QCheckBox>
 #include <QGridLayout>
 #include <QGroupBox>
 #include <QLabel>
 #include <QPointer>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QVBoxLayout>
 #include <QVector>
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 namespace
 {
 static SignerResolvePage::Operation operationFromFlags(bool sign, bool encrypt)
 {
     if (!encrypt && sign) {
         return SignerResolvePage::SignOnly;
     }
     if (!sign && encrypt) {
         return SignerResolvePage::EncryptOnly;
     }
     return SignerResolvePage::SignAndEncrypt;
 }
 
 static QString formatLabel(Protocol p, const Key &key)
 {
     return i18nc("%1=protocol (S/Mime, OpenPGP), %2=certificate", "Sign using %1: %2", Formatting::displayName(p),
                  !key.isNull() ? Formatting::formatForComboBox(key) : i18n("No certificate selected"));
 }
 
 static std::vector<Protocol> supportedProtocols()
 {
     std::vector<Protocol> protocols;
     protocols.push_back(OpenPGP);
     protocols.push_back(CMS);
     return protocols;
 }
 }
 
 AbstractSigningProtocolSelectionWidget::AbstractSigningProtocolSelectionWidget(QWidget *p, Qt::WindowFlags f) : QWidget(p, f)
 {
 }
 
 ReadOnlyProtocolSelectionWidget::ReadOnlyProtocolSelectionWidget(QWidget *p, Qt::WindowFlags f) : AbstractSigningProtocolSelectionWidget(p, f)
 {
-    QVBoxLayout *const layout = new QVBoxLayout(this);
+    auto const layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     const auto supportedProtocolsLst = supportedProtocols();
     for (const Protocol i: supportedProtocolsLst) {
-        QLabel *const l = new QLabel;
+        auto const l = new QLabel;
         l->setText(formatLabel(i, Key()));
         layout->addWidget(l);
         m_labels[i] =  l;
     }
 }
 
 void ReadOnlyProtocolSelectionWidget::setProtocolChecked(Protocol protocol, bool checked)
 {
     QLabel *const l = label(protocol);
     Q_ASSERT(l);
     l->setVisible(checked);
 }
 
 bool ReadOnlyProtocolSelectionWidget::isProtocolChecked(Protocol protocol) const
 {
     QLabel *const l = label(protocol);
     Q_ASSERT(l);
     return l->isVisible();
 }
 
 std::set<Protocol> ReadOnlyProtocolSelectionWidget::checkedProtocols() const
 {
     std::set<Protocol> res;
     Q_FOREACH (const Protocol i, supportedProtocols())  //krazy:exclude=foreach
         if (isProtocolChecked(i)) {
             res.insert(i);
         }
     return res;
 
 }
 
 SigningProtocolSelectionWidget::SigningProtocolSelectionWidget(QWidget *parent, Qt::WindowFlags f)
     : AbstractSigningProtocolSelectionWidget(parent, f)
 {
 
     m_buttonGroup = new QButtonGroup(this);
     connect(m_buttonGroup, &QButtonGroup::idClicked, this, &SigningProtocolSelectionWidget::userSelectionChanged);
 
-    QVBoxLayout *const layout = new QVBoxLayout(this);
+    auto const layout = new QVBoxLayout(this);
     layout->setContentsMargins(0, 0, 0, 0);
     Q_FOREACH (const Protocol i, supportedProtocols()) {   //krazy:exclude=foreach
-        QCheckBox *const b = new QCheckBox;
+        auto const b = new QCheckBox;
         b->setText(formatLabel(i, Key()));
         m_buttons[i] = b;
         layout->addWidget(b);
         m_buttonGroup->addButton(b);
     }
     setExclusive(true);
 }
 
 void SigningProtocolSelectionWidget::setProtocolChecked(Protocol p, bool checked)
 {
     Q_ASSERT(p != UnknownProtocol);
     QCheckBox *const b = button(p);
     Q_ASSERT(b);
     b->setChecked(checked);
 }
 
 bool SigningProtocolSelectionWidget::isProtocolChecked(Protocol p) const
 {
     Q_ASSERT(p != UnknownProtocol);
     const QAbstractButton *const b = button(p);
     Q_ASSERT(b);
     return b->isChecked();
 }
 
 std::set<Protocol> SigningProtocolSelectionWidget::checkedProtocols() const
 {
     std::set<Protocol> res;
-    for (std::map<Protocol, QCheckBox *>::const_iterator it = m_buttons.begin(), end = m_buttons.end();
+    for (auto it = m_buttons.begin(), end = m_buttons.end();
             it != end;
             ++it)
         if (it->second->isChecked()) {
             res.insert(it->first);
         }
     return res;
 }
 
 void SigningProtocolSelectionWidget::setExclusive(bool exclusive)
 {
     if (exclusive == isExclusive()) {
         return;
     }
     m_buttonGroup->setExclusive(exclusive);
     Q_EMIT userSelectionChanged();
 }
 
 QCheckBox *SigningProtocolSelectionWidget::button(Protocol p) const
 {
-    const std::map<Protocol, QCheckBox *>::const_iterator it = m_buttons.find(p);
+    const auto it = m_buttons.find(p);
     return it == m_buttons.end() ? nullptr : it->second;
 }
 
 QLabel *ReadOnlyProtocolSelectionWidget::label(Protocol p) const
 {
-    const std::map<Protocol, QLabel *>::const_iterator it = m_labels.find(p);
+    const auto it = m_labels.find(p);
     return it == m_labels.end() ? nullptr : it->second;
 }
 
 bool SigningProtocolSelectionWidget::isExclusive() const
 {
     return m_buttonGroup->exclusive();
 }
 
 void SigningProtocolSelectionWidget::setCertificate(Protocol prot, const Key &key)
 {
     QAbstractButton *const b = button(prot);
     Q_ASSERT(b);
     b->setText(formatLabel(prot, key));
 }
 
 void ReadOnlyProtocolSelectionWidget::setCertificate(Protocol prot, const Key &key)
 {
     QLabel *const l = label(prot);
     l->setText(formatLabel(prot, key));
 }
 
 namespace
 {
 
 class ValidatorImpl : public SignerResolvePage::Validator
 {
 public:
     QString explanation() const override
     {
         return QString();
     }
     bool isComplete() const override
     {
         return true;
     }
     QString customWindowTitle() const override
     {
         return QString();
     }
 };
 }
 
 class SignerResolvePage::Private
 {
     friend class ::Kleo::Crypto::Gui::SignerResolvePage;
     SignerResolvePage *const q;
 public:
     explicit Private(SignerResolvePage *qq);
     ~Private();
 
     void setOperation(Operation operation);
     void operationButtonClicked(int operation);
     void selectCertificates();
     void setCertificates(const QMap<GpgME::Protocol, GpgME::Key> &certs);
     void updateModeSelectionWidgets();
     void updateUi();
     bool protocolSelected(Protocol p) const;
     bool protocolSelectionActuallyUserMutable() const;
 
 private:
     QButtonGroup *signEncryptGroup;
     QRadioButton *signAndEncryptRB;
     QRadioButton *encryptOnlyRB;
     QRadioButton *signOnlyRB;
     QGroupBox *signingCertificateBox;
     QLabel *signerLabelLabel;
     QLabel *signerLabel;
     QGroupBox *encryptBox;
     QCheckBox *textArmorCO;
     QPushButton *selectCertificatesButton;
     SigningProtocolSelectionWidget *signingProtocolSelectionWidget;
     ReadOnlyProtocolSelectionWidget *readOnlyProtocolSelectionWidget;
     std::vector<Protocol> presetProtocols;
     bool signingMutable;
     bool encryptionMutable;
     bool signingSelected;
     bool encryptionSelected;
     bool multipleProtocolsAllowed;
     bool protocolSelectionUserMutable;
     QMap<GpgME::Protocol, GpgME::Key> certificates;
     std::shared_ptr<SignerResolvePage::Validator> validator;
     std::shared_ptr<SigningPreferences> signingPreferences;
 };
 
 bool SignerResolvePage::Private::protocolSelectionActuallyUserMutable() const
 {
     return (q->protocolSelectionUserMutable() || presetProtocols.empty()) && q->operation() == SignOnly;
 }
 
 SignerResolvePage::Private::Private(SignerResolvePage *qq)
     : q(qq)
     , presetProtocols()
     , signingMutable(true)
     , encryptionMutable(true)
     , signingSelected(false)
     , encryptionSelected(false)
     , multipleProtocolsAllowed(false)
     , protocolSelectionUserMutable(true)
     , validator(new ValidatorImpl)
 
 {
-    QVBoxLayout *layout = new QVBoxLayout(q);
+    auto layout = new QVBoxLayout(q);
 
     signEncryptGroup = new QButtonGroup(q);
     q->connect(signEncryptGroup, SIGNAL(buttonClicked(int)), q, SLOT(operationButtonClicked(int)));
 
     signAndEncryptRB = new QRadioButton;
     signAndEncryptRB->setText(i18n("Sign and encrypt (OpenPGP only)"));
     signAndEncryptRB->setChecked(true);
     signEncryptGroup->addButton(signAndEncryptRB, SignAndEncrypt);
     layout->addWidget(signAndEncryptRB);
 
     encryptOnlyRB = new QRadioButton;
     encryptOnlyRB->setText(i18n("Encrypt only"));
     signEncryptGroup->addButton(encryptOnlyRB, EncryptOnly);
     layout->addWidget(encryptOnlyRB);
 
     signOnlyRB = new QRadioButton;
     signOnlyRB->setText(i18n("Sign only"));
     signEncryptGroup->addButton(signOnlyRB, SignOnly);
     layout->addWidget(signOnlyRB);
 
     encryptBox = new QGroupBox;
     encryptBox->setTitle(i18n("Encryption Options"));
     QBoxLayout *const encryptLayout = new QVBoxLayout(encryptBox);
     textArmorCO = new QCheckBox;
     textArmorCO->setText(i18n("Text output (ASCII armor)"));
     encryptLayout->addWidget(textArmorCO);
     layout->addWidget(encryptBox);
 
     signingCertificateBox = new QGroupBox;
     signingCertificateBox->setTitle(i18n("Signing Options"));
-    QGridLayout *signerLayout = new QGridLayout(signingCertificateBox);
+    auto signerLayout = new QGridLayout(signingCertificateBox);
     signerLayout->setColumnStretch(1, 1);
 
     signerLabelLabel = new QLabel;
     signerLabelLabel->setText(i18n("Signer:"));
     signerLayout->addWidget(signerLabelLabel, 1, 0);
     signerLabel = new QLabel;
     signerLayout->addWidget(signerLabel, 1, 1);
     signerLabelLabel->setVisible(false);
     signerLabel->setVisible(false);
 
     signingProtocolSelectionWidget = new SigningProtocolSelectionWidget;
     connect(signingProtocolSelectionWidget, SIGNAL(userSelectionChanged()), q, SLOT(updateUi()));
     signerLayout->addWidget(signingProtocolSelectionWidget, 2, 0, 1, -1);
 
     readOnlyProtocolSelectionWidget = new ReadOnlyProtocolSelectionWidget;
     signerLayout->addWidget(readOnlyProtocolSelectionWidget, 3, 0, 1, -1);
 
     selectCertificatesButton = new QPushButton;
     selectCertificatesButton->setText(i18n("Change Signing Certificates..."));
     selectCertificatesButton->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Fixed);
     signerLayout->addWidget(selectCertificatesButton, 4, 0, 1, -1, Qt::AlignLeft);
     q->connect(selectCertificatesButton, SIGNAL(clicked()), q, SLOT(selectCertificates()));
     layout->addWidget(signingCertificateBox);
     layout->addStretch();
 }
 
 void SignerResolvePage::setValidator(const std::shared_ptr<SignerResolvePage::Validator> &validator)
 {
     Q_ASSERT(validator);
     d->validator = validator;
     d->updateUi();
 }
 
 std::shared_ptr<SignerResolvePage::Validator> SignerResolvePage::validator() const
 {
     return d->validator;
 }
 
 SignerResolvePage::Private::~Private() {}
 
 bool SignerResolvePage::Private::protocolSelected(Protocol p) const
 {
     Q_ASSERT(p != UnknownProtocol);
     return signingProtocolSelectionWidget->isProtocolChecked(p);
 }
 
 void SignerResolvePage::Private::setCertificates(const QMap<GpgME::Protocol, GpgME::Key> &certs)
 {
     certificates = certs;
     Q_FOREACH (const Protocol i, certs.keys()) {   //krazy:exclude=foreach
         const Key key = certs.value(i);
         readOnlyProtocolSelectionWidget->setCertificate(i, key);
         signingProtocolSelectionWidget->setCertificate(i, key);
     }
     updateUi();
 }
 
 void SignerResolvePage::Private::updateUi()
 {
     const bool ismutable = protocolSelectionActuallyUserMutable();
     readOnlyProtocolSelectionWidget->setVisible(!ismutable);
     signingProtocolSelectionWidget->setVisible(ismutable);
 
     q->setExplanation(validator->explanation());
     Q_EMIT q->completeChanged();
 
     const QString customTitle = validator->customWindowTitle();
     if (!customTitle.isEmpty()) {
         Q_EMIT q->windowTitleChanged(customTitle);
     }
     selectCertificatesButton->setEnabled(signingProtocolSelectionWidget->checkedProtocols().size() > 0);
 }
 
 void SignerResolvePage::setProtocolSelectionUserMutable(bool ismutable)
 {
     if (d->protocolSelectionUserMutable == ismutable) {
         return;
     }
     d->protocolSelectionUserMutable = ismutable;
     d->updateModeSelectionWidgets();
 }
 
 bool SignerResolvePage::protocolSelectionUserMutable() const
 {
     return d->protocolSelectionUserMutable;
 }
 
 void SignerResolvePage::setMultipleProtocolsAllowed(bool allowed)
 {
     if (d->multipleProtocolsAllowed == allowed) {
         return;
     }
     d->multipleProtocolsAllowed = allowed;
     d->updateModeSelectionWidgets();
 }
 
 bool SignerResolvePage::multipleProtocolsAllowed() const
 {
     return d->multipleProtocolsAllowed;
 }
 
 void SignerResolvePage::Private::updateModeSelectionWidgets()
 {
     const bool bothMutable = signingMutable && encryptionMutable;
     const bool noSigningPossible = !signingSelected && !signingMutable;
     const bool noEncryptionPossible = !encryptionSelected && !encryptionMutable;
     signAndEncryptRB->setChecked(signingSelected && encryptionSelected);
     signOnlyRB->setChecked(signingSelected && !encryptionSelected);
     encryptOnlyRB->setChecked(encryptionSelected && !signingSelected);
     const bool canSignAndEncrypt = !noSigningPossible && !noEncryptionPossible && bothMutable && presetProtocols != std::vector<Protocol>(1, CMS);
     const bool canSignOnly = !encryptionSelected || encryptionMutable;
     const bool canEncryptOnly = !signingSelected || signingMutable;
 
     signAndEncryptRB->setEnabled(canSignAndEncrypt);
     signOnlyRB->setEnabled(canSignOnly);
     encryptOnlyRB->setEnabled(canEncryptOnly);
     const bool buttonsVisible = signingMutable || encryptionMutable;
     signOnlyRB->setVisible(buttonsVisible);
     encryptOnlyRB->setVisible(buttonsVisible);
     signAndEncryptRB->setVisible(buttonsVisible);
     signingProtocolSelectionWidget->setExclusive(!multipleProtocolsAllowed);
     signingCertificateBox->setVisible(!noSigningPossible);
     encryptBox->setVisible(!noEncryptionPossible);
     updateUi();
 }
 
 void SignerResolvePage::Private::selectCertificates()
 {
     QPointer<SigningCertificateSelectionDialog> dlg = new SigningCertificateSelectionDialog(q);
     dlg->setAllowedProtocols(signingProtocolSelectionWidget->checkedProtocols());
     if (dlg->exec() == QDialog::Accepted && dlg) {
         const QMap<Protocol, Key> certs = dlg->selectedCertificates();
         setCertificates(certs);
         if (signingPreferences && dlg->rememberAsDefault()) {
             signingPreferences->setPreferredCertificate(OpenPGP, certs.value(OpenPGP));
             signingPreferences->setPreferredCertificate(CMS, certs.value(CMS));
         }
     }
 
     delete dlg;
     updateUi();
 }
 
 void SignerResolvePage::Private::operationButtonClicked(int mode_)
 {
-    const Operation op = static_cast<SignerResolvePage::Operation>(mode_);
+    const auto op = static_cast<SignerResolvePage::Operation>(mode_);
     signingCertificateBox->setEnabled(op != EncryptOnly);
     encryptBox->setEnabled(op != SignOnly);
     if (op == SignAndEncrypt) {
         signingProtocolSelectionWidget->setProtocolChecked(CMS, false);
         readOnlyProtocolSelectionWidget->setProtocolChecked(CMS, false);
         signingProtocolSelectionWidget->setProtocolChecked(OpenPGP, true);
         readOnlyProtocolSelectionWidget->setProtocolChecked(OpenPGP, true);
     }
     updateUi();
 }
 
 void SignerResolvePage::Private::setOperation(Operation op)
 {
     switch (op) {
     case SignOnly:
         signOnlyRB->click();
         break;
     case EncryptOnly:
         encryptOnlyRB->click();
         break;
     case SignAndEncrypt:
         signAndEncryptRB->click();
         break;
     }
 }
 
 SignerResolvePage::Operation SignerResolvePage::operation() const
 {
     return operationFromFlags(signingSelected(), encryptionSelected());
 }
 
 SignerResolvePage::SignerResolvePage(QWidget *parent, Qt::WindowFlags f)
     : WizardPage(parent, f), d(new Private(this))
 {
     setTitle(i18n("<b>Choose Operation to be Performed</b>"));
 //    setSubTitle( i18n( "TODO" ) );
     setPresetProtocol(UnknownProtocol);
     d->setCertificates(QMap<GpgME::Protocol, GpgME::Key>());
     d->updateModeSelectionWidgets();
     d->operationButtonClicked(EncryptOnly);
 }
 
 SignerResolvePage::~SignerResolvePage() {}
 
 void SignerResolvePage::setSignersAndCandidates(const std::vector<KMime::Types::Mailbox> &signers,
         const std::vector< std::vector<GpgME::Key> > &keys)
 {
     kleo_assert(signers.empty() || signers.size() == keys.size());
 
     switch (signers.size()) {
     case 0:
         d->signerLabelLabel->setVisible(false);
         d->signerLabel->setVisible(false);    // TODO: use default identity?
         break;
     case 1:
         d->signerLabelLabel->setVisible(true);
         d->signerLabel->setVisible(true);   // TODO: use default identity?
         d->signerLabel->setText(signers.front().prettyAddress());
         break;
     default: // > 1
         kleo_assert(!"Resolving multiple signers not implemented");
     }
     d->updateUi();
 }
 
 void SignerResolvePage::setPresetProtocol(Protocol protocol)
 {
     std::vector<Protocol> protocols;
     if (protocol != CMS) {
         protocols.push_back(OpenPGP);
     }
     if (protocol != OpenPGP) {
         protocols.push_back(CMS);
     }
     setPresetProtocols(protocols);
     d->updateUi();
 }
 
 void SignerResolvePage::setPresetProtocols(const std::vector<Protocol> &protocols)
 {
     d->presetProtocols = protocols;
     Q_FOREACH (const Protocol i, supportedProtocols()) {   //krazy:exclude=foreach
         const bool checked = std::find(protocols.begin(), protocols.end(), i) != protocols.end();
         d->signingProtocolSelectionWidget->setProtocolChecked(i, checked);
         d->readOnlyProtocolSelectionWidget->setProtocolChecked(i, checked);
     }
     d->updateModeSelectionWidgets();
 }
 
 std::set<Protocol> SignerResolvePage::selectedProtocols() const
 {
     return d->signingProtocolSelectionWidget->checkedProtocols();
 }
 
 std::vector<Key> SignerResolvePage::signingCertificates(Protocol protocol) const
 {
     std::vector<Key> result;
     if (protocol != CMS && d->signingProtocolSelectionWidget->isProtocolChecked(OpenPGP) && !d->certificates[OpenPGP].isNull()) {
         result.push_back(d->certificates[OpenPGP]);
     }
     if (protocol != OpenPGP && d->signingProtocolSelectionWidget->isProtocolChecked(CMS) && !d->certificates[CMS].isNull()) {
         result.push_back(d->certificates[CMS]);
     }
     return result;
 }
 
 std::vector<Key> SignerResolvePage::resolvedSigners() const
 {
     std::vector<Key> result = signingCertificates(CMS);
     const std::vector<Key> pgp = signingCertificates(OpenPGP);
     result.insert(result.end(), pgp.begin(), pgp.end());
     return result;
 }
 
 bool SignerResolvePage::isComplete() const
 {
     Q_ASSERT(d->validator);
     return d->validator->isComplete();
 }
 
 bool SignerResolvePage::encryptionSelected() const
 {
     return !d->signOnlyRB->isChecked();
 }
 
 void SignerResolvePage::setEncryptionSelected(bool selected)
 {
     d->encryptionSelected = selected;
     d->updateModeSelectionWidgets();
     d->setOperation(operationFromFlags(d->signingSelected, d->encryptionSelected));
 }
 
 bool SignerResolvePage::signingSelected() const
 {
     return !d->encryptOnlyRB->isChecked();
 }
 
 void SignerResolvePage::setSigningSelected(bool selected)
 {
     d->signingSelected = selected;
     d->updateModeSelectionWidgets();
     d->setOperation(operationFromFlags(d->signingSelected, d->encryptionSelected));
 }
 
 bool SignerResolvePage::isEncryptionUserMutable() const
 {
     return d->encryptionMutable;
 }
 
 bool SignerResolvePage::isSigningUserMutable() const
 {
     return d->signingMutable;
 }
 
 void SignerResolvePage::setEncryptionUserMutable(bool ismutable)
 {
     d->encryptionMutable = ismutable;
     d->updateModeSelectionWidgets();
 }
 
 void SignerResolvePage::setSigningUserMutable(bool ismutable)
 {
     d->signingMutable = ismutable;
     d->updateModeSelectionWidgets();
 }
 
 std::set<Protocol> SignerResolvePage::selectedProtocolsWithoutSigningCertificate() const
 {
     std::set<Protocol> res;
     Q_FOREACH (const Protocol i, selectedProtocols())   //krazy:exclude=foreach
         if (signingCertificates(i).empty()) {
             res.insert(i);
         }
     return res;
 }
 
 bool SignerResolvePage::isAsciiArmorEnabled() const
 {
     return d->textArmorCO->isChecked();
 }
 
 void SignerResolvePage::setAsciiArmorEnabled(bool enabled)
 {
     d->textArmorCO->setChecked(enabled);
 }
 
 void SignerResolvePage::setSigningPreferences(const std::shared_ptr<SigningPreferences> &prefs)
 {
     d->signingPreferences = prefs;
     QMap<Protocol, Key> map;
     map[OpenPGP] = prefs ? prefs->preferredCertificate(OpenPGP) : Key();
     map[CMS] = prefs ? prefs->preferredCertificate(CMS) : Key();
     d->setCertificates(map);
 }
 
 std::shared_ptr<SigningPreferences> SignerResolvePage::signingPreferences() const
 {
     return d->signingPreferences;
 }
 
 void SignerResolvePage::onNext()
 {
 }
 
 #include "moc_signerresolvepage.cpp"
 #include "moc_signerresolvepage_p.cpp"
 
diff --git a/src/crypto/gui/signingcertificateselectiondialog.cpp b/src/crypto/gui/signingcertificateselectiondialog.cpp
index 0d1eb30f7..98bcd4e09 100644
--- a/src/crypto/gui/signingcertificateselectiondialog.cpp
+++ b/src/crypto/gui/signingcertificateselectiondialog.cpp
@@ -1,62 +1,62 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signingcertificateselectiondialog.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 "signingcertificateselectiondialog.h"
 #include "signingcertificateselectionwidget.h"
 
 #include <KLocalizedString>
 
 #include <QMap>
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 SigningCertificateSelectionDialog::SigningCertificateSelectionDialog(QWidget *parent)
     : QDialog(parent),
       widget(new SigningCertificateSelectionWidget(this))
 {
     setWindowTitle(i18nc("@title:window", "Select Signing Certificates"));
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto mainLayout = new QVBoxLayout(this);
     mainLayout->addWidget(widget);
-    QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
+    auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(buttonBox, &QDialogButtonBox::accepted, this, &SigningCertificateSelectionDialog::accept);
     connect(buttonBox, &QDialogButtonBox::rejected, this, &SigningCertificateSelectionDialog::reject);
     mainLayout->addWidget(buttonBox);
 }
 
 SigningCertificateSelectionDialog::~SigningCertificateSelectionDialog() {}
 
 void SigningCertificateSelectionDialog::setSelectedCertificates(const QMap<GpgME::Protocol, GpgME::Key> &certificates)
 {
     widget->setSelectedCertificates(certificates);
 }
 
 QMap<GpgME::Protocol, GpgME::Key> SigningCertificateSelectionDialog::selectedCertificates() const
 {
     return widget->selectedCertificates();
 }
 
 bool SigningCertificateSelectionDialog::rememberAsDefault() const
 {
     return widget->rememberAsDefault();
 }
 
 void SigningCertificateSelectionDialog::setAllowedProtocols(const std::set<GpgME::Protocol> &allowedProtocols)
 {
     widget->setAllowedProtocols(allowedProtocols);
 }
 
diff --git a/src/crypto/gui/signingcertificateselectionwidget.cpp b/src/crypto/gui/signingcertificateselectionwidget.cpp
index cabdca0fb..bd50e308a 100644
--- a/src/crypto/gui/signingcertificateselectionwidget.cpp
+++ b/src/crypto/gui/signingcertificateselectionwidget.cpp
@@ -1,145 +1,145 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signingcertificateselectionwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007, 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signingcertificateselectionwidget.h"
 
 #include "ui_signingcertificateselectionwidget.h"
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <QByteArray>
 #include <QMap>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 class SigningCertificateSelectionWidget::Private
 {
     friend class ::SigningCertificateSelectionWidget;
     SigningCertificateSelectionWidget *const q;
 public:
     explicit Private(SigningCertificateSelectionWidget *qq);
     ~Private();
     static std::vector<GpgME::Key> candidates(GpgME::Protocol prot);
     static void addCandidates(GpgME::Protocol prot, QComboBox *combo);
 
 private:
     Ui::SigningCertificateSelectionWidget ui;
 };
 
 static GpgME::Key current_cert(const QComboBox &cb)
 {
     const QByteArray fpr = cb.itemData(cb.currentIndex()).toByteArray();
     return KeyCache::instance()->findByFingerprint(fpr.constData());
 }
 
 static void select_cert(QComboBox &cb, const GpgME::Key &key)
 {
     const QByteArray fpr = key.primaryFingerprint();
     if (!fpr.isEmpty()) {
         cb.setCurrentIndex(cb.findData(fpr));
     }
 }
 
 static void add_cert(QComboBox &cb, const GpgME::Key &key)
 {
     cb.addItem(Formatting::formatForComboBox(key),
                QVariant(QByteArray(key.primaryFingerprint())));
 
 }
 
 SigningCertificateSelectionWidget::Private::Private(SigningCertificateSelectionWidget *qq)
     : q(qq), ui()
 {
     ui.setupUi(q);
     addCandidates(GpgME::CMS, ui.cmsCombo);
     addCandidates(GpgME::OpenPGP, ui.pgpCombo);
     ui.rememberCO->setChecked(true);
 }
 
 SigningCertificateSelectionWidget::Private::~Private() {}
 
 SigningCertificateSelectionWidget::SigningCertificateSelectionWidget(QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, f), d(new Private(this))
 {
 
 }
 
 SigningCertificateSelectionWidget::~SigningCertificateSelectionWidget() {}
 
 void SigningCertificateSelectionWidget::setSelectedCertificates(const QMap<GpgME::Protocol, GpgME::Key> &certificates)
 {
     setSelectedCertificates(certificates[GpgME::OpenPGP], certificates[GpgME::CMS]);
 }
 
 void SigningCertificateSelectionWidget::setSelectedCertificates(const GpgME::Key &pgp, const GpgME::Key &cms)
 {
     select_cert(*d->ui.pgpCombo, pgp);
     select_cert(*d->ui.cmsCombo, cms);
 }
 
 std::vector<GpgME::Key> SigningCertificateSelectionWidget::Private::candidates(GpgME::Protocol prot)
 {
     Q_ASSERT(prot != GpgME::UnknownProtocol);
     std::vector<GpgME::Key> keys = KeyCache::instance()->keys();
-    std::vector<GpgME::Key>::iterator end = keys.end();
+    auto end = keys.end();
 
     end = std::remove_if(keys.begin(), end, [prot](const GpgME::Key &key) { return key.protocol() != prot; });
     end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) { return !key.hasSecret(); });
     Q_ASSERT(std::all_of(keys.begin(), end, [](const GpgME::Key &key) { return key.hasSecret(); }));
     end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) { return !key.canReallySign(); });
     end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) { return key.isExpired(); });
     end = std::remove_if(keys.begin(), end, [](const GpgME::Key &key) { return key.isRevoked(); });
     keys.erase(end, keys.end());
     return keys;
 }
 
 void SigningCertificateSelectionWidget::Private::addCandidates(GpgME::Protocol prot, QComboBox *combo)
 {
     const std::vector<GpgME::Key> keys = candidates(prot);
     for (const GpgME::Key &i : keys) {
         add_cert(*combo, i);
     }
 }
 
 QMap<GpgME::Protocol, GpgME::Key> SigningCertificateSelectionWidget::selectedCertificates() const
 {
     QMap<GpgME::Protocol, GpgME::Key> res;
 
     res.insert(GpgME::OpenPGP, current_cert(*d->ui.pgpCombo));
     res.insert(GpgME::CMS,     current_cert(*d->ui.cmsCombo));
 
     return res;
 }
 
 bool SigningCertificateSelectionWidget::rememberAsDefault() const
 {
     return d->ui.rememberCO->isChecked();
 }
 
 void SigningCertificateSelectionWidget::setAllowedProtocols(const std::set<GpgME::Protocol> &allowedProtocols)
 {
     setAllowedProtocols(allowedProtocols.find(GpgME::OpenPGP) != allowedProtocols.end(),
                         allowedProtocols.find(GpgME::CMS) != allowedProtocols.end());
 }
 
 void SigningCertificateSelectionWidget::setAllowedProtocols(bool pgp, bool cms)
 {
     d->ui.pgpLabel->setVisible(pgp);
     d->ui.pgpCombo->setVisible(pgp);
 
     d->ui.cmsLabel->setVisible(cms);
     d->ui.cmsCombo->setVisible(cms);
 }
 
diff --git a/src/crypto/gui/verifychecksumsdialog.cpp b/src/crypto/gui/verifychecksumsdialog.cpp
index a36a7f0be..3b037ae59 100644
--- a/src/crypto/gui/verifychecksumsdialog.cpp
+++ b/src/crypto/gui/verifychecksumsdialog.cpp
@@ -1,394 +1,394 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/verifychecksumsdialog.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 "verifychecksumsdialog.h"
 
 #ifndef QT_NO_DIRMODEL
 
 #include <KLocalizedString>
 #include <KMessageBox>
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QStringList>
 #include <QVBoxLayout>
 #include <QHash>
 #include <QTreeView>
 #include <QSortFilterProxyModel>
 #include <QDirModel>
 #include <QProgressBar>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QHeaderView>
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 namespace
 {
 
 static Qt::GlobalColor statusColor[] = {
     Qt::color0,   // Unknown - nothing
     Qt::green,    // OK
     Qt::red,      // Failed
     Qt::darkRed,  // Error
 };
 static_assert((sizeof(statusColor) / sizeof(*statusColor)) == VerifyChecksumsDialog::NumStatii, "");
 
 class ColorizedFileSystemModel : public QDirModel
 {
     Q_OBJECT
 public:
     explicit ColorizedFileSystemModel(QObject *parent = nullptr)
         : QDirModel(parent),
           statusMap()
     {
 
     }
 
     QVariant data(const QModelIndex &mi, int role = Qt::DisplayRole) const override
     {
         if (mi.isValid() && role == Qt::BackgroundRole) {
             const QHash<QString, VerifyChecksumsDialog::Status>::const_iterator
             it = statusMap.find(filePath(mi));
             if (it != statusMap.end())
                 if (const Qt::GlobalColor c = statusColor[*it]) {
                     return QColor(c);
                 }
         }
         return QDirModel::data(mi, role);
     }
 
 public Q_SLOTS:
     void setStatus(const QString &file, VerifyChecksumsDialog::Status status)
     {
 
         if (status >= VerifyChecksumsDialog::NumStatii || file.isEmpty()) {
             return;
         }
 
         // canonicalize filename:
         const QModelIndex mi = index(file);
         const QString canonical = filePath(mi);
         if (canonical.isEmpty()) {
             qCDebug(KLEOPATRA_LOG) << "can't locate file " << file;
             return;
         }
 
         const QHash<QString, VerifyChecksumsDialog::Status>::iterator
         it = statusMap.find(canonical);
 
         if (it != statusMap.end())
             if (*it == status) {
                 return;    // nothing to do
             } else {
                 *it = status;
             }
         else {
             statusMap[canonical] = status;
         }
 
         emitDataChangedFor(mi);
     }
 
     void clearStatusInformation()
     {
         using std::swap;
 
         QHash<QString, VerifyChecksumsDialog::Status> oldStatusMap;
         swap(statusMap, oldStatusMap);
 
         for (QHash<QString, VerifyChecksumsDialog::Status>::const_iterator it = oldStatusMap.constBegin(), end = oldStatusMap.constEnd(); it != end; ++it) {
             emitDataChangedFor(it.key());
         }
     }
 
 private:
     void emitDataChangedFor(const QString &file)
     {
         emitDataChangedFor(index(file));
     }
     void emitDataChangedFor(const QModelIndex &mi)
     {
         const QModelIndex p = parent(mi);
         Q_EMIT dataChanged(index(mi.row(), 0, p), index(mi.row(), columnCount(p) - 1, p));
     }
 
 private:
     QHash<QString, VerifyChecksumsDialog::Status> statusMap;
 };
 
 static int find_layout_item(const QBoxLayout &blay)
 {
     for (int i = 0, end = blay.count(); i < end; ++i)
         if (QLayoutItem *item = blay.itemAt(i))
             if (item->layout()) {
                 return i;
             }
     return 0;
 }
 
 struct BaseWidget {
     QSortFilterProxyModel proxy;
     QLabel label;
     QTreeView view;
 
     BaseWidget(QDirModel *model, QWidget *parent, QVBoxLayout *vlay)
         : proxy(),
           label(parent),
           view(parent)
     {
         KDAB_SET_OBJECT_NAME(proxy);
         KDAB_SET_OBJECT_NAME(label);
         KDAB_SET_OBJECT_NAME(view);
 
         const int row = find_layout_item(*vlay);
         vlay->insertWidget(row,   &label);
         vlay->insertWidget(row + 1, &view, 1);
 
         proxy.setSourceModel(model);
 
         view.setModel(&proxy);
 
         QRect r;
         for (int i = 0; i < proxy.columnCount(); ++i) {
             view.resizeColumnToContents(i);
         }
 
         // define some minimum sizes
         view.header()->resizeSection(0, qMax(view.header()->sectionSize(0), 220));
         view.header()->resizeSection(1, qMax(view.header()->sectionSize(1), 75));
         view.header()->resizeSection(2, qMax(view.header()->sectionSize(2), 75));
         view.header()->resizeSection(3, qMax(view.header()->sectionSize(3), 140));
 
         for (int i = 0; i < proxy.rowCount(); ++i) {
             r = r.united(view.visualRect(proxy.index(proxy.columnCount() - 1, i)));
         }
         view.setMinimumSize(QSize(qBound(r.width() + 4 * view.frameWidth(), 220 + 75 + 75 + 140 + 4 * view.frameWidth(), 1024), // 100 is the default defaultSectionSize
                                   qBound(r.height(), 220, 512)));
     }
 
     void setBase(const QString &base)
     {
         label.setText(base);
-        if (QDirModel *fsm = qobject_cast<QDirModel *>(proxy.sourceModel())) {
+        if (auto fsm = qobject_cast<QDirModel *>(proxy.sourceModel())) {
             view.setRootIndex(proxy.mapFromSource(fsm->index(base)));
         } else {
             qCWarning(KLEOPATRA_LOG) << "expect a QDirModel-derived class as proxy.sourceModel(), got ";
             if (!proxy.sourceModel()) {
                 qCWarning(KLEOPATRA_LOG) << "a null pointer";
             } else {
                 qCWarning(KLEOPATRA_LOG) << proxy.sourceModel()->metaObject()->className();
             }
         }
     }
 };
 
 } // anon namespace
 
 class VerifyChecksumsDialog::Private
 {
     friend class ::Kleo::Crypto::Gui::VerifyChecksumsDialog;
     VerifyChecksumsDialog *const q;
 public:
     explicit Private(VerifyChecksumsDialog *qq)
         : q(qq),
           bases(),
           errors(),
           model(),
           ui(q)
     {
         qRegisterMetaType<Status>("Kleo::Crypto::Gui::VerifyChecksumsDialog::Status");
     }
 
 private:
     void slotErrorButtonClicked()
     {
         KMessageBox::errorList(q, i18n("The following errors and warnings were recorded:"),
                                errors, i18n("Checksum Verification Errors"));
     }
 
 private:
     void updateErrors()
     {
         const bool active = ui.isProgressBarActive();
         ui.progressLabel.setVisible(active);
         ui.progressBar.  setVisible(active);
         ui.errorLabel.   setVisible(!active);
         ui.errorButton.  setVisible(!active && !errors.empty());
         if (errors.empty()) {
             ui.errorLabel.setText(i18n("No errors occurred"));
         } else {
             ui.errorLabel.setText(i18np("One error occurred", "%1 errors occurred", errors.size()));
         }
     }
 
 private:
     QStringList bases;
     QStringList errors;
     ColorizedFileSystemModel model;
 
     struct UI {
         std::vector<BaseWidget *> baseWidgets;
         QLabel progressLabel;
         QProgressBar progressBar;
         QLabel errorLabel;
         QPushButton errorButton;
         QDialogButtonBox buttonBox;
         QVBoxLayout vlay;
         QHBoxLayout hlay[2];
 
         explicit UI(VerifyChecksumsDialog *q)
             : baseWidgets(),
               progressLabel(i18n("Progress:"), q),
               progressBar(q),
               errorLabel(i18n("No errors occurred"), q),
               errorButton(i18nc("Show Errors", "Show"), q),
               buttonBox(QDialogButtonBox::Close, Qt::Horizontal, q),
               vlay(q)
         {
             KDAB_SET_OBJECT_NAME(progressLabel);
             KDAB_SET_OBJECT_NAME(progressBar);
             KDAB_SET_OBJECT_NAME(errorLabel);
             KDAB_SET_OBJECT_NAME(errorButton);
             KDAB_SET_OBJECT_NAME(buttonBox);
             KDAB_SET_OBJECT_NAME(vlay);
             KDAB_SET_OBJECT_NAME(hlay[0]);
             KDAB_SET_OBJECT_NAME(hlay[1]);
 
             errorButton.setAutoDefault(false);
 
             hlay[0].addWidget(&progressLabel);
             hlay[0].addWidget(&progressBar, 1);
 
             hlay[1].addWidget(&errorLabel, 1);
             hlay[1].addWidget(&errorButton);
 
             vlay.addLayout(&hlay[0]);
             vlay.addLayout(&hlay[1]);
             vlay.addWidget(&buttonBox);
 
             errorLabel.hide();
             errorButton.hide();
 
             QPushButton *close = closeButton();
 
             connect(close, &QPushButton::clicked, q, &VerifyChecksumsDialog::canceled);
             connect(close, &QPushButton::clicked, q, &VerifyChecksumsDialog::accept);
 
             connect(&errorButton, SIGNAL(clicked()), q, SLOT(slotErrorButtonClicked()));
         }
 
         ~UI()
         {
             qDeleteAll(baseWidgets);
         }
 
         QPushButton *closeButton() const
         {
             return buttonBox.button(QDialogButtonBox::Close);
         }
 
         void setBases(const QStringList &bases, QDirModel *model)
         {
 
             // create new BaseWidgets:
             for (unsigned int i = baseWidgets.size(), end = bases.size(); i < end; ++i) {
                 baseWidgets.push_back(new BaseWidget(model, vlay.parentWidget(), &vlay));
             }
 
             // shed surplus BaseWidgets:
             for (unsigned int i = bases.size(), end = baseWidgets.size(); i < end; ++i) {
                 delete baseWidgets.back();
                 baseWidgets.pop_back();
             }
 
             Q_ASSERT(static_cast<unsigned>(bases.size()) == baseWidgets.size());
 
             // update bases:
             for (unsigned int i = 0; i < baseWidgets.size(); ++i) {
                 baseWidgets[i]->setBase(bases[i]);
             }
 
         }
 
         void setProgress(int cur, int tot)
         {
             progressBar.setMaximum(tot);
             progressBar.setValue(cur);
         }
 
         bool isProgressBarActive() const
         {
             const int tot = progressBar.maximum();
             const int cur = progressBar.value();
             return !tot || cur != tot;
         }
 
     } ui;
 };
 
 VerifyChecksumsDialog::VerifyChecksumsDialog(QWidget *parent)
     : QDialog(parent),
       d(new Private(this))
 {
 
 }
 
 VerifyChecksumsDialog::~VerifyChecksumsDialog() {}
 
 // slot
 void VerifyChecksumsDialog::setBaseDirectories(const QStringList &bases)
 {
     if (d->bases == bases) {
         return;
     }
     d->bases = bases;
     d->ui.setBases(bases, &d->model);
 }
 
 // slot
 void VerifyChecksumsDialog::setErrors(const QStringList &errors)
 {
     if (d->errors == errors) {
         return;
     }
     d->errors = errors;
     d->updateErrors();
 }
 
 // slot
 void VerifyChecksumsDialog::setProgress(int cur, int tot)
 {
     d->ui.setProgress(cur, tot);
     d->updateErrors();
 }
 
 // slot
 void VerifyChecksumsDialog::setStatus(const QString &file, Status status)
 {
     d->model.setStatus(file, status);
 }
 
 // slot
 void VerifyChecksumsDialog::clearStatusInformation()
 {
     d->errors.clear();
     d->updateErrors();
     d->model.clearStatusInformation();
 }
 
 #include "verifychecksumsdialog.moc"
 #include "moc_verifychecksumsdialog.cpp"
 
 #endif // QT_NO_DIRMODEL
diff --git a/src/crypto/gui/wizard.cpp b/src/crypto/gui/wizard.cpp
index 3b2265ad2..4a17ad834 100644
--- a/src/crypto/gui/wizard.cpp
+++ b/src/crypto/gui/wizard.cpp
@@ -1,349 +1,349 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/wizard.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 "wizard.h"
 #include "wizardpage.h"
 
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/Algorithm>
 
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <QPushButton>
 #include <KStandardGuiItem>
 
 #include <QDialogButtonBox>
 #include <QFrame>
 #include <QLabel>
 #include <QStackedWidget>
 #include <QTimer>
 #include <QVBoxLayout>
 #include "kleopatra_debug.h"
 
 #include <map>
 #include <set>
 
 
 using namespace Kleo::Crypto::Gui;
 
 class Wizard::Private
 {
     friend class ::Wizard;
     Wizard *const q;
 public:
     explicit Private(Wizard *qq);
     ~Private();
 
     void updateButtonStates();
     bool isLastPage(int id) const;
     int previousPage() const;
     void updateHeader();
 
 private:
     std::vector<int> pageOrder;
     std::set<int> hiddenPages;
     std::map<int, WizardPage *> idToPage;
     int currentId = -1;
     QStackedWidget *const stack;
     QPushButton *nextButton = nullptr;
     QPushButton *backButton = nullptr;
     QPushButton *cancelButton = nullptr;
     KGuiItem finishItem;
     KGuiItem nextItem;
     QFrame *titleFrame = nullptr;
     QLabel *titleLabel = nullptr;
     QLabel *subTitleLabel = nullptr;
     QFrame *explanationFrame = nullptr;
     QLabel *explanationLabel = nullptr;
     QTimer *nextPageTimer = nullptr;
 };
 
 Wizard::Private::Private(Wizard *qq)
     : q(qq), stack(new QStackedWidget)
 {
     nextPageTimer = new QTimer(q);
     nextPageTimer->setInterval(0);
     connect(nextPageTimer, &QTimer::timeout, q, &Wizard::next);
     nextItem = KGuiItem(i18n("&Next"));
     finishItem = KStandardGuiItem::ok();
-    QVBoxLayout *const top = new QVBoxLayout(q);
+    auto const top = new QVBoxLayout(q);
     top->setContentsMargins(0, 0, 0, 0);
     titleFrame = new QFrame;
     titleFrame->setFrameShape(QFrame::StyledPanel);
     titleFrame->setAutoFillBackground(true);
     titleFrame->setBackgroundRole(QPalette::Base);
-    QVBoxLayout *const titleLayout = new QVBoxLayout(titleFrame);
+    auto const titleLayout = new QVBoxLayout(titleFrame);
     titleLabel = new QLabel;
     titleLayout->addWidget(titleLabel);
     subTitleLabel = new QLabel;
     subTitleLabel->setWordWrap(true);
     titleLayout->addWidget(subTitleLabel);
     top->addWidget(titleFrame);
     titleFrame->setVisible(false);
 
     top->addWidget(stack);
 
     explanationFrame = new QFrame;
     explanationFrame->setFrameShape(QFrame::StyledPanel);
     explanationFrame->setAutoFillBackground(true);
     explanationFrame->setBackgroundRole(QPalette::Base);
-    QVBoxLayout *const explanationLayout = new QVBoxLayout(explanationFrame);
+    auto const explanationLayout = new QVBoxLayout(explanationFrame);
     explanationLabel = new QLabel;
     explanationLabel->setWordWrap(true);
     explanationLayout->addWidget(explanationLabel);
     top->addWidget(explanationFrame);
     explanationFrame->setVisible(false);
 
-    QWidget *buttonWidget = new QWidget;
-    QHBoxLayout *buttonLayout = new QHBoxLayout(buttonWidget);
-    QDialogButtonBox *const box = new QDialogButtonBox;
+    auto buttonWidget = new QWidget;
+    auto buttonLayout = new QHBoxLayout(buttonWidget);
+    auto const box = new QDialogButtonBox;
 
     cancelButton = box->addButton(QDialogButtonBox::Cancel);
     q->connect(cancelButton, &QPushButton::clicked, q, &Wizard::reject);
 
     backButton = new QPushButton;
     backButton->setText(i18n("Back"));
     q->connect(backButton, &QPushButton::clicked, q, &Wizard::back);
     box->addButton(backButton, QDialogButtonBox::ActionRole);
 
     nextButton = new QPushButton;
     KGuiItem::assign(nextButton, nextItem);
     q->connect(nextButton, &QPushButton::clicked, q, &Wizard::next);
     box->addButton(nextButton, QDialogButtonBox::ActionRole);
     buttonLayout->addWidget(box);
 
     top->addWidget(buttonWidget);
 
     q->connect(q, &Wizard::rejected, q, &Wizard::canceled);
 }
 
 Wizard::Private::~Private()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 bool Wizard::Private::isLastPage(int id) const
 {
     return !pageOrder.empty() ? pageOrder.back() == id : false;
 }
 
 void Wizard::Private::updateButtonStates()
 {
     const bool isLast = isLastPage(currentId);
     const bool canGoToNext = q->canGoToNextPage();
     WizardPage *const page = q->page(currentId);
     const KGuiItem customNext = page ? page->customNextButton() : KGuiItem();
     if (customNext.text().isEmpty() && customNext.icon().isNull()) {
         KGuiItem::assign(nextButton, isLast ? finishItem : nextItem);
     } else {
         KGuiItem::assign(nextButton, customNext);
     }
     nextButton->setEnabled(canGoToNext);
     cancelButton->setEnabled(!isLast || !canGoToNext);
     backButton->setEnabled(q->canGoToPreviousPage());
     if (page && page->autoAdvance() && page->isComplete()) {
         nextPageTimer->start();
     }
 }
 
 void Wizard::Private::updateHeader()
 {
     WizardPage *const widget = q->page(currentId);
     Q_ASSERT(!widget || stack->indexOf(widget) != -1);
     if (widget) {
         stack->setCurrentWidget(widget);
     }
     const QString title = widget ? widget->title() : QString();
     const QString subTitle = widget ? widget->subTitle() : QString();
     const QString explanation = widget ? widget->explanation() : QString();
     titleFrame->setVisible(!title.isEmpty() || !subTitle.isEmpty() || !explanation.isEmpty());
     titleLabel->setVisible(!title.isEmpty());
     titleLabel->setText(title);
     subTitleLabel->setText(subTitle);
     subTitleLabel->setVisible(!subTitle.isEmpty());
     explanationFrame->setVisible(!explanation.isEmpty());
     explanationLabel->setVisible(!explanation.isEmpty());
     explanationLabel->setText(explanation);
     q->resize(q->sizeHint().expandedTo(q->size()));
 }
 
 Wizard::Wizard(QWidget *parent, Qt::WindowFlags f)
     : QDialog(parent, f), d(new Private(this))
 {
 
 }
 
 Wizard::~Wizard()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void Wizard::setPage(int id, WizardPage *widget)
 {
     kleo_assert(id != InvalidPage);
     kleo_assert(d->idToPage.find(id) == d->idToPage.end());
     d->idToPage[id] = widget;
     d->stack->addWidget(widget);
     connect(widget, SIGNAL(completeChanged()), this, SLOT(updateButtonStates()));
     connect(widget, SIGNAL(titleChanged()), this, SLOT(updateHeader()));
     connect(widget, SIGNAL(subTitleChanged()), this, SLOT(updateHeader()));
     connect(widget, SIGNAL(explanationChanged()), this, SLOT(updateHeader()));
     connect(widget, SIGNAL(autoAdvanceChanged()), this, SLOT(updateButtonStates()));
     connect(widget, SIGNAL(windowTitleChanged(QString)), this, SLOT(setWindowTitle(QString)));
 }
 
 void Wizard::setPageOrder(const std::vector<int> &pageOrder)
 {
     d->pageOrder = pageOrder;
     d->hiddenPages.clear();
     if (pageOrder.empty()) {
         return;
     }
     setCurrentPage(pageOrder.front());
 }
 
 void Wizard::setCurrentPage(int id)
 {
     d->currentId = id;
     if (id == InvalidPage) {
         return;
     }
     d->updateHeader();
     d->updateButtonStates();
 }
 
 void Wizard::setPageVisible(int id, bool visible)
 {
     if (visible) {
         d->hiddenPages.erase(id);
     } else {
         d->hiddenPages.insert(id);
     }
     if (currentPage() == id && !visible) {
         next();
     }
 }
 
 int Wizard::currentPage() const
 {
     return d->currentId;
 }
 
 bool Wizard::canGoToNextPage() const
 {
     const WizardPage *const current = currentPageWidget();
     return current ? current->isComplete() : false;
 }
 
 bool Wizard::canGoToPreviousPage() const
 {
     const int prev = d->previousPage();
     if (prev == InvalidPage) {
         return false;
     }
     const WizardPage *const prevPage = page(prev);
     Q_ASSERT(prevPage);
     return !prevPage->isCommitPage();
 }
 
 void Wizard::next()
 {
     WizardPage *const current = currentPageWidget();
     if (current) {
         current->onNext();
     }
     onNext(d->currentId);
-    std::vector<int>::const_iterator it = Kleo::binary_find(d->pageOrder.begin(), d->pageOrder.end(), d->currentId);
+    auto it = Kleo::binary_find(d->pageOrder.begin(), d->pageOrder.end(), d->currentId);
     Q_ASSERT(it != d->pageOrder.end());
 
     do {
         ++it;
     } while (d->hiddenPages.find(*it) != d->hiddenPages.end());
 
     if (it == d->pageOrder.end()) { // "Finish"
         d->currentId = InvalidPage;
         close();
     } else { // "next"
         setCurrentPage(*it);
     }
 }
 
 int Wizard::Private::previousPage() const
 {
     if (pageOrder.empty()) {
         return InvalidPage;
     }
 
-    std::vector<int>::const_iterator it = Kleo::binary_find(pageOrder.begin(), pageOrder.end(), currentId);
+    auto it = Kleo::binary_find(pageOrder.begin(), pageOrder.end(), currentId);
     if (it == pageOrder.begin() || it == pageOrder.end()) {
         return InvalidPage;
     }
 
     do {
         --it;
     } while (it != pageOrder.begin() && hiddenPages.find(*it) != hiddenPages.end());
     return *it;
 }
 
 void Wizard::back()
 {
     onBack(d->currentId);
     const int prev = d->previousPage();
     if (prev == InvalidPage) {
         return;
     }
     setCurrentPage(prev);
 }
 
 const WizardPage *Wizard::page(int id) const
 {
     if (id == InvalidPage) {
         return nullptr;
     }
 
-    const std::map<int, WizardPage *>::const_iterator it = d->idToPage.find(id);
+    const auto it = d->idToPage.find(id);
     kleo_assert(it != d->idToPage.end());
     return (*it).second;
 }
 
 const WizardPage *Wizard::currentPageWidget() const
 {
     return page(d->currentId);
 }
 
 WizardPage *Wizard::currentPageWidget()
 {
     return page(d->currentId);
 }
 
 void Wizard::onNext(int currentId)
 {
     Q_UNUSED(currentId)
 }
 
 void Wizard::onBack(int currentId)
 {
     Q_UNUSED(currentId)
 }
 
 WizardPage *Wizard::page(int id)
 {
     if (id == InvalidPage) {
         return nullptr;
     }
 
-    const std::map<int, WizardPage *>::const_iterator it = d->idToPage.find(id);
+    const auto it = d->idToPage.find(id);
     kleo_assert(it != d->idToPage.end());
     return (*it).second;
 }
 
 #include "moc_wizard.cpp"
diff --git a/src/crypto/signemailtask.cpp b/src/crypto/signemailtask.cpp
index 5fbd3c4e1..c6cbcae3d 100644
--- a/src/crypto/signemailtask.cpp
+++ b/src/crypto/signemailtask.cpp
@@ -1,284 +1,284 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signemailtask.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 "signemailtask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 #include <algorithm>
 #include <functional>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class SignEMailResult : public Task::Result
 {
     const SigningResult m_result;
     const AuditLog m_auditLog;
 public:
     explicit SignEMailResult(const SigningResult &r, const AuditLog &auditLog)
         : Task::Result(), m_result(r), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLog auditLog() const override;
 };
 
 QString makeResultString(const SigningResult &res)
 {
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed: %1", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     return i18n("Signing succeeded.");
 }
 }
 
 class SignEMailTask::Private
 {
     friend class ::Kleo::Crypto::SignEMailTask;
     SignEMailTask *const q;
 public:
     explicit Private(SignEMailTask *qq);
 
 private:
     std::unique_ptr<QGpgME::SignJob> createJob(GpgME::Protocol proto);
 
 private:
     void slotResult(const SigningResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     std::vector<Key> signers;
     bool detached;
     bool clearsign;
 
     QString micAlg;
 
     QPointer<QGpgME::SignJob> job;
 };
 
 SignEMailTask::Private::Private(SignEMailTask *qq)
     : q(qq),
       input(),
       output(),
       signers(),
       detached(false),
       clearsign(false),
       micAlg(),
       job(nullptr)
 {
 
 }
 
 SignEMailTask::SignEMailTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEMailTask::~SignEMailTask() {}
 
 void SignEMailTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEMailTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEMailTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     kleo_assert(!signers.empty());
     kleo_assert(std::none_of(signers.cbegin(), signers.cend(), std::mem_fn(&Key::isNull)));
     d->signers = signers;
 }
 
 void SignEMailTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
     d->clearsign = false;
 }
 
 void SignEMailTask::setClearsign(bool clear)
 {
     kleo_assert(!d->job);
     d->clearsign = clear;
     d->detached = false;
 }
 
 Protocol SignEMailTask::protocol() const
 {
     kleo_assert(!d->signers.empty());
     return d->signers.front().protocol();
 }
 
 QString SignEMailTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 unsigned long long SignEMailTask::inputSize() const
 {
     return d->input ? d->input->size() : 0;
 }
 
 void SignEMailTask::doStart()
 {
     kleo_assert(!d->job);
     kleo_assert(d->input);
     kleo_assert(d->output);
     kleo_assert(!d->signers.empty());
 
     d->micAlg.clear();
 
     std::unique_ptr<QGpgME::SignJob> job = d->createJob(protocol());
     kleo_assert(job.get());
 
     job->start(d->signers,
                d->input->ioDevice(), d->output->ioDevice(),
                d->clearsign ? GpgME::Clearsigned : d->detached ? GpgME::Detached : GpgME::NormalSignatureMode);
 
     d->job = job.release();
 }
 
 void SignEMailTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEMailTask::Private::createJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     bool shouldArmor = (proto == OpenPGP || q->asciiArmor()) && !output->binaryOpt();
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(/*armor=*/ shouldArmor, /*textmode=*/false));
     kleo_assert(signJob.get());
     if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
         signJob->setOutputIsBase64Encoded(true);
     }
     connect(signJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 static QString collect_micalgs(const GpgME::SigningResult &result, GpgME::Protocol proto)
 {
     const std::vector<GpgME::CreatedSignature> css = result.createdSignatures();
     QStringList micalgs;
     std::transform(css.begin(), css.end(),
                    std::back_inserter(micalgs),
                    [](const GpgME::CreatedSignature &sig) {
                        return QString::fromLatin1(sig.hashAlgorithmAsString()).toLower();
                    });
     if (proto == GpgME::OpenPGP)
         for (QStringList::iterator it = micalgs.begin(), end = micalgs.end(); it != end; ++it) {
             it->prepend(QLatin1String("pgp-"));
         }
     micalgs.sort();
     micalgs.erase(std::unique(micalgs.begin(), micalgs.end()), micalgs.end());
     return micalgs.join(QLatin1Char(','));
 }
 
 void SignEMailTask::Private::slotResult(const SigningResult &result)
 {
-    const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
+    const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     if (result.error().code()) {
         output->cancel();
     } else {
         output->finalize();
         micAlg = collect_micalgs(result, q->protocol());
     }
     q->emitResult(std::shared_ptr<Result>(new SignEMailResult(result, AuditLog::fromJob(job))));
 }
 
 QString SignEMailTask::micAlg() const
 {
     return d->micAlg;
 }
 
 QString SignEMailResult::overview() const
 {
     return makeOverview(makeResultString(m_result));
 }
 
 QString SignEMailResult::details() const
 {
     return QString();
 }
 
 int SignEMailResult::errorCode() const
 {
     return m_result.error().encodedError();
 }
 
 QString SignEMailResult::errorString() const
 {
     return hasError() ? makeResultString(m_result) : QString();
 }
 
 Task::Result::VisualCode SignEMailResult::code() const
 {
     if (m_result.error().isCanceled()) {
         return Warning;
     }
     return m_result.error().code() ? NeutralError : NeutralSuccess;
 }
 
 AuditLog SignEMailResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signemailtask.cpp"
 
diff --git a/src/crypto/signencrypttask.cpp b/src/crypto/signencrypttask.cpp
index c46c861e4..866216601 100644
--- a/src/crypto/signencrypttask.cpp
+++ b/src/crypto/signencrypttask.cpp
@@ -1,682 +1,682 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signencrypttask.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 "signencrypttask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/path-helper.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 #include <QGpgME/SignEncryptJob>
 #include <QGpgME/EncryptJob>
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 QString formatInputOutputLabel(const QString &input, const QString &output, bool outputDeleted)
 {
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  input.toHtmlEscaped(),
                  outputDeleted ? QStringLiteral("<s>%1</s>").arg(output.toHtmlEscaped()) : output.toHtmlEscaped());
 }
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(bool sign, bool encrypt, const Error &err, const QString &errStr, const QString &input, const QString &output, const AuditLog &auditLog)
         : Task::Result(), m_sign(sign), m_encrypt(encrypt), m_error(err), m_errString(errStr), m_inputLabel(input), m_outputLabel(output), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override
     {
         return m_error.encodedError();
     }
     QString errorString() const override
     {
         return m_errString;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLog auditLog() const override
     {
         return m_auditLog;
     }
 private:
     const bool m_sign;
     const bool m_encrypt;
     const Error m_error;
     const QString m_errString;
     const QString m_inputLabel;
     const QString m_outputLabel;
     const AuditLog m_auditLog;
 };
 
 class SignEncryptFilesResult : public Task::Result
 {
 public:
     SignEncryptFilesResult(const SigningResult &sr, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated, const AuditLog &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_sresult.isNull());
     }
     SignEncryptFilesResult(const EncryptionResult &er, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated, const AuditLog &auditLog)
         : Task::Result(),
           m_eresult(er),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_eresult.isNull());
     }
     SignEncryptFilesResult(const SigningResult &sr, const EncryptionResult &er, const std::shared_ptr<Input> &input, const std::shared_ptr<Output> &output, bool outputCreated,  const AuditLog &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_eresult(er),
           m_inputLabel(input ? input->label() : QString()),
           m_inputErrorString(input ? input->errorString() : QString()),
           m_outputLabel(output ? output->label() : QString()),
           m_outputErrorString(output ? output->errorString() : QString()),
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_inputErrorString
                                << "\noutputError:" << m_outputErrorString;
         Q_ASSERT(!m_sresult.isNull() || !m_eresult.isNull());
     }
 
     QString overview() const override;
     QString details() const override;
     int errorCode() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLog auditLog() const override;
 
 private:
     const SigningResult m_sresult;
     const EncryptionResult m_eresult;
     const QString m_inputLabel;
     const QString m_inputErrorString;
     const QString m_outputLabel;
     const QString m_outputErrorString;
     const bool m_outputCreated;
     const AuditLog m_auditLog;
 };
 
 static QString makeSigningOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed.");
     }
     return i18n("Signing succeeded.");
 }
 
 static QString makeResultOverview(const SigningResult &result)
 {
     return makeSigningOverview(result.error());
 }
 
 static QString makeEncryptionOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed.");
     }
 
     return i18n("Encryption succeeded.");
 }
 
 static QString makeResultOverview(const EncryptionResult &result)
 {
     return makeEncryptionOverview(result.error());
 }
 
 static QString makeResultOverview(const SigningResult &sr, const EncryptionResult &er)
 {
     if (er.isNull() && sr.isNull()) {
         return QString();
     }
     if (er.isNull()) {
         return makeResultOverview(sr);
     }
     if (sr.isNull()) {
         return makeResultOverview(er);
     }
     if (sr.error().isCanceled() || sr.error()) {
         return makeResultOverview(sr);
     }
     if (er.error().isCanceled() || er.error()) {
         return makeResultOverview(er);
     }
     return i18n("Signing and encryption succeeded.");
 }
 
 static QString escape(QString s)
 {
     s = s.toHtmlEscaped();
     s.replace(QLatin1Char('\n'), QStringLiteral("<br>"));
     return s;
 }
 
 static QString makeResultDetails(const SigningResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return QString();
 }
 
 static QString makeResultDetails(const EncryptionResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return i18n(" Encryption succeeded.");
 }
 
 }
 
 QString ErrorResult::overview() const
 {
     Q_ASSERT(m_error || m_error.isCanceled());
     Q_ASSERT(m_sign || m_encrypt);
     const QString label = formatInputOutputLabel(m_inputLabel, m_outputLabel, true);
     const bool canceled = m_error.isCanceled();
     if (m_sign && m_encrypt) {
         return canceled ? i18n("%1: <b>Sign/encrypt canceled.</b>", label) : i18n(" %1: Sign/encrypt failed.", label);
     }
     return i18nc("label: result. Example: foo -> foo.gpg: Encryption failed.", "%1: <b>%2</b>", label,
                  m_sign ? makeSigningOverview(m_error) : makeEncryptionOverview(m_error));
 }
 
 QString ErrorResult::details() const
 {
     return m_errString;
 }
 
 class SignEncryptTask::Private
 {
     friend class ::Kleo::Crypto::SignEncryptTask;
     SignEncryptTask *const q;
 public:
     explicit Private(SignEncryptTask *qq);
 
 private:
     std::unique_ptr<QGpgME::SignJob> createSignJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptJob> createSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptJob> createEncryptJob(GpgME::Protocol proto);
     std::shared_ptr<const Task::Result> makeErrorResult(const Error &err, const QString &errStr, const AuditLog &auditLog);
 
 private:
     void slotResult(const SigningResult &);
     void slotResult(const SigningResult &, const EncryptionResult &);
     void slotResult(const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     QStringList inputFileNames;
     QString outputFileName;
     std::vector<Key> signers;
     std::vector<Key> recipients;
 
     bool sign     : 1;
     bool encrypt  : 1;
     bool detached : 1;
     bool symmetric: 1;
     bool clearsign: 1;
 
     QPointer<QGpgME::Job> job;
     std::shared_ptr<OverwritePolicy> m_overwritePolicy;
 };
 
 SignEncryptTask::Private::Private(SignEncryptTask *qq)
     : q(qq),
       input(),
       output(),
       inputFileNames(),
       outputFileName(),
       signers(),
       recipients(),
       sign(true),
       encrypt(true),
       detached(false),
       clearsign(false),
       job(nullptr),
       m_overwritePolicy(new OverwritePolicy(nullptr))
 {
     q->setAsciiArmor(true);
 }
 
 std::shared_ptr<const Task::Result> SignEncryptTask::Private::makeErrorResult(const Error &err, const QString &errStr, const AuditLog &auditLog)
 {
     return std::shared_ptr<const ErrorResult>(new ErrorResult(sign, encrypt, err, errStr, input->label(), output->label(), auditLog));
 }
 
 SignEncryptTask::SignEncryptTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEncryptTask::~SignEncryptTask() {}
 
 void SignEncryptTask::setInputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->inputFileNames = QStringList(fileName);
 }
 
 void SignEncryptTask::setInputFileNames(const QStringList &fileNames)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileNames.empty());
     d->inputFileNames = fileNames;
 }
 
 void SignEncryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEncryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEncryptTask::setOutputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->outputFileName = fileName;
 }
 
 void SignEncryptTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     d->signers = signers;
 }
 
 void SignEncryptTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     d->recipients = recipients;
 }
 
 void SignEncryptTask::setOverwritePolicy(const std::shared_ptr<OverwritePolicy> &policy)
 {
     kleo_assert(!d->job);
     d->m_overwritePolicy = policy;
 }
 
 void SignEncryptTask::setSign(bool sign)
 {
     kleo_assert(!d->job);
     d->sign = sign;
 }
 
 void SignEncryptTask::setEncrypt(bool encrypt)
 {
     kleo_assert(!d->job);
     d->encrypt = encrypt;
 }
 
 void SignEncryptTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
 }
 
 void SignEncryptTask::setEncryptSymmetric(bool symmetric)
 {
     kleo_assert(!d->job);
     d->symmetric = symmetric;
 }
 
 void SignEncryptTask::setClearsign(bool clearsign)
 {
     kleo_assert(!d->job);
     d->clearsign = clearsign;
 }
 
 Protocol SignEncryptTask::protocol() const
 {
     if (d->sign && !d->signers.empty()) {
         return d->signers.front().protocol();
     }
     if (d->encrypt || d->symmetric) {
         if (!d->recipients.empty()) {
             return d->recipients.front().protocol();
         } else {
             return GpgME::OpenPGP;    // symmetric OpenPGP encryption
         }
     }
     throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                           i18n("Cannot determine protocol for task"));
 }
 
 QString SignEncryptTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 QString SignEncryptTask::tag() const
 {
     return Formatting::displayName(protocol());
 }
 
 unsigned long long SignEncryptTask::inputSize() const
 {
     return d->input ? d->input->size() : 0U;
 }
 
 void SignEncryptTask::doStart()
 {
     kleo_assert(!d->job);
     if (d->sign) {
         kleo_assert(!d->signers.empty());
     }
 
     kleo_assert(d->input);
 
     if (!d->output) {
         d->output = Output::createFromFile(d->outputFileName, d->m_overwritePolicy);
     }
 
     if (d->encrypt || d->symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (d->symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (d->sign) {
             std::unique_ptr<QGpgME::SignEncryptJob> job = d->createSignEncryptJob(protocol());
             kleo_assert(job.get());
 
             job->start(d->signers, d->recipients,
                        d->input->ioDevice(), d->output->ioDevice(), flags);
 
             d->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptJob> job = d->createEncryptJob(protocol());
             kleo_assert(job.get());
 
             job->start(d->recipients, d->input->ioDevice(), d->output->ioDevice(), flags);
 
             d->job = job.release();
         }
     } else if (d->sign) {
         std::unique_ptr<QGpgME::SignJob> job = d->createSignJob(protocol());
         kleo_assert(job.get());
         kleo_assert(! (d->detached && d->clearsign));
 
         job->start(d->signers,
                    d->input->ioDevice(), d->output->ioDevice(),
                    d->detached ? GpgME::Detached : d->clearsign ?
                               GpgME::Clearsigned : GpgME::NormalSignatureMode);
 
         d->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 void SignEncryptTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEncryptTask::Private::createSignJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signJob.get());
     connect(signJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptJob> SignEncryptTask::Private::createSignEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptJob> signEncryptJob(backend->signEncryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signEncryptJob.get());
     connect(signEncryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(signEncryptJob.get(), SIGNAL(result(GpgME::SigningResult,GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult,GpgME::EncryptionResult)));
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptJob> SignEncryptTask::Private::createEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(encryptJob.get());
     connect(encryptJob.get(), SIGNAL(progress(QString,int,int)),
             q, SLOT(setProgress(QString,int,int)));
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &result)
 {
-    const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
+    const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (result.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(result, input, output, outputCreated, auditLog)));
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &sresult, const EncryptionResult &eresult)
 {
-    const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
+    const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (sresult.error().code() || eresult.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!sresult.isNull() || !eresult.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(sresult, eresult, input, output, outputCreated, auditLog)));
 }
 
 void SignEncryptTask::Private::slotResult(const EncryptionResult &result)
 {
-    const QGpgME::Job *const job = qobject_cast<const QGpgME::Job *>(q->sender());
+    const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     const AuditLog auditLog = AuditLog::fromJob(job);
     bool outputCreated = false;
     if (input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape(input->errorString())),
                                       auditLog));
         return;
     } else if (result.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             output->finalize();
             outputCreated = true;
             input->finalize();
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(result, input, output, outputCreated, auditLog)));
 }
 
 QString SignEncryptFilesResult::overview() const
 {
     const QString files = formatInputOutputLabel(m_inputLabel, m_outputLabel, !m_outputCreated);
     return files + QLatin1String(": ") + makeOverview(makeResultOverview(m_sresult, m_eresult));
 }
 
 QString SignEncryptFilesResult::details() const
 {
     return errorString();
 }
 
 int SignEncryptFilesResult::errorCode() const
 {
     if (m_sresult.error().code()) {
         return m_sresult.error().encodedError();
     }
     if (m_eresult.error().code()) {
         return m_eresult.error().encodedError();
     }
     return 0;
 }
 
 QString SignEncryptFilesResult::errorString() const
 {
     const bool sign = !m_sresult.isNull();
     const bool encrypt = !m_eresult.isNull();
 
     kleo_assert(sign || encrypt);
 
     if (sign && encrypt) {
         return
             m_sresult.error().code() ? makeResultDetails(m_sresult, m_inputErrorString, m_outputErrorString) :
             m_eresult.error().code() ? makeResultDetails(m_eresult, m_inputErrorString, m_outputErrorString) :
             QString();
     }
 
     return
         sign   ? makeResultDetails(m_sresult, m_inputErrorString, m_outputErrorString) :
         /*else*/ makeResultDetails(m_eresult, m_inputErrorString, m_outputErrorString);
 }
 
 Task::Result::VisualCode SignEncryptFilesResult::code() const
 {
     if (m_sresult.error().isCanceled() || m_eresult.error().isCanceled()) {
         return Warning;
     }
     return (m_sresult.error().code() || m_eresult.error().code()) ? NeutralError : NeutralSuccess;
 }
 
 AuditLog SignEncryptFilesResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signencrypttask.cpp"
diff --git a/src/crypto/taskcollection.cpp b/src/crypto/taskcollection.cpp
index 9c694ee01..8eb2f7e8e 100644
--- a/src/crypto/taskcollection.cpp
+++ b/src/crypto/taskcollection.cpp
@@ -1,222 +1,222 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/taskcollection.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 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 "taskcollection.h"
 #include "task.h"
 #include "kleopatra_debug.h"
 
 #include <Libkleo/GnuPG>
 
 #include <algorithm>
 #include <map>
 
 #include <cmath>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class TaskCollection::Private
 {
     TaskCollection *const q;
 public:
     explicit Private(TaskCollection *qq);
 
     void taskProgress(const QString &, int, int);
     void taskResult(const std::shared_ptr<const Task::Result> &);
     void taskStarted();
     void calculateAndEmitProgress();
 
     std::map<int, std::shared_ptr<Task> > m_tasks;
     mutable quint64 m_totalProgress;
     mutable quint64 m_progress;
     unsigned int m_nCompleted;
     unsigned int m_nErrors;
     QString m_lastProgressMessage;
     bool m_errorOccurred;
     bool m_doneEmitted;
 };
 
 TaskCollection::Private::Private(TaskCollection *qq):
     q(qq),
     m_totalProgress(0),
     m_progress(0),
     m_nCompleted(0),
     m_nErrors(0),
     m_errorOccurred(false),
     m_doneEmitted(false)
 {
 }
 
 int TaskCollection::numberOfCompletedTasks() const
 {
     return d->m_nCompleted;
 }
 
 size_t TaskCollection::size() const
 {
     return d->m_tasks.size();
 }
 
 bool TaskCollection::allTasksCompleted() const
 {
     Q_ASSERT(d->m_nCompleted <= d->m_tasks.size());
     return d->m_nCompleted == d->m_tasks.size();
 }
 
 void TaskCollection::Private::taskProgress(const QString &msg, int, int)
 {
     m_lastProgressMessage = msg;
     calculateAndEmitProgress();
 }
 
 void TaskCollection::Private::taskResult(const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(result);
     ++m_nCompleted;
 
     if (result->hasError()) {
         m_errorOccurred = true;
         ++m_nErrors;
     }
     m_lastProgressMessage.clear();
     calculateAndEmitProgress();
     Q_EMIT q->result(result);
     if (!m_doneEmitted && q->allTasksCompleted()) {
         Q_EMIT q->done();
         m_doneEmitted = true;
     }
 }
 
 void TaskCollection::Private::taskStarted()
 {
     const Task *const task = qobject_cast<Task *>(q->sender());
     Q_ASSERT(task);
     Q_ASSERT(m_tasks.find(task->id()) != m_tasks.end());
     Q_EMIT q->started(m_tasks[task->id()]);
     calculateAndEmitProgress(); // start Knight-Rider-Mode right away (gpgsm doesn't report _any_ progress).
     if (m_doneEmitted) {
         // We are not done anymore, one task restarted.
         m_nCompleted--;
         m_nErrors--;
         m_doneEmitted = false;
     }
 }
 
 void TaskCollection::Private::calculateAndEmitProgress()
 {
-    typedef std::map<int, std::shared_ptr<Task> >::const_iterator ConstIterator;
+    using ConstIterator = std::map<int, std::shared_ptr<Task>>::const_iterator;
 
     quint64 total = 0;
     quint64 processed = 0;
 
     static bool haveWorkingProgress = engineIsVersion(2, 1, 15);
     if (!haveWorkingProgress) {
         // GnuPG before 2.1.15 would overflow on progress values > max int.
         // and did not emit a total for our Qt data types.
         // As we can't know if it overflowed or what the total is we just knight
         // rider in that case
         if (m_doneEmitted) {
             Q_EMIT q->progress(m_lastProgressMessage, 1, 1);
         } else {
             Q_EMIT q->progress(m_lastProgressMessage, 0, 0);
         }
         return;
     }
 
     bool unknowable = false;
-    for (ConstIterator it = m_tasks.begin(), end = m_tasks.end(); it != end; ++it) {
+    for (auto it = m_tasks.begin(), end = m_tasks.end(); it != end; ++it) {
         // Sum up progress and totals
         const std::shared_ptr<Task> &i = it->second;
         Q_ASSERT(i);
         if (!i->totalProgress()) {
             // There still might be jobs for which we don't know the progress.
             qCDebug(KLEOPATRA_LOG) << "Task: " << i->label() << " has no total progress set. ";
             unknowable = true;
             break;
         }
         processed += i->currentProgress();
         total += i->totalProgress();
     }
 
     m_totalProgress = total;
     m_progress = processed;
     if (!unknowable && processed && total >= processed) {
         // Scale down to avoid range issues.
         int scaled = 1000 * (m_progress / static_cast<double>(m_totalProgress));
         qCDebug(KLEOPATRA_LOG) << "Collection Progress: " << scaled << " total: " << 1000;
         Q_EMIT q->progress(m_lastProgressMessage, scaled, 1000);
     } else {
         if (total < processed) {
             qCDebug(KLEOPATRA_LOG) << "Total progress is smaller then current progress.";
         }
         // Knight rider.
         Q_EMIT q->progress(m_lastProgressMessage, 0, 0);
     }
 }
 
 TaskCollection::TaskCollection(QObject *parent) : QObject(parent), d(new Private(this))
 {
 }
 
 TaskCollection::~TaskCollection()
 {
 }
 
 bool TaskCollection::isEmpty() const
 {
     return d->m_tasks.empty();
 }
 
 bool TaskCollection::errorOccurred() const
 {
     return d->m_errorOccurred;
 }
 
 bool TaskCollection::allTasksHaveErrors() const
 {
     return d->m_nErrors == d->m_nCompleted;
 }
 
 std::shared_ptr<Task> TaskCollection::taskById(int id) const
 {
-    const std::map<int, std::shared_ptr<Task> >::const_iterator it = d->m_tasks.find(id);
+    const auto it = d->m_tasks.find(id);
     return it != d->m_tasks.end() ? it->second : std::shared_ptr<Task>();
 }
 
 std::vector<std::shared_ptr<Task> > TaskCollection::tasks() const
 {
-    typedef std::map<int, std::shared_ptr<Task> >::const_iterator ConstIterator;
+    using ConstIterator = std::map<int, std::shared_ptr<Task>>::const_iterator;
     std::vector<std::shared_ptr<Task> > res;
     res.reserve(d->m_tasks.size());
-    for (ConstIterator it = d->m_tasks.begin(), end = d->m_tasks.end(); it != end; ++it) {
+    for (auto it = d->m_tasks.begin(), end = d->m_tasks.end(); it != end; ++it) {
         res.push_back(it->second);
     }
     return res;
 }
 
 void TaskCollection::setTasks(const std::vector<std::shared_ptr<Task> > &tasks)
 {
     for (const std::shared_ptr<Task> &i : tasks) {
         Q_ASSERT(i);
         d->m_tasks[i->id()] = i;
         connect(i.get(), SIGNAL(progress(QString,int,int)),
                 this, SLOT(taskProgress(QString,int,int)));
         connect(i.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
                 this, SLOT(taskResult(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
         connect(i.get(), SIGNAL(started()),
                 this, SLOT(taskStarted()));
     }
 }
 
 #include "moc_taskcollection.cpp"
diff --git a/src/crypto/verifychecksumscontroller.cpp b/src/crypto/verifychecksumscontroller.cpp
index 51a82f79d..68bed3356 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;
-        std::set<QDir, less_dir>::iterator it = dirs.begin();
+        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 (std::map<QDir, std::set<QString, less_file>, less_dir>::const_iterator it = dirs2sums.begin(), end = dirs2sums.end(); it != end; ++it) {
+    for (auto it = dirs2sums.begin(), end = dirs2sums.end(); it != end; ++it) {
 
         if (it->second.empty()) {
             continue;
         }
 
         const QDir &dir = it->first;
 
         Q_FOREACH (const QString &sumFileName, 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) {
                 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/dialogs/adduseriddialog.cpp b/src/dialogs/adduseriddialog.cpp
index 980902244..ea16c20da 100644
--- a/src/dialogs/adduseriddialog.cpp
+++ b/src/dialogs/adduseriddialog.cpp
@@ -1,339 +1,339 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/adduseriddialog.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 "adduseriddialog.h"
 
 #include "ui_adduseriddialog.h"
 
 #include <utils/validation.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <QString>
 #include <QStringList>
 #include <QPushButton>
 #include <QValidator>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 
 namespace
 {
 struct Line {
     QString attr;
     QString label;
     QString regex;
     QLineEdit *edit = nullptr;
 };
 }
 
 static QString pgpLabel(const QString &attr)
 {
     if (attr == QLatin1String("NAME")) {
         return i18n("Name");
     } else if (attr == QLatin1String("COMMENT")) {
         return i18n("Comment");
     } else if (attr == QLatin1String("EMAIL")) {
         return i18n("EMail");
     }
     return QString();
 }
 
 static QString attributeLabel(const QString &attr, bool pgp)
 {
     if (attr.isEmpty()) {
         return QString();
     }
     const QString label = /*pgp ?*/ pgpLabel(attr) /*: Kleo::DNAttributeMapper::instance()->name2label( attr )*/;
     if (!label.isEmpty())
         if (pgp) {
             return label;
         } else
             return i18nc("Format string for the labels in the \"Your Personal Data\" page",
                          "%1 (%2)", label, attr);
     else {
         return attr;
     }
 }
 
 static QString attributeFromKey(QString key)
 {
     return key.remove(QLatin1Char('!'));
 }
 
 static int row_index_of(QWidget *w, QGridLayout *l)
 {
     const int idx = l->indexOf(w);
     int r, c, rs, cs;
     l->getItemPosition(idx, &r, &c, &rs, &cs);
     return r;
 }
 
 static QLineEdit *adjust_row(QGridLayout *l, int row, const QString &label, const QString &preset, QValidator *validator, bool readonly, bool required)
 {
     Q_ASSERT(l);
     Q_ASSERT(row >= 0);
     Q_ASSERT(row < l->rowCount());
 
-    QLabel *lb = qobject_cast<QLabel *>(l->itemAtPosition(row, 0)->widget());
+    auto lb = qobject_cast<QLabel *>(l->itemAtPosition(row, 0)->widget());
     Q_ASSERT(lb);
-    QLineEdit *le = qobject_cast<QLineEdit *>(l->itemAtPosition(row, 1)->widget());
+    auto le = qobject_cast<QLineEdit *>(l->itemAtPosition(row, 1)->widget());
     Q_ASSERT(le);
-    QLabel *reqLB = qobject_cast<QLabel *>(l->itemAtPosition(row, 2)->widget());
+    auto reqLB = qobject_cast<QLabel *>(l->itemAtPosition(row, 2)->widget());
     Q_ASSERT(reqLB);
 
     lb->setText(i18nc("interpunctation for labels", "%1:", label));
     le->setText(preset);
     reqLB->setText(required ? i18n("(required)") : i18n("(optional)"));
     delete le->validator();
     if (validator) {
         if (!validator->parent()) {
             validator->setParent(le);
         }
         le->setValidator(validator);
     }
 
     le->setReadOnly(readonly && le->hasAcceptableInput());
 
     lb->show();
     le->show();
     reqLB->show();
 
     return le;
 }
 
 class AddUserIDDialog::Private
 {
     friend class ::Kleo::Dialogs::AddUserIDDialog;
     AddUserIDDialog *const q;
 public:
     explicit Private(AddUserIDDialog *qq)
         : q(qq),
           ui(q)
     {
     }
 
 private:
     void slotUserIDChanged();
 
 private:
     bool isComplete() const;
 
 private:
     struct UI : public Ui_AddUserIDDialog {
 
         QVector<Line> lineList;
 
         explicit UI(AddUserIDDialog *qq)
             : Ui_AddUserIDDialog()
         {
             setupUi(qq);
 
             // ### this code is mostly the same as the one in
             // ### newcertificatewizard. Find some time to factor them
             // ### into a single copy.
 
             // hide the stuff
             nameLB->hide();
             nameLE->hide();
             nameRequiredLB->hide();
 
             emailLB->hide();
             emailLE->hide();
             emailRequiredLB->hide();
 
             commentLB->hide();
             commentLE->hide();
             commentRequiredLB->hide();
 
             // set errorLB to have a fixed height of two lines:
             errorLB->setText(QStringLiteral("2<br>1"));
             errorLB->setFixedHeight(errorLB->minimumSizeHint().height());
             errorLB->clear();
 
             const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
             const QStringList attrOrder = config.readEntry("OpenPGPAttributeOrder",
                                           QStringList() << QStringLiteral("NAME") << QStringLiteral("EMAIL") << QStringLiteral("COMMENT"));
 
             QMap<int, Line> lines;
 
             for (const QString &rawKey : attrOrder) {
                 const QString key = rawKey.trimmed().toUpper();
                 const QString attr = attributeFromKey(key);
                 if (attr.isEmpty()) {
                     continue;
                 }
                 const QString preset = config.readEntry(attr);
                 const bool required = key.endsWith(QLatin1Char('!'));
                 const bool readonly = config.isEntryImmutable(attr);
                 const QString label = config.readEntry(attr + QLatin1String("_label"),
                                                        attributeLabel(attr, true));
                 const QString regex = config.readEntry(attr + QLatin1String("_regex"));
 
                 int row;
                 QValidator *validator = nullptr;
                 if (attr == QLatin1String("EMAIL")) {
                     validator = regex.isEmpty() ? Validation::email() : Validation::email(QRegExp(regex));
                     row = row_index_of(emailLE, gridLayout);
                 } else if (attr == QLatin1String("NAME")) {
                     validator = regex.isEmpty() ? Validation::pgpName() : Validation::pgpName(QRegExp(regex));
                     row = row_index_of(nameLE, gridLayout);
                 } else if (attr == QLatin1String("COMMENT")) {
                     validator = regex.isEmpty() ? Validation::pgpComment() : Validation::pgpComment(QRegExp(regex));
                     row = row_index_of(commentLE, gridLayout);
                 } else {
                     continue;
                 }
 
                 QLineEdit *le = adjust_row(gridLayout, row, label, preset, validator, readonly, required);
 
                 const Line line = { key, label, regex, le };
                 lines[row] = line;
             }
 
             std::copy(lines.begin(), lines.end(), std::back_inserter(lineList));
 
             QObject::connect(nameLE, SIGNAL(textChanged(QString)), qq, SLOT(slotUserIDChanged()));
             QObject::connect(emailLE, SIGNAL(textChanged(QString)), qq, SLOT(slotUserIDChanged()));
             QObject::connect(commentLE, SIGNAL(textChanged(QString)), qq, SLOT(slotUserIDChanged()));
         }
 
         QPushButton *okPB() const
         {
             return buttonBox->button(QDialogButtonBox::Ok);
         }
     } ui;
 };
 
 AddUserIDDialog::AddUserIDDialog(QWidget *p)
     : QDialog(p), d(new Private(this))
 {
     // explicitly trigger an update after setup is complete
     d->slotUserIDChanged();
 }
 
 AddUserIDDialog::~AddUserIDDialog() {}
 
 void AddUserIDDialog::setName(const QString &name)
 {
     d->ui.nameLE->setText(name);
 }
 
 QString AddUserIDDialog::name() const
 {
     return d->ui.nameLE->text().trimmed();
 }
 
 void AddUserIDDialog::setEmail(const QString &email)
 {
     d->ui.emailLE->setText(email);
 }
 
 QString AddUserIDDialog::email() const
 {
     return d->ui.emailLE->text().trimmed();
 }
 
 void AddUserIDDialog::setComment(const QString &comment)
 {
     d->ui.commentLE->setText(comment);
 }
 
 QString AddUserIDDialog::comment() const
 {
     return d->ui.commentLE->text().trimmed();
 }
 
 static bool has_intermediate_input(const QLineEdit *le)
 {
     QString text = le->text();
     int pos = le->cursorPosition();
     const QValidator *const v = le->validator();
     return !v || v->validate(text, pos) == QValidator::Intermediate;
 }
 
 static bool requirementsAreMet(const QVector<Line> &list, QString &error)
 {
     bool allEmpty = true;
     for (const Line &line : list) {
         const QLineEdit *le = line.edit;
         if (!le) {
             continue;
         }
         const QString key = line.attr;
         qCDebug(KLEOPATRA_LOG) << "requirementsAreMet(): checking \"" << key << "\" against \"" << le->text() << "\":";
         if (le->text().trimmed().isEmpty()) {
             if (key.endsWith(QLatin1Char('!'))) {
                 if (line.regex.isEmpty()) {
                     error = xi18nc("@info", "<interface>%1</interface> is required, but empty.", line.label);
                 } else
                     error = xi18nc("@info", "<interface>%1</interface> is required, but empty.<nl/>"
                                    "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
                 return false;
             }
         } else if (has_intermediate_input(le)) {
             if (line.regex.isEmpty()) {
                 error = xi18nc("@info", "<interface>%1</interface> is incomplete.", line.label);
             } else
                 error = xi18nc("@info", "<interface>%1</interface> is incomplete.<nl/>"
                                "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
             return false;
         } else if (!le->hasAcceptableInput()) {
             if (line.regex.isEmpty()) {
                 error = xi18nc("@info", "<interface>%1</interface> is invalid.", line.label);
             } else
                 error = xi18nc("@info", "<interface>%1</interface> is invalid.<nl/>"
                                "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
             return false;
         } else {
             allEmpty = false;
         }
     }
     return !allEmpty;
 }
 
 bool AddUserIDDialog::Private::isComplete() const
 {
     QString error;
     const bool ok = requirementsAreMet(ui.lineList, error);
     ui.errorLB->setText(error);
     return ok;
 }
 
 void AddUserIDDialog::Private::slotUserIDChanged()
 {
     ui.okPB()->setEnabled(isComplete());
 
     const QString name = q->name();
     const QString email = q->email();
     const QString comment = q->comment();
 
     QStringList parts;
     if (!name.isEmpty()) {
         parts.push_back(name);
     }
     if (!comment.isEmpty()) {
         parts.push_back(QLatin1Char('(') + comment + QLatin1Char(')'));
     }
     if (!email.isEmpty()) {
         parts.push_back(QLatin1Char('<') + email + QLatin1Char('>'));
     }
 
     ui.resultLB->setText(parts.join(QLatin1Char(' ')));
 }
 
 #include "moc_adduseriddialog.cpp"
diff --git a/src/dialogs/certificatedetailsinputwidget.cpp b/src/dialogs/certificatedetailsinputwidget.cpp
index 57fc30e5c..fb7b1453b 100644
--- a/src/dialogs/certificatedetailsinputwidget.cpp
+++ b/src/dialogs/certificatedetailsinputwidget.cpp
@@ -1,352 +1,352 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/certificatedetailsinputwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "certificatedetailsinputwidget.h"
 
 #include <utils/userinfo.h>
 #include <utils/validation.h>
 
 #include <Libkleo/Dn>
 #include <Libkleo/OidMap>
 #include <Libkleo/Stl_Util>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <QLabel>
 #include <QLineEdit>
 #include <QValidator>
 #include <QVBoxLayout>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 
 namespace
 {
     struct Line {
         QString attr;
         QString label;
         QString regex;
         QLineEdit *edit;
         bool required;
     };
 
     QString attributeFromKey(QString key)
     {
         return key.remove(QLatin1Char('!'));
     }
 
     QString attributeLabel(const QString &attr)
     {
         if (attr.isEmpty()) {
             return QString();
         }
         const QString label = DNAttributeMapper::instance()->name2label(attr);
         if (!label.isEmpty()) {
             return i18nc("Format string for the labels in the \"Your Personal Data\" page",
                         "%1 (%2)", label, attr);
         } else {
             return attr;
         }
     }
 
     QLineEdit * addRow(QGridLayout *l, const QString &label, const QString &preset, QValidator *validator, bool readonly, bool required)
     {
         Q_ASSERT(l);
 
-        QLabel *lb = new QLabel(l->parentWidget());
+        auto lb = new QLabel(l->parentWidget());
         lb->setText(i18nc("interpunctation for labels", "%1:", label));
 
-        QLineEdit *le = new QLineEdit(l->parentWidget());
+        auto le = new QLineEdit(l->parentWidget());
         le->setText(preset);
         delete le->validator();
         if (validator) {
             if (!validator->parent()) {
                 validator->setParent(le);
             }
             le->setValidator(validator);
         }
         le->setReadOnly(readonly && le->hasAcceptableInput());
 
-        QLabel *reqLB = new QLabel(l->parentWidget());
+        auto reqLB = new QLabel(l->parentWidget());
         reqLB->setText(required ? i18n("(required)") : i18n("(optional)"));
 
         const int row = l->rowCount();
         l->addWidget(lb, row, 0);
         l->addWidget(le, row, 1);
         l->addWidget(reqLB, row, 2);
         return le;
     }
 
     bool hasIntermediateInput(const QLineEdit *le)
     {
         QString text = le->text();
         int pos = le->cursorPosition();
         const QValidator *const v = le->validator();
         return v && v->validate(text, pos) == QValidator::Intermediate;
     }
 
     QString requirementsAreMet(const QVector<Line> &lines)
     {
         for (const Line &line : lines) {
             const QLineEdit *le = line.edit;
             if (!le) {
                 continue;
             }
             qCDebug(KLEOPATRA_LOG) << "requirementsAreMet(): checking \"" << line.attr << "\" against \"" << le->text() << "\":";
             if (le->text().trimmed().isEmpty()) {
                 if (line.required) {
                     if (line.regex.isEmpty()) {
                         return xi18nc("@info", "<interface>%1</interface> is required, but empty.", line.label);
                     } else {
                         return xi18nc("@info", "<interface>%1</interface> is required, but empty.<nl/>"
                                       "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
                     }
                 }
             } else if (hasIntermediateInput(le)) {
                 if (line.regex.isEmpty()) {
                     return xi18nc("@info", "<interface>%1</interface> is incomplete.", line.label);
                 } else {
                     return xi18nc("@info", "<interface>%1</interface> is incomplete.<nl/>"
                                   "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
                 }
             } else if (!le->hasAcceptableInput()) {
                 if (line.regex.isEmpty()) {
                     return xi18nc("@info", "<interface>%1</interface> is invalid.", line.label);
                 } else {
                     return xi18nc("@info", "<interface>%1</interface> is invalid.<nl/>"
                                   "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
                 }
             }
         }
         return QString();
     }
 }
 
 class CertificateDetailsInputWidget::Private
 {
     friend class ::Kleo::Dialogs::CertificateDetailsInputWidget;
     CertificateDetailsInputWidget *const q;
 
     struct {
         QGridLayout *gridLayout;
         QVector<Line> lines;
         QLineEdit *dn;
         QLabel *error;
     } ui;
 
 public:
     Private(CertificateDetailsInputWidget *qq)
         : q(qq)
     {
         auto mainLayout = new QVBoxLayout(q);
 
         ui.gridLayout = new QGridLayout();
         mainLayout->addLayout(ui.gridLayout);
 
         createForm();
 
         mainLayout->addStretch(1);
 
         ui.dn = new QLineEdit();
         ui.dn->setFrame(false);
         ui.dn->setAlignment(Qt::AlignCenter);
         ui.dn->setReadOnly(true);
         mainLayout->addWidget(ui.dn);
 
         ui.error = new QLabel();
         {
             QSizePolicy sizePolicy(QSizePolicy::MinimumExpanding, QSizePolicy::Preferred);
             sizePolicy.setHorizontalStretch(0);
             sizePolicy.setVerticalStretch(0);
             sizePolicy.setHeightForWidth(ui.error->sizePolicy().hasHeightForWidth());
             ui.error->setSizePolicy(sizePolicy);
         }
         {
             QPalette palette;
             QBrush brush(QColor(255, 0, 0, 255));
             brush.setStyle(Qt::SolidPattern);
             palette.setBrush(QPalette::Active, QPalette::WindowText, brush);
             palette.setBrush(QPalette::Inactive, QPalette::WindowText, brush);
             QBrush brush1(QColor(114, 114, 114, 255));
             brush1.setStyle(Qt::SolidPattern);
             palette.setBrush(QPalette::Disabled, QPalette::WindowText, brush1);
             ui.error->setPalette(palette);
         }
         ui.error->setTextFormat(Qt::RichText);
         // set error label to have a fixed height of two lines:
         ui.error->setText(QStringLiteral("2<br>1"));
         ui.error->setFixedHeight(ui.error->minimumSizeHint().height());
         ui.error->clear();
         mainLayout->addWidget(ui.error);
 
         // select the preset text in the first line edit
         if (!ui.lines.empty()) {
             ui.lines.first().edit->selectAll();
         }
 
         // explicitly update DN and check requirements after setup is complete
         updateDN();
         checkRequirements();
     }
 
     ~Private()
     {
         // remember current attribute values as presets for next certificate
         KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
         for ( const Line &line : ui.lines ) {
             const QString attr = attributeFromKey(line.attr);
             const QString value = line.edit->text().trimmed();
             config.writeEntry(attr, value);
         }
         config.sync();
     }
 
     void createForm()
     {
         const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
 
         QStringList attrOrder = config.readEntry("DNAttributeOrder", QStringList());
         if (attrOrder.empty()) {
             attrOrder << QStringLiteral("CN!")
                       << QStringLiteral("EMAIL!")
                       << QStringLiteral("L")
                       << QStringLiteral("OU")
                       << QStringLiteral("O")
                       << QStringLiteral("C");
         }
 
         for (const QString &rawKey : attrOrder) {
             const QString key = rawKey.trimmed().toUpper();
             const QString attr = attributeFromKey(key);
             if (attr.isEmpty()) {
                 continue;
             }
             const QString defaultPreset = (attr == QLatin1String("CN")) ? userFullName() :
                                           (attr == QLatin1String("EMAIL")) ? userEmailAddress() :
                                           QString();
             const QString preset = config.readEntry(attr, defaultPreset);
             const bool required = key.endsWith(QLatin1Char('!'));
             const bool readonly = config.isEntryImmutable(attr);
             const QString label = config.readEntry(attr + QLatin1String("_label"),
                                                    attributeLabel(attr));
             const QString regex = config.readEntry(attr + QLatin1String("_regex"));
 
             QValidator *validator = nullptr;
             if (attr == QLatin1String("EMAIL")) {
                 validator = regex.isEmpty() ? Validation::email() : Validation::email(QRegExp(regex));
             } else if (!regex.isEmpty()) {
                 validator = new QRegExpValidator(QRegExp(regex), nullptr);
             }
 
             QLineEdit *le = addRow(ui.gridLayout, label, preset, validator, readonly, required);
 
             const Line line = { attr, label, regex, le, required };
             ui.lines.push_back(line);
 
             if (attr != QLatin1String("EMAIL")) {
                 connect(le, &QLineEdit::textChanged, [this] () { updateDN(); });
             }
             connect(le, &QLineEdit::textChanged, [this] () { checkRequirements(); });
         }
     }
 
     void updateDN()
     {
         ui.dn->setText(cmsDN());
     }
 
     QString cmsDN() const
     {
         DN dn;
         for ( const Line &line : ui.lines ) {
             const QString text = line.edit->text().trimmed();
             if (text.isEmpty()) {
                 continue;
             }
             QString attr = attributeFromKey(line.attr);
             if (attr == QLatin1String("EMAIL")) {
                 continue;
             }
             if (const char *const oid = oidForAttributeName(attr)) {
                 attr = QString::fromUtf8(oid);
             }
             dn.append(DN::Attribute(attr, text));
         }
         return dn.dn();
     }
 
     void checkRequirements()
     {
         const QString error = requirementsAreMet(ui.lines);
         ui.error->setText(error);
         Q_EMIT q->validityChanged(error.isEmpty());
     }
 
     QLineEdit * attributeWidget(const QString &attribute)
     {
         for ( const Line &line : ui.lines ) {
             if (attributeFromKey(line.attr) == attribute) {
                 return line.edit;
             }
         }
         qCWarning(KLEOPATRA_LOG) << "CertificateDetailsInputWidget: No widget for attribute" << attribute;
         return nullptr;
     }
 
     void setAttributeValue(const QString &attribute, const QString &value)
     {
         QLineEdit *w = attributeWidget(attribute);
         if (w) {
             w->setText(value);
         }
     }
 
     QString attributeValue(const QString &attribute)
     {
         const QLineEdit *w = attributeWidget(attribute);
         return w ? w->text().trimmed() : QString();
     }
 };
 
 CertificateDetailsInputWidget::CertificateDetailsInputWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
 }
 
 CertificateDetailsInputWidget::~CertificateDetailsInputWidget()
 {
 }
 
 void CertificateDetailsInputWidget::setName(const QString &name)
 {
     d->setAttributeValue(QStringLiteral("CN"), name);
 }
 
 void CertificateDetailsInputWidget::setEmail(const QString &email)
 {
     d->setAttributeValue(QStringLiteral("EMAIL"), email);
 }
 
 QString CertificateDetailsInputWidget::email() const
 {
     return d->attributeValue(QStringLiteral("EMAIL"));
 }
 
 QString CertificateDetailsInputWidget::dn() const
 {
     return d->ui.dn->text();
 }
diff --git a/src/dialogs/certificatedetailswidget.cpp b/src/dialogs/certificatedetailswidget.cpp
index 0aca3f4a0..453641c54 100644
--- a/src/dialogs/certificatedetailswidget.cpp
+++ b/src/dialogs/certificatedetailswidget.cpp
@@ -1,678 +1,678 @@
 /*  SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2017 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "certificatedetailswidget.h"
 #include "ui_certificatedetailswidget.h"
 #include "kleopatra_debug.h"
 #include "exportdialog.h"
 #include "trustchainwidget.h"
 #include "subkeyswidget.h"
 #include "weboftrustdialog.h"
 
 #include "commands/changepassphrasecommand.h"
 #include "commands/changeexpirycommand.h"
 #include "commands/certifycertificatecommand.h"
 #include "commands/revokecertificationcommand.h"
 #include "commands/adduseridcommand.h"
 #include "commands/genrevokecommand.h"
 #include "commands/detailscommand.h"
 #include "commands/dumpcertificatecommand.h"
 
 #include "utils/tags.h"
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Dn>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/context.h>
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 #include <gpgme++/tofuinfo.h>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/KeyListJob>
 
 #include <QDateTime>
 #include <QDialogButtonBox>
 #include <QMenu>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <QLocale>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 #if GPGMEPP_VERSION >= 0x10F00 // 1.15.0
 # define GPGME_HAS_WITH_SECRET
 # include <QGpgME/Debug>
 #endif
 
 #define HIDE_ROW(row) \
     ui.row->setVisible(false); \
     ui.row##Lbl->setVisible(false);
 
 Q_DECLARE_METATYPE(GpgME::UserID)
 
 using namespace Kleo;
 
 class CertificateDetailsWidget::Private
 {
 public:
     Private(CertificateDetailsWidget *parent)
         : updateInProgress (false), q(parent)
     {}
 
     void setupCommonProperties();
     void setupPGPProperties();
     void setupSMIMEProperties();
 
     void revokeUID(const GpgME::UserID &uid);
     void genRevokeCert();
     void certifyClicked();
     void webOfTrustClicked();
     void exportClicked();
     void addUserID();
     void changePassphrase();
     void changeExpiration();
     void keysMayHaveChanged();
     void showTrustChainDialog();
     void showMoreDetails();
     void publishCertificate();
     void userIDTableContextMenuRequested(const QPoint &p);
 
     QString tofuTooltipString(const GpgME::UserID &uid) const;
 
     void smimeLinkActivated(const QString &link);
 
     void setUpdatedKey(const GpgME::Key &key);
     void keyListDone(const GpgME::KeyListResult &,
                      const std::vector<GpgME::Key> &, const QString &,
                      const GpgME::Error &);
 
     Ui::CertificateDetailsWidget ui;
     GpgME::Key key;
     bool updateInProgress;
 private:
     CertificateDetailsWidget *const q;
 };
 
 void CertificateDetailsWidget::Private::setupCommonProperties()
 {
     // TODO: Enable once implemented
     HIDE_ROW(publishing)
 
     const bool hasSecret = key.hasSecret();
     const bool isOpenPGP = key.protocol() == GpgME::OpenPGP;
     // TODO: Enable once implemented
     const bool canRevokeUID = false; // isOpenPGP && hasSecret
 
     ui.changePassphraseBtn->setVisible(hasSecret);
     ui.genRevokeBtn->setVisible(isOpenPGP && hasSecret);
     ui.certifyBtn->setVisible(isOpenPGP && !hasSecret);
     ui.changeExpirationBtn->setVisible(isOpenPGP && hasSecret);
     ui.addUserIDBtn->setVisible(hasSecret && isOpenPGP);
     ui.webOfTrustBtn->setVisible(isOpenPGP);
 
     ui.hboxLayout_1->addStretch(1);
 
     ui.validFrom->setText(Kleo::Formatting::creationDateString(key));
     const QString expiry = Kleo::Formatting::expirationDateString(key);
     ui.expires->setText(expiry.isEmpty() ? i18nc("Expires", "never") : expiry);
     ui.type->setText(Kleo::Formatting::type(key));
     ui.fingerprint->setText(Formatting::prettyID(key.primaryFingerprint()));
 
     if (Kleo::Formatting::complianceMode().isEmpty()) {
         HIDE_ROW(compliance)
     } else {
         ui.complianceLbl->setText(Kleo::Formatting::complianceStringForKey(key));
     }
 
     ui.userIDTable->clear();
 
     QStringList headers = { i18n("Email"), i18n("Name"), i18n("Trust Level"), i18n("Tags") };
     if (canRevokeUID) {
         headers << QString();
     }
     ui.userIDTable->setColumnCount(headers.count());
     ui.userIDTable->setColumnWidth(0, 200);
     ui.userIDTable->setColumnWidth(1, 200);
     ui.userIDTable->setHeaderLabels(headers);
 
     const auto uids = key.userIDs();
     for (unsigned int i = 0; i < uids.size(); ++i) {
         const auto &uid = uids[i];
         auto item = new QTreeWidgetItem;
         const QString toolTip = tofuTooltipString(uid);
         item->setData(0, Qt::UserRole, QVariant::fromValue(uid));
 
         auto pMail = Kleo::Formatting::prettyEMail(uid);
         auto pName = Kleo::Formatting::prettyName(uid);
         if (!isOpenPGP && pMail.isEmpty() && !pName.isEmpty()) {
             // S/MIME UserIDs are sometimes split, with one userID
             // containing the name another the Mail, we merge these
             // UID's into a single item.
 
             if (i + 1 < uids.size()) {
                 pMail = Kleo::Formatting::prettyEMail(uids[i + 1]);
                 // skip next uid
                 ++i;
             }
         }
 
         if (!isOpenPGP && pMail.isEmpty() && pName.isEmpty()) {
             // S/MIME certificates sometimes contain urls where both
             // name and mail is empty. In that case we print whatever
             // the uid is as name.
             //
             // Can be ugly like (3:uri24:http://ca.intevation.org), but
             // this is better then showing an empty entry.
             pName = QString::fromLatin1(uid.id());
         }
 
         item->setData(0, Qt::DisplayRole, pMail);
         item->setData(0, Qt::ToolTipRole, toolTip);
         item->setData(1, Qt::DisplayRole, pName);
         item->setData(1, Qt::ToolTipRole, toolTip);
 
         QIcon trustIcon;
         if (updateInProgress) {
            trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
            item->setData(2, Qt::DisplayRole, i18n("Updating..."));
         } else {
             switch (uid.validity()) {
             case GpgME::UserID::Unknown:
             case GpgME::UserID::Undefined:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-question"));
                 break;
             case GpgME::UserID::Never:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-error"));
                 break;
             case GpgME::UserID::Marginal:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-warning"));
                 break;
             case GpgME::UserID::Full:
             case GpgME::UserID::Ultimate:
                 trustIcon = QIcon::fromTheme(QStringLiteral("emblem-success"));
                 break;
             }
             item->setData(2, Qt::DisplayRole, Kleo::Formatting::validityShort(uid));
         }
         item->setData(2, Qt::DecorationRole, trustIcon);
         item->setData(2, Qt::ToolTipRole, toolTip);
 
         GpgME::Error err;
         QStringList tagList;
 #ifdef GPGME_HAS_REMARKS
         for (const auto &tag: uid.remarks(Tags::tagKeys(), err)) {
             if (err) {
                 qCWarning(KLEOPATRA_LOG) << "Getting remarks for user id" << uid.id() << "failed:" << err;
             }
             tagList << QString::fromStdString(tag);
         }
         qCDebug(KLEOPATRA_LOG) << "tagList:" << tagList;
 #endif
         const auto tags = tagList.join(QStringLiteral("; "));
         item->setData(3, Qt::DisplayRole, tags);
         item->setData(3, Qt::ToolTipRole, toolTip);
 
         ui.userIDTable->addTopLevelItem(item);
 
         if (canRevokeUID) {
             auto button = new QPushButton;
             button->setIcon(QIcon::fromTheme(QStringLiteral("entry-delete")));
             button->setToolTip(i18n("Revoke this User ID"));
             button->setMaximumWidth(32);
             QObject::connect(button, &QPushButton::clicked,
                             q, [this, uid]() { revokeUID(uid); });
             ui.userIDTable->setItemWidget(item, 4, button);
         }
     }
     if (!Tags::tagsEnabled()) {
         ui.userIDTable->hideColumn(3);
     }
 }
 
 void CertificateDetailsWidget::Private::revokeUID(const GpgME::UserID &uid)
 {
     Q_UNUSED(uid)
     qCWarning(KLEOPATRA_LOG) << "Revoking UserID is not implemented. How did you even get here?!?!";
 }
 
 void CertificateDetailsWidget::Private::changeExpiration()
 {
     auto cmd = new Kleo::Commands::ChangeExpiryCommand(key);
     QObject::connect(cmd, &Kleo::Commands::ChangeExpiryCommand::finished,
                      q, [this]() {
                          ui.changeExpirationBtn->setEnabled(true);
                      });
     ui.changeExpirationBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::changePassphrase()
 {
     auto cmd = new Kleo::Commands::ChangePassphraseCommand(key);
     QObject::connect(cmd, &Kleo::Commands::ChangePassphraseCommand::finished,
                      q, [this]() {
                          ui.changePassphraseBtn->setEnabled(true);
                      });
     ui.changePassphraseBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::genRevokeCert()
 {
     auto cmd = new Kleo::Commands::GenRevokeCommand(key);
     QObject::connect(cmd, &Kleo::Commands::GenRevokeCommand::finished,
                      q, [this]() {
                          ui.genRevokeBtn->setEnabled(true);
                      });
     ui.genRevokeBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::certifyClicked()
 {
     auto cmd = new Kleo::Commands::CertifyCertificateCommand(key);
     QObject::connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                      q, [this]() {
                          ui.certifyBtn->setEnabled(true);
                      });
     ui.certifyBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::webOfTrustClicked()
 {
     QScopedPointer<WebOfTrustDialog> dlg(new WebOfTrustDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::exportClicked()
 {
     QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::addUserID()
 {
     auto cmd = new Kleo::Commands::AddUserIDCommand(key);
     QObject::connect(cmd, &Kleo::Commands::AddUserIDCommand::finished,
                      q, [this]() {
                          ui.addUserIDBtn->setEnabled(true);
                          key.update();
                          q->setKey(key);
                      });
     ui.addUserIDBtn->setEnabled(false);
     cmd->start();
 }
 
 void CertificateDetailsWidget::Private::keysMayHaveChanged()
 {
     auto newKey = Kleo::KeyCache::instance()->findByFingerprint(key.primaryFingerprint());
     if (!newKey.isNull()) {
         setUpdatedKey(newKey);
     }
 }
 
 void CertificateDetailsWidget::Private::showTrustChainDialog()
 {
     QScopedPointer<TrustChainDialog> dlg(new TrustChainDialog(q));
     dlg->setKey(key);
     dlg->exec();
 }
 
 void CertificateDetailsWidget::Private::publishCertificate()
 {
     qCWarning(KLEOPATRA_LOG) << "publishCertificateis not implemented.";
     //TODO
 }
 
 void CertificateDetailsWidget::Private::userIDTableContextMenuRequested(const QPoint &p)
 {
     auto item = ui.userIDTable->itemAt(p);
     if (!item) {
         return;
     }
 
     const auto userID = item->data(0, Qt::UserRole).value<GpgME::UserID>();
 
-    QMenu *menu = new QMenu(q);
+    auto menu = new QMenu(q);
     menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")),
                     i18n("Certify..."),
                     q, [this, userID]() {
         auto cmd = new Kleo::Commands::CertifyCertificateCommand(userID);
         ui.userIDTable->setEnabled(false);
         connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                 q, [this]() {
             ui.userIDTable->setEnabled(true);
             // Trigger an update when done
             q->setKey(key);
         });
         cmd->start();
     });
     if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")),
                         i18n("Revoke Certification..."),
                         q, [this, userID]() {
             auto cmd = new Kleo::Commands::RevokeCertificationCommand(userID);
             ui.userIDTable->setEnabled(false);
             connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
                     q, [this]() {
                 ui.userIDTable->setEnabled(true);
                 // Trigger an update when done
                 q->setKey(key);
             });
             cmd->start();
         });
     }
     connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
     menu->popup(ui.userIDTable->viewport()->mapToGlobal(p));
 }
 
 void CertificateDetailsWidget::Private::showMoreDetails()
 {
     ui.moreDetailsBtn->setEnabled(false);
     if (key.protocol() == GpgME::CMS) {
         auto cmd = new Kleo::Commands::DumpCertificateCommand(key);
         connect(cmd, &Kleo::Commands::DumpCertificateCommand::finished,
                 q, [this]() {
                     ui.moreDetailsBtn->setEnabled(true);
                 });
         cmd->setUseDialog(true);
         cmd->start();
     } else {
         QScopedPointer<SubKeysDialog> dlg(new SubKeysDialog(q));
         dlg->setKey(key);
         dlg->exec();
         ui.moreDetailsBtn->setEnabled(true);
     }
 }
 
 QString CertificateDetailsWidget::Private::tofuTooltipString(const GpgME::UserID &uid) const
 {
     const auto tofu = uid.tofuInfo();
     if (tofu.isNull()) {
         return QString();
     }
 
     QString html = QStringLiteral("<table border=\"0\" cell-padding=\"5\">");
     const auto appendRow = [&html](const QString &lbl, const QString &val) {
         html += QStringLiteral("<tr>"
                                "<th style=\"text-align: right; padding-right: 5px; white-space: nowrap;\">%1:</th>"
                                "<td style=\"white-space: nowrap;\">%2</td>"
                                "</tr>")
                     .arg(lbl, val);
     };
     const auto appendHeader = [this, &html](const QString &hdr) {
         html += QStringLiteral("<tr><th colspan=\"2\" style=\"background-color: %1; color: %2\">%3</th></tr>")
                     .arg(q->palette().highlight().color().name(),
                          q->palette().highlightedText().color().name(),
                          hdr);
     };
     const auto dateTime = [](long ts) {
         QLocale l;
         return ts == 0 ? i18n("never") : l.toString(QDateTime::fromSecsSinceEpoch(ts), QLocale::ShortFormat);
     };
     appendHeader(i18n("Signing"));
     appendRow(i18n("First message"), dateTime(tofu.signFirst()));
     appendRow(i18n("Last message"), dateTime(tofu.signLast()));
     appendRow(i18n("Message count"), QString::number(tofu.signCount()));
     appendHeader(i18n("Encryption"));
     appendRow(i18n("First message"), dateTime(tofu.encrFirst()));
     appendRow(i18n("Last message"), dateTime(tofu.encrLast()));
     appendRow(i18n("Message count"), QString::number(tofu.encrCount()));
 
     html += QStringLiteral("</table>");
     // Make sure the tooltip string is different for each UserID, even if the
     // data are the same, otherwise the tooltip is not updated and moved when
     // user moves mouse from one row to another.
     html += QStringLiteral("<!-- %1 //-->").arg(QString::fromUtf8(uid.id()));
     return html;
 }
 
 
 void CertificateDetailsWidget::Private::setupPGPProperties()
 {
     HIDE_ROW(smimeOwner)
     HIDE_ROW(smimeIssuer)
     ui.smimeRelatedAddresses->setVisible(false);
     ui.trustChainDetailsBtn->setVisible(false);
 
     ui.userIDTable->setContextMenuPolicy(Qt::CustomContextMenu);
     connect(ui.userIDTable, &QAbstractItemView::customContextMenuRequested,
             q, [this](const QPoint &p) { userIDTableContextMenuRequested(p); });
 }
 
 static QString formatDNToolTip(const Kleo::DN &dn)
 {
     QString html = QStringLiteral("<table border=\"0\" cell-spacing=15>");
 
     const auto appendRow = [&html, dn](const QString &lbl, const QString &attr) {
                                 const QString val = dn[attr];
                                 if (!val.isEmpty()) {
                                     html += QStringLiteral(
                                             "<tr><th style=\"text-align: left; white-space: nowrap\">%1:</th>"
                                                 "<td style=\"white-space: nowrap\">%2</td>"
                                             "</tr>").arg(lbl, val);
                                 }
                             };
     appendRow(i18n("Common Name"), QStringLiteral("CN"));
     appendRow(i18n("Organization"), QStringLiteral("O"));
     appendRow(i18n("Street"), QStringLiteral("STREET"));
     appendRow(i18n("City"),  QStringLiteral("L"));
     appendRow(i18n("State"), QStringLiteral("ST"));
     appendRow(i18n("Country"), QStringLiteral("C"));
     html += QStringLiteral("</table>");
 
     return html;
 }
 
 void CertificateDetailsWidget::Private::setupSMIMEProperties()
 {
     HIDE_ROW(publishing)
 
     const auto ownerId = key.userID(0);
     const Kleo::DN dn(ownerId.id());
     const QString cn = dn[QStringLiteral("CN")];
     const QString o = dn[QStringLiteral("O")];
     const QString dnEmail = dn[QStringLiteral("EMAIL")];
     const QString name = cn.isEmpty() ? dnEmail : cn;
 
     QString owner;
     if (name.isEmpty()) {
         owner = dn.dn();
     } else if (o.isEmpty()) {
         owner = name;
     } else {
         owner = i18nc("<name> of <company>", "%1 of %2", name, o);
     }
     ui.smimeOwner->setText(owner);
     ui.smimeOwner->setTextInteractionFlags(Qt::TextBrowserInteraction);
 
     const Kleo::DN issuerDN(key.issuerName());
     const QString issuerCN = issuerDN[QStringLiteral("CN")];
     const QString issuer = issuerCN.isEmpty() ? QString::fromUtf8(key.issuerName()) : issuerCN;
     ui.smimeIssuer->setText(QStringLiteral("<a href=\"#issuerDetails\">%1</a>").arg(issuer));
 
     ui.smimeIssuer->setToolTip(formatDNToolTip(issuerDN));
 
     ui.smimeOwner->setToolTip(formatDNToolTip(dn));
 
 }
 
 void CertificateDetailsWidget::Private::smimeLinkActivated(const QString &link)
 {
     if (link == QLatin1String("#issuerDetails")) {
         const auto parentKey = KeyCache::instance()->findIssuers(key, KeyCache::NoOption);
 
         if (!parentKey.size()) {
             return;
         }
         auto cmd = new Kleo::Commands::DetailsCommand(parentKey[0], nullptr);
         cmd->setParentWidget(q);
         cmd->start();
         return;
     }
     qCWarning(KLEOPATRA_LOG) << "Unknown link activated:" << link;
 }
 
 CertificateDetailsWidget::CertificateDetailsWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
     d->ui.setupUi(this);
 
     connect(d->ui.addUserIDBtn, &QPushButton::clicked,
             this, [this]() { d->addUserID(); });
     connect(d->ui.changePassphraseBtn, &QPushButton::clicked,
             this, [this]() { d->changePassphrase(); });
     connect(d->ui.genRevokeBtn, &QPushButton::clicked,
             this, [this]() { d->genRevokeCert(); });
     connect(d->ui.changeExpirationBtn, &QPushButton::clicked,
             this, [this]() { d->changeExpiration(); });
     connect(d->ui.smimeOwner, &QLabel::linkActivated,
             this, [this](const QString &link) { d->smimeLinkActivated(link); });
     connect(d->ui.smimeIssuer, &QLabel::linkActivated,
             this, [this](const QString &link) { d->smimeLinkActivated(link); });
     connect(d->ui.trustChainDetailsBtn, &QPushButton::pressed,
             this, [this]() { d->showTrustChainDialog(); });
     connect(d->ui.moreDetailsBtn, &QPushButton::pressed,
             this, [this]() { d->showMoreDetails(); });
     connect(d->ui.publishing, &QPushButton::pressed,
             this, [this]() { d->publishCertificate(); });
     connect(d->ui.certifyBtn, &QPushButton::clicked,
             this, [this]() { d->certifyClicked(); });
     connect(d->ui.webOfTrustBtn, &QPushButton::clicked,
             this, [this]() { d->webOfTrustClicked(); });
     connect(d->ui.exportBtn, &QPushButton::clicked,
             this, [this]() { d->exportClicked(); });
 
     connect(Kleo::KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, [this]() { d->keysMayHaveChanged(); });
 }
 
 CertificateDetailsWidget::~CertificateDetailsWidget()
 {
 }
 
 void CertificateDetailsWidget::Private::keyListDone(const GpgME::KeyListResult &,
                                                     const std::vector<GpgME::Key> &keys,
                                                     const QString &,
                                                     const GpgME::Error &) {
         updateInProgress = false;
         if (keys.size() != 1) {
             qCWarning(KLEOPATRA_LOG) << "Invalid keylist result in update.";
             return;
         }
         // As we listen for keysmayhavechanged we get the update
         // after updating the keycache.
         KeyCache::mutableInstance()->insert(keys);
 }
 
 void CertificateDetailsWidget::Private::setUpdatedKey(const GpgME::Key &k)
 {
     key = k;
 
     setupCommonProperties();
     if (key.protocol() == GpgME::OpenPGP) {
         setupPGPProperties();
     } else {
         setupSMIMEProperties();
     }
 }
 
 void CertificateDetailsWidget::setKey(const GpgME::Key &key)
 {
     if (key.protocol() == GpgME::CMS) {
         // For everything but S/MIME this should be quick
         // and we don't need to show another status.
         d->updateInProgress = true;
     }
     d->setUpdatedKey(key);
 
     // Run a keylistjob with full details (TOFU / Validate)
     QGpgME::KeyListJob *job = key.protocol() == GpgME::OpenPGP ? QGpgME::openpgp()->keyListJob(false, true, true) :
                                                                  QGpgME::smime()->keyListJob(false, true, true);
 
     auto ctx = QGpgME::Job::context(job);
     ctx->addKeyListMode(GpgME::WithTofu);
     ctx->addKeyListMode(GpgME::SignatureNotations);
 #ifdef GPGME_HAS_WITH_SECRET
     if (key.hasSecret()) {
         ctx->addKeyListMode(GpgME::WithSecret);
     }
 #endif
 
     // Windows QGpgME new style connect problem makes this necessary.
     connect(job, SIGNAL(result(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)),
             this, SLOT(keyListDone(GpgME::KeyListResult,std::vector<GpgME::Key>,QString,GpgME::Error)));
 
 #ifdef GPGME_HAS_WITH_SECRET
     job->start(QStringList() << QLatin1String(key.primaryFingerprint()));
 #else
     job->start(QStringList() << QLatin1String(key.primaryFingerprint()), key.hasSecret());
 #endif
 }
 
 GpgME::Key CertificateDetailsWidget::key() const
 {
     return d->key;
 }
 
 CertificateDetailsDialog::CertificateDetailsDialog(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Certificate Details"));
     auto l = new QVBoxLayout(this);
     l->addWidget(new CertificateDetailsWidget(this));
 
     auto bbox = new QDialogButtonBox(this);
     auto btn = bbox->addButton(QDialogButtonBox::Close);
     connect(btn, &QPushButton::pressed, this, &QDialog::accept);
     l->addWidget(bbox);
     readConfig();
 }
 
 CertificateDetailsDialog::~CertificateDetailsDialog()
 {
     writeConfig();
 }
 
 void CertificateDetailsDialog::readConfig()
 {
     KConfigGroup dialog(KSharedConfig::openStateConfig(), "CertificateDetailsDialog");
     const QSize size = dialog.readEntry("Size", QSize(730, 280));
     if (size.isValid()) {
         resize(size);
     }
 }
 
 void CertificateDetailsDialog::writeConfig()
 {
     KConfigGroup dialog(KSharedConfig::openStateConfig(), "CertificateDetailsDialog");
     dialog.writeEntry("Size", size());
     dialog.sync();
 }
 
 void CertificateDetailsDialog::setKey(const GpgME::Key &key)
 {
     auto w = findChild<CertificateDetailsWidget*>();
     Q_ASSERT(w);
     w->setKey(key);
 }
 
 GpgME::Key CertificateDetailsDialog::key() const
 {
     auto w = findChild<CertificateDetailsWidget*>();
     Q_ASSERT(w);
     return w->key();
 }
 
 #include "moc_certificatedetailswidget.cpp"
diff --git a/src/dialogs/certificateselectiondialog.cpp b/src/dialogs/certificateselectiondialog.cpp
index 7a17c000b..87d6ec1bc 100644
--- a/src/dialogs/certificateselectiondialog.cpp
+++ b/src/dialogs/certificateselectiondialog.cpp
@@ -1,473 +1,473 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/certificateselectiondialog.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 "certificateselectiondialog.h"
 
 #include "settings.h"
 
 #include "conf/groupsconfigdialog.h"
 
 #include <view/keytreeview.h>
 #include <view/searchbar.h>
 #include <view/tabwidget.h>
 
 #include "utils/tags.h"
 
 #include <Libkleo/KeyGroup>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyCache>
 
 #include <commands/reloadkeyscommand.h>
 #include <commands/lookupcertificatescommand.h>
 #include <commands/newcertificatecommand.h>
 #include <commands/importcertificatefromfilecommand.h>
 
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 #include <KConfigDialog>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <QLabel>
 #include <QPushButton>
 #include <QDialogButtonBox>
 #include <QItemSelectionModel>
 #include <QAbstractItemView>
 #include <QPointer>
 #include <QVBoxLayout>
 
 #include <algorithm>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 
 CertificateSelectionDialog::Option CertificateSelectionDialog::optionsFromProtocol(Protocol proto)
 {
     switch (proto) {
     case OpenPGP: return CertificateSelectionDialog::OpenPGPFormat;
     case CMS:     return CertificateSelectionDialog::CMSFormat;
     default:      return CertificateSelectionDialog::AnyFormat;
     }
 }
 
 class CertificateSelectionDialog::Private
 {
     friend class ::Kleo::Dialogs::CertificateSelectionDialog;
     CertificateSelectionDialog *const q;
 public:
     explicit Private(CertificateSelectionDialog *qq);
 
 private:
     void reload()
     {
         Command *const cmd = new ReloadKeysCommand(nullptr);
         cmd->setParentWidget(q);
         cmd->start();
     }
     void create()
     {
-        NewCertificateCommand *cmd = new NewCertificateCommand(nullptr);
+        auto cmd = new NewCertificateCommand(nullptr);
         cmd->setParentWidget(q);
         if ((options & AnyFormat) != AnyFormat) {
             cmd->setProtocol((options & OpenPGPFormat) ? OpenPGP : CMS);
         }
         cmd->start();
     }
     void lookup()
     {
         Command *const cmd = new LookupCertificatesCommand(nullptr);
         cmd->setParentWidget(q);
         cmd->start();
     }
     void manageGroups()
     {
         KConfigDialog *dialog = KConfigDialog::exists(GroupsConfigDialog::dialogName());
         if (dialog) {
             // reparent the dialog to ensure it's shown on top of the modal CertificateSelectionDialog
             dialog->setParent(q, Qt::Dialog);
         } else {
             dialog = new GroupsConfigDialog(q);
         }
         dialog->show();
     }
     void slotKeysMayHaveChanged();
     void slotCurrentViewChanged(QAbstractItemView *newView);
     void slotSelectionChanged();
     void slotDoubleClicked(const QModelIndex &idx);
 
 private:
     bool acceptable(const std::vector<Key> &keys, const std::vector<KeyGroup> &groups)
     {
         return !keys.empty() || !groups.empty();
     }
     void updateLabelText()
     {
         ui.label.setText(!customLabelText.isEmpty() ? customLabelText :
                          (options & MultiSelection)
                          ? i18n("Please select one or more of the following certificates:")
                          : i18n("Please select one of the following certificates:"));
     }
 
 private:
     QSet<QAbstractItemView *> connectedViews;
     QString customLabelText;
     Options options = AnyCertificate | AnyFormat;
 
     struct UI {
         QLabel label;
         SearchBar searchBar;
         TabWidget tabWidget;
         QDialogButtonBox buttonBox;
     } ui;
 
     void setUpUI(CertificateSelectionDialog *q)
     {
         KDAB_SET_OBJECT_NAME(ui.label);
         KDAB_SET_OBJECT_NAME(ui.searchBar);
         KDAB_SET_OBJECT_NAME(ui.tabWidget);
         KDAB_SET_OBJECT_NAME(ui.buttonBox);
 
-        auto *vlay = new QVBoxLayout(q);
+        auto vlay = new QVBoxLayout(q);
         vlay->addWidget(&ui.label);
         vlay->addWidget(&ui.searchBar);
         vlay->addWidget(&ui.tabWidget, 1);
         vlay->addWidget(&ui.buttonBox);
 
         QPushButton *const okButton = ui.buttonBox.addButton(QDialogButtonBox::Ok);
         okButton->setEnabled(false);
         ui.buttonBox.addButton(QDialogButtonBox::Close);
         QPushButton *const reloadButton = ui.buttonBox.addButton(i18n("Reload"), QDialogButtonBox::ActionRole);
         QPushButton *const importButton = ui.buttonBox.addButton(i18n("Import..."), QDialogButtonBox::ActionRole);
         QPushButton *const lookupButton = ui.buttonBox.addButton(i18n("Lookup..."), QDialogButtonBox::ActionRole);
         QPushButton *const createButton = ui.buttonBox.addButton(i18n("New..."), QDialogButtonBox::ActionRole);
         QPushButton *const groupsButton = ui.buttonBox.addButton(i18n("Groups..."), QDialogButtonBox::ActionRole);
         groupsButton->setVisible(Settings().groupsEnabled());
 
         importButton->setToolTip(i18nc("@info:tooltip", "Import certificate from file"));
         lookupButton->setToolTip(i18nc("@info:tooltip", "Lookup certificates on server"));
         reloadButton->setToolTip(i18nc("@info:tooltip", "Refresh certificate list"));
         createButton->setToolTip(i18nc("@info:tooltip", "Create a new certificate"));
         groupsButton->setToolTip(i18nc("@info:tooltip", "Manage certificate groups"));
 
         connect(&ui.buttonBox, &QDialogButtonBox::accepted, q, &CertificateSelectionDialog::accept);
         connect(&ui.buttonBox, &QDialogButtonBox::rejected, q, &CertificateSelectionDialog::reject);
         connect(reloadButton, &QPushButton::clicked, q, [this] () { reload(); });
         connect(lookupButton, &QPushButton::clicked, q, [this] () { lookup(); });
         connect(createButton, &QPushButton::clicked, q, [this] () { create(); });
         connect(groupsButton, &QPushButton::clicked, q, [this] () { manageGroups(); });
         connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged,
                 q, [this] () { slotKeysMayHaveChanged(); });
 
         connect(importButton, &QPushButton::clicked, q, [importButton, q] () {
             importButton->setEnabled(false);
             auto cmd = new Kleo::ImportCertificateFromFileCommand();
             connect(cmd, &Kleo::ImportCertificateFromFileCommand::finished,
                     q, [importButton]() {
                 importButton->setEnabled(true);
             });
             cmd->setParentWidget(q);
             cmd->start();
         });
     }
 };
 
 CertificateSelectionDialog::Private::Private(CertificateSelectionDialog *qq)
     : q(qq)
 {
     setUpUI(q);
     ui.tabWidget.setFlatModel(AbstractKeyListModel::createFlatKeyListModel(q));
     ui.tabWidget.setHierarchicalModel(AbstractKeyListModel::createHierarchicalKeyListModel(q));
 #ifdef GPGME_HAS_REMARKS
     const auto tagKeys = Tags::tagKeys();
     ui.tabWidget.flatModel()->setRemarkKeys(tagKeys);
     ui.tabWidget.hierarchicalModel()->setRemarkKeys(tagKeys);
 #endif
     ui.tabWidget.connectSearchBar(&ui.searchBar);
 
     connect(&ui.tabWidget, &TabWidget::currentViewChanged,
             q, [this] (QAbstractItemView *view) { slotCurrentViewChanged(view); });
 
     updateLabelText();
     q->setWindowTitle(i18nc("@title:window", "Certificate Selection"));
 }
 
 CertificateSelectionDialog::CertificateSelectionDialog(QWidget *parent)
     : QDialog(parent), d(new Private(this))
 {
     const KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kleopatracertificateselectiondialogrc"));
     d->ui.tabWidget.loadViews(config.data());
     const KConfigGroup geometry(config, "Geometry");
     resize(geometry.readEntry("size", size()));
     d->slotKeysMayHaveChanged();
 }
 
 CertificateSelectionDialog::~CertificateSelectionDialog() {}
 
 void CertificateSelectionDialog::setCustomLabelText(const QString &txt)
 {
     if (txt == d->customLabelText) {
         return;
     }
     d->customLabelText = txt;
     d->updateLabelText();
 }
 
 QString CertificateSelectionDialog::customLabelText() const
 {
     return d->customLabelText;
 }
 
 void CertificateSelectionDialog::setOptions(Options options)
 {
     Q_ASSERT((options & CertificateSelectionDialog::AnyCertificate) != 0);
     Q_ASSERT((options & CertificateSelectionDialog::AnyFormat) != 0);
     if (d->options == options) {
         return;
     }
     d->options = options;
 
     d->ui.tabWidget.setMultiSelection(options & MultiSelection);
 
     d->slotKeysMayHaveChanged();
 }
 
 CertificateSelectionDialog::Options CertificateSelectionDialog::options() const
 {
     return d->options;
 }
 
 void CertificateSelectionDialog::setStringFilter(const QString &filter)
 {
     d->ui.tabWidget.setStringFilter(filter);
 }
 
 void CertificateSelectionDialog::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     d->ui.tabWidget.setKeyFilter(filter);
 }
 
 namespace
 {
 
 void selectRows(const QAbstractItemView *view, const QModelIndexList &indexes)
 {
     if (!view) {
         return;
     }
     QItemSelectionModel *const sm = view->selectionModel();
     Q_ASSERT(sm);
 
     for (const QModelIndex &idx : qAsConst(indexes)) {
         if (idx.isValid()) {
             sm->select(idx, QItemSelectionModel::Select | QItemSelectionModel::Rows);
         }
     }
 }
 
 QModelIndexList getGroupIndexes(const KeyListModelInterface *model, const std::vector<KeyGroup> &groups)
 {
     QModelIndexList indexes;
     indexes.reserve(groups.size());
     std::transform(groups.begin(), groups.end(),
                    std::back_inserter(indexes),
                    [model] (const KeyGroup &group) {
                        return model->index(group);
                    });
     indexes.erase(std::remove_if(indexes.begin(), indexes.end(),
                                  [] (const QModelIndex &index) { return !index.isValid(); }),
                   indexes.end());
     return indexes;
 }
 
 }
 
 void CertificateSelectionDialog::selectCertificates(const std::vector<Key> &keys)
 {
     const auto *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     selectRows(d->ui.tabWidget.currentView(), model->indexes(keys));
 }
 
 void CertificateSelectionDialog::selectCertificate(const Key &key)
 {
     selectCertificates(std::vector<Key>(1, key));
 }
 
 void CertificateSelectionDialog::selectGroups(const std::vector<KeyGroup> &groups)
 {
     const auto *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     selectRows(d->ui.tabWidget.currentView(), getGroupIndexes(model, groups));
 }
 
 namespace
 {
 
 QModelIndexList getSelectedRows(const QAbstractItemView *view)
 {
     if (!view) {
         return {};
     }
     const QItemSelectionModel *const sm = view->selectionModel();
     Q_ASSERT(sm);
     return sm->selectedRows();
 }
 
 std::vector<KeyGroup> getGroups(const KeyListModelInterface *model, const QModelIndexList &indexes)
 {
     std::vector<KeyGroup> groups;
     groups.reserve(indexes.size());
     std::transform(indexes.begin(), indexes.end(),
                    std::back_inserter(groups),
                    [model](const QModelIndex &idx) {
                        return model->group(idx);
                    });
     groups.erase(std::remove_if(groups.begin(), groups.end(), std::mem_fn(&Kleo::KeyGroup::isNull)), groups.end());
     return groups;
 }
 
 }
 
 std::vector<Key> CertificateSelectionDialog::selectedCertificates() const
 {
     const KeyListModelInterface *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     return model->keys(getSelectedRows(d->ui.tabWidget.currentView()));
 }
 
 Key CertificateSelectionDialog::selectedCertificate() const
 {
     const std::vector<Key> keys = selectedCertificates();
     return keys.empty() ? Key() : keys.front();
 }
 
 std::vector<KeyGroup> CertificateSelectionDialog::selectedGroups() const
 {
     const KeyListModelInterface *const model = d->ui.tabWidget.currentModel();
     Q_ASSERT(model);
     return getGroups(model, getSelectedRows(d->ui.tabWidget.currentView()));
 }
 
 void CertificateSelectionDialog::hideEvent(QHideEvent *e)
 {
     KSharedConfig::Ptr config = KSharedConfig::openConfig(QStringLiteral("kleopatracertificateselectiondialogrc"));
     d->ui.tabWidget.saveViews(config.data());
     KConfigGroup geometry(config, "Geometry");
     geometry.writeEntry("size", size());
     QDialog::hideEvent(e);
 }
 
 void CertificateSelectionDialog::Private::slotKeysMayHaveChanged()
 {
     q->setEnabled(true);
     std::vector<Key> keys = (options & SecretKeys) ? KeyCache::instance()->secretKeys() : KeyCache::instance()->keys();
     q->filterAllowedKeys(keys, options);
     const std::vector<KeyGroup> groups = (options & IncludeGroups) ? KeyCache::instance()->groups() : std::vector<KeyGroup>();
 
     const std::vector<Key> selectedKeys = q->selectedCertificates();
     const std::vector<KeyGroup> selectedGroups = q->selectedGroups();
     if (AbstractKeyListModel *const model = ui.tabWidget.flatModel()) {
         model->setKeys(keys);
         model->setGroups(groups);
     }
     if (AbstractKeyListModel *const model = ui.tabWidget.hierarchicalModel()) {
         model->setKeys(keys);
         model->setGroups(groups);
     }
     q->selectCertificates(selectedKeys);
     q->selectGroups(selectedGroups);
 }
 
 void CertificateSelectionDialog::filterAllowedKeys(std::vector<Key> &keys, int options)
 {
-    std::vector<Key>::iterator end = keys.end();
+    auto end = keys.end();
 
     switch (options & AnyFormat) {
     case OpenPGPFormat:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return key.protocol() != OpenPGP; });
         break;
     case CMSFormat:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return key.protocol() != CMS; });
         break;
     default:
     case AnyFormat:
         ;
     }
 
     switch (options & AnyCertificate) {
     case SignOnly:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return !key.canReallySign(); });
         break;
     case EncryptOnly:
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return !key.canEncrypt(); });
         break;
     default:
     case AnyCertificate:
         ;
     }
 
     if (options & SecretKeys) {
         end = std::remove_if(keys.begin(), end, [](const Key &key) { return !key.hasSecret(); });
     }
 
     keys.erase(end, keys.end());
 }
 
 void CertificateSelectionDialog::Private::slotCurrentViewChanged(QAbstractItemView *newView)
 {
     if (!connectedViews.contains(newView)) {
         connectedViews.insert(newView);
         connect(newView, &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &index) { slotDoubleClicked(index); });
         Q_ASSERT(newView->selectionModel());
         connect(newView->selectionModel(), &QItemSelectionModel::selectionChanged,
                 q, [this] (const QItemSelection &, const QItemSelection &) { slotSelectionChanged(); });
     }
     slotSelectionChanged();
 }
 
 void CertificateSelectionDialog::Private::slotSelectionChanged()
 {
     if (QPushButton *const pb = ui.buttonBox.button(QDialogButtonBox::Ok)) {
         pb->setEnabled(acceptable(q->selectedCertificates(), q->selectedGroups()));
     }
 }
 
 void CertificateSelectionDialog::Private::slotDoubleClicked(const QModelIndex &idx)
 {
     QAbstractItemView *const view = ui.tabWidget.currentView();
     Q_ASSERT(view);
     const auto *const model = ui.tabWidget.currentModel();
     Q_ASSERT(model);
     Q_UNUSED(model)
     QItemSelectionModel *const sm = view->selectionModel();
     Q_ASSERT(sm);
     sm->select(idx, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
     QMetaObject::invokeMethod(q, [this]() {q->accept();}, Qt::QueuedConnection);
 }
 
 void CertificateSelectionDialog::accept()
 {
     if (d->acceptable(selectedCertificates(), selectedGroups())) {
         QDialog::accept();
     }
 }
 
 #include "moc_certificateselectiondialog.cpp"
diff --git a/src/dialogs/certifycertificatedialog.cpp b/src/dialogs/certifycertificatedialog.cpp
index 142891109..cb9d16842 100644
--- a/src/dialogs/certifycertificatedialog.cpp
+++ b/src/dialogs/certifycertificatedialog.cpp
@@ -1,150 +1,150 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/signcertificatedialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2019 g10code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "kleopatra_debug.h"
 
 #include "certifycertificatedialog.h"
 
 #include "certifywidget.h"
 
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 #include <KStandardGuiItem>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <KMessageBox>
 
 #include <QVBoxLayout>
 #include <QDialogButtonBox>
 #include <QPushButton>
 
 #include <gpg-error.h>
 
 
 using namespace GpgME;
 using namespace Kleo;
 
 CertifyCertificateDialog::CertifyCertificateDialog(QWidget *p, Qt::WindowFlags f)
     : QDialog(p, f)
 {
     setWindowFlags(windowFlags() & (~Qt::WindowContextHelpButtonHint));
 
     // Setup GUI
     auto mainLay = new QVBoxLayout(this);
     mCertWidget = new CertifyWidget(this);
     mainLay->addWidget(mCertWidget);
 
-    QDialogButtonBox *buttonBox = new QDialogButtonBox();
+    auto buttonBox = new QDialogButtonBox();
     buttonBox->setStandardButtons(QDialogButtonBox::Cancel |
                                   QDialogButtonBox::Ok);
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Ok), KStandardGuiItem::ok());
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
 
     buttonBox->button(QDialogButtonBox::Ok)->setText(i18n("Certify"));
     connect(buttonBox->button(QDialogButtonBox::Ok), &QAbstractButton::clicked,
             this, [this] () {
         KConfigGroup conf(KSharedConfig::openConfig(), "CertifySettings");
         const auto lastKey = mCertWidget->secKey();
         // Do not accept if the keys are the same.
         if (!lastKey.isNull() && !mCertWidget->target().isNull() &&
             !strcmp(lastKey.primaryFingerprint(),
                     mCertWidget->target().primaryFingerprint())) {
             KMessageBox::error(this, i18n("You cannot certify using the same key."),
                                i18n("Invalid Selection"), KMessageBox::Notify);
             return;
         }
 
         if (!lastKey.isNull()) {
             conf.writeEntry("LastKey", lastKey.primaryFingerprint());
         }
         conf.writeEntry("ExportCheckState", mCertWidget->exportableSelected());
         conf.writeEntry("PublishCheckState", mCertWidget->publishSelected());
         accept();
     });
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QAbstractButton::clicked,
             this, [this] () {
         close();
     });
 
     mainLay->addWidget(buttonBox);
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "CertifyDialog");
     const QByteArray geom = cfgGroup.readEntry("geometry", QByteArray());
     if (!geom.isEmpty()) {
         restoreGeometry(geom);
         return;
     }
     resize(QSize(640, 480));
 }
 
 CertifyCertificateDialog::~CertifyCertificateDialog()
 {
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "CertifyDialog");
     cfgGroup.writeEntry("geometry", saveGeometry());
     cfgGroup.sync();
 }
 
 void CertifyCertificateDialog::setCertificateToCertify(const Key &key)
 {
     setWindowTitle(i18nc("@title:window arg is name, email of certificate holder", "Certify Certificate: %1", Formatting::prettyName(key)));
     mCertWidget->setTarget(key);
 }
 
 bool CertifyCertificateDialog::exportableCertificationSelected() const
 {
     return mCertWidget->exportableSelected();
 }
 
 bool CertifyCertificateDialog::trustCertificationSelected() const
 {
     return false;
 }
 
 bool CertifyCertificateDialog::nonRevocableCertificationSelected() const
 {
     return false;
 }
 
 Key CertifyCertificateDialog::selectedSecretKey() const
 {
     return mCertWidget->secKey();
 }
 
 bool CertifyCertificateDialog::sendToServer() const
 {
     return mCertWidget->publishSelected();
 }
 
 unsigned int CertifyCertificateDialog::selectedCheckLevel() const
 {
     //PENDING
 #ifdef KLEO_SIGN_KEY_CERTLEVEL_SUPPORT
     return d->selectCheckLevelPage->checkLevel();
 #endif
     return 0;
 }
 
 void CertifyCertificateDialog::setSelectedUserIDs(const std::vector<UserID> &uids)
 {
     mCertWidget->selectUserIDs(uids);
 }
 
 std::vector<unsigned int> CertifyCertificateDialog::selectedUserIDs() const
 {
     return mCertWidget->selectedUserIDs();
 }
 
 QString CertifyCertificateDialog::tags() const
 {
     return mCertWidget->tags();
 }
diff --git a/src/dialogs/certifywidget.cpp b/src/dialogs/certifywidget.cpp
index 96cff42f1..f7f9b39bc 100644
--- a/src/dialogs/certifywidget.cpp
+++ b/src/dialogs/certifywidget.cpp
@@ -1,465 +1,465 @@
 /*  dialogs/certifywidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2019 g 10code GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "certifywidget.h"
 
 #include "kleopatra_debug.h"
 
 #include <KLocalizedString>
 #include <KConfigGroup>
 #include <KSharedConfig>
 
 #include <Libkleo/DefaultKeyFilter>
 #include <Libkleo/KeySelectionCombo>
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyCache>
 
 #include <QCheckBox>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QLineEdit>
 #include <QListView>
 #include <QParallelAnimationGroup>
 #include <QPropertyAnimation>
 #include <QPushButton>
 #include <QScrollArea>
 #include <QStandardItemModel>
 #include <QToolButton>
 #include <QToolTip>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 using namespace Kleo;
 
 namespace {
 
 // Maybe move this in its own file
 // based on code from StackOverflow
 class AnimatedExpander: public QWidget
 {
     Q_OBJECT
 public:
     explicit AnimatedExpander(const QString &title = QString(),
                               const int animationDuration = 300,
                               QWidget *parent = nullptr);
     void setContentLayout(QLayout *contentLayout);
 
 private:
     QGridLayout mainLayout;
     QToolButton toggleButton;
     QFrame headerLine;
     QParallelAnimationGroup toggleAnimation;
     QScrollArea contentArea;
     int animationDuration{300};
 };
 
 AnimatedExpander::AnimatedExpander(const QString &title,
                                    const int animationDuration, QWidget *parent):
     QWidget(parent),
     animationDuration(animationDuration)
 {
     toggleButton.setStyleSheet(QStringLiteral("QToolButton { border: none; }"));
     toggleButton.setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
     toggleButton.setArrowType(Qt::ArrowType::RightArrow);
     toggleButton.setText(title);
     toggleButton.setCheckable(true);
     toggleButton.setChecked(false);
 
     headerLine.setFrameShape(QFrame::HLine);
     headerLine.setFrameShadow(QFrame::Sunken);
     headerLine.setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
 
     contentArea.setStyleSheet(QStringLiteral("QScrollArea { border: none; }"));
     contentArea.setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
 
     // start out collapsed
     contentArea.setMaximumHeight(0);
     contentArea.setMinimumHeight(0);
 
     // let the entire widget grow and shrink with its content
     toggleAnimation.addAnimation(new QPropertyAnimation(this, "minimumHeight"));
     toggleAnimation.addAnimation(new QPropertyAnimation(this, "maximumHeight"));
     toggleAnimation.addAnimation(new QPropertyAnimation(&contentArea, "maximumHeight"));
 
     mainLayout.setVerticalSpacing(0);
     mainLayout.setContentsMargins(0, 0, 0, 0);
     int row = 0;
     mainLayout.addWidget(&toggleButton, row, 0, 1, 1, Qt::AlignLeft);
     mainLayout.addWidget(&headerLine, row++, 2, 1, 1);
     mainLayout.addWidget(&contentArea, row, 0, 1, 3);
     setLayout(&mainLayout);
     QObject::connect(&toggleButton, &QToolButton::clicked, [this](const bool checked) {
         toggleButton.setArrowType(checked ? Qt::ArrowType::DownArrow : Qt::ArrowType::RightArrow);
         toggleAnimation.setDirection(checked ? QAbstractAnimation::Forward : QAbstractAnimation::Backward);
         toggleAnimation.start();
     });
 }
 
 void AnimatedExpander::setContentLayout(QLayout *contentLayout)
 {
     delete contentArea.layout();
     contentArea.setLayout(contentLayout);
     const auto collapsedHeight = sizeHint().height() - contentArea.maximumHeight();
     auto contentHeight = contentLayout->sizeHint().height();
     for (int i = 0; i < toggleAnimation.animationCount() - 1; ++i) {
         auto expanderAnimation = static_cast<QPropertyAnimation *>(toggleAnimation.animationAt(i));
         expanderAnimation->setDuration(animationDuration);
         expanderAnimation->setStartValue(collapsedHeight);
         expanderAnimation->setEndValue(collapsedHeight + contentHeight);
     }
     auto contentAnimation = static_cast<QPropertyAnimation *>(toggleAnimation.animationAt(toggleAnimation.animationCount() - 1));
     contentAnimation->setDuration(animationDuration);
     contentAnimation->setStartValue(0);
     contentAnimation->setEndValue(contentHeight);
 }
 
 class SecKeyFilter: public DefaultKeyFilter
 {
 public:
     SecKeyFilter() : DefaultKeyFilter()
     {
         setRevoked(DefaultKeyFilter::NotSet);
         setExpired(DefaultKeyFilter::NotSet);
         setHasSecret(DefaultKeyFilter::Set);
         setCanCertify(DefaultKeyFilter::Set);
         setIsOpenPGP(DefaultKeyFilter::Set);
     }
 };
 
 class UserIDModel : public QStandardItemModel
 {
     Q_OBJECT
 public:
     enum Role {
         UserIDIndex = Qt::UserRole
     };
     explicit UserIDModel(QObject *parent = nullptr) : QStandardItemModel(parent) {}
 
     GpgME::Key certificateToCertify() const
     {
         return m_key;
     }
 
     void setKey(const GpgME::Key &key)
     {
         m_key = key;
         clear();
         const std::vector<GpgME::UserID> ids = key.userIDs();
         int i = 0;
         for (const auto &uid: key.userIDs()) {
             if (uid.isRevoked() || uid.isInvalid()) {
                 // Skip user ID's that cannot really be certified.
                 i++;
                 continue;
             }
-            QStandardItem *const item = new QStandardItem;
+            auto const item = new QStandardItem;
             item->setText(Formatting::prettyUserID(uid));
             item->setData(i, UserIDIndex);
             item->setCheckable(true);
             item->setEditable(false);
             item->setCheckState(Qt::Checked);
             appendRow(item);
             i++;
         }
     }
 
     void setCheckedUserIDs(const std::vector<unsigned int> &uids)
     {
         std::vector<unsigned int> sorted = uids;
         std::sort(sorted.begin(), sorted.end());
         for (int i = 0, end = rowCount(); i != end; ++i) {
             item(i)->setCheckState(std::binary_search(sorted.begin(), sorted.end(), i) ? Qt::Checked : Qt::Unchecked);
         }
     }
 
     std::vector<unsigned int> checkedUserIDs() const
     {
         std::vector<unsigned int> ids;
         for (int i = 0; i < rowCount(); ++i) {
             if (item(i)->checkState() == Qt::Checked) {
                 ids.push_back(item(i)->data(UserIDIndex).toUInt());
             }
         }
         qCDebug(KLEOPATRA_LOG) << "Checked uids are: " << ids;
         return ids;
     }
 
 private:
     GpgME::Key m_key;
 };
 
 static bool uidEqual(const GpgME::UserID &lhs, const GpgME::UserID &rhs)
 {
     return qstrcmp(lhs.parent().primaryFingerprint(),
                     rhs.parent().primaryFingerprint()) == 0
             && qstrcmp(lhs.id(), rhs.id()) == 0;
 }
 
 } // anonymous namespace
 
 
 // Use of pimpl as this might be moved to libkleo
 class CertifyWidget::Private
 {
 public:
     Private(CertifyWidget *qq) : q(qq),
         mFprLabel(new QLabel)
     {
-        QVBoxLayout *mainLay = new QVBoxLayout(q);
+        auto mainLay = new QVBoxLayout(q);
         mainLay->addWidget(mFprLabel);
 
         auto secKeyLay = new QHBoxLayout;
         secKeyLay->addWidget(new QLabel(i18n("Certify with:")));
 
         mSecKeySelect = new KeySelectionCombo(true);
         mSecKeySelect->setKeyFilter(std::shared_ptr<KeyFilter>(new SecKeyFilter()));
 
         secKeyLay->addWidget(mSecKeySelect, 1);
         mainLay->addLayout(secKeyLay);
 
         auto splitLine = new QFrame;
         splitLine->setFrameShape(QFrame::HLine);
         splitLine->setFrameShadow(QFrame::Sunken);
         splitLine->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
 
         mainLay->addWidget(splitLine);
 
         auto listView = new QListView;
         listView->setModel(&mUserIDModel);
         mainLay->addWidget(listView, 1);
 
         // Setup the advanced area
         auto expander = new AnimatedExpander(i18n("Advanced"));
         mainLay->addWidget(expander);
 
         auto advLay = new QVBoxLayout;
 
         mExportCB = new QCheckBox(i18n("Certify for everyone to see. (exportable)"));
         mPublishCB = new QCheckBox(i18n("Publish on keyserver afterwards."));
         auto publishLay = new QHBoxLayout;
         publishLay->addSpacing(20);
         publishLay->addWidget(mPublishCB);
 
         mTagsLE = new QLineEdit;
         mTagsLE->setPlaceholderText(i18n("Tags"));
 
         auto infoBtn = new QPushButton;
         infoBtn->setIcon(QIcon::fromTheme(QStringLiteral("help-contextual")));
         infoBtn->setFlat(true);
 
         connect(infoBtn, &QPushButton::clicked, q, [this, infoBtn] () {
             const QString msg = i18n("You can use this to add additional info to a "
                                      "certification.") + QStringLiteral("<br/><br/>") +
                                      i18n("Tags created by anyone with full certification trust "
                                           "are shown in the keylist and can be searched.");
             QToolTip::showText(infoBtn->mapToGlobal(QPoint()) + QPoint(infoBtn->width(), 0),
                                msg, infoBtn, QRect(), 30000);
         });
 
         auto tagsLay = new QHBoxLayout;
         tagsLay->addWidget(infoBtn);
         tagsLay->addWidget(mTagsLE);
 
         advLay->addWidget(mExportCB);
         advLay->addLayout(publishLay);
         advLay->addLayout(tagsLay);
 
 #ifndef GPGME_HAS_REMARKS
         // Hide it if we do not have remark support
         mTagsLE->setVisible(false);
         infoBtn->setVisible(false);
 #endif
 
         expander->setContentLayout(advLay);
 
         mPublishCB->setEnabled(false);
 
         connect(mExportCB, &QCheckBox::toggled, [this] (bool on) {
             mPublishCB->setEnabled(on);
         });
 
         connect(mSecKeySelect, &KeySelectionCombo::currentKeyChanged, [this] (const GpgME::Key &) {
 #ifdef GPGME_HAS_REMARKS
             updateTags();
 #endif
         });
 
         loadConfig();
     }
 
     ~Private()
     {
     }
 
     void loadConfig()
     {
         const KConfigGroup conf(KSharedConfig::openConfig(), "CertifySettings");
         mSecKeySelect->setDefaultKey(conf.readEntry("LastKey", QString()));
         mExportCB->setChecked(conf.readEntry("ExportCheckState", false));
         mPublishCB->setChecked(conf.readEntry("PublishCheckState", false));
     }
 
     void updateTags()
     {
         if (mTagsLE->isModified()) {
             return;
         }
 #ifdef GPGME_HAS_REMARKS
         GpgME::Key remarkKey = mSecKeySelect->currentKey();
 
         if (!remarkKey.isNull()) {
             std::vector<GpgME::UserID> uidsWithRemark;
             QString remark;
             for (const auto &uid: mTarget.userIDs()) {
                 GpgME::Error err;
                 const char *c_remark = uid.remark(remarkKey, err);
                 if (c_remark) {
                     const QString candidate = QString::fromUtf8(c_remark);
                     if (candidate != remark) {
                         qCDebug(KLEOPATRA_LOG) << "Different remarks on user ids. Taking last.";
                         remark = candidate;
                         uidsWithRemark.clear();
                     }
                     uidsWithRemark.push_back(uid);
                 }
             }
             // Only select the user ids with the correct remark
             if (!remark.isEmpty()) {
                 selectUserIDs(uidsWithRemark);
             }
             mTagsLE->setText(remark);
         }
 #endif
     }
 
     void setTarget(const GpgME::Key &key)
     {
         mFprLabel->setText(i18n("Fingerprint: <b>%1</b>",
                             Formatting::prettyID(key.primaryFingerprint())) + QStringLiteral("<br/>") +
                             i18n("<i>Only the fingerprint clearly identifies the key and its owner.</i>"));
         mUserIDModel.setKey(key);
         mTarget = key;
 
         updateTags();
     }
 
     GpgME::Key secKey() const
     {
         return mSecKeySelect->currentKey();
     }
 
     void selectUserIDs(const std::vector<GpgME::UserID> &uids)
     {
         const auto all = mTarget.userIDs();
 
         std::vector<unsigned int> indexes;
         indexes.reserve(uids.size());
 
         for (const auto &uid: uids) {
             const unsigned int idx =
                 std::distance(all.cbegin(), std::find_if(all.cbegin(), all.cend(),
                             [uid](const GpgME::UserID &other) { return uidEqual(uid, other); }));
             if (idx < all.size()) {
                 indexes.push_back(idx);
             }
         }
 
         mUserIDModel.setCheckedUserIDs(indexes);
     }
 
     std::vector<unsigned int> selectedUserIDs() const
     {
         return mUserIDModel.checkedUserIDs();
     }
 
     bool exportableSelected() const
     {
         return mExportCB->isChecked();
     }
 
     bool publishSelected() const
     {
         return mPublishCB->isChecked();
     }
 
     QString tags() const
     {
         return mTagsLE->text().trimmed();
     }
 
     GpgME::Key target() const
     {
         return mTarget;
     }
 
 private:
     CertifyWidget *const q;
     QLabel *mFprLabel;
     KeySelectionCombo *mSecKeySelect;
     QCheckBox *mExportCB;
     QCheckBox *mPublishCB;
     QLineEdit *mTagsLE;
 
     UserIDModel mUserIDModel;
     GpgME::Key mTarget;
 };
 
 CertifyWidget::CertifyWidget(QWidget *parent) :
     QWidget(parent),
     d(new Private(this))
 {
 }
 
 void CertifyWidget::setTarget(const GpgME::Key &key)
 {
     d->setTarget(key);
 }
 
 GpgME::Key CertifyWidget::target() const
 {
     return d->target();
 }
 
 void CertifyWidget::selectUserIDs(const std::vector<GpgME::UserID> &uids)
 {
     d->selectUserIDs(uids);
 }
 
 std::vector<unsigned int> CertifyWidget::selectedUserIDs() const
 {
     return d->selectedUserIDs();
 }
 
 GpgME::Key CertifyWidget::secKey() const
 {
     return d->secKey();
 }
 
 bool CertifyWidget::exportableSelected() const
 {
     return d->exportableSelected();
 }
 
 QString CertifyWidget::tags() const
 {
     return d->tags();
 }
 
 bool CertifyWidget::publishSelected() const
 {
     return d->publishSelected();
 }
 
 // For UserID model
 #include "certifywidget.moc"
diff --git a/src/dialogs/editgroupdialog.cpp b/src/dialogs/editgroupdialog.cpp
index 902485b5a..dbde7fed9 100644
--- a/src/dialogs/editgroupdialog.cpp
+++ b/src/dialogs/editgroupdialog.cpp
@@ -1,291 +1,291 @@
 /*
     dialogs/editgroupdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "editgroupdialog.h"
 
 #include "commands/detailscommand.h"
 #include "view/keytreeview.h"
 
 #include <Libkleo/KeyListModel>
 
 #include <KConfigGroup>
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <KSeparator>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 
 #include <QDialogButtonBox>
 #include <QHBoxLayout>
 #include <QItemSelectionModel>
 #include <QLabel>
 #include <QLineEdit>
 #include <QPushButton>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 class EditGroupDialog::Private
 {
     friend class ::Kleo::Dialogs::EditGroupDialog;
     EditGroupDialog *const q;
 
     struct {
         QLineEdit *groupNameEdit = nullptr;
         QLineEdit *availableKeysFilter = nullptr;
         KeyTreeView *availableKeysList = nullptr;
         QLineEdit *groupKeysFilter = nullptr;
         KeyTreeView *groupKeysList = nullptr;
         QDialogButtonBox *buttonBox = nullptr;
     } ui;
     AbstractKeyListModel *availableKeysModel = nullptr;
     AbstractKeyListModel *groupKeysModel = nullptr;
 
 public:
     Private(EditGroupDialog *qq)
         : q(qq)
     {
         auto mainLayout = new QVBoxLayout(q);
 
         auto groupNameLayout = new QHBoxLayout();
         groupNameLayout->addWidget(new QLabel(i18nc("Name of a group of keys", "Name:")));
         ui.groupNameEdit = new QLineEdit();
         groupNameLayout->addWidget(ui.groupNameEdit);
         mainLayout->addLayout(groupNameLayout);
 
         mainLayout->addWidget(new KSeparator(Qt::Horizontal));
 
         auto centerLayout = new QVBoxLayout();
 
         auto availableKeysLayout = new QVBoxLayout();
         availableKeysLayout->addWidget(new QLabel(i18n("Available keys:")));
 
         ui.availableKeysFilter = new QLineEdit();
         ui.availableKeysFilter->setClearButtonEnabled(true);
         ui.availableKeysFilter->setPlaceholderText(i18nc("Placeholder text", "Search..."));
         availableKeysLayout->addWidget(ui.availableKeysFilter);
 
         availableKeysModel = AbstractKeyListModel::createFlatKeyListModel(q);
         availableKeysModel->useKeyCache(true, KeyList::AllKeys);
         ui.availableKeysList = new KeyTreeView(q);
         ui.availableKeysList->view()->setRootIsDecorated(false);
         ui.availableKeysList->setFlatModel(availableKeysModel);
         ui.availableKeysList->setHierarchicalView(false);
         availableKeysLayout->addWidget(ui.availableKeysList, /*stretch=*/ 1);
 
         centerLayout->addLayout(availableKeysLayout, /*stretch=*/ 1);
 
         auto buttonsLayout = new QHBoxLayout();
         buttonsLayout->addStretch(1);
 
         auto addButton = new QPushButton();
         addButton->setIcon(QIcon::fromTheme(QStringLiteral("arrow-down")));
         addButton->setToolTip(i18n("Add the selected keys to the group"));
         addButton->setEnabled(false);
         buttonsLayout->addWidget(addButton);
 
         auto removeButton = new QPushButton();
         removeButton->setIcon(QIcon::fromTheme(QStringLiteral("arrow-up")));
         removeButton->setToolTip(i18n("Remove the selected keys from the group"));
         removeButton->setEnabled(false);
         buttonsLayout->addWidget(removeButton);
 
         buttonsLayout->addStretch(1);
 
         centerLayout->addLayout(buttonsLayout);
 
         auto groupKeysLayout = new QVBoxLayout();
         groupKeysLayout->addWidget(new QLabel(i18n("Group keys:")));
 
         ui.groupKeysFilter = new QLineEdit();
         ui.groupKeysFilter->setClearButtonEnabled(true);
         ui.groupKeysFilter->setPlaceholderText(i18nc("Placeholder text", "Search..."));
         groupKeysLayout->addWidget(ui.groupKeysFilter);
 
         groupKeysModel = AbstractKeyListModel::createFlatKeyListModel(q);
         ui.groupKeysList = new KeyTreeView(q);
         ui.groupKeysList->view()->setRootIsDecorated(false);
         ui.groupKeysList->setFlatModel(groupKeysModel);
         ui.groupKeysList->setHierarchicalView(false);
         groupKeysLayout->addWidget(ui.groupKeysList, /*stretch=*/ 1);
 
         centerLayout->addLayout(groupKeysLayout, /*stretch=*/ 1);
 
         mainLayout->addLayout(centerLayout);
 
         mainLayout->addWidget(new KSeparator(Qt::Horizontal));
 
         ui.buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
         QPushButton *okButton = ui.buttonBox->button(QDialogButtonBox::Ok);
         KGuiItem::assign(okButton, KStandardGuiItem::ok());
         KGuiItem::assign(ui.buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
         okButton->setEnabled(false);
         mainLayout->addWidget(ui.buttonBox);
 
         connect(ui.groupNameEdit, &QLineEdit::textChanged,
                 q, [okButton] (const QString &text) {
                     okButton->setEnabled(!text.trimmed().isEmpty());
                 });
         connect(ui.availableKeysFilter, &QLineEdit::textChanged,
                 ui.availableKeysList, &KeyTreeView::setStringFilter);
         connect(ui.availableKeysList->view()->selectionModel(), &QItemSelectionModel::selectionChanged,
                 q, [addButton] (const QItemSelection &selected, const QItemSelection &) {
                     addButton->setEnabled(!selected.isEmpty());
                 });
         connect(ui.availableKeysList->view(), &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &index) { showKeyDetails(index); });
         connect(ui.groupKeysFilter, &QLineEdit::textChanged,
                 ui.groupKeysList, &KeyTreeView::setStringFilter);
         connect(ui.groupKeysList->view()->selectionModel(), &QItemSelectionModel::selectionChanged,
                 q, [removeButton] (const QItemSelection &selected, const QItemSelection &) {
                     removeButton->setEnabled(!selected.isEmpty());
                 });
         connect(ui.groupKeysList->view(), &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &index) { showKeyDetails(index); });
         connect(addButton, &QPushButton::clicked, q, [this] () { addKeysToGroup(); });
         connect(removeButton, &QPushButton::clicked, q, [this] () { removeKeysFromGroup(); });
         connect(ui.buttonBox, &QDialogButtonBox::accepted, q, &EditGroupDialog::accept);
         connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &EditGroupDialog::reject);
 
         // calculate default size with enough space for the key list
         const auto fm = q->fontMetrics();
         const QSize sizeHint = q->sizeHint();
         const QSize defaultSize = QSize(qMax(sizeHint.width(), 150 * fm.horizontalAdvance(QLatin1Char('x'))),
                                         sizeHint.height());
         restoreLayout(defaultSize);
     }
 
     ~Private()
     {
         saveLayout();
     }
 
 private:
     void saveLayout()
     {
         KConfigGroup configGroup(KSharedConfig::openConfig(), "EditGroupDialog");
         configGroup.writeEntry("Size", q->size());
 
         KConfigGroup availableKeysConfig = configGroup.group("AvailableKeysView");
         ui.availableKeysList->saveLayout(availableKeysConfig);
 
         KConfigGroup groupKeysConfig = configGroup.group("GroupKeysView");
         ui.groupKeysList->saveLayout(groupKeysConfig);
 
         configGroup.sync();
     }
 
     void restoreLayout(const QSize &defaultSize)
     {
         const KConfigGroup configGroup(KSharedConfig::openConfig(), "EditGroupDialog");
 
         const KConfigGroup availableKeysConfig = configGroup.group("AvailableKeysView");
         ui.availableKeysList->restoreLayout(availableKeysConfig);
 
         const KConfigGroup groupKeysConfig = configGroup.group("GroupKeysView");
         ui.groupKeysList->restoreLayout(groupKeysConfig);
 
         const QSize size = configGroup.readEntry("Size", defaultSize);
         if (size.isValid()) {
             q->resize(size);
         }
     }
 
     void showKeyDetails(const QModelIndex &index)
     {
         if (!index.isValid()) {
             return;
         }
-        const GpgME::Key key = index.model()->data(index, KeyList::KeyRole).value<GpgME::Key>();
+        const auto key = index.model()->data(index, KeyList::KeyRole).value<GpgME::Key>();
         if (!key.isNull()) {
             auto cmd = new DetailsCommand(key, nullptr);
             cmd->setParentWidget(q);
             cmd->start();
         }
     }
 
     void addKeysToGroup();
     void removeKeysFromGroup();
 };
 
 void EditGroupDialog::Private::addKeysToGroup()
 {
     const std::vector<Key> selectedGroupKeys = ui.groupKeysList->selectedKeys();
 
     const std::vector<Key> selectedKeys = ui.availableKeysList->selectedKeys();
     groupKeysModel->addKeys(selectedKeys);
 
     ui.groupKeysList->selectKeys(selectedGroupKeys);
 }
 
 void EditGroupDialog::Private::removeKeysFromGroup()
 {
     const std::vector<Key> selectedKeys = ui.groupKeysList->selectedKeys();
     for (const Key &key : selectedKeys) {
         groupKeysModel->removeKey(key);
     }
 }
 
 EditGroupDialog::EditGroupDialog(QWidget *parent)
     : QDialog(parent)
     , d(new Private(this))
 {
     setWindowTitle(i18nc("@title:window", "Edit Group"));
 }
 
 EditGroupDialog::~EditGroupDialog() = default;
 
 void EditGroupDialog::setInitialFocus(FocusWidget widget)
 {
     switch (widget) {
     case GroupName:
         d->ui.groupNameEdit->setFocus();
         break;
     case KeysFilter:
         d->ui.availableKeysFilter->setFocus();
         break;
     default:
         qCDebug(KLEOPATRA_LOG) << "EditGroupDialog::setInitialFocus - invalid focus widget:" << widget;
     }
 }
 
 void EditGroupDialog::setGroupName(const QString &name)
 {
     d->ui.groupNameEdit->setText(name);
 }
 
 QString EditGroupDialog::groupName() const
 {
     return d->ui.groupNameEdit->text().trimmed();
 }
 
 void EditGroupDialog::setGroupKeys(const std::vector<Key> &keys)
 {
     d->groupKeysModel->setKeys(keys);
 }
 
 std::vector<Key> EditGroupDialog::groupKeys() const
 {
     std::vector<Key> keys;
     keys.reserve(d->groupKeysModel->rowCount());
     for (int row = 0; row < d->groupKeysModel->rowCount(); ++row) {
         const QModelIndex index = d->groupKeysModel->index(row, 0);
         keys.push_back(d->groupKeysModel->key(index));
     }
     return keys;
 }
diff --git a/src/dialogs/expirydialog.cpp b/src/dialogs/expirydialog.cpp
index 70240e1bd..c8c5d837c 100644
--- a/src/dialogs/expirydialog.cpp
+++ b/src/dialogs/expirydialog.cpp
@@ -1,206 +1,206 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/expirydialog.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 "expirydialog.h"
 
 #include "ui_expirydialog.h"
 
 #include <QDate>
 
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 
 enum Period {
     Days,
     Weeks,
     Months,
     Years,
 
     NumPeriods
 };
 
 static QDate date_by_amount_and_unit(int inAmount, int inUnit)
 {
     const QDate current = QDate::currentDate();
     switch (inUnit) {
     case Days:   return current.addDays(inAmount);
     case Weeks:  return current.addDays(7 * inAmount);
     case Months: return current.addMonths(inAmount);
     case Years:  return current.addYears(inAmount);
     default:
         Q_ASSERT(!"Should not reach here");
     }
     return QDate();
 }
 
 // these calculations should be precise enough for the forseeable future...
 static const double DAYS_IN_GREGORIAN_YEAR = 365.2425;
 
 static int monthsBetween(const QDate &d1, const QDate &d2)
 {
     const int days = d1.daysTo(d2);
     return qRound(days / DAYS_IN_GREGORIAN_YEAR * 12);
 }
 
 static int yearsBetween(const QDate &d1, const QDate &d2)
 {
     const int days = d1.daysTo(d2);
     return qRound(days / DAYS_IN_GREGORIAN_YEAR);
 }
 
 class ExpiryDialog::Private
 {
     friend class ::Kleo::Dialogs::ExpiryDialog;
     ExpiryDialog *const q;
 public:
     explicit Private(ExpiryDialog *qq)
         : q(qq),
           inUnit(Days),
           ui(q)
     {
         connect(ui.inSB, SIGNAL(valueChanged(int)),
                 q, SLOT(slotInAmountChanged()));
         connect(ui.inCB, SIGNAL(currentIndexChanged(int)),
                 q, SLOT(slotInUnitChanged()));
         connect(ui.onCW, SIGNAL(selectionChanged()),
                 q, SLOT(slotOnDateChanged()));
         connect(ui.onCW, &QCalendarWidget::currentPageChanged,
                 q, [this] (int year, int month) {
                     // We select the ame day in the month when
                     // a page is switched.
                     auto date = ui.onCW->selectedDate();
                     if (!date.setDate(year, month, date.day())) {
                         date.setDate(year, month, 1);
                     }
                     ui.onCW->setSelectedDate(date);
                 });
 
         Q_ASSERT(ui.inCB->currentIndex() == inUnit);
     }
 
 private:
     void slotInAmountChanged();
     void slotInUnitChanged();
     void slotOnDateChanged();
 
 private:
     QDate inDate() const;
     int inAmountByDate(const QDate &date) const;
 
 private:
     int inUnit;
 
     struct UI : public Ui::ExpiryDialog {
         explicit UI(Dialogs::ExpiryDialog *qq)
             : Ui::ExpiryDialog()
         {
-            QWidget *mainWidget = new QWidget(qq);
+            auto mainWidget = new QWidget(qq);
 
             setupUi(mainWidget);
-            QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, qq);
-            QVBoxLayout *mainLayout = new QVBoxLayout;
+            auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, qq);
+            auto mainLayout = new QVBoxLayout;
             qq->setLayout(mainLayout);
             mainLayout->addWidget(mainWidget);
             QPushButton *okButton = buttonBox->button(QDialogButtonBox::Ok);
             okButton->setDefault(true);
             okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
             qq->connect(buttonBox, &QDialogButtonBox::accepted, qq, &QDialog::accept);
             qq->connect(buttonBox, &QDialogButtonBox::rejected, qq, &QDialog::reject);
             mainLayout->addWidget(buttonBox);
 
             Q_ASSERT(inCB->count() == NumPeriods);
 
             onCW->setMinimumDate(QDate::currentDate().addDays(1));
         }
     } ui;
 };
 
 ExpiryDialog::ExpiryDialog(QWidget *p)
     : QDialog(p), d(new Private(this))
 {
     setWindowTitle(i18nc("@title:window", "Change Expiry"));
 }
 
 ExpiryDialog::~ExpiryDialog() {}
 
 void ExpiryDialog::setDateOfExpiry(const QDate &date)
 {
     const QDate current = QDate::currentDate();
     if (date.isValid()) {
         d->ui.onRB->setChecked(true);
         d->ui.onCW->setSelectedDate(qMax(date, current));
     } else {
         d->ui.neverRB->setChecked(true);
         d->ui.onCW->setSelectedDate(current);
         d->ui.inSB->setValue(0);
     }
 }
 
 QDate ExpiryDialog::dateOfExpiry() const
 {
     return
         d->ui.inRB->isChecked() ? d->inDate() :
         d->ui.onRB->isChecked() ? d->ui.onCW->selectedDate() :
         QDate();
 }
 
 void ExpiryDialog::Private::slotInUnitChanged()
 {
     const int oldInAmount = ui.inSB->value();
     const QDate targetDate = date_by_amount_and_unit(oldInAmount, inUnit);
     inUnit = ui.inCB->currentIndex();
     if (targetDate.isValid()) {
         ui.inSB->setValue(inAmountByDate(targetDate));
     } else {
         slotInAmountChanged();
     }
 }
 
 void ExpiryDialog::Private::slotInAmountChanged()
 {
     // Only modify onCW when onCW is slave:
     if (ui.inRB->isChecked()) {
         ui.onCW->setSelectedDate(inDate());
     }
 }
 
 void ExpiryDialog::Private::slotOnDateChanged()
 {
     // Only modify inSB/inCB when onCW is master:
     if (ui.onRB->isChecked()) {
         ui.inSB->setValue(inAmountByDate(ui.onCW->selectedDate()));
     }
 }
 
 QDate ExpiryDialog::Private::inDate() const
 {
     return date_by_amount_and_unit(ui.inSB->value(), ui.inCB->currentIndex());
 }
 
 int ExpiryDialog::Private::inAmountByDate(const QDate &selected) const
 {
     const QDate current  = QDate::currentDate();
 
     switch (ui.inCB->currentIndex()) {
     case Days:   return current.daysTo(selected);
     case Weeks:  return qRound(current.daysTo(selected) / 7.0);
     case Months: return monthsBetween(current, selected);
     case Years:  return yearsBetween(current, selected);
     };
     Q_ASSERT(!"Should not reach here");
     return -1;
 }
 
 #include "moc_expirydialog.cpp"
diff --git a/src/dialogs/groupdetailsdialog.cpp b/src/dialogs/groupdetailsdialog.cpp
index d0d3e155b..00f19959c 100644
--- a/src/dialogs/groupdetailsdialog.cpp
+++ b/src/dialogs/groupdetailsdialog.cpp
@@ -1,156 +1,156 @@
 /*
     dialogs/groupdetailsdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2021 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "groupdetailsdialog.h"
 
 #include "commands/detailscommand.h"
 #include "view/keytreeview.h"
 
 #include <Libkleo/KeyGroup>
 #include <Libkleo/KeyListModel>
 
 #include <KConfigGroup>
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 
 #include <QDialogButtonBox>
 #include <QLabel>
 #include <QPushButton>
 #include <QTreeView>
 #include <QVBoxLayout>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::Dialogs;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 class GroupDetailsDialog::Private
 {
     friend class ::Kleo::Dialogs::GroupDetailsDialog;
     GroupDetailsDialog *const q;
 
     struct {
         QLabel *groupNameLabel = nullptr;
         QLabel *groupCommentLabel = nullptr;
         KeyTreeView *treeView = nullptr;
         QDialogButtonBox *buttonBox = nullptr;
     } ui;
     KeyGroup group;
 
 public:
     Private(GroupDetailsDialog *qq)
         : q(qq)
     {
         auto mainLayout = new QVBoxLayout(q);
 
         ui.groupNameLabel = new QLabel();
         ui.groupNameLabel->setWordWrap(true);
         mainLayout->addWidget(ui.groupNameLabel);
 
         ui.groupCommentLabel = new QLabel();
         ui.groupCommentLabel->setWordWrap(true);
         ui.groupCommentLabel->setVisible(false);
         mainLayout->addWidget(ui.groupCommentLabel);
 
         ui.treeView = new KeyTreeView(q);
         ui.treeView->view()->setRootIsDecorated(false);
         ui.treeView->view()->setSelectionMode(QAbstractItemView::SingleSelection);
         ui.treeView->setFlatModel(AbstractKeyListModel::createFlatKeyListModel(ui.treeView));
         ui.treeView->setHierarchicalView(false);
         connect(ui.treeView->view(), &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &index) { showKeyDetails(index); });
         mainLayout->addWidget(ui.treeView);
 
         ui.buttonBox = new QDialogButtonBox(QDialogButtonBox::Close);
         KGuiItem::assign(ui.buttonBox->button(QDialogButtonBox::Close), KStandardGuiItem::close());
         connect(ui.buttonBox, &QDialogButtonBox::rejected, q, &QDialog::close);
         mainLayout->addWidget(ui.buttonBox);
 
         // calculate default size with enough space for the key list
         const auto fm = ui.treeView->fontMetrics();
         const QSize sizeHint = q->sizeHint();
         const QSize defaultSize = QSize(qMax(sizeHint.width(), 150 * fm.horizontalAdvance(QLatin1Char('x'))),
                                         sizeHint.height() - ui.treeView->sizeHint().height() + 20 * fm.lineSpacing());
         restoreLayout(defaultSize);
     }
 
     ~Private()
     {
         saveLayout();
     }
 
 private:
     void saveLayout()
     {
         KConfigGroup configGroup(KSharedConfig::openStateConfig(), "GroupDetailsDialog");
         ui.treeView->saveLayout(configGroup);
         configGroup.writeEntry("Size", q->size());
         configGroup.sync();
     }
 
     void restoreLayout(const QSize &defaultSize)
     {
         const KConfigGroup configGroup(KSharedConfig::openStateConfig(), "GroupDetailsDialog");
         ui.treeView->restoreLayout(configGroup);
         const QSize size = configGroup.readEntry("Size", defaultSize);
         if (size.isValid()) {
             q->resize(size);
         }
     }
 
     void showKeyDetails(const QModelIndex &index)
     {
-        const GpgME::Key key = ui.treeView->view()->model()->data(index, KeyList::KeyRole).value<GpgME::Key>();
+        const auto key = ui.treeView->view()->model()->data(index, KeyList::KeyRole).value<GpgME::Key>();
         if (!key.isNull()) {
             auto cmd = new DetailsCommand(key, nullptr);
             cmd->setParentWidget(q);
             cmd->start();
         }
     }
 };
 
 GroupDetailsDialog::GroupDetailsDialog(QWidget *parent)
     : QDialog(parent)
     , d(new Private(this))
 {
     setWindowTitle(i18nc("@title:window", "Group Details"));
 }
 
 GroupDetailsDialog::~GroupDetailsDialog()
 {
 }
 
 namespace
 {
 QString groupComment(const KeyGroup &group)
 {
     switch (group.source()) {
     case KeyGroup::GnuPGConfig:
         return i18n("Note: This group is defined in the configuration files of gpg.");
     default:
         return QString();
     }
 }
 }
 
 void GroupDetailsDialog::setGroup(const KeyGroup &group)
 {
     d->group = group;
     d->ui.groupNameLabel->setText(group.name());
     d->ui.groupCommentLabel->setText(groupComment(group));
     d->ui.groupCommentLabel->setVisible(!d->ui.groupCommentLabel->text().isEmpty());
     const KeyGroup::Keys &keys = group.keys();
     d->ui.treeView->setKeys(std::vector<GpgME::Key>(keys.cbegin(), keys.cend()));
 }
diff --git a/src/dialogs/ownertrustdialog.cpp b/src/dialogs/ownertrustdialog.cpp
index 0c046d0aa..99c86308e 100644
--- a/src/dialogs/ownertrustdialog.cpp
+++ b/src/dialogs/ownertrustdialog.cpp
@@ -1,186 +1,186 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/ownertrustdialog.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 "ownertrustdialog.h"
 #include "ui_ownertrustdialog.h"
 
 #include <Libkleo/Formatting>
 
 #include <KLocalizedString>
 
 #include <QPushButton>
 
 #include <QDialogButtonBox>
 #include <QVBoxLayout>
 
 using namespace Kleo;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 class OwnerTrustDialog::Private
 {
     friend class ::Kleo::Dialogs::OwnerTrustDialog;
     OwnerTrustDialog *const q;
 public:
     explicit Private(OwnerTrustDialog *qq)
         : q(qq),
           formattedCertificateName(i18n("(unknown certificate)")),
           originalTrust(Key::Undefined),
           hasSecret(false),
           advancedMode(false),
           ui(qq)
     {
 
     }
 
 private:
     void slotTrustLevelChanged()
     {
         enableDisableWidgets();
     }
 
     void enableDisableWidgets();
 
 private:
     QString formattedCertificateName;
     Key::OwnerTrust originalTrust;
     bool hasSecret : 1;
     bool advancedMode : 1;
 
     struct UI : public Ui::OwnerTrustDialog {
         explicit UI(Dialogs::OwnerTrustDialog *qq)
             : Ui::OwnerTrustDialog(), q(qq)
         {
-            QWidget *mainWidget = new QWidget(q);
+            auto mainWidget = new QWidget(q);
 
             setupUi(mainWidget);
-            QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
-            QVBoxLayout *mainLayout = new QVBoxLayout(q);
+            auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel);
+            auto mainLayout = new QVBoxLayout(q);
             mainLayout->addWidget(mainWidget);
             okButton = buttonBox->button(QDialogButtonBox::Ok);
             okButton->setDefault(true);
             okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
             q->connect(buttonBox, &QDialogButtonBox::accepted, q, &QDialog::accept);
             q->connect(buttonBox, &QDialogButtonBox::rejected, q, &QDialog::reject);
             mainLayout->addWidget(buttonBox);
         }
 
         QPushButton *okPB() const
         {
             return okButton;
         }
         QPushButton *okButton;
         Dialogs::OwnerTrustDialog *const q;
     } ui;
 };
 
 OwnerTrustDialog::OwnerTrustDialog(QWidget *p)
     : QDialog(p), d(new Private(this))
 {
     connect(d->ui.unknownRB, SIGNAL(toggled(bool)), this, SLOT(slotTrustLevelChanged()));
     connect(d->ui.neverRB, SIGNAL(toggled(bool)), this, SLOT(slotTrustLevelChanged()));
     connect(d->ui.marginalRB, SIGNAL(toggled(bool)), this, SLOT(slotTrustLevelChanged()));
     connect(d->ui.fullRB, SIGNAL(toggled(bool)), this, SLOT(slotTrustLevelChanged()));
     connect(d->ui.ultimateRB, SIGNAL(toggled(bool)), this, SLOT(slotTrustLevelChanged()));
 }
 
 OwnerTrustDialog::~OwnerTrustDialog() {}
 
 void OwnerTrustDialog::setFormattedCertificateName(const QString &formatted)
 {
     if (formatted.isEmpty()) {
         return;
     }
     d->formattedCertificateName = formatted;
     setWindowTitle(i18nc("@title:window", "Change Trust Level of %1", formatted));
     d->ui.label->setText(i18nc("@info", "How much do you trust certifications made by <b>%1</b> to correctly verify authenticity of certificates?", formatted));
 }
 
 QString OwnerTrustDialog::formattedCertificateName() const
 {
     return d->formattedCertificateName;
 }
 
 void OwnerTrustDialog::setHasSecretKey(bool secret)
 {
     d->hasSecret = secret;
     d->enableDisableWidgets();
     setOwnerTrust(ownerTrust());
 }
 
 bool OwnerTrustDialog::hasSecretKey() const
 {
     return d->hasSecret;
 }
 
 void OwnerTrustDialog::setAdvancedMode(bool advanced)
 {
     d->advancedMode = advanced;
     d->enableDisableWidgets();
     setOwnerTrust(ownerTrust());
 }
 
 bool OwnerTrustDialog::isAdvancedMode() const
 {
     return d->advancedMode;
 }
 
 void OwnerTrustDialog::Private::enableDisableWidgets()
 {
     ui.unknownRB ->setEnabled(!hasSecret || advancedMode);
     ui.neverRB   ->setEnabled(!hasSecret || advancedMode);
     ui.marginalRB->setEnabled(!hasSecret || advancedMode);
     ui.fullRB    ->setEnabled(!hasSecret || advancedMode);
     ui.ultimateRB->setEnabled(hasSecret || advancedMode);
     ui.okPB()->setEnabled(q->ownerTrust() != Key::Undefined && q->ownerTrust() != originalTrust);
 }
 
 static void force_set_checked(QAbstractButton *b, bool on)
 {
     // work around Qt bug (tested: 4.1.4, 4.2.3, 4.3.4)
     const bool autoExclusive = b->autoExclusive();
     b->setAutoExclusive(false);
     b->setChecked(b->isEnabled() && on);
     b->setAutoExclusive(autoExclusive);
 }
 
 void OwnerTrustDialog::setOwnerTrust(Key::OwnerTrust trust)
 {
     d->originalTrust = trust;
     force_set_checked(d->ui.unknownRB, trust == Key::Unknown);
     force_set_checked(d->ui.neverRB,   trust == Key::Never);
     force_set_checked(d->ui.marginalRB, trust == Key::Marginal);
     force_set_checked(d->ui.fullRB,    trust == Key::Full);
     force_set_checked(d->ui.ultimateRB, trust == Key::Ultimate);
     d->enableDisableWidgets();
 }
 
 Key::OwnerTrust OwnerTrustDialog::ownerTrust() const
 {
     if (d->ui.unknownRB->isChecked()) {
         return Key::Unknown;
     }
     if (d->ui.neverRB->isChecked()) {
         return Key::Never;
     }
     if (d->ui.marginalRB->isChecked()) {
         return Key::Marginal;
     }
     if (d->ui.fullRB->isChecked()) {
         return Key::Full;
     }
     if (d->ui.ultimateRB->isChecked()) {
         return Key::Ultimate;
     }
     return Key::Undefined;
 }
 
 #include "moc_ownertrustdialog.cpp"
diff --git a/src/dialogs/revokecertificationdialog.cpp b/src/dialogs/revokecertificationdialog.cpp
index 65850b18b..04cac5a54 100644
--- a/src/dialogs/revokecertificationdialog.cpp
+++ b/src/dialogs/revokecertificationdialog.cpp
@@ -1,143 +1,143 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/revokecertificationdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "revokecertificationdialog.h"
 
 #include "revokecertificationwidget.h"
 
 #include <Libkleo/Formatting>
 
 #include <KConfigGroup>
 #include <KGuiItem>
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KStandardGuiItem>
 
 #include <QAbstractButton>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QVBoxLayout>
 
 #include "kleopatra_debug.h"
 
 using namespace GpgME;
 using namespace Kleo;
 
 class RevokeCertificationDialog::Private
 {
     friend class ::Kleo::RevokeCertificationDialog;
     RevokeCertificationDialog *const q;
 public:
     explicit Private(RevokeCertificationDialog *qq);
     ~Private();
 
 private:
     void saveGeometry();
     void restoreGeometry(const QSize &defaultSize);
 
 private:
     RevokeCertificationWidget *mainWidget = nullptr;
 };
 
 
 RevokeCertificationDialog::Private::Private(RevokeCertificationDialog *qq)
     : q(qq)
 {
 }
 
 RevokeCertificationDialog::Private::~Private()
 {
 }
 
 void RevokeCertificationDialog::Private::saveGeometry()
 {
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "RevokeCertificationDialog");
     cfgGroup.writeEntry("geometry", q->saveGeometry());
     cfgGroup.sync();
 }
 
 void RevokeCertificationDialog::Private::restoreGeometry(const QSize &defaultSize)
 {
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "RevokeCertificationDialog");
     const QByteArray geometry = cfgGroup.readEntry("geometry", QByteArray());
     if (!geometry.isEmpty()) {
         q->restoreGeometry(geometry);
     } else {
         q->resize(defaultSize);
     }
 }
 
 RevokeCertificationDialog::RevokeCertificationDialog(QWidget *p, Qt::WindowFlags f)
     : QDialog(p, f)
     , d(new Private(this))
 {
     setWindowFlags(windowFlags() & (~Qt::WindowContextHelpButtonHint));
 
     auto mainLay = new QVBoxLayout(this);
     d->mainWidget = new RevokeCertificationWidget(this);
     mainLay->addWidget(d->mainWidget);
 
-    QDialogButtonBox *buttonBox = new QDialogButtonBox();
+    auto buttonBox = new QDialogButtonBox();
     mainLay->addWidget(buttonBox);
     buttonBox->setStandardButtons(QDialogButtonBox::Cancel |
                                   QDialogButtonBox::Ok);
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Ok), KStandardGuiItem::ok());
     KGuiItem::assign(buttonBox->button(QDialogButtonBox::Cancel), KStandardGuiItem::cancel());
     buttonBox->button(QDialogButtonBox::Ok)->setText(i18n("Revoke Certification"));
     connect(buttonBox->button(QDialogButtonBox::Ok), &QAbstractButton::clicked,
             this, [this] () {
                 d->mainWidget->saveConfig();
                 accept();
             });
     connect(buttonBox->button(QDialogButtonBox::Cancel), &QAbstractButton::clicked,
             this, [this] () { close(); });
 
     d->restoreGeometry(QSize(640, 480));
 }
 
 RevokeCertificationDialog::~RevokeCertificationDialog()
 {
     d->saveGeometry();
 }
 
 void RevokeCertificationDialog::setCertificateToRevoke(const Key &key)
 {
     setWindowTitle(i18nc("@title:window arg is name, email of certificate holder",
                          "Revoke Certification: %1", Formatting::prettyName(key)));
     d->mainWidget->setTarget(key);
 }
 
 void RevokeCertificationDialog::setSelectedUserIDs(const std::vector<UserID> &uids)
 {
     d->mainWidget->setSelectUserIDs(uids);
 }
 
 std::vector<GpgME::UserID> RevokeCertificationDialog::selectedUserIDs() const
 {
     return d->mainWidget->selectedUserIDs();
 }
 
 void Kleo::RevokeCertificationDialog::setSelectedCertificationKey(const GpgME::Key &key)
 {
     d->mainWidget->setCertificationKey(key);
 }
 
 Key RevokeCertificationDialog::selectedCertificationKey() const
 {
     return d->mainWidget->certificationKey();
 }
 
 bool RevokeCertificationDialog::sendToServer() const
 {
     return d->mainWidget->publishSelected();
 }
diff --git a/src/dialogs/revokecertificationwidget.cpp b/src/dialogs/revokecertificationwidget.cpp
index 5cba2c5f5..8fb7edf90 100644
--- a/src/dialogs/revokecertificationwidget.cpp
+++ b/src/dialogs/revokecertificationwidget.cpp
@@ -1,270 +1,270 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     dialogs/revokecertificationwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "revokecertificationwidget.h"
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include <KSharedConfig>
 
 #include <Libkleo/DefaultKeyFilter>
 #include <Libkleo/Formatting>
 #include <Libkleo/KeySelectionCombo>
 
 #include <QCheckBox>
 #include <QFrame>
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QListView>
 #include <QStandardItemModel>
 #include <QVBoxLayout>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_UIDHASH
 #endif
 
 using namespace Kleo;
 
 namespace {
 
 class CertificationKeyFilter: public DefaultKeyFilter
 {
 public:
     CertificationKeyFilter(const GpgME::Key &certificationTarget);
 
     bool matches(const GpgME::Key &key, Kleo::KeyFilter::MatchContexts contexts) const override;
 
 private:
     GpgME::Key mCertificationTarget; // the key to certify or to revoke the certification of
 };
 
 CertificationKeyFilter::CertificationKeyFilter(const GpgME::Key &certificationTarget)
     : DefaultKeyFilter()
     , mCertificationTarget(certificationTarget)
 {
     setIsOpenPGP(DefaultKeyFilter::Set);
     setHasSecret(DefaultKeyFilter::Set);
     setCanCertify(DefaultKeyFilter::Set);
     setIsBad(DefaultKeyFilter::NotSet);
 }
 
 bool CertificationKeyFilter::matches(const GpgME::Key &key, Kleo::KeyFilter::MatchContexts contexts) const
 {
     if (!(availableMatchContexts() & contexts)) {
         return false;
     }
     // exclude certification target from list of certification keys
     if (qstrcmp(key.primaryFingerprint(), mCertificationTarget.primaryFingerprint()) == 0) {
         return false;
     }
     return DefaultKeyFilter::matches(key, contexts);
 }
 
 static bool uidsAreEqual(const GpgME::UserID &lhs, const GpgME::UserID &rhs)
 {
     // use uidhash if available
 #ifdef GPGME_HAS_UIDHASH
     if (lhs.uidhash() && rhs.uidhash()) {
         return strcmp(lhs.uidhash(), rhs.uidhash()) == 0;
     }
 #endif
     // compare actual user ID string and primary key; this is not unique, but it's all we can do if uidhash is missing
     return qstrcmp(lhs.id(), rhs.id()) == 0
         && qstrcmp(lhs.parent().primaryFingerprint(), rhs.parent().primaryFingerprint()) == 0;
 }
 
 class UserIDModel : public QStandardItemModel
 {
     Q_OBJECT
 public:
     explicit UserIDModel(QObject *parent = nullptr) : QStandardItemModel(parent)
     {
     }
 
     void setKey(const GpgME::Key &key)
     {
         mKey = key;
         clear();
         const std::vector<GpgME::UserID> uids = key.userIDs();
         for (const auto &uid : uids) {
-            QStandardItem *const item = new QStandardItem;
+            auto const item = new QStandardItem;
             item->setText(Formatting::prettyUserID(uid));
             item->setCheckable(true);
             item->setEditable(false);
             item->setCheckState(Qt::Checked);
             appendRow(item);
         }
     }
 
     void setCheckedUserIDs(const std::vector<GpgME::UserID> &checkedUids)
     {
         const auto keyUids = mKey.userIDs();
         Q_ASSERT(rowCount() == static_cast<int>(keyUids.size()));
 
         for (int i = 0; i < rowCount(); ++i) {
             const auto &keyUid = keyUids[i];
             const bool uidIsChecked = std::find_if(checkedUids.cbegin(), checkedUids.cend(),
                                                    [keyUid](const GpgME::UserID &checkedUid) { return uidsAreEqual(keyUid, checkedUid); }) != checkedUids.cend();
             item(i)->setCheckState(uidIsChecked ? Qt::Checked : Qt::Unchecked);
         }
     }
 
     std::vector<GpgME::UserID> checkedUserIDs() const
     {
         const auto keyUids = mKey.userIDs();
         Q_ASSERT(rowCount() == static_cast<int>(keyUids.size()));
 
         std::vector<GpgME::UserID> checkedUids;
         for (int i = 0; i < rowCount(); ++i) {
             if (item(i)->checkState() == Qt::Checked) {
                 checkedUids.push_back(keyUids[i]);
             }
         }
         return checkedUids;
     }
 
 private:
     GpgME::Key mKey;
 };
 
 } // unnamed namespace
 
 class RevokeCertificationWidget::Private
 {
     friend class ::Kleo::RevokeCertificationWidget;
     RevokeCertificationWidget *const q;
 
     QLabel *mFprLabel;
     KeySelectionCombo *mCertificationKeySelect;
     QCheckBox *mPublishCB;
 
     UserIDModel mUserIDModel;
     GpgME::Key mTarget;
 
 public:
     Private(RevokeCertificationWidget *qq)
         : q(qq)
         , mFprLabel(new QLabel)
         , mCertificationKeySelect(new KeySelectionCombo(/* secretOnly = */ true))
         , mPublishCB(new QCheckBox)
     {
-        QVBoxLayout *mainLayout = new QVBoxLayout(q);
+        auto mainLayout = new QVBoxLayout(q);
         mainLayout->addWidget(mFprLabel);
 
         auto certKeyLayout = new QHBoxLayout;
         {
             auto label = new QLabel(i18n("Certification key:"));
             label->setToolTip(i18n("The key whose certifications shall be revoke"));
             certKeyLayout->addWidget(label);
         }
         certKeyLayout->addWidget(mCertificationKeySelect, 1);
         mainLayout->addLayout(certKeyLayout);
 
         auto splitLine = new QFrame;
         splitLine->setFrameShape(QFrame::HLine);
         splitLine->setFrameShadow(QFrame::Sunken);
         splitLine->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Maximum);
 
         mainLayout->addWidget(splitLine);
 
         auto listView = new QListView;
         listView->setModel(&mUserIDModel);
         mainLayout->addWidget(listView, 1);
 
         mPublishCB = new QCheckBox(i18n("Publish revocations on keyserver"));
         mainLayout->addWidget(mPublishCB);
 
         loadConfig();
     }
 
     ~Private()
     {
     }
 
     void saveConfig()
     {
         KConfigGroup conf(KSharedConfig::openConfig(), "RevokeCertificationSettings");
         const auto certificationKey = mCertificationKeySelect->currentKey();
         if (!certificationKey.isNull()) {
             conf.writeEntry("LastKey", certificationKey.primaryFingerprint());
         }
         conf.writeEntry("PublishCheckState", mPublishCB->isChecked());
     }
 
     void loadConfig()
     {
         const KConfigGroup conf(KSharedConfig::openConfig(), "RevokeCertificationSettings");
         mCertificationKeySelect->setDefaultKey(conf.readEntry("LastKey", QString()));
         mPublishCB->setChecked(conf.readEntry("PublishCheckState", false));
     }
 };
 
 RevokeCertificationWidget::RevokeCertificationWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
 }
 
 RevokeCertificationWidget::~RevokeCertificationWidget()
 {
 }
 
 void RevokeCertificationWidget::setTarget(const GpgME::Key &key)
 {
     d->mTarget = key;
     d->mFprLabel->setText(i18n("Fingerprint: <b>%1</b>",
                           Formatting::prettyID(d->mTarget.primaryFingerprint())) + QStringLiteral("<br/>") +
                           i18n("<i>Only the fingerprint clearly identifies the key and its owner.</i>"));
     d->mCertificationKeySelect->setKeyFilter(std::shared_ptr<KeyFilter>(new CertificationKeyFilter(d->mTarget)));
     d->mUserIDModel.setKey(d->mTarget);
 }
 
 GpgME::Key RevokeCertificationWidget::target() const
 {
     return d->mTarget;
 }
 
 void RevokeCertificationWidget::setSelectUserIDs(const std::vector<GpgME::UserID> &uids)
 {
     d->mUserIDModel.setCheckedUserIDs(uids);
 }
 
 std::vector<GpgME::UserID> RevokeCertificationWidget::selectedUserIDs() const
 {
     return d->mUserIDModel.checkedUserIDs();
 }
 
 void RevokeCertificationWidget::setCertificationKey(const GpgME::Key &key)
 {
     d->mCertificationKeySelect->setDefaultKey(QString::fromLatin1(key.primaryFingerprint()));
 }
 
 GpgME::Key RevokeCertificationWidget::certificationKey() const
 {
     return d->mCertificationKeySelect->currentKey();
 }
 
 bool RevokeCertificationWidget::publishSelected() const
 {
     return d->mPublishCB->isChecked();
 }
 
 void Kleo::RevokeCertificationWidget::saveConfig() const
 {
     d->saveConfig();
 }
 
 // for UserIDModel
 #include "revokecertificationwidget.moc"
diff --git a/src/dialogs/subkeyswidget.cpp b/src/dialogs/subkeyswidget.cpp
index 9b3e4c183..97a4dc001 100644
--- a/src/dialogs/subkeyswidget.cpp
+++ b/src/dialogs/subkeyswidget.cpp
@@ -1,255 +1,255 @@
 /*  SPDX-FileCopyrightText: 2016 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "subkeyswidget.h"
 #include "ui_subkeyswidget.h"
 
 #include "commands/changeexpirycommand.h"
 #include "commands/keytocardcommand.h"
 #include "commands/importpaperkeycommand.h"
 #include "exportdialog.h"
 
 #include <gpgme++/key.h>
 #include <gpgme++/context.h>
 
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <QDialogButtonBox>
 #include <QPushButton>
 #include <QTreeWidgetItem>
 #include <QMenu>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_EXPORT_FLAGS
 #endif
 #if GPGMEPP_VERSION >= 0x10E01 // 1.14.1
 # define CHANGEEXPIRYJOB_SUPPORTS_SUBKEYS
 #endif
 
 #include <Libkleo/Formatting>
 
 Q_DECLARE_METATYPE(GpgME::Subkey)
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 
 class SubKeysWidget::Private
 {
 public:
     Private(SubKeysWidget *q)
         : q(q)
     {
         ui.setupUi(q);
         ui.subkeysTree->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(ui.subkeysTree, &QAbstractItemView::customContextMenuRequested,
                 q, [this](const QPoint &p) { tableContextMenuRequested(p); });
     }
 
     GpgME::Key key;
     Ui::SubKeysWidget ui;
     void tableContextMenuRequested(const QPoint &p);
 private:
     SubKeysWidget *const q;
 };
 
 void SubKeysWidget::Private::tableContextMenuRequested(const QPoint &p)
 {
     auto item = ui.subkeysTree->itemAt(p);
     if (!item) {
         return;
     }
     const auto subkey = item->data(0, Qt::UserRole).value<GpgME::Subkey>();
 
-    QMenu *menu = new QMenu(q);
+    auto menu = new QMenu(q);
     connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
 
     bool hasActions = false;
 
 #ifdef CHANGEEXPIRYJOB_SUPPORTS_SUBKEYS
     if (subkey.parent().protocol() == GpgME::OpenPGP && subkey.parent().hasSecret()) {
         hasActions = true;
         menu->addAction(i18n("Change Expiry Date..."), q,
                 [this, subkey]() {
                     auto cmd = new ChangeExpiryCommand(subkey.parent());
                     if (subkey.keyID() != key.keyID()) {
                         // do not set the primary key as subkey
                         cmd->setSubkey(subkey);
                     }
                     ui.subkeysTree->setEnabled(false);
                     connect(cmd, &ChangeExpiryCommand::finished,
                             q, [this]() {
                                 ui.subkeysTree->setEnabled(true);
                                 key.update();
                                 q->setKey(key);
                             });
                     cmd->setParentWidget(q);
                     cmd->start();
                 }
         );
     }
 #endif // CHANGEEXPIRYJOB_SUPPORTS_SUBKEYS
 
 #ifdef GPGME_HAS_EXPORT_FLAGS
     if (subkey.parent().protocol() == GpgME::OpenPGP && subkey.canAuthenticate()) {
         hasActions = true;
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-export")),
                 i18n("Export OpenSSH key"),
                 q, [this, subkey]() {
             QScopedPointer<ExportDialog> dlg(new ExportDialog(q));
             dlg->setKey(subkey, static_cast<unsigned int> (GpgME::Context::ExportSSH));
             dlg->exec();
         });
     }
 #endif // GPGME_HAS_EXPORT_FLAGS
 
     if (!subkey.isSecret()) {
         hasActions = true;
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-import")),
                         i18n("Restore printed backup"),
                         q, [this, subkey] () {
             auto cmd = new ImportPaperKeyCommand(subkey.parent());
             ui.subkeysTree->setEnabled(false);
             connect(cmd, &ImportPaperKeyCommand::finished,
                     q, [this]() { ui.subkeysTree->setEnabled(true); });
             cmd->setParentWidget(q);
             cmd->start();
         });
     }
 
     if (subkey.isSecret()) {
         hasActions = true;
         auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("send-to-symbolic")),
                                       i18n("Transfer to smartcard"),
                                       q, [this, subkey]() {
             auto cmd = new KeyToCardCommand(subkey);
             ui.subkeysTree->setEnabled(false);
             connect(cmd, &KeyToCardCommand::finished,
                     q, [this]() { ui.subkeysTree->setEnabled(true); });
             cmd->setParentWidget(q);
             cmd->start();
         });
         action->setEnabled(!KeyToCardCommand::getSuitableCards(subkey).empty());
     }
 
     if (hasActions) {
         menu->popup(ui.subkeysTree->viewport()->mapToGlobal(p));
     } else {
         delete menu;
     }
 }
 
 SubKeysWidget::SubKeysWidget(QWidget *parent)
     : QWidget(parent)
     , d(new Private(this))
 {
 }
 
 SubKeysWidget::~SubKeysWidget()
 {
 }
 
 void SubKeysWidget::setKey(const GpgME::Key &key)
 {
     d->key = key;
 
     const auto currentItem = d->ui.subkeysTree->currentItem();
     const QByteArray selectedKeyFingerprint = currentItem ?
         QByteArray(currentItem->data(0, Qt::UserRole).value<GpgME::Subkey>().fingerprint()) : QByteArray();
     d->ui.subkeysTree->clear();
 
     for (const auto &subkey : key.subkeys()) {
         auto item = new QTreeWidgetItem();
         item->setData(0, Qt::DisplayRole, Formatting::prettyID(subkey.keyID()));
         item->setData(0, Qt::UserRole, QVariant::fromValue(subkey));
         item->setData(1, Qt::DisplayRole, Kleo::Formatting::type(subkey));
         item->setData(2, Qt::DisplayRole, Kleo::Formatting::creationDateString(subkey));
         item->setData(3, Qt::DisplayRole, Kleo::Formatting::expirationDateString(subkey));
         item->setData(4, Qt::DisplayRole, Kleo::Formatting::validityShort(subkey));
         switch (subkey.publicKeyAlgorithm()) {
             case GpgME::Subkey::AlgoECDSA:
             case GpgME::Subkey::AlgoEDDSA:
             case GpgME::Subkey::AlgoECDH:
                 item->setData(5, Qt::DisplayRole, QString::fromStdString(subkey.algoName()));
                 break;
             default:
                 item->setData(5, Qt::DisplayRole, QString::number(subkey.length()));
         }
         item->setData(6, Qt::DisplayRole, Kleo::Formatting::usageString(subkey));
         item->setData(7, Qt::DisplayRole, subkey.keyID() == key.keyID() ? QStringLiteral("✓") : QString());
         d->ui.subkeysTree->addTopLevelItem(item);
         if (subkey.fingerprint() == selectedKeyFingerprint) {
             d->ui.subkeysTree->setCurrentItem(item);
         }
     }
 
     const auto subkey = key.subkey(0);
     if (const char *card = subkey.cardSerialNumber()) {
         d->ui.stored->setText(i18nc("stored...", "on SmartCard with serial no. %1", QString::fromUtf8(card)));
     } else {
         d->ui.stored->setText(i18nc("stored...", "on this computer"));
     }
     d->ui.subkeysTree->resizeColumnToContents(0);
 }
 
 
 GpgME::Key SubKeysWidget::key() const
 {
     return d->key;
 }
 
 
 
 SubKeysDialog::SubKeysDialog(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Subkeys Details"));
     auto l = new QVBoxLayout(this);
     l->addWidget(new SubKeysWidget(this));
 
     auto bbox = new QDialogButtonBox(this);
     auto btn = bbox->addButton(QDialogButtonBox::Close);
     connect(btn, &QPushButton::clicked, this, &QDialog::accept);
     l->addWidget(bbox);
     readConfig();
 }
 
 SubKeysDialog::~SubKeysDialog()
 {
     writeConfig();
 }
 
 void SubKeysDialog::readConfig()
 {
     KConfigGroup dialog(KSharedConfig::openStateConfig(), "SubKeysDialog");
     const QSize size = dialog.readEntry("Size", QSize(820, 280));
     if (size.isValid()) {
         resize(size);
     }
 }
 
 void SubKeysDialog::writeConfig()
 {
     KConfigGroup dialog(KSharedConfig::openStateConfig(), "SubKeysDialog");
     dialog.writeEntry("Size", size());
     dialog.sync();
 }
 
 void SubKeysDialog::setKey(const GpgME::Key &key)
 {
     auto w = findChild<SubKeysWidget*>();
     Q_ASSERT(w);
     w->setKey(key);
 }
 
 GpgME::Key SubKeysDialog::key() const
 {
     auto w = findChild<SubKeysWidget*>();
     Q_ASSERT(w);
     return w->key();
 }
diff --git a/src/dialogs/weboftrustwidget.cpp b/src/dialogs/weboftrustwidget.cpp
index ed8089d4d..910061e6e 100644
--- a/src/dialogs/weboftrustwidget.cpp
+++ b/src/dialogs/weboftrustwidget.cpp
@@ -1,271 +1,271 @@
 /*
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "weboftrustwidget.h"
 
 #include "commands/certifycertificatecommand.h"
 #include "commands/revokecertificationcommand.h"
 
 #include <QHeaderView>
 #include <QVBoxLayout>
 #include <QTreeView>
 
 #include <gpgme++/key.h>
 #include <gpgme++/keylistresult.h>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/KeyListJob>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/UserIDListModel>
 
 #include "kleopatra_debug.h"
 #include "commands/command.h"
 #include "utils/tags.h"
 
 #include <KMessageBox>
 #include <KLocalizedString>
 
 #include <QMenu>
 
 using namespace Kleo;
 
 class WebOfTrustWidget::Private
 {
     friend class ::Kleo::WebOfTrustWidget;
     WebOfTrustWidget *const q;
 
 private:
     GpgME::Key key;
     UserIDListModel certificationsModel;
     QGpgME::KeyListJob *keyListJob = nullptr;
     QTreeView *certificationsTV = nullptr;
 
 public:
     Private(WebOfTrustWidget *qq)
         : q(qq)
     {
         certificationsModel.enableRemarks(Tags::tagsEnabled());
 
         certificationsTV = new QTreeView;
         certificationsTV->setModel(&certificationsModel);
         certificationsTV->setAllColumnsShowFocus(true);
         certificationsTV->setSelectionMode(QAbstractItemView::ExtendedSelection);
 
         auto vLay = new QVBoxLayout(q);
         vLay->setContentsMargins(0, 0, 0, 0);
         vLay->addWidget(certificationsTV);
 
         connect(certificationsTV, &QAbstractItemView::doubleClicked,
                 q, [this] (const QModelIndex &idx) {
                     certificationDblClicked(idx);
                 });
         certificationsTV->setContextMenuPolicy(Qt::CustomContextMenu);
         connect(certificationsTV, &QWidget::customContextMenuRequested,
                 q, [this] (const QPoint &p) {
                     contextMenuRequested(p);
                 });
     }
 
     void certificationDblClicked(const QModelIndex &idx)
     {
         if (!idx.isValid()) {
             return;
         }
 
         if (!idx.parent().isValid()) {
             // No parent -> root item.
             return;
         }
 
         // grab the keyid
         const auto query = certificationsModel.data(idx.sibling(idx.row(), 0)).toString();
 
         // Show details widget or search
         auto cmd = Command::commandForQuery(query);
         cmd->setParentWId(q->winId());
         cmd->start();
     }
 
     void addActionsForUserID(QMenu *menu, const GpgME::UserID &userID)
     {
         menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-sign")),
                         i18n("Certify..."),
                         q, [this, userID]() {
             auto cmd = new Kleo::Commands::CertifyCertificateCommand(userID);
             cmd->setParentWidget(q);
             certificationsTV->setEnabled(false);
             connect(cmd, &Kleo::Commands::CertifyCertificateCommand::finished,
                     q, [this]() {
                 certificationsTV->setEnabled(true);
                 // Trigger an update when done
                 q->setKey(key);
             });
             cmd->start();
         });
         if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
             menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")),
                             i18n("Revoke Certification..."),
                             q, [this, userID]() {
                 auto cmd = new Kleo::Commands::RevokeCertificationCommand(userID);
                 cmd->setParentWidget(q);
                 certificationsTV->setEnabled(false);
                 connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
                         q, [this]() {
                     certificationsTV->setEnabled(true);
                     // Trigger an update when done
                     q->setKey(key);
                 });
                 cmd->start();
             });
         }
     }
 
     void addActionsForSignature(QMenu *menu, const GpgME::UserID::Signature &signature)
     {
         menu->addAction(QIcon::fromTheme(QStringLiteral("dialog-information")),
                         i18n("Show Certificate Details..."),
                         q, [this, signature]() {
             auto cmd = Command::commandForQuery(QString::fromUtf8(signature.signerKeyID()));
             cmd->setParentWId(q->winId());
             cmd->start();
         });
         if (Kleo::Commands::RevokeCertificationCommand::isSupported()) {
             auto action = menu->addAction(QIcon::fromTheme(QStringLiteral("view-certificate-revoke")),
                                           i18n("Revoke Certification..."),
                                           q, [this, signature]() {
                 auto cmd = new Kleo::Commands::RevokeCertificationCommand(signature);
                 cmd->setParentWidget(q);
                 certificationsTV->setEnabled(false);
                 connect(cmd, &Kleo::Commands::RevokeCertificationCommand::finished,
                         q, [this]() {
                     certificationsTV->setEnabled(true);
                     // Trigger an update when done
                     q->setKey(key);
                 });
                 cmd->start();
             });
             const auto certificationKey = KeyCache::instance()->findByKeyIDOrFingerprint(signature.signerKeyID());
             const bool isSelfSignature = qstrcmp(signature.parent().parent().keyID(), signature.signerKeyID()) == 0;
             action->setEnabled(!isSelfSignature && certificationKey.hasSecret() && !signature.isRevokation() && !signature.isExpired() && !signature.isInvalid());
             if (isSelfSignature) {
                 action->setToolTip(i18n("Revocation of self-certifications is currently not possible."));
             } else if (!certificationKey.hasSecret()) {
                 action->setToolTip(i18n("You cannot revoke this certification because it wasn't made with one of your keys (or the required secret key is missing)."));
             } else if (signature.isRevokation()) {
                 action->setToolTip(i18n("You cannot revoke this revocation certification. (But you can re-certify the corresponding user ID.)"));
             } else if (signature.isExpired()) {
                 action->setToolTip(i18n("You cannot revoke this expired certification."));
             } else if (signature.isInvalid()) {
                 action->setToolTip(i18n("You cannot revoke this invalid certification."));
             }
             if (!action->isEnabled()) {
                 menu->setToolTipsVisible(true);
             }
         }
     }
 
     void contextMenuRequested(const QPoint &p)
     {
         const auto index = certificationsTV->indexAt(p);
         const auto userID = certificationsModel.userID(index);
         const auto signature = certificationsModel.signature(index);
 
         if (userID.isNull() && signature.isNull()) {
             return;
         }
 
-        QMenu *menu = new QMenu(q);
+        auto menu = new QMenu(q);
         if (!userID.isNull()) {
             addActionsForUserID(menu, userID);
         }
         else if (!signature.isNull()) {
             addActionsForSignature(menu, signature);
         }
         connect(menu, &QMenu::aboutToHide, menu, &QObject::deleteLater);
         menu->popup(certificationsTV->viewport()->mapToGlobal(p));
     }
 
     void startSignatureListing()
     {
         if (keyListJob) {
             return;
         }
         QGpgME::KeyListJob *const job = QGpgME::openpgp()->keyListJob(/*remote*/false, /*includeSigs*/true, /*validate*/true);
         if (!job) {
             return;
         }
 
         if (Tags::tagsEnabled()) {
             job->addMode(GpgME::SignatureNotations);
         }
 
 
         /* Old style connect here again as QGPGME newstyle connects with
          * default arguments don't work on windows. */
 
         connect(job, &QGpgME::KeyListJob::result,
             q, &WebOfTrustWidget::signatureListingDone);
 
         connect(job, &QGpgME::KeyListJob::nextKey,
             q, &WebOfTrustWidget::signatureListingNextKey);
 
         job->start(QStringList(QString::fromLatin1(key.primaryFingerprint())));
         keyListJob = job;
     }
 };
 
 
 WebOfTrustWidget::WebOfTrustWidget(QWidget *parent) :
     QWidget(parent),
     d(new Private(this))
 {
 }
 
 GpgME::Key WebOfTrustWidget::key() const
 {
     return d->key;
 }
 
 void WebOfTrustWidget::setKey(const GpgME::Key &key)
 {
     if (key.protocol() != GpgME::OpenPGP) {
         qCDebug(KLEOPATRA_LOG) << "Trust chain is only supported for CMS keys";
         return;
     }
 
     d->key = key;
     d->certificationsModel.setKey(key);
     d->certificationsTV->expandAll();
     d->certificationsTV->header()->resizeSections(QHeaderView::ResizeToContents);
     d->startSignatureListing();
 }
 
 WebOfTrustWidget::~WebOfTrustWidget()
 {
 }
 
 void WebOfTrustWidget::signatureListingNextKey(const GpgME::Key &key)
 {
     GpgME::Key merged = key;
     merged.mergeWith(d->key);
     setKey(merged);
 }
 
 void WebOfTrustWidget::signatureListingDone(const GpgME::KeyListResult &result)
 {
     if (result.error()) {
         KMessageBox::information(this, xi18nc("@info",
                                            "<para>An error occurred while loading the certifications: "
                                            "<message>%1</message></para>",
                                            QString::fromLocal8Bit(result.error().asString())),
                                  i18nc("@title", "Certifications Loading Failed"));
     }
     d->keyListJob = nullptr;
 }
diff --git a/src/kleo-assuan.h b/src/kleo-assuan.h
index 4819cb9ed..51ec64c7e 100644
--- a/src/kleo-assuan.h
+++ b/src/kleo-assuan.h
@@ -1,46 +1,46 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     kleo-assuan.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #ifndef _ASSUAN_ONLY_GPG_ERRORS
 #define _ASSUAN_ONLY_GPG_ERRORS
 #endif
 
 #ifdef HAVE_USABLE_ASSUAN
 # include <assuan.h>
 #else
 /*
  * copied from assuan.h:
  */
 
 /* assuan.h - Definitions for the Assuan IPC library
  * SPDX-FileCopyrightText: 2001, 2002, 2003, 2005, 2007 Free Software Foundation Inc.
  *
  * This file is part of Assuan.
  *
  * SPDX-License-Identifier: LGPL-2.1-or-later
  */
 
 #ifdef _WIN32
 typedef void *assuan_fd_t;
 #define ASSUAN_INVALID_FD ((void*)(-1))
 #define ASSUAN_INT2FD(s)  ((void *)(s))
 #define ASSUAN_FD2INT(h)  ((unsigned int)(h))
 #else
-typedef int assuan_fd_t;
+using assuan_fd_t = int;
 #define ASSUAN_INVALID_FD (-1)
 #define ASSUAN_INT2FD(s)  ((s))
 #define ASSUAN_FD2INT(h)  ((h))
 #endif
 /*
  * end copied from assuan.h
  */
 #endif
 
diff --git a/src/kleopatraapplication.cpp b/src/kleopatraapplication.cpp
index b70d15bb6..90d7fd0dc 100644
--- a/src/kleopatraapplication.cpp
+++ b/src/kleopatraapplication.cpp
@@ -1,651 +1,651 @@
 /*
     kleopatraapplication.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 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 "kleopatraapplication.h"
 
 #include "mainwindow.h"
 #include "kleopatra_options.h"
 #include "systrayicon.h"
 #include "settings.h"
 
 #include <smartcard/readerstatus.h>
 #include <conf/configuredialog.h>
 
 #include <Libkleo/GnuPG>
 #include <utils/kdpipeiodevice.h>
 #include <utils/log.h>
 
 #include <gpgme++/key.h>
 
 #include <Libkleo/FileSystemWatcher>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Classify>
 
 #ifdef HAVE_USABLE_ASSUAN
 # include <uiserver/uiserver.h>
 #endif
 
 #include "commands/signencryptfilescommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/lookupcertificatescommand.h"
 #include "commands/checksumcreatefilescommand.h"
 #include "commands/checksumverifyfilescommand.h"
 #include "commands/detailscommand.h"
 #include "commands/newcertificatecommand.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KIconLoader>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 #include <KMessageBox>
 #include <KWindowSystem>
 
 #include <QFile>
 #include <QDir>
 #include <QPointer>
 
 #include <memory>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 
 static void add_resources()
 {
     KIconLoader::global()->addAppDir(QStringLiteral("libkleopatra"));
     KIconLoader::global()->addAppDir(QStringLiteral("kwatchgnupg"));
 }
 
 static QList<QByteArray> default_logging_options()
 {
     QList<QByteArray> result;
     result.push_back("io");
     return result;
 }
 
 class KleopatraApplication::Private
 {
     friend class ::KleopatraApplication;
     KleopatraApplication *const q;
 public:
     explicit Private(KleopatraApplication *qq)
         : q(qq),
           ignoreNewInstance(true),
           firstNewInstance(true),
           sysTray(nullptr)
     {
     }
     ~Private() {
 #ifndef QT_NO_SYSTEMTRAYICON
         delete sysTray;
 #endif
     }
     void init()
     {
         KDAB_SET_OBJECT_NAME(readerStatus);
 #ifndef QT_NO_SYSTEMTRAYICON
         sysTray = new SysTrayIcon();
         sysTray->setFirstCardWithNullPin(readerStatus.firstCardWithNullPin());
         sysTray->setAnyCardCanLearnKeys(readerStatus.anyCardCanLearnKeys());
 
         connect(&readerStatus, &SmartCard::ReaderStatus::firstCardWithNullPinChanged,
                 sysTray, &SysTrayIcon::setFirstCardWithNullPin);
         connect(&readerStatus, &SmartCard::ReaderStatus::anyCardCanLearnKeysChanged,
                 sysTray, &SysTrayIcon::setAnyCardCanLearnKeys);
 #endif
     }
 
 private:
     void connectConfigureDialog()
     {
         if (configureDialog && q->mainWindow()) {
             connect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
         }
     }
     void disconnectConfigureDialog()
     {
         if (configureDialog && q->mainWindow()) {
             disconnect(configureDialog, SIGNAL(configCommitted()), q->mainWindow(), SLOT(slotConfigCommitted()));
         }
     }
 
 public:
     bool ignoreNewInstance;
     bool firstNewInstance;
     QPointer<ConfigureDialog> configureDialog;
     QPointer<MainWindow> mainWindow;
     SmartCard::ReaderStatus readerStatus;
 #ifndef QT_NO_SYSTEMTRAYICON
     SysTrayIcon *sysTray;
 #endif
     std::shared_ptr<KeyCache> keyCache;
     std::shared_ptr<Log> log;
     std::shared_ptr<FileSystemWatcher> watcher;
 
 public:
     void setupKeyCache()
     {
         keyCache = KeyCache::mutableInstance();
         watcher.reset(new FileSystemWatcher);
 
         watcher->whitelistFiles(gnupgFileWhitelist());
         watcher->addPath(gnupgHomeDirectory());
         watcher->setDelay(1000);
         keyCache->addFileSystemWatcher(watcher);
         keyCache->setGroupsConfig(QStringLiteral("kleopatragroupsrc"));
         keyCache->setGroupsEnabled(Settings().groupsEnabled());
     }
 
     void setupLogging()
     {
         log = Log::mutableInstance();
 
         const QByteArray envOptions = qgetenv("KLEOPATRA_LOGOPTIONS");
         const bool logAll = envOptions.trimmed() == "all";
         const QList<QByteArray> options = envOptions.isEmpty() ? default_logging_options() : envOptions.split(',');
 
         const QByteArray dirNative = qgetenv("KLEOPATRA_LOGDIR");
         if (dirNative.isEmpty()) {
             return;
         }
         const QString dir = QFile::decodeName(dirNative);
         const QString logFileName = QDir(dir).absoluteFilePath(QStringLiteral("kleopatra.log.%1").arg(QCoreApplication::applicationPid()));
         std::unique_ptr<QFile> logFile(new QFile(logFileName));
         if (!logFile->open(QIODevice::WriteOnly | QIODevice::Append)) {
             qCDebug(KLEOPATRA_LOG) << "Could not open file for logging: " << logFileName << "\nLogging disabled";
             return;
         }
 
         log->setOutputDirectory(dir);
         if (logAll || options.contains("io")) {
             log->setIOLoggingEnabled(true);
         }
         qInstallMessageHandler(Log::messageHandler);
 
 #ifdef HAVE_USABLE_ASSUAN
         if (logAll || options.contains("pipeio")) {
             KDPipeIODevice::setDebugLevel(KDPipeIODevice::Debug);
         }
         UiServer::setLogStream(log->logFile());
 #endif
 
     }
 };
 
 KleopatraApplication::KleopatraApplication(int &argc, char *argv[])
     : QApplication(argc, argv), d(new Private(this))
 {
 }
 
 void KleopatraApplication::init()
 {
     d->init();
     add_resources();
     d->setupKeyCache();
     d->setupLogging();
 #ifndef QT_NO_SYSTEMTRAYICON
     d->sysTray->show();
 #endif
     setQuitOnLastWindowClosed(false);
     KWindowSystem::allowExternalProcessWindowActivation();
 }
 
 KleopatraApplication::~KleopatraApplication()
 {
     // main window doesn't receive "close" signal and cannot
     // save settings before app exit
     delete d->mainWindow;
 
     // work around kdelibs bug https://bugs.kde.org/show_bug.cgi?id=162514
     KSharedConfig::openConfig()->sync();
 }
 
 namespace
 {
-typedef void (KleopatraApplication::*Func)(const QStringList &, GpgME::Protocol);
+using Func = void (KleopatraApplication::*)(const QStringList &, GpgME::Protocol);
 }
 
 void KleopatraApplication::slotActivateRequested(const QStringList &arguments,
         const QString &workingDirectory)
 {
     QCommandLineParser parser;
 
     kleopatra_options(&parser);
     QString err;
     if (!arguments.isEmpty() && !parser.parse(arguments)) {
         err = parser.errorText();
     } else if (arguments.isEmpty()) {
         // KDBusServices omits the application name if no other
         // arguments are provided. In that case the parser prints
         // a warning.
         parser.parse(QStringList() << QCoreApplication::applicationFilePath());
     }
 
     if (err.isEmpty()) {
         err = newInstance(parser, workingDirectory);
     }
 
     if (!err.isEmpty()) {
         KMessageBox::sorry(nullptr, err.toHtmlEscaped(), i18n("Failed to execute command"));
         Q_EMIT setExitValue(1);
         return;
     }
     Q_EMIT setExitValue(0);
 }
 
 QString KleopatraApplication::newInstance(const QCommandLineParser &parser,
         const QString &workingDirectory)
 {
     if (d->ignoreNewInstance) {
         qCDebug(KLEOPATRA_LOG) << "New instance ignored because of ignoreNewInstance";
         return QString();
     }
 
     QStringList files;
     const QDir cwd = QDir(workingDirectory);
     bool queryMode = parser.isSet(QStringLiteral("query")) || parser.isSet(QStringLiteral("search"));
 
     // Query and Search treat positional arguments differently, see below.
     if (!queryMode) {
         const auto positionalArguments = parser.positionalArguments();
         for (const QString &file : positionalArguments) {
             // We do not check that file exists here. Better handle
             // these errors in the UI.
             if (QFileInfo(file).isAbsolute()) {
                 files << file;
             } else {
                 files << cwd.absoluteFilePath(file);
             }
         }
     }
 
     GpgME::Protocol protocol = GpgME::UnknownProtocol;
 
     if (parser.isSet(QStringLiteral("openpgp"))) {
         qCDebug(KLEOPATRA_LOG) << "found OpenPGP";
         protocol = GpgME::OpenPGP;
     }
 
     if (parser.isSet(QStringLiteral("cms"))) {
         qCDebug(KLEOPATRA_LOG) << "found CMS";
         if (protocol == GpgME::OpenPGP) {
             return i18n("Ambiguous protocol: --openpgp and --cms");
         }
         protocol = GpgME::CMS;
     }
 
     // Check for Parent Window id
     WId parentId = 0;
     if (parser.isSet(QStringLiteral("parent-windowid"))) {
 #ifdef Q_OS_WIN
         // WId is not a portable type as it is a pointer type on Windows.
         // casting it from an integer is ok though as the values are guaranteed to
         // be compatible in the documentation.
         parentId = reinterpret_cast<WId>(parser.value(QStringLiteral("parent-windowid")).toUInt());
 #else
         parentId = parser.value(QStringLiteral("parent-windowid")).toUInt();
 #endif
     }
 
     // Handle openpgp4fpr URI scheme
     QString needle;
     if (queryMode) {
         needle = parser.positionalArguments().join(QLatin1Char(' '));
     }
     if (needle.startsWith(QLatin1String("openpgp4fpr:"))) {
         needle.remove(0, 12);
     }
 
     // Check for --search command.
     if (parser.isSet(QStringLiteral("search"))) {
         // This is an extra command instead of a combination with the
         // similar query to avoid changing the older query commands behavior
         // and query's "show details if a certificate exist or search on a
         // keyserver" logic is hard to explain and use consistently.
         if (needle.isEmpty()) {
             return i18n("No search string specified for --search");
         }
-        LookupCertificatesCommand *const cmd = new LookupCertificatesCommand(needle, nullptr);
+        auto const cmd = new LookupCertificatesCommand(needle, nullptr);
         cmd->setParentWId(parentId);
         cmd->start();
         return QString();
     }
 
     // Check for --query command
     if (parser.isSet(QStringLiteral("query"))) {
         if (needle.isEmpty()) {
             return i18n("No fingerprint argument specified for --query");
         }
         auto cmd = Command::commandForQuery(needle);
         cmd->setParentWId(parentId);
         cmd->start();
         return QString();
     }
 
     // Check for --gen-key command
     if (parser.isSet(QStringLiteral("gen-key"))) {
         auto cmd = new NewCertificateCommand(nullptr);
         cmd->setParentWId(parentId);
         cmd->setProtocol(protocol);
         cmd->start();
         return QString();
     }
 
     // Check for --config command
     if (parser.isSet(QStringLiteral("config"))) {
         openConfigDialogWithForeignParent(parentId);
         return QString();
     }
 
     static const QMap<QString, Func> funcMap {
         { QStringLiteral("import-certificate"), &KleopatraApplication::importCertificatesFromFile },
         { QStringLiteral("encrypt"), &KleopatraApplication::encryptFiles },
         { QStringLiteral("sign"), &KleopatraApplication::signFiles },
         { QStringLiteral("encrypt-sign"), &KleopatraApplication::signEncryptFiles },
         { QStringLiteral("sign-encrypt"), &KleopatraApplication::signEncryptFiles },
         { QStringLiteral("decrypt"), &KleopatraApplication::decryptFiles },
         { QStringLiteral("verify"), &KleopatraApplication::verifyFiles },
         { QStringLiteral("decrypt-verify"), &KleopatraApplication::decryptVerifyFiles },
         { QStringLiteral("checksum"), &KleopatraApplication::checksumFiles },
     };
 
     QString found;
     Q_FOREACH (const QString &opt, funcMap.keys()) {
         if (parser.isSet(opt) && found.isEmpty()) {
             found = opt;
         } else if (parser.isSet(opt)) {
-            return i18n("Ambiguous commands \"%1\" and \"%2\"", found, opt);
+            return i18n(R"(Ambiguous commands "%1" and "%2")", found, opt);
         }
     }
 
     QStringList errors;
     if (!found.isEmpty()) {
         if (files.empty()) {
             return i18n("No files specified for \"%1\" command", found);
         }
         qCDebug(KLEOPATRA_LOG) << "found" << found;
         (this->*funcMap.value(found))(files, protocol);
     } else {
         if (files.empty()) {
             if (!(d->firstNewInstance && isSessionRestored())) {
                 qCDebug(KLEOPATRA_LOG) << "openOrRaiseMainWindow";
                 openOrRaiseMainWindow();
             }
         } else {
             for (const QString& fileName : qAsConst(files)) {
                 QFileInfo fi(fileName);
                 if (!fi.isReadable()) {
                     errors << i18n("Cannot read \"%1\"", fileName);
                 }
             }
             Q_FOREACH (Command *cmd, Command::commandsForFiles(files)) {
                 if (parentId) {
                     cmd->setParentWId(parentId);
                 } else {
                     MainWindow *mw = mainWindow();
                     if (!mw) {
                         mw = new MainWindow;
                         mw->setAttribute(Qt::WA_DeleteOnClose);
                         setMainWindow(mw);
                         d->connectConfigureDialog();
                     }
                     cmd->setParentWidget(mw);
                 }
                 cmd->start();
             }
         }
     }
     d->firstNewInstance = false;
 
 #ifdef Q_OS_WIN
     // On Windows we might be started from the
     // explorer in any working directory. E.g.
     // a double click on a file. To avoid preventing
     // the folder from deletion we set the
     // working directory to the users homedir.
     QDir::setCurrent(QDir::homePath());
 #endif
 
     return errors.join(QLatin1Char('\n'));
 }
 
 #ifndef QT_NO_SYSTEMTRAYICON
 const SysTrayIcon *KleopatraApplication::sysTrayIcon() const
 {
     return d->sysTray;
 }
 
 SysTrayIcon *KleopatraApplication::sysTrayIcon()
 {
     return d->sysTray;
 }
 #endif
 
 const MainWindow *KleopatraApplication::mainWindow() const
 {
     return d->mainWindow;
 }
 
 MainWindow *KleopatraApplication::mainWindow()
 {
     return d->mainWindow;
 }
 
 void KleopatraApplication::setMainWindow(MainWindow *mainWindow)
 {
     if (mainWindow == d->mainWindow) {
         return;
     }
 
     d->disconnectConfigureDialog();
 
     d->mainWindow = mainWindow;
 #ifndef QT_NO_SYSTEMTRAYICON
     d->sysTray->setMainWindow(mainWindow);
 #endif
 
     d->connectConfigureDialog();
 }
 
 static void open_or_raise(QWidget *w)
 {
     if (w->isMinimized()) {
         KWindowSystem::unminimizeWindow(w->winId());
         w->raise();
     } else if (w->isVisible()) {
         w->raise();
     } else {
         w->show();
     }
 }
 
 void KleopatraApplication::toggleMainWindowVisibility()
 {
     if (mainWindow()) {
         mainWindow()->setVisible(!mainWindow()->isVisible());
     } else {
         openOrRaiseMainWindow();
     }
 }
 
 void KleopatraApplication::restoreMainWindow()
 {
     qCDebug(KLEOPATRA_LOG) << "restoring main window";
 
     // Sanity checks
     if (!isSessionRestored()) {
         qCDebug(KLEOPATRA_LOG) << "Not in session restore";
         return;
     }
 
     if (mainWindow()) {
         qCDebug(KLEOPATRA_LOG) << "Already have main window";
         return;
     }
 
-    MainWindow *mw = new MainWindow;
+    auto mw = new MainWindow;
     if (KMainWindow::canBeRestored(1)) {
         // restore to hidden state, Mainwindow::readProperties() will
         // restore saved visibility.
         mw->restore(1, false);
     }
 
     mw->setAttribute(Qt::WA_DeleteOnClose);
     setMainWindow(mw);
     d->connectConfigureDialog();
 
 }
 
 void KleopatraApplication::openOrRaiseMainWindow()
 {
     MainWindow *mw = mainWindow();
     if (!mw) {
         mw = new MainWindow;
         mw->setAttribute(Qt::WA_DeleteOnClose);
         setMainWindow(mw);
         d->connectConfigureDialog();
     }
     open_or_raise(mw);
     UpdateNotification::checkUpdate(mw);
 }
 
 void KleopatraApplication::openConfigDialogWithForeignParent(WId parentWId)
 {
     if (!d->configureDialog) {
         d->configureDialog = new ConfigureDialog;
         d->configureDialog->setAttribute(Qt::WA_DeleteOnClose);
         d->connectConfigureDialog();
     }
 
     // This is similar to what the commands do.
     if (parentWId) {
         if (QWidget *pw = QWidget::find(parentWId)) {
             d->configureDialog->setParent(pw, d->configureDialog->windowFlags());
         } else {
             d->configureDialog->setAttribute(Qt::WA_NativeWindow, true);
             KWindowSystem::setMainWindow(d->configureDialog->windowHandle(), parentWId);
         }
     }
 
     open_or_raise(d->configureDialog);
 
     // If we have a parent we want to raise over it.
     if (parentWId) {
         d->configureDialog->raise();
     }
 }
 
 void KleopatraApplication::openOrRaiseConfigDialog()
 {
     openConfigDialogWithForeignParent(0);
 }
 
 #ifndef QT_NO_SYSTEMTRAYICON
 void KleopatraApplication::startMonitoringSmartCard()
 {
     d->readerStatus.startMonitoring();
 }
 #endif // QT_NO_SYSTEMTRAYICON
 
 void KleopatraApplication::importCertificatesFromFile(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     openOrRaiseMainWindow();
     if (!files.empty()) {
         mainWindow()->importCertificatesFromFile(files);
     }
 }
 
 void KleopatraApplication::encryptFiles(const QStringList &files, GpgME::Protocol proto)
 {
-    SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
+    auto const cmd = new SignEncryptFilesCommand(files, nullptr);
     cmd->setEncryptionPolicy(Force);
     cmd->setSigningPolicy(Allow);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::signFiles(const QStringList &files, GpgME::Protocol proto)
 {
-    SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
+    auto const cmd = new SignEncryptFilesCommand(files, nullptr);
     cmd->setSigningPolicy(Force);
     cmd->setEncryptionPolicy(Deny);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::signEncryptFiles(const QStringList &files, GpgME::Protocol proto)
 {
-    SignEncryptFilesCommand *const cmd = new SignEncryptFilesCommand(files, nullptr);
+    auto const cmd = new SignEncryptFilesCommand(files, nullptr);
     if (proto != GpgME::UnknownProtocol) {
         cmd->setProtocol(proto);
     }
     cmd->start();
 }
 
 void KleopatraApplication::decryptFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
-    DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
+    auto const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->setOperation(Decrypt);
     cmd->start();
 }
 
 void KleopatraApplication::verifyFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
-    DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
+    auto const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->setOperation(Verify);
     cmd->start();
 }
 
 void KleopatraApplication::decryptVerifyFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
-    DecryptVerifyFilesCommand *const cmd = new DecryptVerifyFilesCommand(files, nullptr);
+    auto const cmd = new DecryptVerifyFilesCommand(files, nullptr);
     cmd->start();
 }
 
 void KleopatraApplication::checksumFiles(const QStringList &files, GpgME::Protocol /*proto*/)
 {
     QStringList verifyFiles, createFiles;
 
     for (const QString &file : files) {
         if (isChecksumFile(file)) {
             verifyFiles << file;
         } else {
             createFiles << file;
         }
     }
 
     if (!verifyFiles.isEmpty()) {
         auto const cmd = new ChecksumVerifyFilesCommand(verifyFiles, nullptr);
         cmd->start();
     }
     if (!createFiles.isEmpty()) {
         auto const cmd = new ChecksumCreateFilesCommand(createFiles, nullptr);
         cmd->start();
     }
 }
 
 void KleopatraApplication::setIgnoreNewInstance(bool ignore)
 {
     d->ignoreNewInstance = ignore;
 }
 
 bool KleopatraApplication::ignoreNewInstance() const
 {
     return d->ignoreNewInstance;
 }
diff --git a/src/kwatchgnupg/kwatchgnupgconfig.cpp b/src/kwatchgnupg/kwatchgnupgconfig.cpp
index f4e5a14e2..ce6ed76a7 100644
--- a/src/kwatchgnupg/kwatchgnupgconfig.cpp
+++ b/src/kwatchgnupg/kwatchgnupgconfig.cpp
@@ -1,195 +1,195 @@
 /*
     kwatchgnupgconfig.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2001, 2002, 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "kwatchgnupgconfig.h"
 #include "kwatchgnupg.h"
 
 #include <Libkleo/FileNameRequester>
 
 #include <KLocalizedString>
 #include <KConfig>
 #include <KPluralHandlingSpinBox>
 
 #include <QVBoxLayout>
 #include <QLabel>
 #include <QCheckBox>
 #include <QComboBox>
 #include <QPushButton>
 #include <QGroupBox>
 #include <KSharedConfig>
 #include <KConfigGroup>
 #include <QDialogButtonBox>
 
 static const char *log_levels[] = { "none", "basic", "advanced", "expert", "guru" };
 
 static int log_level_to_int(const QString &loglevel)
 {
     if (loglevel == QLatin1String("none")) {
         return 0;
     } else if (loglevel == QLatin1String("basic")) {
         return 1;
     } else if (loglevel == QLatin1String("advanced")) {
         return 2;
     } else if (loglevel == QLatin1String("expert")) {
         return 3;
     } else if (loglevel == QLatin1String("guru")) {
         return 4;
     } else {
         // default
         return 1;
     }
 }
 
 KWatchGnuPGConfig::KWatchGnuPGConfig(QWidget *parent)
     : QDialog(parent)
 {
     setWindowTitle(i18nc("@title:window", "Configure KWatchGnuPG"));
-    QVBoxLayout *mainLayout = new QVBoxLayout(this);
+    auto mainLayout = new QVBoxLayout(this);
 
     mButtonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
     QPushButton *okButton = mButtonBox->button(QDialogButtonBox::Ok);
     okButton->setDefault(true);
     okButton->setShortcut(Qt::CTRL | Qt::Key_Return);
     connect(mButtonBox, &QDialogButtonBox::rejected, this, &KWatchGnuPGConfig::reject);
 
-    QWidget *top = new QWidget;
+    auto top = new QWidget;
     mainLayout->addWidget(top);
     mainLayout->addWidget(mButtonBox);
 
-    QVBoxLayout *vlay = new QVBoxLayout(top);
+    auto vlay = new QVBoxLayout(top);
     vlay->setContentsMargins(0, 0, 0, 0);
 
-    QGroupBox *group = new QGroupBox(i18n("WatchGnuPG"), top);
+    auto group = new QGroupBox(i18n("WatchGnuPG"), top);
     vlay->addWidget(group);
 
-    QGridLayout *glay = new QGridLayout(group);
+    auto glay = new QGridLayout(group);
     glay->setColumnStretch(1, 1);
 
     int row = -1;
 
     ++row;
     mExeED = new Kleo::FileNameRequester(group);
-    QLabel *label = new QLabel(i18n("&Executable:"), group);
+    auto label = new QLabel(i18n("&Executable:"), group);
     label->setBuddy(mExeED);
     glay->addWidget(label, row, 0);
     glay->addWidget(mExeED, row, 1);
 
     connect(mExeED, &Kleo::FileNameRequester::fileNameChanged, this, &KWatchGnuPGConfig::slotChanged);
 
     ++row;
     mSocketED = new Kleo::FileNameRequester(group);
     label = new QLabel(i18n("&Socket:"), group);
     label->setBuddy(mSocketED);
     glay->addWidget(label, row, 0);
     glay->addWidget(mSocketED, row, 1);
 
     connect(mSocketED, &Kleo::FileNameRequester::fileNameChanged, this, &KWatchGnuPGConfig::slotChanged);
 
     ++row;
     mLogLevelCB = new QComboBox(group);
     mLogLevelCB->addItem(i18n("None"));
     mLogLevelCB->addItem(i18n("Basic"));
     mLogLevelCB->addItem(i18n("Advanced"));
     mLogLevelCB->addItem(i18n("Expert"));
     mLogLevelCB->addItem(i18n("Guru"));
     label = new QLabel(i18n("Default &log level:"), group);
     label->setBuddy(mLogLevelCB);
     glay->addWidget(label, row, 0);
     glay->addWidget(mLogLevelCB, row, 1);
 
     connect(mLogLevelCB, static_cast<void (QComboBox::*)(int)>(&QComboBox::activated), this, &KWatchGnuPGConfig::slotChanged);
 
     /******************* Log Window group *******************/
     group = new QGroupBox(i18n("Log Window"), top);
     vlay->addWidget(group);
 
     glay = new QGridLayout(group);
     glay->setColumnStretch(1, 1);
 
     row = -1;
 
     ++row;
     mLoglenSB = new KPluralHandlingSpinBox(group);
     mLoglenSB->setRange(0, 1000000);
     mLoglenSB->setSingleStep(100);
     mLoglenSB->setSuffix(ki18ncp("history size spinbox suffix", " line", " lines"));
     mLoglenSB->setSpecialValueText(i18n("unlimited"));
     label = new QLabel(i18n("&History size:"), group);
     label->setBuddy(mLoglenSB);
     glay->addWidget(label, row, 0);
     glay->addWidget(mLoglenSB, row, 1);
-    QPushButton *button = new QPushButton(i18n("Set &Unlimited"), group);
+    auto button = new QPushButton(i18n("Set &Unlimited"), group);
     glay->addWidget(button, row, 2);
 
     connect(mLoglenSB, static_cast<void (KPluralHandlingSpinBox::*)(int)>(&KPluralHandlingSpinBox::valueChanged), this, &KWatchGnuPGConfig::slotChanged);
     connect(button, &QPushButton::clicked, this, &KWatchGnuPGConfig::slotSetHistorySizeUnlimited);
 
     ++row;
     mWordWrapCB = new QCheckBox(i18n("Enable &word wrapping"), group);
     mWordWrapCB->hide(); // QTextEdit doesn't support word wrapping in LogText mode
     glay->addWidget(mWordWrapCB, row, 0, 1, 3);
 
     connect(mWordWrapCB, &QCheckBox::clicked, this, &KWatchGnuPGConfig::slotChanged);
 
     vlay->addStretch(1);
 
     connect(okButton, &QPushButton::clicked, this, &KWatchGnuPGConfig::slotSave);
 }
 
 KWatchGnuPGConfig::~KWatchGnuPGConfig() {}
 
 void KWatchGnuPGConfig::slotSetHistorySizeUnlimited()
 {
     mLoglenSB->setValue(0);
 }
 
 void KWatchGnuPGConfig::loadConfig()
 {
     const KConfigGroup watchGnuPG(KSharedConfig::openConfig(), "WatchGnuPG");
     mExeED->setFileName(watchGnuPG.readEntry("Executable", WATCHGNUPGBINARY));
     mSocketED->setFileName(watchGnuPG.readEntry("Socket", WATCHGNUPGSOCKET));
     mLogLevelCB->setCurrentIndex(log_level_to_int(watchGnuPG.readEntry("LogLevel", "basic")));
 
     const KConfigGroup logWindow(KSharedConfig::openConfig(), "LogWindow");
     mLoglenSB->setValue(logWindow.readEntry("MaxLogLen", 10000));
     mWordWrapCB->setChecked(logWindow.readEntry("WordWrap", false));
 
     mButtonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 }
 
 void KWatchGnuPGConfig::saveConfig()
 {
     KConfigGroup watchGnuPG(KSharedConfig::openConfig(), "WatchGnuPG");
     watchGnuPG.writeEntry("Executable", mExeED->fileName());
     watchGnuPG.writeEntry("Socket", mSocketED->fileName());
     watchGnuPG.writeEntry("LogLevel", log_levels[mLogLevelCB->currentIndex()]);
 
     KConfigGroup logWindow(KSharedConfig::openConfig(), "LogWindow");
     logWindow.writeEntry("MaxLogLen", mLoglenSB->value());
     logWindow.writeEntry("WordWrap", mWordWrapCB->isChecked());
 
     KSharedConfig::openConfig()->sync();
 
     mButtonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
 }
 
 void KWatchGnuPGConfig::slotChanged()
 {
     mButtonBox->button(QDialogButtonBox::Ok)->setEnabled(true);
 }
 
 void KWatchGnuPGConfig::slotSave()
 {
     saveConfig();
     Q_EMIT reconfigure();
     accept();
 }
 
diff --git a/src/kwatchgnupg/main.cpp b/src/kwatchgnupg/main.cpp
index 61cb65e2c..7e0db0d64 100644
--- a/src/kwatchgnupg/main.cpp
+++ b/src/kwatchgnupg/main.cpp
@@ -1,53 +1,53 @@
 /*
     main.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2001, 2002, 2004 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "aboutdata.h"
 #include "kwatchgnupgmainwin.h"
 #include <kcoreaddons_version.h>
 #if KCOREADDONS_VERSION < QT_VERSION_CHECK(6, 0, 0)
 #include <Kdelibs4ConfigMigrator>
 #endif
 #include "utils/kuniqueservice.h"
 
 #include <KLocalizedString>
 #include <KCrash>
 #include "kwatchgnupg_debug.h"
 #include <QCommandLineParser>
 #include <QApplication>
 
 int main(int argc, char **argv)
 {
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
     QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling, true);
     QApplication app(argc, argv);
     KCrash::initialize();
 #if KCOREADDONS_VERSION < QT_VERSION_CHECK(6, 0, 0)
     Kdelibs4ConfigMigrator migrate(QStringLiteral("kwatchgnupg"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("kwatchgnupgrc"));
     migrate.setUiFiles(QStringList() << QStringLiteral("kwatchgnupgui.rc"));
     migrate.migrate();
 #endif
 
     KLocalizedString::setApplicationDomain("kwatchgnupg");
     AboutData aboutData;
 
     KAboutData::setApplicationData(aboutData);
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
     parser.process(app);
     aboutData.processCommandLine(&parser);
 
     KUniqueService service;
 
-    KWatchGnuPGMainWindow *mMainWin = new KWatchGnuPGMainWindow();
+    auto mMainWin = new KWatchGnuPGMainWindow();
     mMainWin->show();
     return app.exec();
 }
diff --git a/src/libkleopatraclient/core/command.cpp b/src/libkleopatraclient/core/command.cpp
index 03d14cdf8..443165cbd 100644
--- a/src/libkleopatraclient/core/command.cpp
+++ b/src/libkleopatraclient/core/command.cpp
@@ -1,695 +1,695 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     command.cpp
 
     This file is part of KleopatraClient, the Kleopatra interface library
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: LGPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "command.h"
 #include "command_p.h"
 
 #include <QtGlobal> // Q_OS_WIN
 
 #ifdef Q_OS_WIN // HACK: AllowSetForegroundWindow needs _WIN32_WINDOWS >= 0x0490 set
 # ifndef _WIN32_WINDOWS
 #  define _WIN32_WINDOWS 0x0500
 #  define _WIN32_WINNT 0x0500 // good enough for Vista too
 # endif
 # include <utils/gnupg-registry.h>
 # include <windows.h>
 #endif
 
 #include <QMutexLocker>
 #include <QFile>
 #include "libkleopatraclientcore_debug.h"
 #include <QDir>
 #include <QProcess>
 #include <KLocalizedString>
 
 #include <assuan.h>
 #include <gpg-error.h>
 #include <gpgme++/global.h>
 
 #include <algorithm>
 #include <string>
 #include <sstream>
 #include <memory>
 #include <type_traits>
 
 using namespace KleopatraClientCopy;
 
 // copied from kleopatra/utils/hex.cpp
 static std::string hexencode(const std::string &in)
 {
     std::string result;
     result.reserve(3 * in.size());
 
     static const char hex[] = "0123456789ABCDEF";
 
     for (std::string::const_iterator it = in.begin(), end = in.end(); it != end; ++it)
         switch (const unsigned char ch = *it) {
         default:
             if ((ch >= '!' && ch <= '~') || ch > 0xA0) {
                 result += ch;
                 break;
             }
             Q_FALLTHROUGH();
         // else fall through
         case ' ':
             result += '+';
             break;
         case '"':
         case '#':
         case '$':
         case '%':
         case '\'':
         case '+':
         case '=':
             result += '%';
             result += hex[(ch & 0xF0) >> 4 ];
             result += hex[(ch & 0x0F)      ];
             break;
         }
 
     return result;
 }
 
 #ifdef UNUSED
 static std::string hexencode(const char *in)
 {
     if (!in) {
         return std::string();
     }
     return hexencode(std::string(in));
 }
 #endif
 
 // changed from returning QByteArray to returning std::string
 static std::string hexencode(const QByteArray &in)
 {
     if (in.isNull()) {
         return std::string();
     }
     return hexencode(std::string(in.data(), in.size()));
 }
 // end copied from kleopatra/utils/hex.cpp
 
 Command::Command(QObject *p)
     : QObject(p), d(new Private(this))
 {
     d->init();
 }
 
 Command::Command(Private *pp, QObject *p)
     : QObject(p), d(pp)
 {
     d->init();
 }
 
 Command::~Command()
 {
     delete d; d = nullptr;
 }
 
 void Command::Private::init()
 {
     connect(this, &QThread::started,  q, &Command::started);
     connect(this, &QThread::finished, q, &Command::finished);
 }
 
 void Command::setParentWId(WId wid)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.parentWId = wid;
 }
 
 WId Command::parentWId() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.parentWId;
 }
 
 void Command::setServerLocation(const QString &location)
 {
     const QMutexLocker locker(&d->mutex);
     d->outputs.serverLocation = location;
 }
 
 QString Command::serverLocation() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->outputs.serverLocation;
 }
 
 bool Command::waitForFinished()
 {
     return d->wait();
 }
 
 bool Command::waitForFinished(unsigned long ms)
 {
     return d->wait(ms);
 }
 
 bool Command::error() const
 {
     const QMutexLocker locker(&d->mutex);
     return !d->outputs.errorString.isEmpty();
 }
 
 bool Command::wasCanceled() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->outputs.canceled;
 }
 
 QString Command::errorString() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->outputs.errorString;
 }
 
 qint64 Command::serverPid() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->outputs.serverPid;
 }
 
 void Command::start()
 {
     d->start();
 }
 
 void Command::cancel()
 {
     qCDebug(LIBKLEOPATRACLIENTCORE_LOG) << "Sorry, not implemented: KleopatraClient::Command::Cancel";
 }
 
 void Command::setOptionValue(const char *name, const QVariant &value, bool critical)
 {
     if (!name || !*name) {
         return;
     }
     const Private::Option opt = {
         value,
         true,
         critical
     };
     const QMutexLocker locker(&d->mutex);
     d->inputs.options[name] = opt;
 }
 
 QVariant Command::optionValue(const char *name) const
 {
     if (!name || !*name) {
         return QVariant();
     }
     const QMutexLocker locker(&d->mutex);
 
-    const std::map<std::string, Private::Option>::const_iterator it = d->inputs.options.find(name);
+    const auto it = d->inputs.options.find(name);
     if (it == d->inputs.options.end()) {
         return QVariant();
     } else {
         return it->second.value;
     }
 }
 
 void Command::setOption(const char *name, bool critical)
 {
     if (!name || !*name) {
         return;
     }
     const QMutexLocker locker(&d->mutex);
 
     if (isOptionSet(name)) {
         unsetOption(name);
     }
 
     const Private::Option opt = {
         QVariant(),
         false,
         critical
     };
 
     d->inputs.options[name] = opt;
 }
 
 void Command::unsetOption(const char *name)
 {
     if (!name || !*name) {
         return;
     }
     const QMutexLocker locker(&d->mutex);
     d->inputs.options.erase(name);
 }
 
 bool Command::isOptionSet(const char *name) const
 {
     if (!name || !*name) {
         return false;
     }
     const QMutexLocker locker(&d->mutex);
     return d->inputs.options.count(name);
 }
 
 bool Command::isOptionCritical(const char *name) const
 {
     if (!name || !*name) {
         return false;
     }
     const QMutexLocker locker(&d->mutex);
-    const std::map<std::string, Private::Option>::const_iterator it = d->inputs.options.find(name);
+    const auto it = d->inputs.options.find(name);
     return it != d->inputs.options.end() && it->second.isCritical;
 }
 
 void Command::setFilePaths(const QStringList &filePaths)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.filePaths = filePaths;
 }
 
 QStringList Command::filePaths() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.filePaths;
 }
 
 void Command::setRecipients(const QStringList &recipients, bool informative)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.recipients = recipients;
     d->inputs.areRecipientsInformative = informative;
 }
 
 QStringList Command::recipients() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.recipients;
 }
 
 bool Command::areRecipientsInformative() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.areRecipientsInformative;
 }
 
 void Command::setSenders(const QStringList &senders, bool informative)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.senders = senders;
     d->inputs.areSendersInformative = informative;
 }
 
 QStringList Command::senders() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.senders;
 }
 
 bool Command::areSendersInformative() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.areSendersInformative;
 }
 
 void Command::setInquireData(const char *what, const QByteArray &data)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.inquireData[what] = data;
 }
 
 void Command::unsetInquireData(const char *what)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.inquireData.erase(what);
 }
 
 QByteArray Command::inquireData(const char *what) const
 {
     const QMutexLocker locker(&d->mutex);
-    const std::map<std::string, QByteArray>::const_iterator it = d->inputs.inquireData.find(what);
+    const auto it = d->inputs.inquireData.find(what);
     if (it == d->inputs.inquireData.end()) {
         return QByteArray();
     } else {
         return it->second;
     }
 }
 
 bool Command::isInquireDataSet(const char *what) const
 {
     const QMutexLocker locker(&d->mutex);
-    const std::map<std::string, QByteArray>::const_iterator it = d->inputs.inquireData.find(what);
+    const auto it = d->inputs.inquireData.find(what);
     return it != d->inputs.inquireData.end();
 }
 
 QByteArray Command::receivedData() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->outputs.data;
 }
 
 void Command::setCommand(const char *command)
 {
     const QMutexLocker locker(&d->mutex);
     d->inputs.command = command;
 }
 
 QByteArray Command::command() const
 {
     const QMutexLocker locker(&d->mutex);
     return d->inputs.command;
 }
 
 //
 // here comes the ugly part
 //
 
 #ifdef HAVE_ASSUAN2
 static void my_assuan_release(assuan_context_t ctx)
 {
     if (ctx) {
         assuan_release(ctx);
     }
 }
 #endif
 
-typedef std::shared_ptr<std::remove_pointer<assuan_context_t>::type > AssuanContextBase;
+using AssuanContextBase = std::shared_ptr<std::remove_pointer<assuan_context_t>::type>;
 namespace
 {
 struct AssuanClientContext : AssuanContextBase {
     AssuanClientContext() : AssuanContextBase() {}
 #ifndef HAVE_ASSUAN2
     explicit AssuanClientContext(assuan_context_t ctx) : AssuanContextBase(ctx, &assuan_disconnect) {}
     void reset(assuan_context_t ctx = nullptr)
     {
         AssuanContextBase::reset(ctx, &assuan_disconnect);
     }
 #else
     explicit AssuanClientContext(assuan_context_t ctx) : AssuanContextBase(ctx, &my_assuan_release) {}
     void reset(assuan_context_t ctx = nullptr)
     {
         AssuanContextBase::reset(ctx, &my_assuan_release);
     }
 #endif
 };
 }
 
 #ifdef HAVE_ASSUAN2
 // compatibility typedef - remove when we require assuan v2...
-typedef gpg_error_t assuan_error_t;
+using assuan_error_t = gpg_error_t;
 #endif
 
 static assuan_error_t
 my_assuan_transact(const AssuanClientContext &ctx,
                    const char *command,
                    assuan_error_t (*data_cb)(void *, const void *, size_t) = nullptr,
                    void *data_cb_arg = nullptr,
                    assuan_error_t (*inquire_cb)(void *, const char *) = nullptr,
                    void *inquire_cb_arg = nullptr,
                    assuan_error_t (*status_cb)(void *, const char *) = nullptr,
                    void *status_cb_arg = nullptr)
 {
     return assuan_transact(ctx.get(), command, data_cb, data_cb_arg, inquire_cb, inquire_cb_arg, status_cb, status_cb_arg);
 }
 
 static QString to_error_string(int err)
 {
     char buffer[1024];
     gpg_strerror_r(static_cast<gpg_error_t>(err),
                    buffer, sizeof buffer);
     buffer[sizeof buffer - 1] = '\0';
     return QString::fromLocal8Bit(buffer);
 }
 
 static QString gnupg_home_directory()
 {
     static const char *hDir = GpgME::dirInfo("homedir");
     return QFile::decodeName(hDir);
 }
 
 static QString get_default_socket_name()
 {
     const QString homeDir = gnupg_home_directory();
     if (homeDir.isEmpty()) {
         return QString();
     }
     return QDir(homeDir).absoluteFilePath(QStringLiteral("S.uiserver"));
 }
 
 static QString default_socket_name()
 {
     static QString name = get_default_socket_name();
     return name;
 }
 
 static QString uiserver_executable()
 {
     return QStringLiteral("kleopatra");
 }
 
 static QString start_uiserver()
 {
     if (!QProcess::startDetached(uiserver_executable(), QStringList() << QStringLiteral("--daemon"))) {
         return i18n("Failed to start uiserver %1", uiserver_executable());
     } else {
         return QString();
     }
 }
 
 static assuan_error_t getinfo_pid_cb(void *opaque, const void *buffer, size_t length)
 {
     qint64 &pid = *static_cast<qint64 *>(opaque);
     pid = QByteArray(static_cast<const char *>(buffer), length).toLongLong();
     return 0;
 }
 
 static assuan_error_t command_data_cb(void *opaque, const void *buffer, size_t length)
 {
     QByteArray &ba = *static_cast<QByteArray *>(opaque);
     ba.append(QByteArray(static_cast<const char *>(buffer), length));
     return 0;
 }
 
 namespace
 {
 struct inquire_data {
     const std::map<std::string, QByteArray> *map;
     const AssuanClientContext *ctx;
 };
 }
 
 static assuan_error_t command_inquire_cb(void *opaque, const char *what)
 {
     if (!opaque) {
         return 0;
     }
     const inquire_data &id = *static_cast<const inquire_data *>(opaque);
-    const std::map<std::string, QByteArray>::const_iterator it = id.map->find(what);
+    const auto it = id.map->find(what);
     if (it != id.map->end()) {
         const QByteArray &v = it->second;
         assuan_send_data(id.ctx->get(), v.data(), v.size());
     }
     return 0;
 }
 
 static inline std::ostream &operator<<(std::ostream &s, const QByteArray &ba)
 {
     return s << std::string(ba.data(), ba.size());
 }
 
 static assuan_error_t send_option(const AssuanClientContext &ctx, const char *name, const QVariant &value)
 {
     std::stringstream ss;
     ss << "OPTION " << name;
     if (value.isValid()) {
         ss << '=' << value.toString().toUtf8();
     }
     return my_assuan_transact(ctx, ss.str().c_str());
 }
 
 static assuan_error_t send_file(const AssuanClientContext &ctx, const QString &file)
 {
     std::stringstream ss;
     ss << "FILE " << hexencode(QFile::encodeName(file));
     return my_assuan_transact(ctx, ss.str().c_str());
 }
 
 static assuan_error_t send_recipient(const AssuanClientContext &ctx, const QString &recipient, bool info)
 {
     std::stringstream ss;
     ss << "RECIPIENT ";
     if (info) {
         ss << "--info ";
     }
     ss << "--" << hexencode(recipient.toUtf8());
     return my_assuan_transact(ctx, ss.str().c_str());
 }
 
 static assuan_error_t send_sender(const AssuanClientContext &ctx, const QString &sender, bool info)
 {
     std::stringstream ss;
     ss << "SENDER ";
     if (info) {
         ss << "--info ";
     }
     ss << "--" << hexencode(sender.toUtf8());
     return my_assuan_transact(ctx, ss.str().c_str());
 }
 
 void Command::Private::run()
 {
 
     // Take a snapshot of the input data, and clear the output data:
     Inputs in;
     Outputs out;
     {
         const QMutexLocker locker(&mutex);
         in = inputs;
         outputs = out;
     }
 
     out.canceled = false;
 
     if (out.serverLocation.isEmpty()) {
         out.serverLocation = default_socket_name();
     }
 
 #ifndef HAVE_ASSUAN2
     assuan_context_t naked_ctx = 0;
 #endif
     AssuanClientContext ctx;
     assuan_error_t err = 0;
 
     inquire_data id = { &in.inquireData, &ctx };
 
     const QString socketName = out.serverLocation;
     if (socketName.isEmpty()) {
         out.errorString = i18n("Invalid socket name!");
         goto leave;
     }
 
 #ifndef HAVE_ASSUAN2
     err = assuan_socket_connect(&naked_ctx, QFile::encodeName(socketName).constData(), -1);
 #else
     {
         assuan_context_t naked_ctx = nullptr;
         err = assuan_new(&naked_ctx);
         if (err) {
             out.errorString = i18n("Could not allocate resources to connect to Kleopatra UI server at %1: %2"
                                    , socketName, to_error_string(err));
             goto leave;
         }
 
         ctx.reset(naked_ctx);
     }
 
     err = assuan_socket_connect(ctx.get(), QFile::encodeName(socketName).constData(), -1, 0);
 #endif
     if (err) {
         qDebug("UI server not running, starting it");
 
         const QString errorString = start_uiserver();
         if (!errorString.isEmpty()) {
             out.errorString = errorString;
             goto leave;
         }
 
         // give it a bit of time to start up and try a couple of times
         for (int i = 0; err && i < 20; ++i) {
             msleep(500);
             err = assuan_socket_connect(ctx.get(), socketName.toUtf8().constData(), -1, 0);
         }
     }
 
     if (err) {
         out.errorString = i18n("Could not connect to Kleopatra UI server at %1: %2",
                                socketName, to_error_string(err));
         goto leave;
     }
 
 #ifndef HAVE_ASSUAN2
     ctx.reset(naked_ctx);
     naked_ctx = 0;
 #endif
 
     out.serverPid = -1;
     err = my_assuan_transact(ctx, "GETINFO pid", &getinfo_pid_cb, &out.serverPid);
     if (err || out.serverPid <= 0) {
         out.errorString = i18n("Could not get the process-id of the Kleopatra UI server at %1: %2", socketName, to_error_string(err));
         goto leave;
     }
 
     qCDebug(LIBKLEOPATRACLIENTCORE_LOG) << "Server PID =" << out.serverPid;
 
 #if defined(Q_OS_WIN)
     if (!AllowSetForegroundWindow((pid_t)out.serverPid)) {
         qCDebug(LIBKLEOPATRACLIENTCORE_LOG) << "AllowSetForegroundWindow(" << out.serverPid << ") failed: " << GetLastError();
     }
 #endif
 
     if (in.command.isEmpty()) {
         goto leave;
     }
 
     if (in.parentWId) {
 #if defined(Q_OS_WIN32)
         err = send_option(ctx, "window-id", QString::asprintf("%lx", reinterpret_cast<quintptr>(in.parentWId)));
 #else
         err = send_option(ctx, "window-id", QString::asprintf("%lx", static_cast<unsigned long>(in.parentWId)));
 #endif
         if (err) {
             qDebug("sending option window-id failed - ignoring");
         }
     }
 
-    for (std::map<std::string, Option>::const_iterator it = in.options.begin(), end = in.options.end(); it != end; ++it)
+    for (auto it = in.options.begin(), end = in.options.end(); it != end; ++it)
         if ((err = send_option(ctx, it->first.c_str(), it->second.hasValue ? it->second.value.toString() : QVariant()))) {
             if (it->second.isCritical) {
                 out.errorString = i18n("Failed to send critical option %1: %2", QString::fromLatin1(it->first.c_str()), to_error_string(err));
                 goto leave;
             } else {
                 qCDebug(LIBKLEOPATRACLIENTCORE_LOG) << "Failed to send non-critical option" << it->first.c_str() << ":" << to_error_string(err);
             }
         }
 
     Q_FOREACH (const QString &filePath, in.filePaths)
         if ((err = send_file(ctx, filePath))) {
             out.errorString = i18n("Failed to send file path %1: %2", filePath, to_error_string(err));
             goto leave;
         }
 
     Q_FOREACH (const QString &sender, in.senders)
         if ((err = send_sender(ctx, sender, in.areSendersInformative))) {
             out.errorString = i18n("Failed to send sender %1: %2", sender, to_error_string(err));
             goto leave;
         }
 
     Q_FOREACH (const QString &recipient, in.recipients)
         if ((err = send_recipient(ctx, recipient, in.areRecipientsInformative))) {
             out.errorString = i18n("Failed to send recipient %1: %2", recipient, to_error_string(err));
             goto leave;
         }
 
 #if 0
     setup I / O;
 #endif
 
     err = my_assuan_transact(ctx, in.command.constData(), &command_data_cb, &out.data, &command_inquire_cb, &id);
     if (err) {
         if (gpg_err_code(err) == GPG_ERR_CANCELED) {
             out.canceled = true;
         } else {
             out.errorString = i18n("Command (%1) failed: %2", QString::fromLatin1(in.command.constData()), to_error_string(err));
         }
         goto leave;
     }
 
 leave:
     const QMutexLocker locker(&mutex);
     // copy outputs to where Command can see them:
     outputs = out;
 }
diff --git a/src/main.cpp b/src/main.cpp
index 88af3a772..6ae5d0e78 100644
--- a/src/main.cpp
+++ b/src/main.cpp
@@ -1,269 +1,269 @@
 /*
     main.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2001, 2002, 2004, 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 "aboutdata.h"
 #include "kleopatraapplication.h"
 #include "mainwindow.h"
 
 #include <kcoreaddons_version.h>
 #if KCOREADDONS_VERSION < QT_VERSION_CHECK(6, 0, 0)
 #include <Kdelibs4ConfigMigrator>
 #endif
 
 #include <commands/reloadkeyscommand.h>
 #include <commands/selftestcommand.h>
 
 #include <Libkleo/GnuPG>
 #include <utils/archivedefinition.h>
 #include "utils/kuniqueservice.h"
 #include "utils/userinfo.h"
 
 #include <uiserver/uiserver.h>
 #include <uiserver/assuancommand.h>
 #include <uiserver/echocommand.h>
 #include <uiserver/decryptcommand.h>
 #include <uiserver/verifycommand.h>
 #include <uiserver/decryptverifyfilescommand.h>
 #include <uiserver/decryptfilescommand.h>
 #include <uiserver/verifyfilescommand.h>
 #include <uiserver/prepencryptcommand.h>
 #include <uiserver/prepsigncommand.h>
 #include <uiserver/encryptcommand.h>
 #include <uiserver/signcommand.h>
 #include <uiserver/signencryptfilescommand.h>
 #include <uiserver/selectcertificatecommand.h>
 #include <uiserver/importfilescommand.h>
 #include <uiserver/createchecksumscommand.h>
 #include <uiserver/verifychecksumscommand.h>
 
 #include <Libkleo/ChecksumDefinition>
 
 #include "kleopatra_debug.h"
 #include "kleopatra_options.h"
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KCrash>
 
 #include <QTextDocument> // for Qt::escape
 #include <QMessageBox>
 #include <QTimer>
 #include <QTime>
 #include <QEventLoop>
 #include <QThreadPool>
 #include <QElapsedTimer>
 
 #include <gpgme++/global.h>
 #include <gpgme++/error.h>
 
 #include <memory>
 #include <iostream>
 #include <QCommandLineParser>
 
 static bool selfCheck()
 {
     Kleo::Commands::SelfTestCommand cmd(nullptr);
     cmd.setAutoDelete(false);
     cmd.setAutomaticMode(true);
     QEventLoop loop;
     QObject::connect(&cmd, &Kleo::Commands::SelfTestCommand::finished, &loop, &QEventLoop::quit);
     QTimer::singleShot(0, &cmd, &Kleo::Command::start);   // start() may Q_EMIT finished()...
     loop.exec();
     if (cmd.isCanceled()) {
         return false;
     } else {
         return true;
     }
 }
 
 static void fillKeyCache(Kleo::UiServer *server)
 {
-    Kleo::ReloadKeysCommand *cmd = new Kleo::ReloadKeysCommand(nullptr);
+    auto cmd = new Kleo::ReloadKeysCommand(nullptr);
     QObject::connect(cmd, SIGNAL(finished()), server, SLOT(enableCryptoCommands()));
     cmd->start();
 }
 
 int main(int argc, char **argv)
 {
     QCoreApplication::setAttribute(Qt::AA_EnableHighDpiScaling, true);
     QCoreApplication::setAttribute(Qt::AA_UseHighDpiPixmaps, true);
     KleopatraApplication app(argc, argv);
     KCrash::initialize();
 
 
     QElapsedTimer timer;
     timer.start();
 
     KLocalizedString::setApplicationDomain("kleopatra");
 
     if (Kleo::userIsElevated()) {
         /* This is a safeguard against bugreports that something fails because
          * of permission problems on windows.  Some users still have the Windows
          * Vista behavior of running things as Administrator.  This can break
          * GnuPG in horrible ways for example if a stale lockfile is left that
          * can't be removed without another elevation.
          *
          * Note: This is not the same as running as root on Linux. Elevated means
          * that you are temporarily running with the "normal" user environment but
          * with elevated permissions.
          * */
         if (KMessageBox::warningContinueCancel(nullptr, xi18nc("@info",
                                                "<para><application>Kleopatra</application> cannot be run as adminstrator without "
                                                "breaking file permissions in the GnuPG data folder.</para>"
                                                "<para>To manage keys for other users please manage them as a normal user and "
                                                "copy the <filename>AppData\\Roaming\\gnupg</filename> directory with proper permissions.</para>") +
                                                xi18n("<para>Are you sure that you want to continue?</para>"),
                                                i18nc("@title", "Running as Administrator")) != KMessageBox::Continue) {
             return EXIT_FAILURE;
         }
         qCWarning(KLEOPATRA_LOG) << "User is running with administrative permissions.";
     }
 
     KUniqueService service;
     QObject::connect(&service, &KUniqueService::activateRequested,
                      &app, &KleopatraApplication::slotActivateRequested);
     QObject::connect(&app, &KleopatraApplication::setExitValue,
     &service, [&service](int i) {
         service.setExitValue(i);
     });
     // Delay init after KUniqueservice call as this might already
     // have terminated us and so we can avoid overhead (e.g. keycache
     // setup / systray icon).
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: Service created";
     app.init();
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: Application initialized";
 
     AboutData aboutData;
 
     KAboutData::setApplicationData(aboutData);
 
     QCommandLineParser parser;
     aboutData.setupCommandLine(&parser);
     kleopatra_options(&parser);
 
     parser.process(QApplication::arguments());
     aboutData.processCommandLine(&parser);
 #if KCOREADDONS_VERSION < QT_VERSION_CHECK(6, 0, 0)
     Kdelibs4ConfigMigrator migrate(QStringLiteral("kleopatra"));
     migrate.setConfigFiles(QStringList() << QStringLiteral("kleopatrarc")
                                          << QStringLiteral("libkleopatrarc"));
     migrate.setUiFiles(QStringList() << QStringLiteral("kleopatra.rc"));
     migrate.migrate();
 #endif
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: Application created";
 
     // Initialize GpgME
     const GpgME::Error gpgmeInitError = GpgME::initializeLibrary(0);
 
     {
         const unsigned int threads = QThreadPool::globalInstance()->maxThreadCount();
         QThreadPool::globalInstance()->setMaxThreadCount(qMax(2U, threads));
     }
     if (gpgmeInitError) {
         KMessageBox::sorry(nullptr, xi18nc("@info",
                                      "<para>The version of the <application>GpgME</application> library you are running against "
                                      "is older than the one that the <application>GpgME++</application> library was built against.</para>"
                                      "<para><application>Kleopatra</application> will not function in this setting.</para>"
                                      "<para>Please ask your administrator for help in resolving this issue.</para>"),
                            i18nc("@title", "GpgME Too Old"));
         return EXIT_FAILURE;
     }
 
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: GPGME Initialized";
 
     Kleo::ChecksumDefinition::setInstallPath(Kleo::gpg4winInstallPath());
     Kleo::ArchiveDefinition::setInstallPath(Kleo::gnupgInstallPath());
 
     int rc;
     Kleo::UiServer server(parser.value(QStringLiteral("uiserver-socket")));
     try {
         qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: UiServer created";
 
         QObject::connect(&server, &Kleo::UiServer::startKeyManagerRequested, &app, &KleopatraApplication::openOrRaiseMainWindow);
 
         QObject::connect(&server, &Kleo::UiServer::startConfigDialogRequested, &app, &KleopatraApplication::openOrRaiseConfigDialog);
 
 #define REGISTER( Command ) server.registerCommandFactory( std::shared_ptr<Kleo::AssuanCommandFactory>( new Kleo::GenericAssuanCommandFactory<Kleo::Command> ) )
         REGISTER(CreateChecksumsCommand);
         REGISTER(DecryptCommand);
         REGISTER(DecryptFilesCommand);
         REGISTER(DecryptVerifyFilesCommand);
         REGISTER(EchoCommand);
         REGISTER(EncryptCommand);
         REGISTER(EncryptFilesCommand);
         REGISTER(EncryptSignFilesCommand);
         REGISTER(ImportFilesCommand);
         REGISTER(PrepEncryptCommand);
         REGISTER(PrepSignCommand);
         REGISTER(SelectCertificateCommand);
         REGISTER(SignCommand);
         REGISTER(SignEncryptFilesCommand);
         REGISTER(SignFilesCommand);
         REGISTER(VerifyChecksumsCommand);
         REGISTER(VerifyCommand);
         REGISTER(VerifyFilesCommand);
 #undef REGISTER
 
         server.start();
         qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: UiServer started";
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Failed to start UI Server: " << e.what();
 #ifdef Q_OS_WIN
         // Once there actually is a plugin for other systems then Windows this
         // error should probably be shown, too. But currently only Windows users need
         // to care.
         QMessageBox::information(nullptr, i18n("GPG UI Server Error"),
                                  i18n("<qt>The Kleopatra GPG UI Server Module could not be initialized.<br/>"
                                       "The error given was: <b>%1</b><br/>"
                                       "You can use Kleopatra as a certificate manager, but cryptographic plugins that "
                                       "rely on a GPG UI Server being present might not work correctly, or at all.</qt>",
                                       QString::fromUtf8(e.what()).toHtmlEscaped()));
 #endif
     }
     const bool daemon = parser.isSet(QStringLiteral("daemon"));
     if (!daemon && app.isSessionRestored()) {
         app.restoreMainWindow();
     }
 
     if (!selfCheck()) {
         return EXIT_FAILURE;
     }
     qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: SelfCheck completed";
 
     fillKeyCache(&server);
 #ifndef QT_NO_SYSTEMTRAYICON
     app.startMonitoringSmartCard();
 #endif
     app.setIgnoreNewInstance(false);
 
     if (!daemon) {
         const QString err = app.newInstance(parser);
         if (!err.isEmpty()) {
             std::cerr << i18n("Invalid arguments: %1", err).toLocal8Bit().constData() << "\n";
             return EXIT_FAILURE;
         }
         qCDebug(KLEOPATRA_LOG) << "Startup timing:" << timer.elapsed() << "ms elapsed: new instance created";
     }
 
     rc = app.exec();
 
     app.setIgnoreNewInstance(true);
     QObject::disconnect(&server, &Kleo::UiServer::startKeyManagerRequested, &app, &KleopatraApplication::openOrRaiseMainWindow);
     QObject::disconnect(&server, &Kleo::UiServer::startConfigDialogRequested, &app, &KleopatraApplication::openOrRaiseConfigDialog);
 
     server.stop();
     server.waitForStopped();
 
     return rc;
 }
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 16179ef6b..39421a4a3 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,703 +1,703 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     mainwindow.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 "mainwindow.h"
 #include "aboutdata.h"
 #include "settings.h"
 
 #include "view/padwidget.h"
 #include "view/searchbar.h"
 #include "view/tabwidget.h"
 #include "view/keylistcontroller.h"
 #include "view/keycacheoverlay.h"
 #include "view/smartcardwidget.h"
 #include "view/welcomewidget.h"
 
 #include "commands/selftestcommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 
 #include "conf/groupsconfigdialog.h"
 
 #include "utils/detail_p.h"
 #include <Libkleo/GnuPG>
 #include "utils/action_data.h"
 #include "utils/filedialog.h"
 #include "utils/clipboardmenu.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KXMLGUIFactory>
 #include <QApplication>
 #include <QSize>
 #include <QLineEdit>
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <QAction>
 #include <KAboutData>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KShortcutsDialog>
 #include <KEditToolBar>
 #include "kleopatra_debug.h"
 #include <KConfigGroup>
 #include <KConfigDialog>
 
 #include <QAbstractItemView>
 #include <QCloseEvent>
 #include <QMenu>
 #include <QTimer>
 #include <QProcess>
 #include <QVBoxLayout>
 #include <QMimeData>
 #include <QDesktopServices>
 #include <QDir>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QLabel>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/CryptoConfigDialog>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <vector>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 static KGuiItem KStandardGuiItem_quit()
 {
     static const QString app = KAboutData::applicationData().componentName();
     KGuiItem item = KStandardGuiItem::quit();
     item.setText(i18nc("Quit [ApplicationName]", "&Quit %1", app));
     return item;
 }
 
 static KGuiItem KStandardGuiItem_close()
 {
     KGuiItem item = KStandardGuiItem::close();
     item.setText(i18n("Only &Close Window"));
     return item;
 }
 
 static bool isQuitting = false;
 
 namespace
 {
 static const std::vector<QString> mainViewActionNames = {
     QStringLiteral("view_certificate_overview"),
     QStringLiteral("manage_smartcard"),
     QStringLiteral("pad_view")
 };
 }
 
 class MainWindow::Private
 {
     friend class ::MainWindow;
     MainWindow *const q;
 
 public:
     explicit Private(MainWindow *qq);
     ~Private();
 
     template <typename T>
     void createAndStart()
     {
         (new T(this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(QAbstractItemView *view)
     {
         (new T(view, &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a)
     {
         (new T(a, this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a, QAbstractItemView *view)
     {
         (new T(a, view, &this->controller))->start();
     }
 
     void closeAndQuit()
     {
         const QString app = KAboutData::applicationData().componentName();
         const int rc = KMessageBox::questionYesNoCancel(q,
                        i18n("%1 may be used by other applications as a service.\n"
                             "You may instead want to close this window without exiting %1.", app),
                        i18n("Really Quit?"), KStandardGuiItem_close(), KStandardGuiItem_quit(), KStandardGuiItem::cancel(),
                        QLatin1String("really-quit-") + app.toLower());
         if (rc == KMessageBox::Cancel) {
             return;
         }
         isQuitting = true;
         if (!q->close()) {
             return;
         }
         // WARNING: 'this' might be deleted at this point!
         if (rc == KMessageBox::No) {
             qApp->quit();
         }
     }
     void configureToolbars()
     {
         KEditToolBar dlg(q->factory());
         dlg.exec();
     }
     void editKeybindings()
     {
         KShortcutsDialog::configure(q->actionCollection(), KShortcutsEditor::LetterShortcutsAllowed);
         updateSearchBarClickMessage();
     }
 
     void updateSearchBarClickMessage()
     {
         const QString shortcutStr = focusToClickSearchAction->shortcut().toString();
         ui.searchBar->updateClickMessage(shortcutStr);
     }
 
     void updateStatusBar()
     {
         const auto complianceMode = Formatting::complianceMode();
         if (complianceMode == QStringLiteral("de-vs")) {
             auto statusBar = new QStatusBar;
             q->setStatusBar(statusBar);
             auto statusLbl = new QLabel(Formatting::deVsString());
             statusBar->insertPermanentWidget(0, statusLbl);
 
         } else {
             q->setStatusBar(nullptr);
         }
     }
 
     void selfTest()
     {
         createAndStart<SelfTestCommand>();
     }
 
     void configureGroups()
     {
         if (KConfigDialog::showDialog(GroupsConfigDialog::dialogName())) {
             return;
         }
         KConfigDialog *dialog = new GroupsConfigDialog(q);
         dialog->show();
     }
 
     void configureBackend();
 
     void showHandbook();
 
     void gnupgLogViewer()
     {
         if (!QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList()))
             KMessageBox::error(q, i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
                                        "Please check your installation."),
                                i18n("Error Starting KWatchGnuPG"));
     }
 
     void forceUpdateCheck()
     {
         UpdateNotification::forceUpdateCheck(q);
     }
 
     void openCompendium()
     {
         QDir datadir(QCoreApplication::applicationDirPath() + QStringLiteral("/../share/gpg4win"));
         const auto path = datadir.filePath(i18nc("The Gpg4win compendium is only available"
                                                  "at this point (24.7.2017) in german and english."
                                                  "Please check with Gpg4win before translating this filename.",
                                                  "gpg4win-compendium-en.pdf"));
         qCDebug(KLEOPATRA_LOG) << "Opening Compendium at:" << path;
         // The compendium is always installed. So this should work. Otherwise
         // we have debug output.
         QDesktopServices::openUrl(QUrl::fromLocalFile(path));
     }
 
     void slotConfigCommitted();
     void slotContextMenuRequested(QAbstractItemView *, const QPoint &p)
     {
-        if (QMenu *const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
+        if (auto const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
             menu->exec(p);
         } else {
             qCDebug(KLEOPATRA_LOG) << "no \"listview_popup\" <Menu> in kleopatra's ui.rc file";
         }
     }
 
     void slotFocusQuickSearch()
     {
         ui.searchBar->lineEdit()->setFocus();
     }
 
     void showView(const QString &actionName, QWidget *widget)
     {
         const auto coll = q->actionCollection();
         if (coll) {
             for ( const QString &name : mainViewActionNames ) {
                 if (auto action = coll->action(name)) {
                     action->setChecked(name == actionName);
                 }
             }
         }
         ui.stackWidget->setCurrentWidget(widget);
     }
 
     void showCertificateView()
     {
         showView(QStringLiteral("view_certificate_overview"),
                  KeyCache::instance()->keys().empty() ? ui.welcomeWidget : ui.searchTab);
     }
 
     void showSmartcardView()
     {
         showView(QStringLiteral("manage_smartcard"), ui.scWidget);
     }
 
     void showPadView()
     {
         if (!ui.padWidget) {
             ui.padWidget = new PadWidget;
             ui.stackWidget->addWidget(ui.padWidget);
         }
         showView(QStringLiteral("pad_view"), ui.padWidget);
         ui.stackWidget->resize(ui.padWidget->sizeHint());
     }
 
 private:
     void setupActions();
 
     QAbstractItemView *currentView() const
     {
         return ui.tabWidget.currentView();
     }
 
     void keyListingDone()
     {
         const auto curWidget = ui.stackWidget->currentWidget();
         if (curWidget == ui.scWidget || curWidget == ui.padWidget) {
            return;
         }
         showCertificateView();
     }
 
 private:
     Kleo::KeyListController controller;
     bool firstShow : 1;
     struct UI {
         QWidget *searchTab;
         TabWidget tabWidget;
         SearchBar *searchBar;
         PadWidget *padWidget;
         SmartCardWidget *scWidget;
         WelcomeWidget *welcomeWidget;
         QStackedWidget *stackWidget;
         explicit UI(MainWindow *q);
     } ui;
     QAction *focusToClickSearchAction;
     ClipboardMenu *clipboadMenu;
 };
 
 MainWindow::Private::UI::UI(MainWindow *q)
     : tabWidget(q), padWidget(nullptr)
 {
     KDAB_SET_OBJECT_NAME(tabWidget);
 
     searchTab = new QWidget;
-    QVBoxLayout *vbox = new QVBoxLayout(searchTab);
+    auto vbox = new QVBoxLayout(searchTab);
     vbox->setSpacing(0);
     searchBar = new SearchBar;
     vbox->addWidget(searchBar);
     tabWidget.connectSearchBar(searchBar);
     vbox->addWidget(&tabWidget);
 
-    QWidget *mainWidget = new QWidget;
+    auto mainWidget = new QWidget;
     auto mainLayout = new QVBoxLayout(mainWidget);
     stackWidget = new QStackedWidget;
 
     mainLayout->addWidget(stackWidget);
 
     stackWidget->addWidget(searchTab);
 
     new KeyCacheOverlay(mainWidget, q);
 
     scWidget = new SmartCardWidget();
     stackWidget->addWidget(scWidget);
 
     welcomeWidget = new WelcomeWidget();
     stackWidget->addWidget(welcomeWidget);
 
     q->setCentralWidget(mainWidget);
 }
 
 MainWindow::Private::Private(MainWindow *qq)
     : q(qq),
       controller(q),
       firstShow(true),
       ui(q)
 {
     KDAB_SET_OBJECT_NAME(controller);
 
     AbstractKeyListModel *flatModel = AbstractKeyListModel::createFlatKeyListModel(q);
     AbstractKeyListModel *hierarchicalModel = AbstractKeyListModel::createHierarchicalKeyListModel(q);
 
     KDAB_SET_OBJECT_NAME(flatModel);
     KDAB_SET_OBJECT_NAME(hierarchicalModel);
 
     controller.setFlatModel(flatModel);
     controller.setHierarchicalModel(hierarchicalModel);
     controller.setTabWidget(&ui.tabWidget);
 
     ui.tabWidget.setFlatModel(flatModel);
     ui.tabWidget.setHierarchicalModel(hierarchicalModel);
 
     setupActions();
 
     ui.stackWidget->setCurrentWidget(ui.searchTab);
     if (auto action = q->actionCollection()->action(QStringLiteral("view_certificate_overview"))) {
         action->setChecked(true);
     }
 
     connect(&controller, SIGNAL(contextMenuRequested(QAbstractItemView*,QPoint)), q, SLOT(slotContextMenuRequested(QAbstractItemView*,QPoint)));
     connect(KeyCache::instance().get(), &KeyCache::keyListingDone, q, [this] () {keyListingDone();});
 
     q->createGUI(QStringLiteral("kleopatra.rc"));
 
     q->setAcceptDrops(true);
 
     // set default window size
     q->resize(QSize(1024, 500));
     q->setAutoSaveSettings();
 
     updateSearchBarClickMessage();
     updateStatusBar();
 }
 
 MainWindow::Private::~Private() {}
 
 MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags), d(new Private(this))
 {}
 
 MainWindow::~MainWindow() {}
 
 void MainWindow::Private::setupActions()
 {
 
     KActionCollection *const coll = q->actionCollection();
 
     const action_data action_data[] = {
         // most have been MOVED TO keylistcontroller.cpp
         // Tools menu
 #ifndef Q_OS_WIN
         {
             "tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
             "kwatchgnupg", q, SLOT(gnupgLogViewer()), QString(), false, true
         },
 #endif
 #ifdef Q_OS_WIN
         {
             "help_check_updates", i18n("Check for updates"), QString(),
             "gpg4win-compact", q, SLOT(forceUpdateCheck()), QString(), false, true
         },
         {
             "help_show_compendium", i18n("Gpg4win Compendium"), QString(),
             "gpg4win-compact", q, SLOT(openCompendium()), QString(), false, true
         },
 #endif
         {
             "view_certificate_overview", i18nc("@action show certificate overview", "Certificates"),
             i18n("Show certificate overview"), "view-certificate", q, SLOT(showCertificateView()), QString(), false, true
         },
         {
             "pad_view", i18nc("@action show input / output area for encrypting/signing resp. decrypting/verifying text", "Notepad"),
             i18n("Show pad for encrypting/decrypting and signing/verifying text"), "note", q, SLOT(showPadView()), QString(), false, true
         },
         // most have been MOVED TO keylistcontroller.cpp
 #if 0
         {
             "configure_backend", i18n("Configure GnuPG Backend..."), QString(),
             0, q, SLOT(configureBackend()), QString(), false, true
         },
 #endif
         // Settings menu
         {
             "settings_self_test", i18n("Perform Self-Test"), QString(),
             nullptr, q, SLOT(selfTest()), QString(), false, true
         },
         {
             "configure_groups", i18n("Configure Groups..."), QString(),
             "group", q, SLOT(configureGroups()), QString(), false, true
         },
         {
             "manage_smartcard", i18nc("@action show smartcard management view", "Smartcards"),
             i18n("Show smartcard management"), "auth-sim-locked", q, SLOT(showSmartcardView()), QString(), false, true
         }
 
         // most have been MOVED TO keylistcontroller.cpp
     };
 
     make_actions_from_data(action_data, /*sizeof action_data / sizeof *action_data,*/ coll);
 
     if (!Settings().groupsEnabled()) {
-        if (auto *action = coll->action(QStringLiteral("configure_groups"))) {
+        if (auto action = coll->action(QStringLiteral("configure_groups"))) {
             delete action;
         }
     }
 
     for ( const QString &name : mainViewActionNames ) {
         if (auto action = coll->action(name)) {
             action->setCheckable(true);
         }
     }
 
     if (QAction *action = coll->action(QStringLiteral("configure_backend"))) {
         action->setMenuRole(QAction::NoRole);    //prevent Qt OS X heuristics for config* actions
     }
 
     KStandardAction::close(q, SLOT(close()), coll);
     KStandardAction::quit(q, SLOT(closeAndQuit()), coll);
     KStandardAction::configureToolbars(q, SLOT(configureToolbars()), coll);
     KStandardAction::keyBindings(q, SLOT(editKeybindings()), coll);
     KStandardAction::preferences(qApp, SLOT(openOrRaiseConfigDialog()), coll);
 
     focusToClickSearchAction = new QAction(i18n("Set Focus to Quick Search"), q);
     coll->addAction(QStringLiteral("focus_to_quickseach"), focusToClickSearchAction);
     coll->setDefaultShortcut(focusToClickSearchAction, QKeySequence(Qt::ALT | Qt::Key_Q));
     connect(focusToClickSearchAction, SIGNAL(triggered(bool)), q, SLOT(slotFocusQuickSearch()));
     clipboadMenu = new ClipboardMenu(q);
     clipboadMenu->setMainWindow(q);
     clipboadMenu->clipboardMenu()->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
     clipboadMenu->clipboardMenu()->setPopupMode(QToolButton::InstantPopup);
     coll->addAction(QStringLiteral("clipboard_menu"), clipboadMenu->clipboardMenu());
 
     q->setStandardToolBarMenuEnabled(true);
 
     controller.createActions(coll);
 
     ui.tabWidget.createActions(coll);
 }
 
 void MainWindow::Private::configureBackend()
 {
     QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         KMessageBox::error(q, i18n("Could not configure the cryptography backend (gpgconf tool not found)"), i18n("Configuration Error"));
         return;
     }
 
     Kleo::CryptoConfigDialog dlg(config);
 
     const int result = dlg.exec();
 
     // Forget all data parsed from gpgconf, so that we show updated information
     // when reopening the configuration dialog.
     config->clear();
 
     if (result == QDialog::Accepted) {
 #if 0
         // Tell other apps (e.g. kmail) that the gpgconf data might have changed
         QDBusMessage message =
             QDBusMessage::createSignal(QString(), "org.kde.kleo.CryptoConfig", "changed");
         QDBusConnection::sessionBus().send(message);
 #endif
     }
 }
 
 void MainWindow::Private::slotConfigCommitted()
 {
     controller.updateConfig();
     updateStatusBar();
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
     // KMainWindow::closeEvent() insists on quitting the application,
     // so do not let it touch the event...
     qCDebug(KLEOPATRA_LOG);
     if (d->controller.hasRunningCommands()) {
         if (d->controller.shutdownWarningRequired()) {
             const int ret = KMessageBox::warningContinueCancel(this, i18n("There are still some background operations ongoing. "
                             "These will be terminated when closing the window. "
                             "Proceed?"),
                             i18n("Ongoing Background Tasks"));
             if (ret != KMessageBox::Continue) {
                 e->ignore();
                 return;
             }
         }
         d->controller.cancelCommands();
         if (d->controller.hasRunningCommands()) {
             // wait for them to be finished:
             setEnabled(false);
             QEventLoop ev;
             QTimer::singleShot(100, &ev, &QEventLoop::quit);
             connect(&d->controller, &KeyListController::commandsExecuting, &ev, &QEventLoop::quit);
             ev.exec();
             if (d->controller.hasRunningCommands())
                 qCWarning(KLEOPATRA_LOG)
                         << "controller still has commands running, this may crash now...";
             setEnabled(true);
         }
     }
     if (isQuitting || qApp->isSavingSession()) {
         d->ui.tabWidget.saveViews(KSharedConfig::openConfig().data());
         KConfigGroup grp(KConfigGroup(KSharedConfig::openConfig(), autoSaveGroup()));
         saveMainWindowSettings(grp);
         e->accept();
     } else {
         e->ignore();
         hide();
     }
 }
 
 void MainWindow::showEvent(QShowEvent *e)
 {
     KXmlGuiWindow::showEvent(e);
     if (d->firstShow) {
         d->ui.tabWidget.loadViews(KSharedConfig::openConfig().data());
         d->firstShow = false;
     }
 
     if (!savedGeometry.isEmpty()) {
         restoreGeometry(savedGeometry);
     }
 
 }
 
 void MainWindow::hideEvent(QHideEvent *e)
 {
     savedGeometry = saveGeometry();
     KXmlGuiWindow::hideEvent(e);
 }
 
 void MainWindow::importCertificatesFromFile(const QStringList &files)
 {
     if (!files.empty()) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     }
 }
 
 static QStringList extract_local_files(const QMimeData *data)
 {
     const QList<QUrl> urls = data->urls();
     // begin workaround KDE/Qt misinterpretation of text/uri-list
     QList<QUrl>::const_iterator end = urls.end();
     if (urls.size() > 1 && !urls.back().isValid()) {
         --end;
     }
     // end workaround
     QStringList result;
     std::transform(urls.begin(), end,
                    std::back_inserter(result),
                    std::mem_fn(&QUrl::toLocalFile));
     result.erase(std::remove_if(result.begin(), result.end(),
                                 std::mem_fn(&QString::isEmpty)), result.end());
     return result;
 }
 
 static bool can_decode_local_files(const QMimeData *data)
 {
     if (!data) {
         return false;
     }
     return !extract_local_files(data).empty();
 }
 
 void MainWindow::dragEnterEvent(QDragEnterEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (can_decode_local_files(e->mimeData())) {
         e->acceptProposedAction();
     }
 }
 
 void MainWindow::dropEvent(QDropEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (!can_decode_local_files(e->mimeData())) {
         return;
     }
 
     e->setDropAction(Qt::CopyAction);
 
     const QStringList files = extract_local_files(e->mimeData());
 
     const unsigned int classification = classify(files);
 
     QMenu menu;
 
     QAction *const signEncrypt = menu.addAction(i18n("Sign/Encrypt..."));
     QAction *const decryptVerify = mayBeAnyMessageType(classification) ? menu.addAction(i18n("Decrypt/Verify...")) : nullptr;
     if (signEncrypt || decryptVerify) {
         menu.addSeparator();
     }
 
     QAction *const importCerts = mayBeAnyCertStoreType(classification) ? menu.addAction(i18n("Import Certificates")) : nullptr;
     QAction *const importCRLs  = mayBeCertificateRevocationList(classification) ? menu.addAction(i18n("Import CRLs")) : nullptr;
     if (importCerts || importCRLs) {
         menu.addSeparator();
     }
 
     if (!signEncrypt && !decryptVerify && !importCerts && !importCRLs) {
         return;
     }
 
     menu.addAction(i18n("Cancel"));
 
     const QAction *const chosen = menu.exec(mapToGlobal(e->pos()));
 
     if (!chosen) {
         return;
     }
 
     if (chosen == signEncrypt) {
         d->createAndStart<SignEncryptFilesCommand>(files);
     } else if (chosen == decryptVerify) {
         d->createAndStart<DecryptVerifyFilesCommand>(files);
     } else if (chosen == importCerts) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     } else if (chosen == importCRLs) {
         d->createAndStart<ImportCrlCommand>(files);
     }
 
     e->accept();
 }
 
 void MainWindow::readProperties(const KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::readProperties(cg);
     setHidden(cg.readEntry("hidden", false));
 }
 
 void MainWindow::saveProperties(KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::saveProperties(cg);
     cg.writeEntry("hidden", isHidden());
 }
 
 #include "moc_mainwindow.cpp"
diff --git a/src/newcertificatewizard/listwidget.cpp b/src/newcertificatewizard/listwidget.cpp
index cd69eb49d..8b20d3eff 100644
--- a/src/newcertificatewizard/listwidget.cpp
+++ b/src/newcertificatewizard/listwidget.cpp
@@ -1,225 +1,225 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     newcertificatewizard/listwidget.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 "listwidget.h"
 
 #include "ui_listwidget.h"
 
 #include <QIcon>
 
 #include <QItemSelectionModel>
 #include <QStringListModel>
 #include <QRegExp>
 #include <QRegExpValidator>
 #include <QItemDelegate>
 #include <QLineEdit>
 
 using namespace Kleo::NewCertificateUi;
 
 namespace
 {
 
 class ItemDelegate : public QItemDelegate
 {
     Q_OBJECT
 public:
     explicit ItemDelegate(QObject *p = nullptr)
         : QItemDelegate(p), m_rx() {}
     explicit ItemDelegate(const QRegExp &rx, QObject *p = nullptr)
         : QItemDelegate(p), m_rx(rx) {}
 
     void setRegExpFilter(const QRegExp &rx)
     {
         m_rx = rx;
     }
     const QRegExp &regExpFilter() const
     {
         return m_rx;
     }
 
     QWidget *createEditor(QWidget *p, const QStyleOptionViewItem &o, const QModelIndex &i) const override
     {
         QWidget *w = QItemDelegate::createEditor(p, o, i);
         if (!m_rx.isEmpty())
-            if (QLineEdit *const le = qobject_cast<QLineEdit *>(w)) {
+            if (auto const le = qobject_cast<QLineEdit *>(w)) {
                 le->setValidator(new QRegExpValidator(m_rx, le));
             }
         return w;
     }
 private:
     QRegExp m_rx;
 };
 }
 
 class ListWidget::Private
 {
     friend class ::Kleo::NewCertificateUi::ListWidget;
     ListWidget *const q;
 public:
     explicit Private(ListWidget *qq)
         : q(qq),
           stringListModel(),
           ui(q)
     {
         ui.listView->setModel(&stringListModel);
         ui.listView->setItemDelegate(&delegate);
         connect(ui.listView->selectionModel(), SIGNAL(selectionChanged(QItemSelection,QItemSelection)),
                 q, SLOT(slotSelectionChanged()));
         connect(&stringListModel, &QAbstractItemModel::dataChanged,
                 q, &ListWidget::itemsChanged);
         connect(&stringListModel, &QAbstractItemModel::rowsInserted,
                 q, &ListWidget::itemsChanged);
         connect(&stringListModel, &QAbstractItemModel::rowsRemoved,
                 q, &ListWidget::itemsChanged);
     }
 
 private:
     void slotAdd()
     {
         const int idx = stringListModel.rowCount();
         if (stringListModel.insertRows(idx, 1)) {
             stringListModel.setData(stringListModel.index(idx), defaultValue);
             editRow(idx);
         }
     }
 
     void slotRemove()
     {
         const int idx = selectedRow();
         stringListModel.removeRows(idx, 1);
         selectRow(idx);
     }
 
     void slotUp()
     {
         const int idx = selectedRow();
         swapRows(idx - 1, idx);
         selectRow(idx - 1);
     }
 
     void slotDown()
     {
         const int idx = selectedRow();
         swapRows(idx, idx + 1);
         selectRow(idx + 1);
     }
 
     void slotSelectionChanged()
     {
         enableDisableActions();
     }
 
 private:
     void editRow(int idx)
     {
         const QModelIndex mi = stringListModel.index(idx);
         if (!mi.isValid()) {
             return;
         }
         ui.listView->setCurrentIndex(mi);
         ui.listView->edit(mi);
     }
 
     QModelIndexList selectedIndexes() const
     {
         return ui.listView->selectionModel()->selectedRows();
     }
     int selectedRow() const
     {
         const QModelIndexList mil = selectedIndexes();
         return mil.empty() ? -1 : mil.front().row();
     }
     void selectRow(int idx)
     {
         const QModelIndex mi = stringListModel.index(idx);
         if (mi.isValid()) {
             ui.listView->selectionModel()->select(mi, QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
         }
     }
     void swapRows(int r1, int r2)
     {
         if (r1 < 0 || r2 < 0 || r1 >= stringListModel.rowCount() || r2 >= stringListModel.rowCount()) {
             return;
         }
         const QModelIndex m1 = stringListModel.index(r1);
         const QModelIndex m2 = stringListModel.index(r2);
         const QVariant data1 = m1.data();
         const QVariant data2 = m2.data();
         stringListModel.setData(m1, data2);
         stringListModel.setData(m2, data1);
     }
     void enableDisableActions()
     {
         const QModelIndexList mil = selectedIndexes();
         ui.removeTB->setEnabled(!mil.empty());
         ui.upTB->setEnabled(mil.size() == 1 && mil.front().row() > 0);
         ui.downTB->setEnabled(mil.size() == 1 && mil.back().row() < stringListModel.rowCount() - 1);
     }
 
 private:
     QStringListModel stringListModel;
     ItemDelegate delegate;
     QString defaultValue;
     struct UI : Ui_ListWidget {
         explicit UI(ListWidget *q)
             : Ui_ListWidget()
         {
             setupUi(q);
 
             addTB->setIcon(QIcon::fromTheme(QStringLiteral("list-add")));
             removeTB->setIcon(QIcon::fromTheme(QStringLiteral("list-remove")));
             upTB->setIcon(QIcon::fromTheme(QStringLiteral("go-up")));
             downTB->setIcon(QIcon::fromTheme(QStringLiteral("go-down")));
         }
     } ui;
 
 };
 
 ListWidget::ListWidget(QWidget *p)
     : QWidget(p), d(new Private(this))
 {
 
 }
 
 ListWidget::~ListWidget() {}
 
 QStringList ListWidget::items() const
 {
     return d->stringListModel.stringList();
 }
 
 void ListWidget::setItems(const QStringList &items)
 {
     d->stringListModel.setStringList(items);
 }
 
 QRegExp ListWidget::regExpFilter() const
 {
     return d->delegate.regExpFilter();
 }
 
 void ListWidget::setRegExpFilter(const QRegExp &rx)
 {
     d->delegate.setRegExpFilter(rx);
 }
 
 QString ListWidget::defaultValue() const
 {
     return d->defaultValue;
 }
 
 void ListWidget::setDefaultValue(const QString &df)
 {
     d->defaultValue = df;
 }
 
 #include "moc_listwidget.cpp"
 #include "listwidget.moc"
diff --git a/src/newcertificatewizard/newcertificatewizard.cpp b/src/newcertificatewizard/newcertificatewizard.cpp
index cf459f12f..9ea6f68ec 100644
--- a/src/newcertificatewizard/newcertificatewizard.cpp
+++ b/src/newcertificatewizard/newcertificatewizard.cpp
@@ -1,1910 +1,1910 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     newcertificatewizard/newcertificatewizard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016, 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "newcertificatewizard.h"
 
 #include "ui_chooseprotocolpage.h"
 #include "ui_enterdetailspage.h"
 #include "ui_keycreationpage.h"
 #include "ui_resultpage.h"
 
 #include "ui_advancedsettingsdialog.h"
 
 #include "commands/exportsecretkeycommand.h"
 #include "commands/exportopenpgpcertstoservercommand.h"
 #include "commands/exportcertificatecommand.h"
 
 #include "kleopatraapplication.h"
 
 #include "utils/validation.h"
 #include "utils/filedialog.h"
 #include "utils/keyparameters.h"
 #include "utils/userinfo.h"
 
 #include <Libkleo/Compat>
 #include <Libkleo/GnuPG>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Dn>
 #include <Libkleo/OidMap>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <QGpgME/KeyGenerationJob>
 #include <QGpgME/Protocol>
 #include <QGpgME/CryptoConfig>
 
 #include <gpgme++/global.h>
 #include <gpgme++/keygenerationresult.h>
 #include <gpgme++/context.h>
 #include <gpgme++/interfaces/passphraseprovider.h>
 
 #include <KConfigGroup>
 #include <KLocalizedString>
 #include "kleopatra_debug.h"
 #include <QTemporaryDir>
 #include <KMessageBox>
 #include <QIcon>
 
 #include <QRegExpValidator>
 #include <QLineEdit>
 #include <QMetaProperty>
 #include <QDir>
 #include <QFile>
 #include <QUrl>
 #include <QDesktopServices>
 #include <QUrlQuery>
 
 #include <algorithm>
 
 #include <KSharedConfig>
 #include <QLocale>
 
 using namespace Kleo;
 using namespace Kleo::NewCertificateUi;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 static const char RSA_KEYSIZES_ENTRY[] = "RSAKeySizes";
 static const char DSA_KEYSIZES_ENTRY[] = "DSAKeySizes";
 static const char ELG_KEYSIZES_ENTRY[] = "ELGKeySizes";
 
 static const char RSA_KEYSIZE_LABELS_ENTRY[] = "RSAKeySizeLabels";
 static const char DSA_KEYSIZE_LABELS_ENTRY[] = "DSAKeySizeLabels";
 static const char ELG_KEYSIZE_LABELS_ENTRY[] = "ELGKeySizeLabels";
 
 static const char PGP_KEY_TYPE_ENTRY[] = "PGPKeyType";
 static const char CMS_KEY_TYPE_ENTRY[] = "CMSKeyType";
 
 // This should come from gpgme in the future
 // For now we only support the basic 2.1 curves and check
 // for GnuPG 2.1. The whole subkey / usage generation needs
 // new api and a reworked dialog. (ah 10.3.16)
 // EDDSA should be supported, too.
 static const QStringList curveNames {
     { QStringLiteral("brainpoolP256r1") },
     { QStringLiteral("brainpoolP384r1") },
     { QStringLiteral("brainpoolP512r1") },
     { QStringLiteral("NIST P-256") },
     { QStringLiteral("NIST P-384") },
     { QStringLiteral("NIST P-521") },
 };
 
 class EmptyPassphraseProvider: public PassphraseProvider
 {
 public:
     char *getPassphrase(const char * /*useridHint*/, const char * /*description*/,
                         bool /*previousWasBad*/, bool &/*canceled*/) Q_DECL_OVERRIDE
     {
         return gpgrt_strdup ("");
     }
 };
 
 static void set_tab_order(const QList<QWidget *> &wl)
 {
     kdtools::for_each_adjacent_pair(wl.begin(), wl.end(), &QWidget::setTabOrder);
 }
 
 enum KeyAlgo { RSA, DSA, ELG, ECDSA, ECDH, EDDSA };
 
 static bool is_algo(Subkey::PubkeyAlgo algo, KeyAlgo what)
 {
     switch (algo) {
         case Subkey::AlgoRSA:
         case Subkey::AlgoRSA_E:
         case Subkey::AlgoRSA_S:
             return what == RSA;
         case Subkey::AlgoELG_E:
         case Subkey::AlgoELG:
             return what == ELG;
         case Subkey::AlgoDSA:
             return what == DSA;
         case Subkey::AlgoECDSA:
             return what == ECDSA;
         case Subkey::AlgoECDH:
             return what == ECDH;
         case Subkey::AlgoEDDSA:
             return what == EDDSA;
         default:
             break;
     }
     return false;
 }
 
 static bool is_rsa(unsigned int algo)
 {
     return is_algo(static_cast<Subkey::PubkeyAlgo>(algo), RSA);
 }
 
 static bool is_dsa(unsigned int algo)
 {
     return is_algo(static_cast<Subkey::PubkeyAlgo>(algo), DSA);
 }
 
 static bool is_elg(unsigned int algo)
 {
     return is_algo(static_cast<Subkey::PubkeyAlgo>(algo), ELG);
 }
 
 static bool is_ecdsa(unsigned int algo)
 {
     return is_algo(static_cast<Subkey::PubkeyAlgo>(algo), ECDSA);
 }
 
 static bool is_eddsa(unsigned int algo)
 {
     return is_algo(static_cast<Subkey::PubkeyAlgo>(algo), EDDSA);
 }
 
 static bool is_ecdh(unsigned int algo)
 {
     return is_algo(static_cast<Subkey::PubkeyAlgo>(algo), ECDH);
 }
 
 static void force_set_checked(QAbstractButton *b, bool on)
 {
     // work around Qt bug (tested: 4.1.4, 4.2.3, 4.3.4)
     const bool autoExclusive = b->autoExclusive();
     b->setAutoExclusive(false);
     b->setChecked(b->isEnabled() && on);
     b->setAutoExclusive(autoExclusive);
 }
 
 static void set_keysize(QComboBox *cb, unsigned int strength)
 {
     if (!cb) {
         return;
     }
     const int idx = cb->findData(static_cast<int>(strength));
     cb->setCurrentIndex(idx);
 }
 
 static unsigned int get_keysize(const QComboBox *cb)
 {
     if (!cb) {
         return 0;
     }
     const int idx = cb->currentIndex();
     if (idx < 0) {
         return 0;
     }
     return cb->itemData(idx).toInt();
 }
 
 static void set_curve(QComboBox *cb, const QString &curve)
 {
     if (!cb) {
         return;
     }
     const int idx = cb->findText(curve);
     if (idx < 0) {
         // Can't happen as we don't have them configurable.
         qCWarning(KLEOPATRA_LOG) << "curve " << curve << " not allowed";
     }
     cb->setCurrentIndex(idx);
 }
 
 static QString get_curve(const QComboBox *cb)
 {
     if (!cb) {
         return QString();
     }
     return cb->currentText();
 }
 
 // Extract the algo information from default_pubkey_algo format
 //
 // and put it into the return values size, algo and curve.
 //
 // Values look like:
 // RSA-2048
 // rsa2048/cert,sign+rsa2048/enc
 // brainpoolP256r1+brainpoolP256r1
 static void parseAlgoString(const QString &algoString, int *size, Subkey::PubkeyAlgo *algo, QString &curve)
 {
     const auto split = algoString.split(QLatin1Char('/'));
     bool isEncrypt = split.size() == 2 && split[1].contains(QLatin1String("enc"));
 
     // Normalize
     const auto lowered = split[0].toLower().remove(QLatin1Char('-'));
     if (!algo || !size) {
         return;
     }
     *algo = Subkey::AlgoUnknown;
     if (lowered.startsWith(QLatin1String("rsa"))) {
         *algo = Subkey::AlgoRSA;
     } else if (lowered.startsWith(QLatin1String("dsa"))) {
         *algo = Subkey::AlgoDSA;
     } else if (lowered.startsWith(QLatin1String("elg"))) {
         *algo = Subkey::AlgoELG;
     }
 
     if (*algo != Subkey::AlgoUnknown) {
         bool ok;
         *size = lowered.rightRef(lowered.size() - 3).toInt(&ok);
         if (!ok) {
             qCWarning(KLEOPATRA_LOG) << "Could not extract size from: " << lowered;
             *size = 3072;
         }
         return;
     }
 
     // Now the ECC Algorithms
     if (lowered.startsWith(QLatin1String("ed25519"))) {
         // Special handling for this as technically
         // this is a cv25519 curve used for EDDSA
         curve = split[0];
         *algo = Subkey::AlgoEDDSA;
         return;
     }
 
     if (lowered.startsWith(QLatin1String("cv25519")) ||
         lowered.startsWith(QLatin1String("nist")) ||
         lowered.startsWith(QLatin1String("brainpool")) ||
         lowered.startsWith(QLatin1String("secp"))) {
         curve = split[0];
         *algo = isEncrypt ? Subkey::AlgoECDH : Subkey::AlgoECDSA;
         return;
     }
 
     qCWarning(KLEOPATRA_LOG) << "Failed to parse default_pubkey_algo:" << algoString;
 }
 
 Q_DECLARE_METATYPE(GpgME::Subkey::PubkeyAlgo)
 namespace Kleo
 {
 namespace NewCertificateUi
 {
 class WizardPage : public QWizardPage
 {
     Q_OBJECT
 protected:
     explicit WizardPage(QWidget *parent = nullptr)
         : QWizardPage(parent) {}
 
     NewCertificateWizard *wizard() const
     {
         Q_ASSERT(static_cast<NewCertificateWizard *>(QWizardPage::wizard()) == qobject_cast<NewCertificateWizard *>(QWizardPage::wizard()));
         return static_cast<NewCertificateWizard *>(QWizardPage::wizard());
     }
 
     QAbstractButton *button(QWizard::WizardButton button) const
     {
         return QWizardPage::wizard() ? QWizardPage::wizard()->button(button) : nullptr;
     }
 
     bool isButtonVisible(QWizard::WizardButton button) const
     {
         if (const QAbstractButton *const b = this->button(button)) {
             return b->isVisible();
         } else {
             return false;
         }
     }
 
     QDir tmpDir() const;
 
 protected Q_SLOTS:
     void setButtonVisible(QWizard::WizardButton button, bool visible)
     {
         if (QAbstractButton *const b = this->button(button)) {
             b->setVisible(visible);
         }
     }
 
 protected:
 #define FIELD(type, name) type name() const { return field( QStringLiteral(#name) ).value<type>(); }
     FIELD(bool, pgp)
     FIELD(bool, signingAllowed)
     FIELD(bool, encryptionAllowed)
     FIELD(bool, certificationAllowed)
     FIELD(bool, authenticationAllowed)
 
     FIELD(QString, name)
     FIELD(QString, email)
     FIELD(QString, dn)
     FIELD(bool, protectedKey)
 
     FIELD(Subkey::PubkeyAlgo, keyType)
     FIELD(int, keyStrength)
     FIELD(QString, keyCurve)
 
     FIELD(Subkey::PubkeyAlgo, subkeyType)
     FIELD(int, subkeyStrength)
     FIELD(QString, subkeyCurve)
 
     FIELD(QDate, expiryDate)
 
     FIELD(QStringList, additionalUserIDs)
     FIELD(QStringList, additionalEMailAddresses)
     FIELD(QStringList, dnsNames)
     FIELD(QStringList, uris)
 
     FIELD(QString, url)
     FIELD(QString, error)
     FIELD(QString, result)
     FIELD(QString, fingerprint)
 #undef FIELD
 };
 } // namespace NewCertificateUi
 } // namespace Kleo
 
 using namespace Kleo::NewCertificateUi;
 
 namespace
 {
 
 class AdvancedSettingsDialog : public QDialog
 {
     Q_OBJECT
     Q_PROPERTY(QStringList additionalUserIDs READ additionalUserIDs WRITE setAdditionalUserIDs)
     Q_PROPERTY(QStringList additionalEMailAddresses READ additionalEMailAddresses WRITE setAdditionalEMailAddresses)
     Q_PROPERTY(QStringList dnsNames READ dnsNames WRITE setDnsNames)
     Q_PROPERTY(QStringList uris READ uris WRITE setUris)
     Q_PROPERTY(uint keyStrength READ keyStrength WRITE setKeyStrength)
     Q_PROPERTY(Subkey::PubkeyAlgo keyType READ keyType WRITE setKeyType)
     Q_PROPERTY(QString keyCurve READ keyCurve WRITE setKeyCurve)
     Q_PROPERTY(uint subkeyStrength READ subkeyStrength WRITE setSubkeyStrength)
     Q_PROPERTY(QString subkeyCurve READ subkeyCurve WRITE setSubkeyCurve)
     Q_PROPERTY(Subkey::PubkeyAlgo subkeyType READ subkeyType WRITE setSubkeyType)
     Q_PROPERTY(bool signingAllowed READ signingAllowed WRITE setSigningAllowed)
     Q_PROPERTY(bool encryptionAllowed READ encryptionAllowed WRITE setEncryptionAllowed)
     Q_PROPERTY(bool certificationAllowed READ certificationAllowed WRITE setCertificationAllowed)
     Q_PROPERTY(bool authenticationAllowed READ authenticationAllowed WRITE setAuthenticationAllowed)
     Q_PROPERTY(QDate expiryDate READ expiryDate WRITE setExpiryDate)
 public:
     explicit AdvancedSettingsDialog(QWidget *parent = nullptr)
         : QDialog(parent),
           protocol(UnknownProtocol),
           pgpDefaultAlgorithm(Subkey::AlgoELG_E),
           cmsDefaultAlgorithm(Subkey::AlgoRSA),
           keyTypeImmutable(false),
           ui(),
           mECCSupported(engineIsVersion(2, 1, 0)),
           mEdDSASupported(engineIsVersion(2, 1, 15))
     {
         qRegisterMetaType<Subkey::PubkeyAlgo>("Subkey::PubkeyAlgo");
         ui.setupUi(this);
         const QDate today = QDate::currentDate();
         ui.expiryDE->setMinimumDate(today);
         ui.expiryDE->setDate(today.addYears(2));
         ui.expiryCB->setChecked(true);
         ui.emailLW->setDefaultValue(i18n("new email"));
         ui.dnsLW->setDefaultValue(i18n("new dns name"));
         ui.uriLW->setDefaultValue(i18n("new uri"));
 
         fillKeySizeComboBoxen();
     }
 
     void setProtocol(GpgME::Protocol proto)
     {
         if (protocol == proto) {
             return;
         }
         protocol = proto;
         loadDefaultKeyType();
     }
 
     void setAdditionalUserIDs(const QStringList &items)
     {
         ui.uidLW->setItems(items);
     }
     QStringList additionalUserIDs() const
     {
         return ui.uidLW->items();
     }
 
     void setAdditionalEMailAddresses(const QStringList &items)
     {
         ui.emailLW->setItems(items);
     }
     QStringList additionalEMailAddresses() const
     {
         return ui.emailLW->items();
     }
 
     void setDnsNames(const QStringList &items)
     {
         ui.dnsLW->setItems(items);
     }
     QStringList dnsNames() const
     {
         return ui.dnsLW->items();
     }
 
     void setUris(const QStringList &items)
     {
         ui.uriLW->setItems(items);
     }
     QStringList uris() const
     {
         return ui.uriLW->items();
     }
 
     void setKeyStrength(unsigned int strength)
     {
         set_keysize(ui.rsaKeyStrengthCB, strength);
         set_keysize(ui.dsaKeyStrengthCB, strength);
     }
     unsigned int keyStrength() const
     {
         return
             ui.dsaRB->isChecked() ? get_keysize(ui.dsaKeyStrengthCB) :
             ui.rsaRB->isChecked() ? get_keysize(ui.rsaKeyStrengthCB) : 0;
     }
 
     void setKeyType(Subkey::PubkeyAlgo algo)
     {
         QRadioButton *const rb =
             is_rsa(algo) ? ui.rsaRB :
             is_dsa(algo) ? ui.dsaRB :
             is_ecdsa(algo) || is_eddsa(algo) ? ui.ecdsaRB : nullptr;
         if (rb) {
             rb->setChecked(true);
         }
     }
     Subkey::PubkeyAlgo keyType() const
     {
         return
             ui.dsaRB->isChecked() ? Subkey::AlgoDSA :
             ui.rsaRB->isChecked() ? Subkey::AlgoRSA :
             ui.ecdsaRB->isChecked() ?
                 ui.ecdsaKeyCurvesCB->currentText() == QLatin1String("ed25519") ? Subkey::AlgoEDDSA :
                 Subkey::AlgoECDSA :
             Subkey::AlgoUnknown;
     }
 
     void setKeyCurve(const QString &curve)
     {
         set_curve(ui.ecdsaKeyCurvesCB, curve);
     }
 
     QString keyCurve() const
     {
         return get_curve(ui.ecdsaKeyCurvesCB);
     }
 
     void setSubkeyType(Subkey::PubkeyAlgo algo)
     {
         ui.elgCB->setChecked(is_elg(algo));
         ui.rsaSubCB->setChecked(is_rsa(algo));
         ui.ecdhCB->setChecked(is_ecdh(algo));
     }
     Subkey::PubkeyAlgo subkeyType() const
     {
         if (ui.elgCB->isChecked()) {
             return Subkey::AlgoELG_E;
         } else if (ui.rsaSubCB->isChecked()) {
             return Subkey::AlgoRSA;
         } else if (ui.ecdhCB->isChecked()) {
             return Subkey::AlgoECDH;
         }
         return Subkey::AlgoUnknown;
     }
 
     void setSubkeyCurve(const QString &curve)
     {
         set_curve(ui.ecdhKeyCurvesCB, curve);
     }
 
     QString subkeyCurve() const
     {
         return get_curve(ui.ecdhKeyCurvesCB);
     }
 
     void setSubkeyStrength(unsigned int strength)
     {
         if (subkeyType() == Subkey::AlgoRSA) {
             set_keysize(ui.rsaKeyStrengthSubCB, strength);
         } else {
             set_keysize(ui.elgKeyStrengthCB, strength);
         }
     }
     unsigned int subkeyStrength() const
     {
         if (subkeyType() == Subkey::AlgoRSA) {
             return get_keysize(ui.rsaKeyStrengthSubCB);
         }
         return get_keysize(ui.elgKeyStrengthCB);
     }
 
     void setSigningAllowed(bool on)
     {
         ui.signingCB->setChecked(on);
     }
     bool signingAllowed() const
     {
         return ui.signingCB->isChecked();
     }
 
     void setEncryptionAllowed(bool on)
     {
         ui.encryptionCB->setChecked(on);
     }
     bool encryptionAllowed() const
     {
         return ui.encryptionCB->isChecked();
     }
 
     void setCertificationAllowed(bool on)
     {
         ui.certificationCB->setChecked(on);
     }
     bool certificationAllowed() const
     {
         return ui.certificationCB->isChecked();
     }
 
     void setAuthenticationAllowed(bool on)
     {
         ui.authenticationCB->setChecked(on);
     }
     bool authenticationAllowed() const
     {
         return ui.authenticationCB->isChecked();
     }
 
     void setExpiryDate(QDate date)
     {
         if (date.isValid()) {
             ui.expiryDE->setDate(date);
         } else {
             ui.expiryCB->setChecked(false);
         }
     }
     QDate expiryDate() const
     {
         return ui.expiryCB->isChecked() ? ui.expiryDE->date() : QDate();
     }
 
 Q_SIGNALS:
     void changed();
 
 private Q_SLOTS:
     void slotKeyMaterialSelectionChanged()
     {
         const unsigned int algo = keyType();
         const unsigned int sk_algo = subkeyType();
 
         if (protocol == OpenPGP) {
             if (!keyTypeImmutable) {
                 ui.elgCB->setEnabled(is_dsa(algo));
                 ui.rsaSubCB->setEnabled(is_rsa(algo));
                 ui.ecdhCB->setEnabled(is_ecdsa(algo) || is_eddsa(algo));
                 if (sender() == ui.dsaRB || sender() == ui.rsaRB || sender() == ui.ecdsaRB) {
                     ui.elgCB->setChecked(is_dsa(algo));
                     ui.ecdhCB->setChecked(is_ecdsa(algo) || is_eddsa(algo));
                     ui.rsaSubCB->setChecked(is_rsa(algo));
                 }
                 if (is_rsa(algo)) {
                     ui.encryptionCB->setEnabled(true);
                     ui.encryptionCB->setChecked(true);
                     ui.signingCB->setEnabled(true);
                     ui.signingCB->setChecked(true);
                     ui.authenticationCB->setEnabled(true);
                     if (is_rsa(sk_algo)) {
                         ui.encryptionCB->setEnabled(false);
                         ui.encryptionCB->setChecked(true);
                     } else {
                         ui.encryptionCB->setEnabled(true);
                     }
                 } else if (is_dsa(algo)) {
                     ui.encryptionCB->setEnabled(false);
                     if (is_elg(sk_algo)) {
                         ui.encryptionCB->setChecked(true);
                     } else {
                         ui.encryptionCB->setChecked(false);
                     }
                 } else if (is_ecdsa(algo) || is_eddsa(algo)) {
                     ui.signingCB->setEnabled(true);
                     ui.signingCB->setChecked(true);
                     ui.authenticationCB->setEnabled(true);
                     ui.encryptionCB->setEnabled(false);
                     ui.encryptionCB->setChecked(is_ecdh(sk_algo));
                 }
             }
         } else {
             //assert( is_rsa( keyType() ) ); // it can happen through misconfiguration by the admin that no key type is selectable at all
         }
     }
 
     void slotSigningAllowedToggled(bool on)
     {
         if (!on && protocol == CMS && !encryptionAllowed()) {
             setEncryptionAllowed(true);
         }
     }
     void slotEncryptionAllowedToggled(bool on)
     {
         if (!on && protocol == CMS && !signingAllowed()) {
             setSigningAllowed(true);
         }
     }
 
 private:
     void fillKeySizeComboBoxen();
     void loadDefaultKeyType();
     void loadDefaultGnuPGKeyType();
     void updateWidgetVisibility();
 
 private:
     GpgME::Protocol protocol;
     unsigned int pgpDefaultAlgorithm;
     unsigned int cmsDefaultAlgorithm;
     bool keyTypeImmutable;
     Ui_AdvancedSettingsDialog ui;
     bool mECCSupported;
     bool mEdDSASupported;
 };
 
 class ChooseProtocolPage : public WizardPage
 {
     Q_OBJECT
 public:
     explicit ChooseProtocolPage(QWidget *p = nullptr)
         : WizardPage(p),
           initialized(false),
           ui()
     {
         ui.setupUi(this);
         registerField(QStringLiteral("pgp"), ui.pgpCLB);
     }
 
     void setProtocol(Protocol proto)
     {
         if (proto == OpenPGP) {
             ui.pgpCLB->setChecked(true);
         } else if (proto == CMS) {
             ui.x509CLB->setChecked(true);
         } else {
             force_set_checked(ui.pgpCLB,  false);
             force_set_checked(ui.x509CLB, false);
         }
     }
 
     Protocol protocol() const
     {
         return
             ui.pgpCLB->isChecked()  ? OpenPGP :
             ui.x509CLB->isChecked() ? CMS : UnknownProtocol;
     }
 
     void initializePage() override {
         if (!initialized)
         {
             connect(ui.pgpCLB,  &QAbstractButton::clicked, wizard(), &QWizard::next, Qt::QueuedConnection);
             connect(ui.x509CLB, &QAbstractButton::clicked, wizard(), &QWizard::next, Qt::QueuedConnection);
         }
         initialized = true;
     }
 
     bool isComplete() const override
     {
         return protocol() != UnknownProtocol;
     }
 
 private:
     bool initialized : 1;
     Ui_ChooseProtocolPage ui;
 };
 
 struct Line {
     QString attr;
     QString label;
     QString regex;
     QLineEdit *edit;
 };
 
 class EnterDetailsPage : public WizardPage
 {
     Q_OBJECT
 public:
     explicit EnterDetailsPage(QWidget *p = nullptr)
         : WizardPage(p), dialog(this), ui()
     {
         ui.setupUi(this);
 
         // set errorLB to have a fixed height of two lines:
         ui.errorLB->setText(QStringLiteral("2<br>1"));
         ui.errorLB->setFixedHeight(ui.errorLB->minimumSizeHint().height());
         ui.errorLB->clear();
 
         connect(ui.resultLE, &QLineEdit::textChanged,
                 this, &QWizardPage::completeChanged);
         // The email doesn't necessarily show up in ui.resultLE:
         connect(ui.emailLE, &QLineEdit::textChanged,
                 this, &QWizardPage::completeChanged);
         registerDialogPropertiesAsFields();
         registerField(QStringLiteral("dn"), ui.resultLE);
         registerField(QStringLiteral("name"), ui.nameLE);
         registerField(QStringLiteral("email"), ui.emailLE);
         registerField(QStringLiteral("protectedKey"), ui.withPassCB);
         updateForm();
         setCommitPage(true);
         setButtonText(QWizard::CommitButton, i18nc("@action", "Create"));
 
         const auto conf = QGpgME::cryptoConfig();
         if (!conf) {
             qCWarning(KLEOPATRA_LOG) << "Failed to obtain cryptoConfig.";
             return;
         }
         const auto entry = getCryptoConfigEntry(conf, "gpg-agent", "enforce-passphrase-constraints");
         if (entry && entry->boolValue()) {
             qCDebug(KLEOPATRA_LOG) << "Disabling passphrace cb because of agent config.";
             ui.withPassCB->setEnabled(false);
             ui.withPassCB->setChecked(true);
         } else {
             const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
             ui.withPassCB->setChecked(config.readEntry("WithPassphrase", false));
             ui.withPassCB->setEnabled(!config.isEntryImmutable("WithPassphrase"));
         }
     }
 
     bool isComplete() const override;
     void initializePage() override {
         updateForm();
         dialog.setProtocol(pgp() ? OpenPGP : CMS);
     }
     void cleanupPage() override {
         saveValues();
     }
 
 private:
     void updateForm();
     void clearForm();
     void saveValues();
     void registerDialogPropertiesAsFields();
 
 private:
     QString pgpUserID() const;
     QString cmsDN() const;
 
 private Q_SLOTS:
     void slotAdvancedSettingsClicked();
     void slotUpdateResultLabel()
     {
         ui.resultLE->setText(pgp() ? pgpUserID() : cmsDN());
         ui.withPassCB->setVisible(pgp());
     }
 
 private:
     QVector<Line> lineList;
     QList<QWidget *> dynamicWidgets;
     QMap<QString, QString> savedValues;
     AdvancedSettingsDialog dialog;
     Ui_EnterDetailsPage ui;
 };
 
 class KeyCreationPage : public WizardPage
 {
     Q_OBJECT
 public:
     explicit KeyCreationPage(QWidget *p = nullptr)
         : WizardPage(p),
           ui()
     {
         ui.setupUi(this);
     }
 
     bool isComplete() const override
     {
         return !job;
     }
 
     void initializePage() override {
         startJob();
     }
 
 private:
     void startJob()
     {
         const auto proto = pgp() ? QGpgME::openpgp() : QGpgME::smime();
         if (!proto) {
             return;
         }
         QGpgME::KeyGenerationJob *const j = proto->keyGenerationJob();
         if (!j) {
             return;
         }
         if (!protectedKey() && pgp()) {
             auto ctx = QGpgME::Job::context(j);
             ctx->setPassphraseProvider(&mEmptyPWProvider);
             ctx->setPinentryMode(Context::PinentryLoopback);
         }
         connect(j, &QGpgME::KeyGenerationJob::result,
                 this, &KeyCreationPage::slotResult);
         if (const Error err = j->start(createGnupgKeyParms()))
             setField(QStringLiteral("error"), i18n("Could not start key pair creation: %1",
                                                    QString::fromLocal8Bit(err.asString())));
         else {
             job = j;
         }
     }
     QStringList keyUsages() const;
     QStringList subkeyUsages() const;
     QString createGnupgKeyParms() const;
     EmptyPassphraseProvider mEmptyPWProvider;
 
 private Q_SLOTS:
     void slotResult(const GpgME::KeyGenerationResult &result, const QByteArray &request, const QString &auditLog)
     {
         Q_UNUSED(auditLog)
         if (result.error().code() || (pgp() && !result.fingerprint())) {
             setField(QStringLiteral("error"), result.error().isCanceled()
                      ? i18n("Operation canceled.")
                      : i18n("Could not create key pair: %1",
                             QString::fromLocal8Bit(result.error().asString())));
             setField(QStringLiteral("url"), QString());
             setField(QStringLiteral("result"), QString());
         } else if (pgp()) {
             setField(QStringLiteral("error"), QString());
             setField(QStringLiteral("url"), QString());
             setField(QStringLiteral("result"), i18n("Key pair created successfully.\n"
                                                     "Fingerprint: %1", QLatin1String(result.fingerprint())));
         } else {
             QFile file(tmpDir().absoluteFilePath(QStringLiteral("request.p10")));
 
             if (!file.open(QIODevice::WriteOnly)) {
                 setField(QStringLiteral("error"), i18n("Could not write output file %1: %2",
                                                        file.fileName(), file.errorString()));
                 setField(QStringLiteral("url"), QString());
                 setField(QStringLiteral("result"), QString());
             } else {
                 file.write(request);
                 setField(QStringLiteral("error"), QString());
                 setField(QStringLiteral("url"), QUrl::fromLocalFile(file.fileName()).toString());
                 setField(QStringLiteral("result"), i18n("Key pair created successfully."));
             }
         }
         // Ensure that we have the key in the keycache
         if (pgp() && !result.error().code() && result.fingerprint()) {
             auto ctx = Context::createForProtocol(OpenPGP);
             if (ctx) {
                 // Check is pretty useless something very buggy in that case.
                 Error e;
                 const auto key = ctx->key(result.fingerprint(), e, true);
                 if (!key.isNull()) {
                     KeyCache::mutableInstance()->insert(key);
                 } else {
                     qCDebug(KLEOPATRA_LOG) << "Failed to find newly generated key.";
                 }
                 delete ctx;
             }
         }
         setField(QStringLiteral("fingerprint"), result.fingerprint() ?
                  QString::fromLatin1(result.fingerprint()) : QString());
         job = nullptr;
         Q_EMIT completeChanged();
         const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
         if (config.readEntry("SkipResultPage", false)) {
             if (result.fingerprint()) {
                 KleopatraApplication::instance()->slotActivateRequested(QStringList() <<
                        QStringLiteral("kleopatra") << QStringLiteral("--query") << QLatin1String(result.fingerprint()), QString());
                 QMetaObject::invokeMethod(wizard(), "close", Qt::QueuedConnection);
             } else {
                 QMetaObject::invokeMethod(wizard(), "next", Qt::QueuedConnection);
             }
         } else {
             QMetaObject::invokeMethod(wizard(), "next", Qt::QueuedConnection);
         }
     }
 
 private:
     QPointer<QGpgME::KeyGenerationJob> job;
     Ui_KeyCreationPage ui;
 };
 
 class ResultPage : public WizardPage
 {
     Q_OBJECT
 public:
     explicit ResultPage(QWidget *p = nullptr)
         : WizardPage(p),
           initialized(false),
           successfullyCreatedSigningCertificate(false),
           successfullyCreatedEncryptionCertificate(false),
           ui()
     {
         ui.setupUi(this);
         ui.dragQueen->setPixmap(QIcon::fromTheme(QStringLiteral("kleopatra")).pixmap(64, 64));
         registerField(QStringLiteral("error"),  ui.errorTB,   "plainText");
         registerField(QStringLiteral("result"), ui.resultTB,  "plainText");
         registerField(QStringLiteral("url"),    ui.dragQueen, "url");
         // hidden field, since QWizard can't deal with non-widget-backed fields...
-        QLineEdit *le = new QLineEdit(this);
+        auto le = new QLineEdit(this);
         le->hide();
         registerField(QStringLiteral("fingerprint"), le);
     }
 
     void initializePage() override {
         const bool error = isError();
 
         if (error)
         {
             setTitle(i18nc("@title", "Key Creation Failed"));
             setSubTitle(i18n("Key pair creation failed. Please find details about the failure below."));
         } else {
             setTitle(i18nc("@title", "Key Pair Successfully Created"));
             setSubTitle(i18n("Your new key pair was created successfully. Please find details on the result and some suggested next steps below."));
         }
 
         ui.resultTB                 ->setVisible(!error);
         ui.errorTB                  ->setVisible(error);
         ui.dragQueen                ->setVisible(!error &&!pgp());
         ui.restartWizardPB          ->setVisible(error);
         ui.nextStepsGB              ->setVisible(!error);
         ui.saveRequestToFilePB      ->setVisible(!pgp());
         ui.makeBackupPB             ->setVisible(pgp());
         ui.createRevocationRequestPB->setVisible(pgp() &&false);     // not implemented
 
         ui.sendCertificateByEMailPB ->setVisible(pgp());
         ui.sendRequestByEMailPB     ->setVisible(!pgp());
         ui.uploadToKeyserverPB      ->setVisible(pgp());
 
         if (!error && !pgp())
         {
             if (signingAllowed() && !encryptionAllowed()) {
                 successfullyCreatedSigningCertificate = true;
             } else if (!signingAllowed() && encryptionAllowed()) {
                 successfullyCreatedEncryptionCertificate = true;
             } else {
                 successfullyCreatedEncryptionCertificate = successfullyCreatedSigningCertificate = true;
             }
         }
 
         ui.createSigningCertificatePB->setVisible(successfullyCreatedEncryptionCertificate &&!successfullyCreatedSigningCertificate);
         ui.createEncryptionCertificatePB->setVisible(successfullyCreatedSigningCertificate &&!successfullyCreatedEncryptionCertificate);
 
         setButtonVisible(QWizard::CancelButton, error);
 
         if (!initialized)
             connect(ui.restartWizardPB, &QAbstractButton::clicked,
                     wizard(), &QWizard::restart);
         initialized = true;
     }
 
     void cleanupPage() override {
         setButtonVisible(QWizard::CancelButton, true);
     }
 
     bool isError() const
     {
         return !ui.errorTB->document()->isEmpty();
     }
 
     bool isComplete() const override
     {
         return !isError();
     }
 
 private:
     Key key() const
     {
         return KeyCache::instance()->findByFingerprint(fingerprint().toLatin1().constData());
     }
 
 private Q_SLOTS:
     void slotSaveRequestToFile()
     {
         QString fileName = FileDialog::getSaveFileName(this, i18nc("@title", "Save Request"),
                            QStringLiteral("imp"), i18n("PKCS#10 Requests (*.p10)"));
         if (fileName.isEmpty()) {
             return;
         }
         if (!fileName.endsWith(QLatin1String(".p10"), Qt::CaseInsensitive)) {
             fileName += QLatin1String(".p10");
         }
         QFile src(QUrl(url()).toLocalFile());
         if (!src.copy(fileName))
             KMessageBox::error(this,
                                xi18nc("@info",
                                       "Could not copy temporary file <filename>%1</filename> "
                                       "to file <filename>%2</filename>: <message>%3</message>",
                                       src.fileName(), fileName, src.errorString()),
                                i18nc("@title", "Error Saving Request"));
         else
             KMessageBox::information(this,
                                      xi18nc("@info",
                                             "<para>Successfully wrote request to <filename>%1</filename>.</para>"
                                             "<para>You should now send the request to the Certification Authority (CA).</para>",
                                             fileName),
                                      i18nc("@title", "Request Saved"));
     }
 
     void slotSendRequestByEMail()
     {
         if (pgp()) {
             return;
         }
         const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
         invokeMailer(config.readEntry("CAEmailAddress"),    // to
                      i18n("Please process this certificate."), // subject
                      i18n("Please process this certificate and inform the sender about the location to fetch the resulting certificate.\n\nThanks,\n"), // body
                      QUrl(url()).toLocalFile());    // attachment
     }
 
     void slotSendCertificateByEMail()
     {
         if (!pgp() || exportCertificateCommand) {
             return;
         }
-        ExportCertificateCommand *cmd = new ExportCertificateCommand(key());
+        auto cmd = new ExportCertificateCommand(key());
         connect(cmd, &ExportCertificateCommand::finished, this, &ResultPage::slotSendCertificateByEMailContinuation);
         cmd->setOpenPGPFileName(tmpDir().absoluteFilePath(fingerprint() + QLatin1String(".asc")));
         cmd->start();
         exportCertificateCommand = cmd;
     }
 
     void slotSendCertificateByEMailContinuation()
     {
         if (!exportCertificateCommand) {
             return;
         }
         // ### better error handling?
         const QString fileName = exportCertificateCommand->openPGPFileName();
         qCDebug(KLEOPATRA_LOG) << "fileName" << fileName;
         exportCertificateCommand = nullptr;
         if (fileName.isEmpty()) {
             return;
         }
         invokeMailer(QString(),  // to
                      i18n("My new public OpenPGP key"), // subject
                      i18n("Please find attached my new public OpenPGP key."), // body
                      fileName);
     }
 
     QByteArray ol_quote(QByteArray str)
     {
 #ifdef Q_OS_WIN
         return "\"\"" + str.replace('"', "\\\"") + "\"\"";
         //return '"' + str.replace( '"', "\\\"" ) + '"';
 #else
         return str;
 #endif
     }
 
     void invokeMailer(const QString &to, const QString &subject, const QString &body, const QString &attachment)
     {
         qCDebug(KLEOPATRA_LOG) << "to:" << to << "subject:" << subject
                                << "body:" << body << "attachment:" << attachment;
 
         // RFC 2368 says body's linebreaks need to be encoded as
         // "%0D%0A", so normalize body to CRLF:
         //body.replace(QLatin1Char('\n'), QStringLiteral("\r\n")).remove(QStringLiteral("\r\r"));
 
         QUrlQuery query;
         query.addQueryItem(QStringLiteral("subject"), subject);
         query.addQueryItem(QStringLiteral("body"), body);
         if (!attachment.isEmpty()) {
             query.addQueryItem(QStringLiteral("attach"), attachment);
         }
         QUrl url;
         url.setScheme(QStringLiteral("mailto"));
         url.setQuery(query);
         qCDebug(KLEOPATRA_LOG) << "openUrl" << url;
         QDesktopServices::openUrl(url);
         KMessageBox::information(this,
                                  xi18nc("@info",
                                         "<para><application>Kleopatra</application> tried to send a mail via your default mail client.</para>"
                                         "<para>Some mail clients are known not to support attachments when invoked this way.</para>"
                                         "<para>If your mail client does not have an attachment, then drag the <application>Kleopatra</application> icon and drop it on the message compose window of your mail client.</para>"
                                         "<para>If that does not work, either, save the request to a file, and then attach that.</para>"),
                                  i18nc("@title", "Sending Mail"),
                                  QStringLiteral("newcertificatewizard-mailto-troubles"));
     }
 
     void slotUploadCertificateToDirectoryServer()
     {
         if (pgp()) {
             (new ExportOpenPGPCertsToServerCommand(key()))->start();
         }
     }
 
     void slotBackupCertificate()
     {
         if (pgp()) {
             (new ExportSecretKeyCommand(key()))->start();
         }
     }
 
     void slotCreateRevocationRequest()
     {
 
     }
 
     void slotCreateSigningCertificate()
     {
         if (successfullyCreatedSigningCertificate) {
             return;
         }
         toggleSignEncryptAndRestart();
     }
 
     void slotCreateEncryptionCertificate()
     {
         if (successfullyCreatedEncryptionCertificate) {
             return;
         }
         toggleSignEncryptAndRestart();
     }
 
 private:
     void toggleSignEncryptAndRestart()
     {
         if (!wizard()) {
             return;
         }
         if (KMessageBox::warningContinueCancel(
                     this,
                     i18nc("@info",
                           "This operation will delete the certification request. "
                           "Please make sure that you have sent or saved it before proceeding."),
                     i18nc("@title", "Certification Request About To Be Deleted")) != KMessageBox::Continue) {
             return;
         }
         const bool sign = signingAllowed();
         const bool encr = encryptionAllowed();
         setField(QStringLiteral("signingAllowed"),    !sign);
         setField(QStringLiteral("encryptionAllowed"), !encr);
         // restart and skip to enter details Page:
         wizard()->restart();
         for (int i = wizard()->currentId(); i < NewCertificateWizard::EnterDetailsPageId; ++i) {
             wizard()->next();
         }
     }
 
 private:
     bool initialized : 1;
     bool successfullyCreatedSigningCertificate : 1;
     bool successfullyCreatedEncryptionCertificate : 1;
     QPointer<ExportCertificateCommand> exportCertificateCommand;
     Ui_ResultPage ui;
 };
 }
 
 class NewCertificateWizard::Private
 {
     friend class ::Kleo::NewCertificateWizard;
     friend class ::Kleo::NewCertificateUi::WizardPage;
     NewCertificateWizard *const q;
 public:
     explicit Private(NewCertificateWizard *qq)
         : q(qq),
           tmp(QDir::temp().absoluteFilePath(QStringLiteral("kleo-"))),
           ui(q)
     {
         q->setWindowTitle(i18nc("@title:window", "Key Pair Creation Wizard"));
     }
 
 private:
     QTemporaryDir tmp;
     struct Ui {
         ChooseProtocolPage chooseProtocolPage;
         EnterDetailsPage enterDetailsPage;
         KeyCreationPage keyCreationPage;
         ResultPage resultPage;
 
         explicit Ui(NewCertificateWizard *q)
             : chooseProtocolPage(q),
               enterDetailsPage(q),
               keyCreationPage(q),
               resultPage(q)
         {
             KDAB_SET_OBJECT_NAME(chooseProtocolPage);
             KDAB_SET_OBJECT_NAME(enterDetailsPage);
             KDAB_SET_OBJECT_NAME(keyCreationPage);
             KDAB_SET_OBJECT_NAME(resultPage);
 
             q->setOptions(DisabledBackButtonOnLastPage);
 
             q->setPage(ChooseProtocolPageId, &chooseProtocolPage);
             q->setPage(EnterDetailsPageId,   &enterDetailsPage);
             q->setPage(KeyCreationPageId,    &keyCreationPage);
             q->setPage(ResultPageId,         &resultPage);
 
             q->setStartId(ChooseProtocolPageId);
         }
 
     } ui;
 
 };
 
 NewCertificateWizard::NewCertificateWizard(QWidget *p)
     : QWizard(p), d(new Private(this))
 {
 
 }
 
 NewCertificateWizard::~NewCertificateWizard() {}
 
 void NewCertificateWizard::setProtocol(Protocol proto)
 {
     d->ui.chooseProtocolPage.setProtocol(proto);
     setStartId(proto == UnknownProtocol ? ChooseProtocolPageId : EnterDetailsPageId);
 }
 
 Protocol NewCertificateWizard::protocol() const
 {
     return d->ui.chooseProtocolPage.protocol();
 }
 
 static QString pgpLabel(const QString &attr)
 {
     if (attr == QLatin1String("NAME")) {
         return i18n("Name");
     }
     if (attr == QLatin1String("EMAIL")) {
         return i18n("EMail");
     }
     return QString();
 }
 
 static QString attributeLabel(const QString &attr, bool pgp)
 {
     if (attr.isEmpty()) {
         return QString();
     }
     const QString label = pgp ? pgpLabel(attr) : Kleo::DNAttributeMapper::instance()->name2label(attr);
     if (!label.isEmpty())
         if (pgp) {
             return label;
         } else
             return i18nc("Format string for the labels in the \"Your Personal Data\" page",
                          "%1 (%2)", label, attr);
     else {
         return attr;
     }
 }
 
 #if 0
 //Not used anywhere
 static QString attributeLabelWithColor(const QString &attr, bool pgp)
 {
     const QString result = attributeLabel(attr, pgp);
     if (result.isEmpty()) {
         return QString();
     } else {
         return result + ':';
     }
 }
 #endif
 
 static QString attributeFromKey(QString key)
 {
     return key.remove(QLatin1Char('!'));
 }
 
 QDir WizardPage::tmpDir() const
 {
     return wizard() ? QDir(wizard()->d->tmp.path()) : QDir::home();
 }
 
 void EnterDetailsPage::registerDialogPropertiesAsFields()
 {
 
     const QMetaObject *const mo = dialog.metaObject();
     for (unsigned int i = mo->propertyOffset(), end = i + mo->propertyCount(); i != end; ++i) {
         const QMetaProperty mp = mo->property(i);
         if (mp.isValid()) {
             registerField(QLatin1String(mp.name()), &dialog, mp.name(), SIGNAL(accepted()));
         }
     }
 
 }
 
 void EnterDetailsPage::saveValues()
 {
     for (const Line &line : qAsConst(lineList)) {
         savedValues[ attributeFromKey(line.attr) ] = line.edit->text().trimmed();
     }
 }
 
 void EnterDetailsPage::clearForm()
 {
     qDeleteAll(dynamicWidgets);
     dynamicWidgets.clear();
     lineList.clear();
 
     ui.nameLE->hide();
     ui.nameLE->clear();
     ui.nameLB->hide();
     ui.nameRequiredLB->hide();
 
     ui.emailLE->hide();
     ui.emailLE->clear();
     ui.emailLB->hide();
     ui.emailRequiredLB->hide();
 }
 
 static int row_index_of(QWidget *w, QGridLayout *l)
 {
     const int idx = l->indexOf(w);
     int r, c, rs, cs;
     l->getItemPosition(idx, &r, &c, &rs, &cs);
     return r;
 }
 
 static QLineEdit *adjust_row(QGridLayout *l, int row, const QString &label, const QString &preset, QValidator *validator, bool readonly, bool required)
 {
     Q_ASSERT(l);
     Q_ASSERT(row >= 0);
     Q_ASSERT(row < l->rowCount());
 
-    QLabel *lb = qobject_cast<QLabel *>(l->itemAtPosition(row, 0)->widget());
+    auto lb = qobject_cast<QLabel *>(l->itemAtPosition(row, 0)->widget());
     Q_ASSERT(lb);
-    QLineEdit *le = qobject_cast<QLineEdit *>(l->itemAtPosition(row, 1)->widget());
+    auto le = qobject_cast<QLineEdit *>(l->itemAtPosition(row, 1)->widget());
     Q_ASSERT(le);
     lb->setBuddy(le);   // For better accessibility
-    QLabel *reqLB = qobject_cast<QLabel *>(l->itemAtPosition(row, 2)->widget());
+    auto reqLB = qobject_cast<QLabel *>(l->itemAtPosition(row, 2)->widget());
     Q_ASSERT(reqLB);
 
     lb->setText(i18nc("interpunctation for labels", "%1:", label));
     le->setText(preset);
     reqLB->setText(required ? i18n("(required)") : i18n("(optional)"));
     delete le->validator();
     if (validator) {
         if (!validator->parent()) {
             validator->setParent(le);
         }
         le->setValidator(validator);
     }
 
     le->setReadOnly(readonly && le->hasAcceptableInput());
 
     lb->show();
     le->show();
     reqLB->show();
 
     return le;
 }
 
 static int add_row(QGridLayout *l, QList<QWidget *> *wl)
 {
     Q_ASSERT(l);
     Q_ASSERT(wl);
     const int row = l->rowCount();
     QWidget *w1, *w2, *w3;
     l->addWidget(w1 = new QLabel(l->parentWidget()),    row, 0);
     l->addWidget(w2 = new QLineEdit(l->parentWidget()), row, 1);
     l->addWidget(w3 = new QLabel(l->parentWidget()),    row, 2);
     wl->push_back(w1);
     wl->push_back(w2);
     wl->push_back(w3);
     return row;
 }
 
 void EnterDetailsPage::updateForm()
 {
 
     clearForm();
 
     const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
 
     QStringList attrOrder = config.readEntry(pgp() ? "OpenPGPAttributeOrder" : "DNAttributeOrder", QStringList());
     if (attrOrder.empty()) {
         if (pgp()) {
             attrOrder << QStringLiteral("NAME") << QStringLiteral("EMAIL");
         } else {
             attrOrder << QStringLiteral("CN!") << QStringLiteral("L") << QStringLiteral("OU") << QStringLiteral("O") << QStringLiteral("C") << QStringLiteral("EMAIL!");
         }
     }
 
     QList<QWidget *> widgets;
     widgets.push_back(ui.nameLE);
     widgets.push_back(ui.emailLE);
 
     QMap<int, Line> lines;
 
     for (const QString &rawKey : qAsConst(attrOrder)) {
         const QString key = rawKey.trimmed().toUpper();
         const QString attr = attributeFromKey(key);
         if (attr.isEmpty()) {
             continue;
         }
         const QString preset = savedValues.value(attr, config.readEntry(attr, QString()));
         const bool required = key.endsWith(QLatin1Char('!'));
         const bool readonly = config.isEntryImmutable(attr);
         const QString label = config.readEntry(attr + QLatin1String("_label"),
                                                attributeLabel(attr, pgp()));
         const QString regex = config.readEntry(attr + QLatin1String("_regex"));
 
         int row;
         bool known = true;
         QValidator *validator = nullptr;
         if (attr == QLatin1String("EMAIL")) {
             row = row_index_of(ui.emailLE, ui.gridLayout);
             validator = regex.isEmpty() ? Validation::email() : Validation::email(QRegExp(regex));
         } else if (attr == QLatin1String("NAME") || attr == QLatin1String("CN")) {
             if ((pgp() && attr == QLatin1String("CN")) || (!pgp() && attr == QLatin1String("NAME"))) {
                 continue;
             }
             if (pgp()) {
                 validator = regex.isEmpty() ? Validation::pgpName() : Validation::pgpName(QRegExp(regex));
             }
             row = row_index_of(ui.nameLE, ui.gridLayout);
         } else {
             known = false;
             row = add_row(ui.gridLayout, &dynamicWidgets);
         }
         if (!validator && !regex.isEmpty()) {
             validator = new QRegExpValidator(QRegExp(regex), nullptr);
         }
 
         QLineEdit *le = adjust_row(ui.gridLayout, row, label, preset, validator, readonly, required);
 
         const Line line = { key, label, regex, le };
         lines[row] = line;
 
         if (!known) {
             widgets.push_back(le);
         }
 
         // don't connect twice:
         disconnect(le, &QLineEdit::textChanged, this, &EnterDetailsPage::slotUpdateResultLabel);
         connect(le, &QLineEdit::textChanged, this, &EnterDetailsPage::slotUpdateResultLabel);
     }
 
     // create lineList in visual order, so requirementsAreMet()
     // complains from top to bottom:
     lineList.reserve(lines.count());
     std::copy(lines.cbegin(), lines.cend(), std::back_inserter(lineList));
 
     widgets.push_back(ui.resultLE);
     widgets.push_back(ui.advancedPB);
 
     if (ui.nameLE->text().isEmpty()) {
         ui.nameLE->setText(userFullName());
     }
     if (ui.emailLE->text().isEmpty()) {
         ui.emailLE->setText(userEmailAddress());
     }
 
     set_tab_order(widgets);
 }
 
 QString EnterDetailsPage::cmsDN() const
 {
     DN dn;
     for (QVector<Line>::const_iterator it = lineList.begin(), end = lineList.end(); it != end; ++it) {
         const QString text = it->edit->text().trimmed();
         if (text.isEmpty()) {
             continue;
         }
         QString attr = attributeFromKey(it->attr);
         if (attr == QLatin1String("EMAIL")) {
             continue;
         }
         if (const char *const oid = oidForAttributeName(attr)) {
             attr = QString::fromUtf8(oid);
         }
         dn.append(DN::Attribute(attr, text));
     }
     return dn.dn();
 }
 
 QString EnterDetailsPage::pgpUserID() const
 {
     return Formatting::prettyNameAndEMail(OpenPGP, QString(),
                                           ui.nameLE->text().trimmed(),
                                           ui.emailLE->text().trimmed(),
                                           QString());
 }
 
 static bool has_intermediate_input(const QLineEdit *le)
 {
     QString text = le->text();
     int pos = le->cursorPosition();
     const QValidator *const v = le->validator();
     return v && v->validate(text, pos) == QValidator::Intermediate;
 }
 
 static bool requirementsAreMet(const QVector<Line> &list, QString &error)
 {
     bool allEmpty = true;
     for (const Line &line : list) {
         const QLineEdit *le = line.edit;
         if (!le) {
             continue;
         }
         const QString key = line.attr;
         qCDebug(KLEOPATRA_LOG) << "requirementsAreMet(): checking \"" << key << "\" against \"" << le->text() << "\":";
         if (le->text().trimmed().isEmpty()) {
             if (key.endsWith(QLatin1Char('!'))) {
                 if (line.regex.isEmpty()) {
                     error = xi18nc("@info", "<interface>%1</interface> is required, but empty.", line.label);
                 } else
                     error = xi18nc("@info", "<interface>%1</interface> is required, but empty.<nl/>"
                                    "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
                 return false;
             }
         } else if (has_intermediate_input(le)) {
             if (line.regex.isEmpty()) {
                 error = xi18nc("@info", "<interface>%1</interface> is incomplete.", line.label);
             } else
                 error = xi18nc("@info", "<interface>%1</interface> is incomplete.<nl/>"
                                "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
             return false;
         } else if (!le->hasAcceptableInput()) {
             if (line.regex.isEmpty()) {
                 error = xi18nc("@info", "<interface>%1</interface> is invalid.", line.label);
             } else
                 error = xi18nc("@info", "<interface>%1</interface> is invalid.<nl/>"
                                "Local Admin rule: <icode>%2</icode>", line.label, line.regex);
             return false;
         } else {
             allEmpty = false;
         }
     }
     // Ensure that at least one value is acceptable
     return !allEmpty;
 }
 
 bool EnterDetailsPage::isComplete() const
 {
     QString error;
     const bool ok = requirementsAreMet(lineList, error);
     ui.errorLB->setText(error);
     return ok;
 }
 
 void EnterDetailsPage::slotAdvancedSettingsClicked()
 {
     dialog.exec();
 }
 
 QStringList KeyCreationPage::keyUsages() const
 {
     QStringList usages;
     if (signingAllowed()) {
         usages << QStringLiteral("sign");
     }
     if (encryptionAllowed() && !is_ecdh(subkeyType()) &&
         !is_dsa(keyType()) && !is_rsa(subkeyType())) {
         usages << QStringLiteral("encrypt");
     }
     if (authenticationAllowed()) {
         usages << QStringLiteral("auth");
     }
     if (usages.empty() && certificationAllowed()) {
         /* Empty usages cause an error so we need to
          * add at least certify if nothing else is selected */
         usages << QStringLiteral("cert");
     }
     return usages;
 }
 
 QStringList KeyCreationPage::subkeyUsages() const
 {
     QStringList usages;
     if (encryptionAllowed() && (is_dsa(keyType()) || is_rsa(subkeyType()) ||
                                 is_ecdh(subkeyType()))) {
         Q_ASSERT(subkeyType());
         usages << QStringLiteral("encrypt");
     }
     return usages;
 }
 
 namespace
 {
 template <typename T = QString>
 struct Row {
     QString key;
     T value;
 
     Row(const QString &k, const T &v) : key(k), value(v) {}
 };
 template <typename T>
 QTextStream &operator<<(QTextStream &s, const Row<T> &row)
 {
     if (row.key.isEmpty()) {
         return s;
     } else {
         return s << "<tr><td>" << row.key << "</td><td>" << row.value << "</td></tr>";
     }
 }
 }
 
 QString KeyCreationPage::createGnupgKeyParms() const
 {
     KeyParameters keyParameters(pgp() ? KeyParameters::OpenPGP : KeyParameters::CMS);
 
     keyParameters.setKeyType(keyType());
     if (is_ecdsa(keyType()) || is_eddsa(keyType())) {
         keyParameters.setKeyCurve(keyCurve());
     } else if (const unsigned int strength = keyStrength()) {
         keyParameters.setKeyLength(strength);
     }
     keyParameters.setKeyUsages(keyUsages());
 
     if (subkeyType()) {
         keyParameters.setSubkeyType(subkeyType());
         if (is_ecdh(subkeyType())) {
             keyParameters.setSubkeyCurve(subkeyCurve());
         } else if (const unsigned int strength = subkeyStrength()) {
             keyParameters.setSubkeyLength(strength);
         }
         keyParameters.setSubkeyUsages(subkeyUsages());
     }
 
     if (pgp()) {
         if (expiryDate().isValid()) {
             keyParameters.setExpirationDate(expiryDate());
         }
         if (!name().isEmpty()) {
             keyParameters.setName(name());
         }
         if (!email().isEmpty()) {
             keyParameters.setEmail(email());
         }
     } else {
         keyParameters.setDN(dn());
         keyParameters.setEmail(email());
         Q_FOREACH (const QString &email, additionalEMailAddresses()) {
             keyParameters.addEmail(email);
         }
         Q_FOREACH (const QString &dns, dnsNames()) {
             keyParameters.addDomainName(dns);
         }
         Q_FOREACH (const QString &uri, uris()) {
             keyParameters.addURI(uri);
         }
     }
 
     const QString result = keyParameters.toString();
     qCDebug(KLEOPATRA_LOG) << '\n' << result;
     return result;
 }
 
 static void fill_combobox(QComboBox &cb, const QList<int> &sizes, const QStringList &labels)
 {
     cb.clear();
     for (int i = 0, end = sizes.size(); i != end; ++i) {
         const int size = std::abs(sizes[i]);
         /* As we respect the defaults configurable in GnuPG, and we also have configurable
          * defaults in Kleopatra its difficult to print out "default" here. To avoid confusion
          * about that its better not to show any default indication.  */
         cb.addItem(i < labels.size() && !labels[i].trimmed().isEmpty()
                    ? i18ncp("%2: some admin-supplied text, %1: key size in bits", "%2 (1 bit)", "%2 (%1 bits)", size, labels[i].trimmed())
                    : i18ncp("%1: key size in bits", "1 bit", "%1 bits", size),
                    size);
         if (sizes[i] < 0) {
             cb.setCurrentIndex(cb.count() - 1);
         }
     }
 }
 
 void AdvancedSettingsDialog::fillKeySizeComboBoxen()
 {
 
     const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
 
     QList<int> rsaKeySizes = config.readEntry(RSA_KEYSIZES_ENTRY, QList<int>() << 2048 << -3072 << 4096);
     if (Kleo::gpgComplianceP("de-vs")) {
         rsaKeySizes = config.readEntry(RSA_KEYSIZES_ENTRY, QList<int>() << -3072 << 4096);
     }
     const QList<int> dsaKeySizes = config.readEntry(DSA_KEYSIZES_ENTRY, QList<int>() << -2048);
     const QList<int> elgKeySizes = config.readEntry(ELG_KEYSIZES_ENTRY, QList<int>() << -2048 << 3072 << 4096);
 
     const QStringList rsaKeySizeLabels = config.readEntry(RSA_KEYSIZE_LABELS_ENTRY, QStringList());
     const QStringList dsaKeySizeLabels = config.readEntry(DSA_KEYSIZE_LABELS_ENTRY, QStringList());
     const QStringList elgKeySizeLabels = config.readEntry(ELG_KEYSIZE_LABELS_ENTRY, QStringList());
 
     fill_combobox(*ui.rsaKeyStrengthCB, rsaKeySizes, rsaKeySizeLabels);
     fill_combobox(*ui.rsaKeyStrengthSubCB, rsaKeySizes, rsaKeySizeLabels);
     fill_combobox(*ui.dsaKeyStrengthCB, dsaKeySizes, dsaKeySizeLabels);
     fill_combobox(*ui.elgKeyStrengthCB, elgKeySizes, elgKeySizeLabels);
     if (mEdDSASupported) {
         // If supported we recommend cv25519
         ui.ecdsaKeyCurvesCB->addItem(QStringLiteral("ed25519"));
         ui.ecdhKeyCurvesCB->addItem(QStringLiteral("cv25519"));
     }
     ui.ecdhKeyCurvesCB->addItems(curveNames);
     ui.ecdsaKeyCurvesCB->addItems(curveNames);
 }
 
 // Try to load the default key type from GnuPG
 void AdvancedSettingsDialog::loadDefaultGnuPGKeyType()
 {
     const auto conf = QGpgME::cryptoConfig();
     if (!conf) {
         qCWarning(KLEOPATRA_LOG) << "Failed to obtain cryptoConfig.";
         return;
     }
     const auto entry = getCryptoConfigEntry(conf, protocol == CMS ? "gpgsm" : "gpg", "default_pubkey_algo");
     if (!entry) {
         qCDebug(KLEOPATRA_LOG) << "GnuPG does not have default key type. Fallback to RSA";
         setKeyType(Subkey::AlgoRSA);
         setSubkeyType(Subkey::AlgoRSA);
         return;
     }
 
     qCDebug(KLEOPATRA_LOG) << "Have default key type: " << entry->stringValue();
 
     // Format is <primarytype>[/usage]+<subkeytype>[/usage]
     const auto split = entry->stringValue().split(QLatin1Char('+'));
     int size = 0;
     Subkey::PubkeyAlgo algo = Subkey::AlgoUnknown;
     QString curve;
 
     parseAlgoString(split[0], &size, &algo, curve);
     if (algo == Subkey::AlgoUnknown) {
         setSubkeyType(Subkey::AlgoRSA);
         return;
     }
 
     setKeyType(algo);
 
     if (is_rsa(algo) || is_elg(algo) || is_dsa(algo)) {
         setKeyStrength(size);
     } else {
         setKeyCurve(curve);
     }
 
     if (split.size() == 2) {
         auto algoString = split[1];
         // If it has no usage we assume encrypt subkey
         if (!algoString.contains(QLatin1Char('/'))) {
             algoString += QStringLiteral("/enc");
         }
 
         parseAlgoString(algoString, &size, &algo, curve);
 
         if (algo == Subkey::AlgoUnknown) {
             setSubkeyType(Subkey::AlgoRSA);
             return;
         }
 
         setSubkeyType(algo);
 
         if (is_rsa(algo) || is_elg(algo)) {
             setSubkeyStrength(size);
         } else {
             setSubkeyCurve(curve);
         }
     }
 }
 
 void AdvancedSettingsDialog::loadDefaultKeyType()
 {
 
     if (protocol != CMS && protocol != OpenPGP) {
         return;
     }
 
     const KConfigGroup config(KSharedConfig::openConfig(), "CertificateCreationWizard");
 
     const QString entry = protocol == CMS ? QLatin1String(CMS_KEY_TYPE_ENTRY) : QLatin1String(PGP_KEY_TYPE_ENTRY);
     const QString keyType = config.readEntry(entry).trimmed().toUpper();
 
     if (protocol == OpenPGP && keyType == QLatin1String("DSA")) {
         setKeyType(Subkey::AlgoDSA);
         setSubkeyType(Subkey::AlgoUnknown);
     } else if (protocol == OpenPGP && keyType == QLatin1String("DSA+ELG")) {
         setKeyType(Subkey::AlgoDSA);
         setSubkeyType(Subkey::AlgoELG_E);
     } else if (keyType.isEmpty() && engineIsVersion(2, 1, 17)) {
         loadDefaultGnuPGKeyType();
     } else {
         if (!keyType.isEmpty() && keyType != QLatin1String("RSA"))
             qCWarning(KLEOPATRA_LOG) << "invalid value \"" << qPrintable(keyType)
                                      << "\" for entry \"[CertificateCreationWizard]"
                                      << qPrintable(entry) << "\"";
         setKeyType(Subkey::AlgoRSA);
         setSubkeyType(Subkey::AlgoRSA);
     }
 
     keyTypeImmutable = config.isEntryImmutable(entry);
     updateWidgetVisibility();
 }
 
 void AdvancedSettingsDialog::updateWidgetVisibility()
 {
     // Personal Details Page
     if (protocol == OpenPGP) {    // ### hide until multi-uid is implemented
         if (ui.tabWidget->indexOf(ui.personalTab) != -1) {
             ui.tabWidget->removeTab(ui.tabWidget->indexOf(ui.personalTab));
         }
     } else {
         if (ui.tabWidget->indexOf(ui.personalTab) == -1) {
             ui.tabWidget->addTab(ui.personalTab, tr2i18n("Personal Details", nullptr));
         }
     }
     ui.uidGB->setVisible(protocol == OpenPGP);
     ui.uidGB->setEnabled(false);
     ui.uidGB->setToolTip(i18nc("@info:tooltip", "Adding more than one User ID is not yet implemented."));
     ui.emailGB->setVisible(protocol == CMS);
     ui.dnsGB->setVisible(protocol == CMS);
     ui.uriGB->setVisible(protocol == CMS);
 
     ui.ecdhCB->setVisible(mECCSupported);
     ui.ecdhKeyCurvesCB->setVisible(mECCSupported);
     ui.ecdsaKeyCurvesCB->setVisible(mECCSupported);
     ui.ecdsaRB->setVisible(mECCSupported);
     if (mEdDSASupported) {
         // We use the same radio button for EdDSA as we use for
         // ECDSA GnuPG does the same and this is really super technical
         // land.
         ui.ecdsaRB->setText(QStringLiteral("ECDSA/EdDSA"));
     }
 
     bool deVsHack = Kleo::gpgComplianceP("de-vs");
 
     if (deVsHack) {
         // GnuPG Provides no API to query which keys are compliant for
         // a mode. If we request a different one it will error out so
         // we have to remove the options.
         //
         // Does anyone want to use NIST anyway?
         int i;
         while ((i = ui.ecdsaKeyCurvesCB->findText(QStringLiteral("NIST"), Qt::MatchStartsWith)) != -1 ||
                (i = ui.ecdsaKeyCurvesCB->findText(QStringLiteral("25519"), Qt::MatchEndsWith)) != -1) {
             ui.ecdsaKeyCurvesCB->removeItem(i);
         }
         while ((i = ui.ecdhKeyCurvesCB->findText(QStringLiteral("NIST"), Qt::MatchStartsWith)) != -1 ||
                (i = ui.ecdhKeyCurvesCB->findText(QStringLiteral("25519"), Qt::MatchEndsWith)) != -1) {
             ui.ecdhKeyCurvesCB->removeItem(i);
         }
     }
     // Technical Details Page
     if (keyTypeImmutable) {
         ui.rsaRB->setEnabled(false);
         ui.rsaSubCB->setEnabled(false);
         ui.dsaRB->setEnabled(false);
         ui.elgCB->setEnabled(false);
         ui.ecdsaRB->setEnabled(false);
         ui.ecdhCB->setEnabled(false);
     } else {
         ui.rsaRB->setEnabled(true);
         ui.rsaSubCB->setEnabled(protocol == OpenPGP);
         ui.dsaRB->setEnabled(protocol == OpenPGP && !deVsHack);
         ui.elgCB->setEnabled(protocol == OpenPGP && !deVsHack);
         ui.ecdsaRB->setEnabled(protocol == OpenPGP);
         ui.ecdhCB->setEnabled(protocol == OpenPGP);
     }
     ui.certificationCB->setVisible(protocol == OpenPGP);   // gpgsm limitation?
     ui.authenticationCB->setVisible(protocol == OpenPGP);
     if (protocol == OpenPGP) {   // pgp keys must have certify capability
         ui.certificationCB->setChecked(true);
         ui.certificationCB->setEnabled(false);
     }
     if (protocol == CMS) {
         ui.encryptionCB->setEnabled(true);
         ui.rsaSubCB->setChecked(false);
         ui.rsaKeyStrengthSubCB->setEnabled(false);
     }
     ui.expiryDE->setVisible(protocol == OpenPGP);
     ui.expiryCB->setVisible(protocol == OpenPGP);
     slotKeyMaterialSelectionChanged();
 }
 
 #include "newcertificatewizard.moc"
diff --git a/src/smartcard/deviceinfowatcher.cpp b/src/smartcard/deviceinfowatcher.cpp
index 21356ae9a..403b9f9ee 100644
--- a/src/smartcard/deviceinfowatcher.cpp
+++ b/src/smartcard/deviceinfowatcher.cpp
@@ -1,131 +1,131 @@
 /*  smartcard/deviceinfowatcher.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "deviceinfowatcher.h"
 #include "deviceinfowatcher_p.h"
 
 #include <QGpgME/Debug>
 
 #include <gpgme++/context.h>
 #include <gpgme++/engineinfo.h>
 #include <gpgme++/statusconsumerassuantransaction.h>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace GpgME;
 
 DeviceInfoWatcher::Worker::~Worker()
 {
     if (mContext) {
         mContext->cancelPendingOperationImmediately();
     }
 }
 
 void DeviceInfoWatcher::Worker::start()
 {
     if (!mContext) {
         Error err;
         mContext = Context::createForEngine(AssuanEngine, &err);
         if (err) {
             qCWarning(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::start: Creating context failed:" << err;
             return;
         }
     }
 
     // try to connect to the agent for at most ~12.8 seconds with increasing delay between retries
     static const int MaxRetryDelay = 100 * 64;
     static const char *command = "SCD DEVINFO --watch";
     std::unique_ptr<AssuanTransaction> t(new StatusConsumerAssuanTransaction(this));
     const Error err = mContext->startAssuanTransaction(command, std::move(t));
     if (!err) {
         qCDebug(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::start: Assuan transaction for" << command << "started";
         QMetaObject::invokeMethod(this, "poll", Qt::QueuedConnection);
         return;
     } else if (err.code() == GPG_ERR_ASS_CONNECT_FAILED) {
         if (mRetryDelay <= MaxRetryDelay) {
             qCInfo(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::start: Connecting to the agent failed. Retrying in" << mRetryDelay << "ms";
             QThread::msleep(mRetryDelay);
             mRetryDelay *= 2;
             QMetaObject::invokeMethod(this, "start", Qt::QueuedConnection);
             return;
         }
         qCWarning(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::start: Connecting to the agent failed too often. Giving up.";
     } else {
         qCWarning(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::start: Starting Assuan transaction for" << command << "failed:" << err;
     }
 }
 
 void DeviceInfoWatcher::Worker::poll()
 {
     const bool finished = mContext->poll();
     if (finished) {
         qCDebug(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::poll: context finished with" << mContext->lastError();
         QMetaObject::invokeMethod(this, "start", Qt::QueuedConnection);
     } else {
         QMetaObject::invokeMethod(this, "poll", Qt::QueuedConnection);
     }
 }
 
 void DeviceInfoWatcher::Worker::status(const char* status, const char* details)
 {
     qCDebug(KLEOPATRA_LOG) << "DeviceInfoWatcher::Worker::status:" << status << details;
     if (status && std::strcmp(status, "DEVINFO_STATUS") == 0) {
         Q_EMIT statusChanged(QByteArray(details));
     }
 }
 
 DeviceInfoWatcher::Private::Private(DeviceInfoWatcher *qq)
     : q(qq)
 {
 }
 
 DeviceInfoWatcher::Private::~Private()
 {
     workerThread.quit();
     workerThread.wait();
 }
 
 void DeviceInfoWatcher::Private::start()
 {
-    DeviceInfoWatcher::Worker *worker = new DeviceInfoWatcher::Worker;
+    auto worker = new DeviceInfoWatcher::Worker;
     worker->moveToThread(&workerThread);
     connect(&workerThread, &QThread::started, worker, &DeviceInfoWatcher::Worker::start);
     connect(&workerThread, &QThread::finished, worker, &QObject::deleteLater);
     connect(worker, &DeviceInfoWatcher::Worker::statusChanged,
             q, &DeviceInfoWatcher::statusChanged);
     workerThread.start();
 }
 
 DeviceInfoWatcher::DeviceInfoWatcher(QObject *parent)
     : QObject(parent)
     , d(new Private(this))
 {
 }
 
 DeviceInfoWatcher::~DeviceInfoWatcher()
 {
     delete d;
 }
 
 // static
 bool DeviceInfoWatcher::isSupported()
 {
 #ifdef Q_OS_WIN
     // "SCD DEVINFO --watch" does not seem to work on Windows; see https://dev.gnupg.org/T5359
     return false;
 #else
     return engineInfo(GpgEngine).engineVersion() >= "2.3.0";
 #endif
 }
 
 void DeviceInfoWatcher::start()
 {
     d->start();
 }
diff --git a/src/smartcard/openpgpcard.cpp b/src/smartcard/openpgpcard.cpp
index 42e83d187..77c214e01 100644
--- a/src/smartcard/openpgpcard.cpp
+++ b/src/smartcard/openpgpcard.cpp
@@ -1,162 +1,162 @@
 /*  smartcard/openpgpcard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 /* Code in this file is partly based on the GNU Privacy Assistant
  * (cm-openpgp.c) git rev. 0a78795146661234070681737b3e08228616441f
  *
  * Whis is:
  * SPDX-FileCopyrightText: 2008, 2009 g 10 Code GmbH
  *
  * And may be licensed under the GNU General Public License
  * as published by the Free Software Foundation; either version 2 of the
  * License, or (at your option) any later version.
  */
 
 #include "openpgpcard.h"
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 // static
 const std::string OpenPGPCard::AppName = "openpgp";
 
 OpenPGPCard::OpenPGPCard(const Card &card)
     : Card(card)
 {
     setAppName(AppName);
     setInitialKeyInfos(OpenPGPCard::supportedKeys());
 }
 
 // static
 std::string OpenPGPCard::pgpSigKeyRef()
 {
     return std::string("OPENPGP.1");
 }
 
 // static
 std::string OpenPGPCard::pgpEncKeyRef()
 {
     return std::string("OPENPGP.2");
 }
 
 // static
 std::string OpenPGPCard::pgpAuthKeyRef()
 {
     return std::string("OPENPGP.3");
 }
 
 // static
 std::string OpenPGPCard::pinKeyRef()
 {
     return std::string("OPENPGP.1");
 }
 
 // static
 std::string OpenPGPCard::adminPinKeyRef()
 {
     return std::string("OPENPGP.3");
 }
 
 // static
 std::string OpenPGPCard::resetCodeKeyRef()
 {
     return std::string("OPENPGP.2");
 }
 
 // static
 const std::vector<KeyPairInfo> & OpenPGPCard::supportedKeys()
 {
     static const std::vector<KeyPairInfo> keyInfos = {
         {OpenPGPCard::pgpSigKeyRef(), "", "sc", "", ""},
         {OpenPGPCard::pgpEncKeyRef(), "", "e", "", ""},
         {OpenPGPCard::pgpAuthKeyRef(), "", "a", "", ""}
     };
 
     return keyInfos;
 }
 
 // static
 QString OpenPGPCard::keyDisplayName(const std::string &keyRef)
 {
     static const QMap<std::string, QString> displayNames = {
         { OpenPGPCard::pgpSigKeyRef(), i18n("Signature") },
         { OpenPGPCard::pgpEncKeyRef(), i18n("Encryption") },
         { OpenPGPCard::pgpAuthKeyRef(), i18n("Authentication") }
     };
 
     return displayNames.value(keyRef);
 }
 
 void OpenPGPCard::setCardInfo(const std::vector< std::pair<std::string, std::string> > &infos)
 {
     qCDebug(KLEOPATRA_LOG) << "Card" << serialNumber().c_str() << "info:";
     for (const auto &pair: infos) {
         qCDebug(KLEOPATRA_LOG) << pair.first.c_str() << ":" << pair.second.c_str();
         if (parseCardInfo(pair.first, pair.second)) {
             continue;
         }
         if (pair.first == "KEY-FPR") {
             const auto values = QString::fromStdString(pair.second).split(QLatin1Char(' '));
             if (values.size() < 2) {
                 qCWarning(KLEOPATRA_LOG) << "Invalid entry.";
                 setStatus(Card::CardError);
                 continue;
             }
             const auto keyNumber = values[0];
             const std::string keyRef = "OPENPGP." + keyNumber.toStdString();
             const auto fpr = values[1].toStdString();
             if (keyNumber == QLatin1Char('1') || keyNumber == QLatin1Char('2') || keyNumber == QLatin1Char('3')) {
                 mMetaInfo.insert("KLEO-FPR-" + keyRef, fpr);
             } else {
                 // Maybe more keyslots in the future?
                 qCDebug(KLEOPATRA_LOG) << "Unhandled keyslot";
             }
         } else {
             mMetaInfo.insert(pair.first, pair.second);
         }
     }
 }
 
 std::string OpenPGPCard::keyFingerprint(const std::string &keyRef) const
 {
     return mMetaInfo.value("KLEO-FPR-" + keyRef);
 }
 
 bool OpenPGPCard::operator == (const Card& rhs) const
 {
-    const OpenPGPCard *other = dynamic_cast<const OpenPGPCard *>(&rhs);
+    const auto other = dynamic_cast<const OpenPGPCard *>(&rhs);
     if (!other) {
         return false;
     }
 
     return Card::operator ==(rhs)
         && mMetaInfo == other->mMetaInfo
         && mManufacturer == other->mManufacturer;
 }
 
 void OpenPGPCard::setManufacturer(const std::string &manufacturer)
 {
     mManufacturer = manufacturer;
 }
 
 std::string OpenPGPCard::manufacturer() const
 {
     return mManufacturer;
 }
 
 std::string OpenPGPCard::pubkeyUrl() const
 {
     return mMetaInfo.value("PUBKEY-URL");
 }
diff --git a/src/smartcard/pivcard.cpp b/src/smartcard/pivcard.cpp
index 7a006eb81..7cceb8def 100644
--- a/src/smartcard/pivcard.cpp
+++ b/src/smartcard/pivcard.cpp
@@ -1,158 +1,158 @@
 /*  smartcard/pivcard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "pivcard.h"
 
 #include "keypairinfo.h"
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 // static
 const std::string PIVCard::AppName = "piv";
 
 PIVCard::PIVCard(const Card &card)
     : Card(card)
 {
     setAppName(AppName);
     setInitialKeyInfos(PIVCard::supportedKeys());
 }
 
 // static
 std::string PIVCard::pivAuthenticationKeyRef()
 {
     return std::string("PIV.9A");
 }
 
 // static
 std::string PIVCard::cardAuthenticationKeyRef()
 {
     return std::string("PIV.9E");
 }
 
 // static
 std::string PIVCard::digitalSignatureKeyRef()
 {
     return std::string("PIV.9C");
 }
 
 // static
 std::string PIVCard::keyManagementKeyRef()
 {
     return std::string("PIV.9D");
 }
 
 // static
 std::string PIVCard::pinKeyRef()
 {
     return std::string("PIV.80");
 }
 
 // static
 std::string PIVCard::pukKeyRef()
 {
     return std::string("PIV.81");
 }
 
 // static
 const std::vector<KeyPairInfo> & PIVCard::supportedKeys()
 {
     static const std::vector<KeyPairInfo> keyInfos = {
         {PIVCard::pivAuthenticationKeyRef(), "", "a", "", ""},
         {PIVCard::cardAuthenticationKeyRef(), "", "a", "", ""},
         {PIVCard::digitalSignatureKeyRef(), "", "sc", "", ""},
         {PIVCard::keyManagementKeyRef(), "", "e", "", ""}
     };
 
     return keyInfos;
 }
 
 // static
 QString PIVCard::keyDisplayName(const std::string &keyRef)
 {
     static const QMap<std::string, QString> displayNames = {
         { PIVCard::pivAuthenticationKeyRef(), i18n("PIV Authentication Key") },
         { PIVCard::cardAuthenticationKeyRef(), i18n("Card Authentication Key") },
         { PIVCard::digitalSignatureKeyRef(), i18n("Digital Signature Key") },
         { PIVCard::keyManagementKeyRef(), i18n("Key Management Key") },
     };
 
     return displayNames.value(keyRef);
 }
 
 // static
 std::vector< std::pair<std::string, QString> > PIVCard::supportedAlgorithms(const std::string &keyRef)
 {
     if (keyRef == PIVCard::keyManagementKeyRef()) {
         return {
             { "rsa2048", i18n("RSA key transport (2048 bits)") },
             { "nistp256", i18n("ECDH (Curve P-256)") },
             { "nistp384", i18n("ECDH (Curve P-384)") }
         };
     } else if (keyRef == PIVCard::digitalSignatureKeyRef()) {
         return {
             { "rsa2048", i18n("RSA (2048 bits)") },
             { "nistp256", i18n("ECDSA (Curve P-256)") },
             { "nistp384", i18n("ECDSA (Curve P-384)") }
         };
     }
 
     // NIST SP 800-78-4 does not allow Curve P-384 for PIV Authentication key or Card Authentication key
     return {
         { "rsa2048", i18n("RSA (2048 bits)") },
         { "nistp256", i18n("ECDSA (Curve P-256)") },
     };
 }
 
 void PIVCard::setCardInfo(const std::vector< std::pair<std::string, std::string> > &infos)
 {
     qCDebug(KLEOPATRA_LOG) << "Card" << serialNumber().c_str() << "info:";
     for (const auto &pair: infos) {
         qCDebug(KLEOPATRA_LOG) << pair.first.c_str() << ":" << pair.second.c_str();
         if (parseCardInfo(pair.first, pair.second)) {
             continue;
         }
         mMetaInfo.insert(pair.first, pair.second);
     }
 }
 
 std::string PIVCard::keyAlgorithm(const std::string &keyRef) const
 {
     return mMetaInfo.value("KLEO-KEYALGO-" + keyRef);
 }
 
 void PIVCard::setKeyAlgorithm(const std::string &keyRef, const std::string &algorithm)
 {
     mMetaInfo.insert("KLEO-KEYALGO-" + keyRef, algorithm);
 }
 
 std::string PIVCard::certificateData(const std::string &keyRef) const
 {
     return mMetaInfo.value("KLEO-CERTIFICATE-" + keyRef);
 }
 
 void PIVCard::setCertificateData(const std::string &keyRef, const std::string &data)
 {
     mMetaInfo.insert("KLEO-CERTIFICATE-" + keyRef, data);
 }
 
 bool PIVCard::operator == (const Card& rhs) const
 {
-    const PIVCard *other = dynamic_cast<const PIVCard *>(&rhs);
+    const auto other = dynamic_cast<const PIVCard *>(&rhs);
     if (!other) {
         return false;
     }
 
     return Card::operator ==(rhs)
         && mMetaInfo == other->mMetaInfo;
 }
diff --git a/src/smartcard/readerstatus.cpp b/src/smartcard/readerstatus.cpp
index 744e20a76..9c3fda26b 100644
--- a/src/smartcard/readerstatus.cpp
+++ b/src/smartcard/readerstatus.cpp
@@ -1,1152 +1,1153 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     smartcard/readerstatus.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E01 // 1.14.1
 # define QGPGME_HAS_DEBUG
 # define GPGME_SUPPORTS_API_FOR_DEVICEINFOWATCHER
 #endif
 
 #include "readerstatus.h"
 
 #ifdef GPGME_SUPPORTS_API_FOR_DEVICEINFOWATCHER
 # include "deviceinfowatcher.h"
 #endif
 #include "keypairinfo.h"
 
 #include <Libkleo/GnuPG>
 
 #include <Libkleo/FileSystemWatcher>
 #include <Libkleo/Stl_Util>
 
 #ifdef QGPGME_HAS_DEBUG
 # include <QGpgME/Debug>
 #endif
 
 #include <gpgme++/context.h>
 #include <gpgme++/defaultassuantransaction.h>
 #include <gpgme++/key.h>
 
 #include <gpg-error.h>
 
 #include "openpgpcard.h"
 #include "netkeycard.h"
 #include "pivcard.h"
 #include "p15card.h"
 
 #include <QStringList>
 #include <QMutex>
 #include <QWaitCondition>
 #include <QThread>
 #include <QPointer>
 #include <QRegularExpression>
 
-#include <set>
-#include <list>
 #include <algorithm>
+#include <cstdlib>
 #include <iterator>
+#include <list>
+#include <memory>
+#include <set>
 #include <utility>
-#include <cstdlib>
 
 #include "utils/kdtoolsglobal.h"
 
 #include "kleopatra_debug.h"
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 using namespace GpgME;
 
 static ReaderStatus *self = nullptr;
 
 #define xtoi_1(p)   (*(p) <= '9'? (*(p)- '0'): \
                      *(p) <= 'F'? (*(p)-'A'+10):(*(p)-'a'+10))
 #define xtoi_2(p)   ((xtoi_1(p) * 16) + xtoi_1((p)+1))
 
 static const char *flags[] = {
     "NOCARD",
     "PRESENT",
     "ACTIVE",
     "USABLE",
 };
 static_assert(sizeof flags / sizeof * flags == Card::_NumScdStates, "");
 
 static const char *prettyFlags[] = {
     "NoCard",
     "CardPresent",
     "CardActive",
     "CardUsable",
     "CardError",
 };
 static_assert(sizeof prettyFlags / sizeof * prettyFlags == Card::NumStates, "");
 
 Q_DECLARE_METATYPE(GpgME::Error)
 
 namespace
 {
 static bool gpgHasMultiCardMultiAppSupport()
 {
     return !(engineInfo(GpgME::GpgEngine).engineVersion() < "2.3.0");
 }
 
 static QDebug operator<<(QDebug s, const std::string &string)
 {
     return s << QString::fromStdString(string);
 }
 
 #ifndef QGPGME_HAS_DEBUG
 static QDebug operator<<(QDebug s, const GpgME::Error &err)
 {
     const bool oldSetting = s.autoInsertSpaces();
     s.nospace() << err.asString() << " (code: " << err.code() << ", source: " << err.source() << ")";
     s.setAutoInsertSpaces(oldSetting);
     return s.maybeSpace();
 }
 #endif
 
 static QDebug operator<<(QDebug s, const std::vector< std::pair<std::string, std::string> > &v)
 {
-    typedef std::pair<std::string, std::string> pair;
+    using pair = std::pair<std::string, std::string>;
     s << '(';
     for (const pair &p : v) {
         s << "status(" << QString::fromStdString(p.first) << ") =" << QString::fromStdString(p.second) << '\n';
     }
     return s << ')';
 }
 
 struct CardApp {
     std::string serialNumber;
     std::string appName;
 };
 
 static void logUnexpectedStatusLine(const std::pair<std::string, std::string> &line,
                                     const std::string &prefix = std::string(),
                                     const std::string &command = std::string())
 {
     qCWarning(KLEOPATRA_LOG) << (!prefix.empty() ? QString::fromStdString(prefix + ": ") : QString())
             << "Unexpected status line"
             << (!command.empty() ? QString::fromStdString(" on " + command + ":") : QLatin1String(":"))
             << QString::fromStdString(line.first)
             << QString::fromStdString(line.second);
 }
 
 static int parse_app_version(const std::string &s)
 {
     return std::atoi(s.c_str());
 }
 
 static Card::PinState parse_pin_state(const QString &s)
 {
     bool ok;
     int i = s.toInt(&ok);
     if (!ok) {
         qCDebug(KLEOPATRA_LOG) << "Failed to parse pin state" << s;
         return Card::UnknownPinState;
     }
     switch (i) {
     case -4: return Card::NullPin;
     case -3: return Card::PinBlocked;
     case -2: return Card::NoPin;
     case -1: return Card::UnknownPinState;
     default:
         if (i < 0) {
             return Card::UnknownPinState;
         } else {
             return Card::PinOk;
         }
     }
 }
 
 template<typename T>
 static std::unique_ptr<T> gpgagent_transact(std::shared_ptr<Context> &gpgAgent, const char *command, std::unique_ptr<T> transaction, Error &err)
 {
     qCDebug(KLEOPATRA_LOG) << "gpgagent_transact(" << command << ")";
     err = gpgAgent->assuanTransact(command, std::move(transaction));
     if (err.code()) {
         qCDebug(KLEOPATRA_LOG) << "gpgagent_transact(" << command << "): Error:" << err;
         if (err.code() >= GPG_ERR_ASS_GENERAL && err.code() <= GPG_ERR_ASS_UNKNOWN_INQUIRE) {
             qCDebug(KLEOPATRA_LOG) << "Assuan problem, killing context";
             gpgAgent.reset();
         }
         return std::unique_ptr<T>();
     }
     std::unique_ptr<AssuanTransaction> t = gpgAgent->takeLastAssuanTransaction();
     return std::unique_ptr<T>(dynamic_cast<T*>(t.release()));
 }
 
 static std::unique_ptr<DefaultAssuanTransaction> gpgagent_default_transact(std::shared_ptr<Context> &gpgAgent, const char *command, Error &err)
 {
-    return gpgagent_transact(gpgAgent, command, std::unique_ptr<DefaultAssuanTransaction>(new DefaultAssuanTransaction), err);
+    return gpgagent_transact(gpgAgent, command, std::make_unique<DefaultAssuanTransaction>(), err);
 }
 
 static const std::string gpgagent_data(std::shared_ptr<Context> gpgAgent, const char *command, Error &err)
 {
     const std::unique_ptr<DefaultAssuanTransaction> t = gpgagent_default_transact(gpgAgent, command, err);
     if (t.get()) {
         qCDebug(KLEOPATRA_LOG) << "gpgagent_data(" << command << "): got" << QString::fromStdString(t->data());
         return t->data();
     } else {
         qCDebug(KLEOPATRA_LOG) << "gpgagent_data(" << command << "): t == NULL";
         return std::string();
     }
 }
 
 static const std::vector< std::pair<std::string, std::string> > gpgagent_statuslines(std::shared_ptr<Context> gpgAgent, const char *what, Error &err)
 {
     const std::unique_ptr<DefaultAssuanTransaction> t = gpgagent_default_transact(gpgAgent, what, err);
     if (t.get()) {
         qCDebug(KLEOPATRA_LOG) << "agent_getattr_status(" << what << "): got" << t->statusLines();
         return t->statusLines();
     } else {
         qCDebug(KLEOPATRA_LOG) << "agent_getattr_status(" << what << "): t == NULL";
         return std::vector<std::pair<std::string, std::string> >();
     }
 }
 
 static const std::string gpgagent_status(const std::shared_ptr<Context> &gpgAgent, const char *what, Error &err)
 {
     const auto lines = gpgagent_statuslines (gpgAgent, what, err);
     // The status is only the last attribute
     // e.g. for SCD SERIALNO it would only be "SERIALNO" and for SCD GETATTR FOO
     // it would only be FOO
     const char *p = strrchr(what, ' ');
     const char *needle = (p + 1) ? (p + 1) : what;
     for (const auto &pair: lines) {
         if (pair.first == needle) {
             return pair.second;
         }
     }
     return std::string();
 }
 
 static const std::string scd_getattr_status(std::shared_ptr<Context> &gpgAgent, const char *what, Error &err)
 {
     std::string cmd = "SCD GETATTR ";
     cmd += what;
     return gpgagent_status(gpgAgent, cmd.c_str(), err);
 }
 
 static const std::string getAttribute(std::shared_ptr<Context> &gpgAgent, const char *attribute, const char *versionHint)
 {
     Error err;
     const auto result = scd_getattr_status(gpgAgent, attribute, err);
     if (err) {
         if (err.code() == GPG_ERR_INV_NAME) {
             qCDebug(KLEOPATRA_LOG) << "Querying for attribute" << attribute << "not yet supported; needs GnuPG" << versionHint;
         } else {
             qCWarning(KLEOPATRA_LOG) << "Running SCD GETATTR " << attribute << " failed:" << err;
         }
         return std::string();
     }
     return result;
 }
 
 static std::vector<CardApp> getCardsAndApps(std::shared_ptr<Context> &gpgAgent, Error &err)
 {
     std::vector<CardApp> result;
     if (gpgHasMultiCardMultiAppSupport()) {
         const std::string command = "SCD GETINFO all_active_apps";
         const auto statusLines = gpgagent_statuslines(gpgAgent, command.c_str(), err);
         if (err) {
             return result;
         }
         for (const auto &statusLine: statusLines) {
             if (statusLine.first == "SERIALNO") {
                 const auto serialNumberAndApps = QByteArray::fromStdString(statusLine.second).split(' ');
                 if (serialNumberAndApps.size() >= 2) {
                     const auto serialNumber = serialNumberAndApps[0];
                     auto apps = serialNumberAndApps.mid(1);
                     // sort the apps to get a stable order independently of the currently selected application
                     std::sort(apps.begin(), apps.end());
                     for (const auto &app: apps) {
                         qCDebug(KLEOPATRA_LOG) << "getCardsAndApps(): Found card" << serialNumber << "with app" << app;
                         result.push_back({ serialNumber.toStdString(), app.toStdString() });
                     }
                 } else {
                     logUnexpectedStatusLine(statusLine, "getCardsAndApps()", command);
                 }
             } else {
                 logUnexpectedStatusLine(statusLine, "getCardsAndApps()", command);
             }
         }
     } else {
         // use SCD SERIALNO to get the currently active card
         const auto serialNumber = gpgagent_status(gpgAgent, "SCD SERIALNO", err);
         if (err) {
             return result;
         }
         // use SCD GETATTR APPTYPE to find out which app is active
         auto appName = scd_getattr_status(gpgAgent, "APPTYPE", err);
         std::transform(appName.begin(), appName.end(), appName.begin(),
                        [](unsigned char c){ return std::tolower(c); });
         if (err) {
             return result;
         }
         result.push_back({ serialNumber, appName });
     }
     return result;
 }
 
 static std::string switchCard(std::shared_ptr<Context> &gpgAgent, const std::string &serialNumber, Error &err)
 {
     const std::string command = "SCD SWITCHCARD " + serialNumber;
     const auto statusLines = gpgagent_statuslines(gpgAgent, command.c_str(), err);
     if (err) {
         return std::string();
     }
     if (statusLines.size() == 1 && statusLines[0].first == "SERIALNO" && statusLines[0].second == serialNumber) {
         return serialNumber;
     }
     qCWarning(KLEOPATRA_LOG) << "switchCard():" << command << "returned" << statusLines
             << "(expected:" << "SERIALNO " + serialNumber << ")";
     return std::string();
 }
 
 static std::string switchApp(std::shared_ptr<Context> &gpgAgent, const std::string &serialNumber,
                              const std::string &appName, Error &err)
 {
     const std::string command = "SCD SWITCHAPP " + appName;
     const auto statusLines = gpgagent_statuslines(gpgAgent, command.c_str(), err);
     if (err) {
         return std::string();
     }
     if (statusLines.size() == 1 && statusLines[0].first == "SERIALNO" &&
         statusLines[0].second.find(serialNumber + ' ' + appName) == 0) {
         return appName;
     }
     qCWarning(KLEOPATRA_LOG) << "switchApp():" << command << "returned" << statusLines
             << "(expected:" << "SERIALNO " + serialNumber + ' ' + appName + "..." << ")";
     return std::string();
 }
 
 static const char * get_openpgp_card_manufacturer_from_serial_number(const std::string &serialno)
 {
     qCDebug(KLEOPATRA_LOG) << "get_openpgp_card_manufacturer_from_serial_number(" << serialno.c_str() << ")";
 
     const bool isProperOpenPGPCardSerialNumber =
         serialno.size() == 32 && serialno.substr(0, 12) == "D27600012401";
     if (isProperOpenPGPCardSerialNumber) {
         const char *sn = serialno.c_str();
         const int manufacturerId = xtoi_2(sn + 16)*256 + xtoi_2(sn + 18);
         switch (manufacturerId) {
             case 0x0001: return "PPC Card Systems";
             case 0x0002: return "Prism";
             case 0x0003: return "OpenFortress";
             case 0x0004: return "Wewid";
             case 0x0005: return "ZeitControl";
             case 0x0006: return "Yubico";
             case 0x0007: return "OpenKMS";
             case 0x0008: return "LogoEmail";
 
             case 0x002A: return "Magrathea";
 
             case 0x1337: return "Warsaw Hackerspace";
 
             case 0xF517: return "FSIJ";
 
             /* 0x0000 and 0xFFFF are defined as test cards per spec,
                0xFF00 to 0xFFFE are assigned for use with randomly created
                serial numbers.  */
             case 0x0000:
             case 0xffff: return "test card";
             default: return (manufacturerId & 0xff00) == 0xff00 ? "unmanaged S/N range" : "unknown";
         }
     } else {
         return "unknown";
     }
 }
 
 static const std::string get_manufacturer(std::shared_ptr<Context> &gpgAgent, Error &err)
 {
     // The result of SCD GETATTR MANUFACTURER is the manufacturer ID as unsigned number
     // optionally followed by the name of the manufacturer, e.g.
     // 6 Yubico
     // 65534 unmanaged S/N range
     const auto manufacturerIdAndName = scd_getattr_status(gpgAgent, "MANUFACTURER", err);
     if (err.code()) {
         if (err.code() == GPG_ERR_INV_NAME) {
             qCDebug(KLEOPATRA_LOG) << "get_manufacturer(): Querying for attribute MANUFACTURER not yet supported; needs GnuPG 2.2.21+";
         } else {
             qCWarning(KLEOPATRA_LOG) << "Running SCD GETATTR MANUFACTURER failed:" << err;
         }
         return std::string();
     }
     const auto startOfManufacturerName = manufacturerIdAndName.find(' ');
     if (startOfManufacturerName == std::string::npos) {
         // only ID without manufacturer name
         return "unknown";
     }
     const auto manufacturerName = manufacturerIdAndName.substr(startOfManufacturerName + 1);
     return manufacturerName;
 }
 
 static bool isOpenPGPCardSerialNumber(const std::string &serialNumber)
 {
     return serialNumber.size() == 32 && serialNumber.substr(0, 12) == "D27600012401";
 }
 
 static const std::string getDisplaySerialNumber(std::shared_ptr<Context> &gpgAgent, Error &err)
 {
     const auto displaySerialNumber = scd_getattr_status(gpgAgent, "$DISPSERIALNO", err);
     if (err && err.code() != GPG_ERR_INV_NAME) {
         qCWarning(KLEOPATRA_LOG) << "Running SCD GETATTR $DISPSERIALNO failed:" << err;
     }
     return displaySerialNumber;
 }
 
 static void setDisplaySerialNumber(Card *card, std::shared_ptr<Context> &gpgAgent)
 {
     static const QRegularExpression leadingZeros(QStringLiteral("^0*"));
 
     Error err;
     const QString displaySerialNumber = QString::fromStdString(getDisplaySerialNumber(gpgAgent, err));
     if (err) {
         card->setDisplaySerialNumber(QString::fromStdString(card->serialNumber()));
         return;
     }
     if (isOpenPGPCardSerialNumber(card->serialNumber()) && displaySerialNumber.size() == 12) {
         // add a space between manufacturer id and card id for OpenPGP cards
         card->setDisplaySerialNumber(displaySerialNumber.left(4) + QLatin1Char(' ') + displaySerialNumber.right(8));
     } else {
         card->setDisplaySerialNumber(displaySerialNumber);
     }
     return;
 }
 
 static void handle_openpgp_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto pgpCard = new OpenPGPCard(*ci);
 
     pgpCard->setManufacturer(get_manufacturer(gpg_agent, err));
     if (err.code()) {
         // fallback, e.g. if gpg does not yet support querying for the MANUFACTURER attribute
         pgpCard->setManufacturer(get_openpgp_card_manufacturer_from_serial_number(ci->serialNumber()));
     }
 
     const auto info = gpgagent_statuslines(gpg_agent, "SCD LEARN --force", err);
     if (err.code()) {
         ci->setStatus(Card::CardError);
         return;
     }
     pgpCard->setCardInfo(info);
 
     setDisplaySerialNumber(pgpCard, gpg_agent);
 
     ci.reset(pgpCard);
 }
 
 static void readKeyPairInfoFromPIVCard(const std::string &keyRef, PIVCard *pivCard, const std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     const std::string command = std::string("SCD READKEY --info-only -- ") + keyRef;
     const auto keyPairInfoLines = gpgagent_statuslines(gpg_agent, command.c_str(), err);
     if (err) {
         qCWarning(KLEOPATRA_LOG) << "Running" << command << "failed:" << err;
         return;
     }
     for (const auto &pair: keyPairInfoLines) {
         if (pair.first == "KEYPAIRINFO") {
             const KeyPairInfo info = KeyPairInfo::fromStatusLine(pair.second);
             if (info.grip.empty()) {
                 qCWarning(KLEOPATRA_LOG) << "Invalid KEYPAIRINFO status line"
                         << QString::fromStdString(pair.second);
                 continue;
             }
             pivCard->setKeyAlgorithm(keyRef, info.algorithm);
         } else {
             logUnexpectedStatusLine(pair, "readKeyPairInfoFromPIVCard()", command);
         }
     }
 }
 
 static void readCertificateFromPIVCard(const std::string &keyRef, PIVCard *pivCard, const std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     const std::string command = std::string("SCD READCERT ") + keyRef;
     const std::string certificateData = gpgagent_data(gpg_agent, command.c_str(), err);
     if (err && err.code() != GPG_ERR_NOT_FOUND) {
         qCWarning(KLEOPATRA_LOG) << "Running" << command << "failed:" << err;
         return;
     }
     if (certificateData.empty()) {
         qCDebug(KLEOPATRA_LOG) << "readCertificateFromPIVCard(" << QString::fromStdString(keyRef) << "): No certificate stored on card";
         return;
     }
     qCDebug(KLEOPATRA_LOG) << "readCertificateFromPIVCard(" << QString::fromStdString(keyRef) << "): Found certificate stored on card";
     pivCard->setCertificateData(keyRef, certificateData);
 }
 
 static void handle_piv_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto pivCard = new PIVCard(*ci);
 
     const auto info = gpgagent_statuslines(gpg_agent, "SCD LEARN --force", err);
     if (err) {
         ci->setStatus(Card::CardError);
         return;
     }
     pivCard->setCardInfo(info);
 
     setDisplaySerialNumber(pivCard, gpg_agent);
 
     for (const KeyPairInfo &keyInfo : pivCard->keyInfos()) {
         if (!keyInfo.grip.empty()) {
             readKeyPairInfoFromPIVCard(keyInfo.keyRef, pivCard, gpg_agent);
             readCertificateFromPIVCard(keyInfo.keyRef, pivCard, gpg_agent);
         }
     }
 
     ci.reset(pivCard);
 }
 
 static void handle_p15_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto p15Card = new P15Card(*ci);
 
     auto info = gpgagent_statuslines(gpg_agent, "SCD LEARN --force", err);
     if (err) {
         ci->setStatus(Card::CardError);
         return;
     }
     const auto fprs = gpgagent_statuslines(gpg_agent, "SCD GETATTR KEY-FPR", err);
     if (!err) {
         info.insert(info.end(), fprs.begin(), fprs.end());
     }
 
     /* Create the key stubs */
     gpgagent_statuslines(gpg_agent, "READKEY --card -- $SIGNKEYID", err);
 
     p15Card->setCardInfo(info);
     p15Card->setManufacturer(get_manufacturer(gpg_agent, err));
 
     setDisplaySerialNumber(p15Card, gpg_agent);
 
     ci.reset(p15Card);
 }
 
 static void handle_netkey_card(std::shared_ptr<Card> &ci, std::shared_ptr<Context> &gpg_agent)
 {
     Error err;
     auto nkCard = new NetKeyCard(*ci);
     ci.reset(nkCard);
 
     ci->setAppVersion(parse_app_version(scd_getattr_status(gpg_agent, "NKS-VERSION", err)));
 
     if (err.code()) {
         qCWarning(KLEOPATRA_LOG) << "Running SCD GETATTR NKS-VERSION failed:" << err;
         ci->setErrorMsg(QStringLiteral ("NKS-VERSION failed: ") + QString::fromUtf8(err.asString()));
         return;
     }
 
     if (ci->appVersion() != 3) {
         qCDebug(KLEOPATRA_LOG) << "not a NetKey v3 card, giving up. Version:" << ci->appVersion();
         ci->setErrorMsg(QStringLiteral("NetKey v%1 cards are not supported.").arg(ci->appVersion()));
         return;
     }
 
     setDisplaySerialNumber(nkCard, gpg_agent);
 
     // the following only works for NKS v3...
     const auto chvStatus = QString::fromStdString(
             scd_getattr_status(gpg_agent, "CHV-STATUS", err)).split(QLatin1Char(' '));
     if (err.code()) {
         qCDebug(KLEOPATRA_LOG) << "Running SCD GETATTR CHV-STATUS failed:" << err;
         ci->setErrorMsg(QStringLiteral ("CHV-Status failed: ") + QString::fromUtf8(err.asString()));
         return;
     }
 
     std::vector<Card::PinState> states;
     states.reserve(chvStatus.count());
     // CHV Status for NKS v3 is
     // Pin1 (Normal pin) Pin2 (Normal PUK)
     // SigG1 SigG PUK.
     int num = 0;
     for (const auto &state: chvStatus) {
         const auto parsed = parse_pin_state (state);
         states.push_back(parsed);
         if (parsed == Card::NullPin) {
             if (num == 0) {
                 ci->setHasNullPin(true);
             }
         }
         ++num;
     }
     nkCard->setPinStates(states);
 
     const auto info = gpgagent_statuslines(gpg_agent, "SCD LEARN --force", err);
     if (err) {
         ci->setStatus(Card::CardError);
         return;
     }
     nkCard->setCardInfo(info);
 }
 
 static std::shared_ptr<Card> get_card_status(const std::string &serialNumber, const std::string &appName, std::shared_ptr<Context> &gpg_agent)
 {
     qCDebug(KLEOPATRA_LOG) << "get_card_status(" << serialNumber << ',' << appName << ',' << gpg_agent.get() << ')';
     auto ci = std::shared_ptr<Card>(new Card());
 
     if (gpgHasMultiCardMultiAppSupport()) {
         // select card
         Error err;
         const auto result = switchCard(gpg_agent, serialNumber, err);
         if (err) {
             if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
                 ci->setStatus(Card::NoCard);
             } else {
                 ci->setStatus(Card::CardError);
             }
             return ci;
         }
         if (result.empty()) {
             qCWarning(KLEOPATRA_LOG) << "get_card_status: switching card failed";
             ci->setStatus(Card::CardError);
             return ci;
         }
         ci->setStatus(Card::CardPresent);
     } else {
         ci->setStatus(Card::CardPresent);
     }
 
     if (gpgHasMultiCardMultiAppSupport()) {
         // select app
         Error err;
         const auto result = switchApp(gpg_agent, serialNumber, appName, err);
         if (err) {
             if (err.code() == GPG_ERR_CARD_NOT_PRESENT || err.code() == GPG_ERR_CARD_REMOVED) {
                 ci->setStatus(Card::NoCard);
             } else {
                 ci->setStatus(Card::CardError);
             }
             return ci;
         }
         if (result.empty()) {
             qCWarning(KLEOPATRA_LOG) << "get_card_status: switching app failed";
             ci->setStatus(Card::CardError);
             return ci;
         }
     }
 
     ci->setSerialNumber(serialNumber);
 
     ci->setSigningKeyRef(getAttribute(gpg_agent, "$SIGNKEYID", "2.2.18"));
     ci->setEncryptionKeyRef(getAttribute(gpg_agent, "$ENCRKEYID", "2.2.18"));
 
     // Handle different card types
     if (appName == NetKeyCard::AppName) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found Netkey card" << ci->serialNumber().c_str() << "end";
         handle_netkey_card(ci, gpg_agent);
         return ci;
     } else if (appName == OpenPGPCard::AppName) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found OpenPGP card" << ci->serialNumber().c_str() << "end";
         handle_openpgp_card(ci, gpg_agent);
         return ci;
     } else if (appName == PIVCard::AppName) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found PIV card" << ci->serialNumber().c_str() << "end";
         handle_piv_card(ci, gpg_agent);
         return ci;
     } else if (appName == P15Card::AppName) {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: found P15 card" << ci->serialNumber().c_str() << "end";
         handle_p15_card(ci, gpg_agent);
         return ci;
     } else {
         qCDebug(KLEOPATRA_LOG) << "get_card_status: unhandled application:" << appName;
         return ci;
     }
 
     return ci;
 }
 
 static bool isCardNotPresentError(const GpgME::Error &err)
 {
     // see fixup_scd_errors() in gpg-card.c
     return err && ((err.code() == GPG_ERR_CARD_NOT_PRESENT) ||
                    ((err.code() == GPG_ERR_ENODEV || err.code() == GPG_ERR_CARD_REMOVED) &&
                     (err.sourceID() == GPG_ERR_SOURCE_SCD)));
 }
 
 static std::vector<std::shared_ptr<Card> > update_cardinfo(std::shared_ptr<Context> &gpgAgent)
 {
     qCDebug(KLEOPATRA_LOG) << "update_cardinfo()";
 
     // ensure that a card is present and that all cards are properly set up
     {
         Error err;
         const char *command = (gpgHasMultiCardMultiAppSupport()) ? "SCD SERIALNO --all" : "SCD SERIALNO";
         const std::string serialno = gpgagent_status(gpgAgent, command, err);
         if (err) {
             if (isCardNotPresentError(err)) {
                 qCDebug(KLEOPATRA_LOG) << "update_cardinfo: No card present";
                 return std::vector<std::shared_ptr<Card> >();
             } else {
                 qCWarning(KLEOPATRA_LOG) << "Running" << command << "failed:" << err;
                 auto ci = std::shared_ptr<Card>(new Card());
                 ci->setStatus(Card::CardError);
                 return std::vector<std::shared_ptr<Card> >(1, ci);
             }
         }
     }
 
     Error err;
     const std::vector<CardApp> cardApps = getCardsAndApps(gpgAgent, err);
     if (err) {
         if (isCardNotPresentError(err)) {
             qCDebug(KLEOPATRA_LOG) << "update_cardinfo: No card present";
             return std::vector<std::shared_ptr<Card> >();
         } else {
             qCWarning(KLEOPATRA_LOG) << "Getting active apps on all inserted cards failed:" << err;
             auto ci = std::shared_ptr<Card>(new Card());
             ci->setStatus(Card::CardError);
             return std::vector<std::shared_ptr<Card> >(1, ci);
         }
     }
 
     std::vector<std::shared_ptr<Card> > cards;
     for (const auto &cardApp: cardApps) {
         const auto card = get_card_status(cardApp.serialNumber, cardApp.appName, gpgAgent);
         cards.push_back(card);
     }
     return cards;
 }
 } // namespace
 
 struct Transaction {
     CardApp cardApp;
     QByteArray command;
     QPointer<QObject> receiver;
     const char *slot;
     AssuanTransaction* assuanTransaction;
 };
 
 static const Transaction updateTransaction = { { "__all__", "__all__" }, "__update__", nullptr, nullptr, nullptr };
 static const Transaction quitTransaction   = { { "__all__", "__all__" }, "__quit__",   nullptr, nullptr, nullptr };
 
 namespace
 {
 class ReaderStatusThread : public QThread
 {
     Q_OBJECT
 public:
     explicit ReaderStatusThread(QObject *parent = nullptr)
         : QThread(parent),
           m_gnupgHomePath(Kleo::gnupgHomeDirectory()),
           m_transactions(1, updateTransaction)   // force initial scan
     {
         connect(this, &ReaderStatusThread::oneTransactionFinished,
                 this, &ReaderStatusThread::slotOneTransactionFinished);
     }
 
     std::vector<std::shared_ptr<Card> > cardInfos() const
     {
         const QMutexLocker locker(&m_mutex);
         return m_cardInfos;
     }
 
     Card::Status cardStatus(unsigned int slot) const
     {
         const QMutexLocker locker(&m_mutex);
         if (slot < m_cardInfos.size()) {
             return m_cardInfos[slot]->status();
         } else {
             return Card::NoCard;
         }
     }
 
     void addTransaction(const Transaction &t)
     {
         const QMutexLocker locker(&m_mutex);
         m_transactions.push_back(t);
         m_waitForTransactions.wakeOne();
     }
 
 Q_SIGNALS:
     void firstCardWithNullPinChanged(const std::string &serialNumber);
     void anyCardCanLearnKeysChanged(bool);
     void cardAdded(const std::string &serialNumber, const std::string &appName);
     void cardChanged(const std::string &serialNumber, const std::string &appName);
     void cardRemoved(const std::string &serialNumber, const std::string &appName);
     void oneTransactionFinished(const GpgME::Error &err);
 
 public Q_SLOTS:
     void deviceStatusChanged(const QByteArray &details)
     {
         qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[GUI]::deviceStatusChanged(" << details << ")";
         addTransaction(updateTransaction);
     }
 
     void ping()
     {
         qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[GUI]::ping()";
         addTransaction(updateTransaction);
     }
 
     void stop()
     {
         const QMutexLocker locker(&m_mutex);
         m_transactions.push_front(quitTransaction);
         m_waitForTransactions.wakeOne();
     }
 
 private Q_SLOTS:
     void slotOneTransactionFinished(const GpgME::Error &err)
     {
         std::list<Transaction> ft;
         KDAB_SYNCHRONIZED(m_mutex)
         ft.splice(ft.begin(), m_finishedTransactions);
         for (const Transaction &t : qAsConst(ft))
             if (t.receiver && t.slot && *t.slot) {
                 QMetaObject::invokeMethod(t.receiver, t.slot, Qt::DirectConnection, Q_ARG(GpgME::Error, err));
             }
     }
 
 private:
     void run() override {
         while (true) {
             std::shared_ptr<Context> gpgAgent;
 
             CardApp cardApp;
             QByteArray command;
             bool nullSlot = false;
             AssuanTransaction* assuanTransaction = nullptr;
             std::list<Transaction> item;
             std::vector<std::shared_ptr<Card> > oldCards;
 
             Error err;
             std::unique_ptr<Context> c = Context::createForEngine(AssuanEngine, &err);
             if (err.code() == GPG_ERR_NOT_SUPPORTED) {
                 return;
             }
             gpgAgent = std::shared_ptr<Context>(c.release());
 
             KDAB_SYNCHRONIZED(m_mutex) {
 
                 while (m_transactions.empty()) {
                     // go to sleep waiting for more work:
                     qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[2nd]: waiting for commands";
                     m_waitForTransactions.wait(&m_mutex);
                 }
 
                 // splice off the first transaction without
                 // copying, so we own it without really importing
                 // it into this thread (the QPointer isn't
                 // thread-safe):
                 item.splice(item.end(),
                             m_transactions, m_transactions.begin());
 
                 // make local copies of the interesting stuff so
                 // we can release the mutex again:
                 cardApp = item.front().cardApp;
                 command = item.front().command;
                 nullSlot = !item.front().slot;
                 // we take ownership of the assuan transaction
                 std::swap(assuanTransaction, item.front().assuanTransaction);
                 oldCards = m_cardInfos;
             }
 
             qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread[2nd]: new iteration command=" << command << " ; nullSlot=" << nullSlot;
             // now, let's see what we got:
             if (nullSlot && command == quitTransaction.command) {
                 return;    // quit
             }
 
             if ((nullSlot && command == updateTransaction.command)) {
 
                 std::vector<std::shared_ptr<Card> > newCards = update_cardinfo(gpgAgent);
 
                 KDAB_SYNCHRONIZED(m_mutex)
                 m_cardInfos = newCards;
 
                 bool anyLC = false;
                 std::string firstCardWithNullPin;
                 bool anyError = false;
                 for (const auto &newCard: newCards) {
                     const auto serialNumber = newCard->serialNumber();
                     const auto appName = newCard->appName();
                     const auto matchingOldCard = std::find_if(oldCards.cbegin(), oldCards.cend(),
                         [serialNumber, appName] (const std::shared_ptr<Card> &card) {
                             return card->serialNumber() == serialNumber && card->appName() == appName;
                         });
                     if (matchingOldCard == oldCards.cend()) {
                         qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread: Card" << serialNumber << "with app" << appName << "was added";
                         Q_EMIT cardAdded(serialNumber, appName);
                     } else {
                         if (*newCard != **matchingOldCard) {
                             qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread: Card" << serialNumber << "with app" << appName << "changed";
                             Q_EMIT cardChanged(serialNumber, appName);
                         }
                         oldCards.erase(matchingOldCard);
                     }
                     if (newCard->canLearnKeys()) {
                         anyLC = true;
                     }
                     if (newCard->hasNullPin() && firstCardWithNullPin.empty()) {
                         firstCardWithNullPin = newCard->serialNumber();
                     }
                     if (newCard->status() == Card::CardError) {
                         anyError = true;
                     }
                 }
                 for (const auto &oldCard: oldCards) {
                     qCDebug(KLEOPATRA_LOG) << "ReaderStatusThread: Card" << oldCard->serialNumber() << "with app" << oldCard->appName() << "was removed";
                     Q_EMIT cardRemoved(oldCard->serialNumber(), oldCard->appName());
                 }
 
                 Q_EMIT firstCardWithNullPinChanged(firstCardWithNullPin);
                 Q_EMIT anyCardCanLearnKeysChanged(anyLC);
 
                 if (anyError) {
                     gpgAgent.reset();
                 }
             } else {
                 GpgME::Error err;
                 if (gpgHasMultiCardMultiAppSupport()) {
                     switchCard(gpgAgent, cardApp.serialNumber, err);
                     if (!err) {
                         switchApp(gpgAgent, cardApp.serialNumber, cardApp.appName, err);
                     }
                 }
                 if (!err) {
                     if (assuanTransaction) {
                         (void)gpgagent_transact(gpgAgent, command.constData(), std::unique_ptr<AssuanTransaction>(assuanTransaction), err);
                     } else {
                         (void)gpgagent_default_transact(gpgAgent, command.constData(), err);
                     }
                 }
 
                 KDAB_SYNCHRONIZED(m_mutex)
                 // splice 'item' into m_finishedTransactions:
                 m_finishedTransactions.splice(m_finishedTransactions.end(), item);
 
                 Q_EMIT oneTransactionFinished(err);
             }
         }
     }
 
 private:
     mutable QMutex m_mutex;
     QWaitCondition m_waitForTransactions;
     const QString m_gnupgHomePath;
     // protected by m_mutex:
     std::vector<std::shared_ptr<Card> > m_cardInfos;
     std::list<Transaction> m_transactions, m_finishedTransactions;
 };
 
 }
 
 class ReaderStatus::Private : ReaderStatusThread
 {
     friend class Kleo::SmartCard::ReaderStatus;
     ReaderStatus *const q;
 public:
     explicit Private(ReaderStatus *qq)
         : ReaderStatusThread(qq),
           q(qq),
           watcher()
     {
         KDAB_SET_OBJECT_NAME(watcher);
 
         qRegisterMetaType<Card::Status>("Kleo::SmartCard::Card::Status");
         qRegisterMetaType<GpgME::Error>("GpgME::Error");
 
         connect(this, &::ReaderStatusThread::cardAdded,
                 q, &ReaderStatus::cardAdded);
         connect(this, &::ReaderStatusThread::cardChanged,
                 q, &ReaderStatus::cardChanged);
         connect(this, &::ReaderStatusThread::cardRemoved,
                 q, &ReaderStatus::cardRemoved);
         connect(this, &::ReaderStatusThread::firstCardWithNullPinChanged,
                 q, &ReaderStatus::firstCardWithNullPinChanged);
         connect(this, &::ReaderStatusThread::anyCardCanLearnKeysChanged,
                 q, &ReaderStatus::anyCardCanLearnKeysChanged);
 
 #ifdef GPGME_SUPPORTS_API_FOR_DEVICEINFOWATCHER
         if (DeviceInfoWatcher::isSupported()) {
             qCDebug(KLEOPATRA_LOG) << "ReaderStatus::Private: Using new DeviceInfoWatcher";
             connect(&devInfoWatcher, &DeviceInfoWatcher::statusChanged, this, &::ReaderStatusThread::deviceStatusChanged);
         } else
 #endif
         {
             qCDebug(KLEOPATRA_LOG) << "ReaderStatus::Private: Using deprecated FileSystemWatcher";
 
             watcher.whitelistFiles(QStringList(QStringLiteral("reader_*.status")));
             watcher.addPath(Kleo::gnupgHomeDirectory());
             watcher.setDelay(100);
 
             connect(&watcher, &FileSystemWatcher::triggered, this, &::ReaderStatusThread::ping);
         }
     }
     ~Private()
     {
         stop();
         if (!wait(100)) {
             terminate();
             wait();
         }
     }
 
 private:
     std::string firstCardWithNullPinImpl() const
     {
         const auto cis = cardInfos();
         const auto firstWithNullPin = std::find_if(cis.cbegin(), cis.cend(),
                                                    [](const std::shared_ptr<Card> &ci) { return ci->hasNullPin(); });
         return firstWithNullPin != cis.cend() ? (*firstWithNullPin)->serialNumber() : std::string();
     }
 
     bool anyCardCanLearnKeysImpl() const
     {
         const auto cis = cardInfos();
         return std::any_of(cis.cbegin(), cis.cend(),
                            [](const std::shared_ptr<Card> &ci) { return ci->canLearnKeys(); });
     }
 
 private:
     FileSystemWatcher watcher;
 #ifdef GPGME_SUPPORTS_API_FOR_DEVICEINFOWATCHER
     DeviceInfoWatcher devInfoWatcher;
 #endif
 };
 
 ReaderStatus::ReaderStatus(QObject *parent)
     : QObject(parent), d(new Private(this))
 {
     self = this;
 
     qRegisterMetaType<std::string>("std::string");
 }
 
 ReaderStatus::~ReaderStatus()
 {
     self = nullptr;
 }
 
 // slot
 void ReaderStatus::startMonitoring()
 {
     d->start();
 #ifdef GPGME_SUPPORTS_API_FOR_DEVICEINFOWATCHER
     if (DeviceInfoWatcher::isSupported()) {
         d->devInfoWatcher.start();
     }
 #endif
 }
 
 // static
 ReaderStatus *ReaderStatus::mutableInstance()
 {
     return self;
 }
 
 // static
 const ReaderStatus *ReaderStatus::instance()
 {
     return self;
 }
 
 Card::Status ReaderStatus::cardStatus(unsigned int slot) const
 {
     return d->cardStatus(slot);
 }
 
 std::string ReaderStatus::firstCardWithNullPin() const
 {
     return d->firstCardWithNullPinImpl();
 }
 
 bool ReaderStatus::anyCardCanLearnKeys() const
 {
     return d->anyCardCanLearnKeysImpl();
 }
 
 void ReaderStatus::startSimpleTransaction(const std::shared_ptr<Card> &card, const QByteArray &command, QObject *receiver, const char *slot)
 {
     const CardApp cardApp = { card->serialNumber(), card->appName() };
     const Transaction t = { cardApp, command, receiver, slot, nullptr };
     d->addTransaction(t);
 }
 
 void ReaderStatus::startTransaction(const std::shared_ptr<Card> &card, const QByteArray &command, QObject *receiver, const char *slot,
                                     std::unique_ptr<AssuanTransaction> transaction)
 {
     const CardApp cardApp = { card->serialNumber(), card->appName() };
     const Transaction t = { cardApp, command, receiver, slot, transaction.release() };
     d->addTransaction(t);
 }
 
 void ReaderStatus::updateStatus()
 {
     d->ping();
 }
 
 std::vector <std::shared_ptr<Card> > ReaderStatus::getCards() const
 {
     return d->cardInfos();
 }
 
 std::shared_ptr<Card> ReaderStatus::getCard(const std::string &serialNumber, const std::string &appName) const
 {
     for (const auto &card: d->cardInfos()) {
         if (card->serialNumber() == serialNumber && card->appName() == appName) {
             qCDebug(KLEOPATRA_LOG) << "ReaderStatus::getCard() - Found card with serial number" << serialNumber << "and app" << appName;
             return card;
         }
     }
     qCWarning(KLEOPATRA_LOG) << "ReaderStatus::getCard() - Did not find card with serial number" << serialNumber << "and app" << appName;
     return std::shared_ptr<Card>();
 }
 
 // static
 std::string ReaderStatus::switchCard(std::shared_ptr<Context>& ctx, const std::string& serialNumber, Error& err)
 {
     return ::switchCard(ctx, serialNumber, err);
 }
 
 // static
 std::string ReaderStatus::switchApp(std::shared_ptr<Context>& ctx, const std::string& serialNumber, const std::string& appName, Error& err)
 {
     return ::switchApp(ctx, serialNumber, appName, err);
 }
 
 // static
 Error ReaderStatus::switchCardAndApp(const std::string &serialNumber, const std::string &appName)
 {
     Error err;
     if (!(engineInfo(GpgEngine).engineVersion() < "2.3.0")) {
         std::unique_ptr<Context> c = Context::createForEngine(AssuanEngine, &err);
         if (err.code() == GPG_ERR_NOT_SUPPORTED) {
             return err;
         }
         auto assuanContext = std::shared_ptr<Context>(c.release());
         const auto resultSerialNumber = switchCard(assuanContext, serialNumber, err);
         if (err || resultSerialNumber != serialNumber) {
             qCWarning(KLEOPATRA_LOG) << "Switching to card" << QString::fromStdString(serialNumber) << "failed";
             if (!err) {
                 err = Error::fromCode(GPG_ERR_UNEXPECTED);
             }
             return err;
         }
         const auto resultAppName = switchApp(assuanContext, serialNumber, appName, err);
         if (err || resultAppName != appName) {
             qCWarning(KLEOPATRA_LOG) << "Switching card to" << QString::fromStdString(appName) << "app failed";
             if (!err) {
                 err = Error::fromCode(GPG_ERR_UNEXPECTED);
             }
             return err;
         }
     }
     return err;
 }
 
 #include "readerstatus.moc"
diff --git a/src/systrayicon.cpp b/src/systrayicon.cpp
index f9ec4a5a9..1e2b081b3 100644
--- a/src/systrayicon.cpp
+++ b/src/systrayicon.cpp
@@ -1,256 +1,256 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     systemtrayicon.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 "systrayicon.h"
 
 #ifndef QT_NO_SYSTEMTRAYICON
 
 #include "mainwindow.h"
 #include "kleopatraapplication.h"
 
 #include <smartcard/readerstatus.h>
 
 #include <utils/clipboardmenu.h>
 
 #include <commands/importcertificatefromclipboardcommand.h>
 #include <commands/encryptclipboardcommand.h>
 #include <commands/signclipboardcommand.h>
 #include <commands/decryptverifyclipboardcommand.h>
 #include <commands/setinitialpincommand.h>
 #include <commands/learncardkeyscommand.h>
 
 #include <QIcon>
 #include <KLocalizedString>
 #include <KAboutApplicationDialog>
 #include <KAboutData>
 #include <KActionMenu>
 #include <QEventLoopLocker>
 
 #include <QMenu>
 #include <QAction>
 #include <QApplication>
 #include <QClipboard>
 #include <QPointer>
 #include <QSignalBlocker>
 
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 
 class SysTrayIcon::Private
 {
     friend class ::SysTrayIcon;
     SysTrayIcon *const q;
 public:
     explicit Private(SysTrayIcon *qq);
     ~Private();
 
 private:
     void slotAbout()
     {
         if (!aboutDialog) {
             aboutDialog = new KAboutApplicationDialog(KAboutData::applicationData());
             aboutDialog->setAttribute(Qt::WA_DeleteOnClose);
         }
 
         if (aboutDialog->isVisible()) {
             aboutDialog->raise();
         } else {
             aboutDialog->show();
         }
     }
 
     void enableDisableActions()
     {
         //work around a Qt bug (seen with Qt 4.4.0, Windows): QClipBoard->mimeData() triggers QClipboard::changed(),
         //triggering slotEnableDisableActions again
         const QSignalBlocker blocker(QApplication::clipboard());
         openCertificateManagerAction.setEnabled(!q->mainWindow() || !q->mainWindow()->isVisible());
         setInitialPinAction.setEnabled(!firstCardWithNullPin.empty());
         learnCertificatesAction.setEnabled(anyCardCanLearnKeys);
 
         q->setAttentionWanted((!firstCardWithNullPin.empty() || anyCardCanLearnKeys) && !q->attentionWindow());
     }
 
     void slotSetInitialPin()
     {
         if (!firstCardWithNullPin.empty()) {
-            SetInitialPinCommand *cmd = new SetInitialPinCommand(firstCardWithNullPin);
+            auto cmd = new SetInitialPinCommand(firstCardWithNullPin);
             q->setAttentionWindow(cmd->dialog());
             startCommand(cmd);
         }
     }
 
     void slotLearnCertificates()
     {
-        LearnCardKeysCommand *cmd = new LearnCardKeysCommand(GpgME::CMS);
+        auto cmd = new LearnCardKeysCommand(GpgME::CMS);
         q->setAttentionWindow(cmd->dialog());
         startCommand(cmd);
     }
     void startCommand(Command *cmd)
     {
         Q_ASSERT(cmd);
         cmd->setParent(q->mainWindow());
         cmd->start();
     }
 
 private:
     std::string firstCardWithNullPin;
     bool anyCardCanLearnKeys = false;
     bool learningInProgress = false;
 
     QMenu menu;
     QAction openCertificateManagerAction;
     QAction configureAction;
     QAction aboutAction;
     QAction quitAction;
 
     ClipboardMenu clipboardMenu;
 
     QMenu cardMenu;
     QAction updateCardStatusAction;
     QAction setInitialPinAction;
     QAction learnCertificatesAction;
 
     QPointer<KAboutApplicationDialog> aboutDialog;
     QEventLoopLocker eventLoopLocker;
 };
 
 SysTrayIcon::Private::Private(SysTrayIcon *qq)
     : q(qq),
       menu(),
       openCertificateManagerAction(i18n("&Open Certificate Manager..."), q),
       configureAction(QIcon::fromTheme(QStringLiteral("configure")), i18n("&Configure %1...", KAboutData::applicationData().componentName()), q),
       aboutAction(QIcon::fromTheme(QStringLiteral("kleopatra")), i18n("&About %1...", KAboutData::applicationData().componentName()), q),
       quitAction(QIcon::fromTheme(QStringLiteral("application-exit")),i18n("&Shutdown Kleopatra"), q),
       clipboardMenu(q),
       cardMenu(i18n("SmartCard")),
       updateCardStatusAction(i18n("Update Card Status"), q),
       setInitialPinAction(i18n("Set NetKey v3 Initial PIN..."), q),
       learnCertificatesAction(i18n("Learn NetKey v3 Card Certificates"), q),
       aboutDialog()
 {
     q->setNormalIcon(QIcon::fromTheme(QStringLiteral("kleopatra")));
     q->setAttentionIcon(QIcon::fromTheme(QStringLiteral("auth-sim-locked")));
 
     KDAB_SET_OBJECT_NAME(menu);
     KDAB_SET_OBJECT_NAME(openCertificateManagerAction);
     KDAB_SET_OBJECT_NAME(configureAction);
     KDAB_SET_OBJECT_NAME(aboutAction);
     KDAB_SET_OBJECT_NAME(quitAction);
     KDAB_SET_OBJECT_NAME(clipboardMenu);
     KDAB_SET_OBJECT_NAME(cardMenu);
     KDAB_SET_OBJECT_NAME(setInitialPinAction);
     KDAB_SET_OBJECT_NAME(learnCertificatesAction);
 
     connect(&openCertificateManagerAction, SIGNAL(triggered()), qApp, SLOT(openOrRaiseMainWindow()));
     connect(&configureAction, SIGNAL(triggered()), qApp, SLOT(openOrRaiseConfigDialog()));
     connect(&aboutAction, SIGNAL(triggered()), q, SLOT(slotAbout()));
     connect(&quitAction, &QAction::triggered, QCoreApplication::instance(), &QCoreApplication::quit);
     connect(&updateCardStatusAction, &QAction::triggered, ReaderStatus::instance(), &ReaderStatus::updateStatus);
     connect(&setInitialPinAction, SIGNAL(triggered()), q, SLOT(slotSetInitialPin()));
     connect(&learnCertificatesAction, SIGNAL(triggered()), q, SLOT(slotLearnCertificates()));
 
     connect(QApplication::clipboard(), SIGNAL(changed(QClipboard::Mode)),
             q, SLOT(slotEnableDisableActions()));
 
     menu.addAction(&openCertificateManagerAction);
     menu.addAction(&configureAction);
     menu.addAction(&aboutAction);
     menu.addSeparator();
     menu.addMenu(clipboardMenu.clipboardMenu()->menu());
     menu.addSeparator();
     menu.addMenu(&cardMenu);
     cardMenu.addAction(&updateCardStatusAction);
     cardMenu.addAction(&setInitialPinAction);
     cardMenu.addAction(&learnCertificatesAction);
     menu.addSeparator();
     menu.addAction(&quitAction);
 
     q->setContextMenu(&menu);
     clipboardMenu.setMainWindow(q->mainWindow());
 }
 
 SysTrayIcon::Private::~Private() {}
 
 SysTrayIcon::SysTrayIcon(QObject *p)
     : SystemTrayIcon(p), d(new Private(this))
 {
     slotEnableDisableActions();
 }
 
 SysTrayIcon::~SysTrayIcon()
 {
 }
 
 MainWindow *SysTrayIcon::mainWindow() const
 {
     return static_cast<MainWindow *>(SystemTrayIcon::mainWindow());
 }
 
 QDialog *SysTrayIcon::attentionWindow() const
 {
     return static_cast<QDialog *>(SystemTrayIcon::attentionWindow());
 }
 
 void SysTrayIcon::doActivated()
 {
     if (const QWidget *const aw = attentionWindow())
         if (aw->isVisible()) {
             return;    // ignore clicks while an attention window is open.
         }
     if (!d->firstCardWithNullPin.empty()) {
         d->slotSetInitialPin();
     } else if (d->anyCardCanLearnKeys) {
         d->slotLearnCertificates();
     } else {
         // Toggle visibility of MainWindow
         KleopatraApplication::instance()->toggleMainWindowVisibility();
     }
 }
 
 void SysTrayIcon::setFirstCardWithNullPin(const std::string &serialNumber)
 {
     if (d->firstCardWithNullPin == serialNumber) {
         return;
     }
     d->firstCardWithNullPin = serialNumber;
     slotEnableDisableActions();
 }
 
 void SysTrayIcon::setAnyCardCanLearnKeys(bool on)
 {
     if (d->anyCardCanLearnKeys == on || d->learningInProgress) {
         return;
     }
     d->anyCardCanLearnKeys = on;
     slotEnableDisableActions();
 }
 
 void SysTrayIcon::slotEnableDisableActions()
 {
     d->enableDisableActions();
 }
 
 /* We need this as the readerstatus might update even
  * while the loading is in progress. */
 void SysTrayIcon::setLearningInProgress(bool value)
 {
     if (value) {
         setAnyCardCanLearnKeys(false);
     }
     d->learningInProgress = value;
 }
 
 #include "moc_systrayicon.cpp"
 
 #endif // QT_NO_SYSTEMTRAYICON
diff --git a/src/uiserver/assuancommand.h b/src/uiserver/assuancommand.h
index 8a63027a9..9477df40f 100644
--- a/src/uiserver/assuancommand.h
+++ b/src/uiserver/assuancommand.h
@@ -1,385 +1,385 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/assuancommand.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <utils/pimpl_ptr.h>
 #include <utils/types.h>
 
 #include <gpgme++/global.h>
 #include <gpgme++/error.h>
 
 #ifdef HAVE_ASSUAN2
 #include <gpg-error.h>
 
 #endif
 #include <kmime/kmime_header_parsing.h>
 
 #include <qwindowdefs.h> // for WId
 
 #include <memory>
 #include <string>
 #include <map>
 #include <vector>
 
 class QVariant;
 class QObject;
 #include <QStringList>
 
 struct assuan_context_s;
 
 namespace Kleo
 {
 
 class Input;
 class Output;
 
 class AssuanCommandFactory;
 
 /*!
   \brief Base class for GnuPG UI Server commands
 
   \note large parts of this are outdated by now!
 
   <h3>Implementing a new AssuanCommand</h3>
 
   You do not directly inherit AssuanCommand, unless you want to
   deal with implementing low-level, repetitive things like name()
   in terms of staticName(). Assuming you don't, then you inherit
   your command class from AssuanCommandMixin, passing your class
   as the template argument to AssuanCommandMixin, like this:
 
   \code
   class MyFooCommand : public AssuanCommandMixin<MyFooCommand> {
   \endcode
   (http://en.wikipedia.org/wiki/Curiously_recurring_template_pattern)
 
   You then choose a command name, and return that from the static
   method staticName(), which is by convention queried by both
   AssuanCommandMixin<> and GenericAssuanCommandFactory<>:
 
   \code
       static const char * staticName() { return "MYFOO"; }
   \endcode
 
   The string should be all-uppercase by convention, but the
   UiServer implementation doesn't enforce this.
 
   The next step is to implement start(), the starting point of
   command execution:
 
   <h3>Executing the command</h3>
 
   \code
       int start( const std::string & line ) {
   \endcode
 
   This should set everything up and check the parameters in \a
   line and any options this command understands. If there's an
   error, choose one of the gpg-error codes and create a
   gpg_error_t from it using the protected makeError() function:
 
   \code
           return makeError( GPG_ERR_NOT_IMPLEMENTED );
   \endcode
 
   But usually, you will want to create a dialog, or call some
   GpgME function from here. In case of errors from GpgME, you
   shouldn't pipe them through makeError(), but return them
   as-is. This will preserve the error source. Error created using
   makeError() will have Kleopatra as their error source, so watch
   out what you're doing :)
 
   In addition to options and the command line, your command might
   require <em>bulk data</em> input or output. That's what the bulk
   input and output channels are for. You can check whether the
   client handed you an input channel by checking that
   bulkInputDevice() isn't NULL, likewise for bulkOutputDevice().
 
   If everything is ok, you return 0. This indicates to the client
   that the command has been accepted and is now in progress.
 
   In this mode (start() returned 0), there are a bunch of options
   for your command to do. Some commands may require additional
   information from the client. The options passed to start() are
   designed to be persistent across commands, and rather limited in
   length (there's a strict line length limit in the assuan
   protocol with no line continuation mechanism). The same is true
   for command line arguments, which, in addition, you have to
   parse yourself. Those usually apply only to this command, and
   not to following ones.
 
   If you need data that might be larger than the line length
   limit, you can either expect it on the bulkInputDevice(), or, if
   you have the need for more than one such data channel, or the
   data is optional or conditional on some condition that can only
   be determined during command execution, you can \em inquire the
   missing information from the client.
 
   As an example, a VERIFY command would expect the signed data on
   the bulkInputDevice(). But if the input stream doesn't contain
   an embedded (opaque) signature, indicating a \em detached
   signature, it would go and inquire that data from the
   client. Here's how it works:
 
   \code
   const int err = inquire( "DETACHED_SIGNATURE",
                            this, SLOT(slotDetachedSignature(int,QByteArray,QByteArray)) );
   if ( err )
       done( err );
   \endcode
 
   This should be self-explanatory: You give a slot to call when
   the data has arrived. The slot's first argument is an error
   code. The second the data (if any), and the third is just
   repeating what you gave as inquire()'s first argument. As usual,
   you can leave argument off of the end, if you are not interested
   in them.
 
   You can do as many inquiries as you want, but only one at a
   time.
 
   You should periodically send status updates to the client. You do
   that by calling sendStatus().
 
   Once your command has finished executing, call done(). If it's
   with an error code, call done(err) like above. <b>Do not
   forget to call done() when done!</b>. It will close
   bulkInputDevice(), bulkOutputDevice(), and send an OK or ERR
   message back to the client.
 
   At that point, your command has finished executing, and a new
   one can be accepted, or the connection closed.
 
   Apropos connection closed. The only way for the client to cancel
   an operation is to shut down the connection. In this case, the
   canceled() function will be called. At that point, the
   connection to the client will have been broken already, and all
   you can do is pack your things and go down gracefully.
 
   If _you_ detect that the user has canceled (your dialog contains
   a cancel button, doesn't it?), then you should instead call
   done( GPG_ERR_CANCELED ), like for normal operation.
 
   <h3>Registering the command with UiServer</h3>
 
   To register a command, you implement a AssuanCommandFactory for
   your AssuanCommand subclass, and register it with the
   UiServer. This can be made considerably easier using
   GenericAssuanCommandFactory:
 
   \code
   UiServer server;
   server.registerCommandFactory( shared_ptr<AssuanCommandFactory>( new GenericAssuanCommandFactory<MyFooCommand> ) );
   // more registerCommandFactory calls...
   server.start();
   \endcode
 
 */
 class AssuanCommand : public ExecutionContext, public std::enable_shared_from_this<AssuanCommand>
 {
     // defined in assuanserverconnection.cpp!
 public:
     AssuanCommand();
     virtual ~AssuanCommand();
 
     int start();
     void canceled();
 
     virtual const char *name() const = 0;
 
     class Memento
     {
     public:
         virtual ~Memento() {}
     };
 
     template <typename T>
     class TypedMemento : public Memento
     {
         T m_t;
     public:
         explicit TypedMemento(const T &t) : m_t(t) {}
 
         const T &get() const
         {
             return m_t;
         }
         T &get()
         {
             return m_t;
         }
     };
 
     template <typename T>
     static std::shared_ptr< TypedMemento<T> > make_typed_memento(const T &t)
     {
         return std::shared_ptr< TypedMemento<T> >(new TypedMemento<T>(t));
     }
 
     static int makeError(int code);
 
     // convenience methods:
     enum Mode { NoMode, EMail, FileManager };
     Mode checkMode() const;
 
     enum CheckProtocolOption {
         AllowProtocolMissing = 0x01
     };
 
     GpgME::Protocol checkProtocol(Mode mode, int options = 0) const;
 
     void applyWindowID(QWidget *w) const override
     {
         doApplyWindowID(w);
     }
     WId parentWId() const;
 
     void setNohup(bool on);
     bool isNohup() const;
     bool isDone() const;
 
     QString sessionTitle() const;
     unsigned int sessionId() const;
 
     bool informativeRecipients() const;
     bool informativeSenders() const;
 
     const std::vector<KMime::Types::Mailbox> &recipients() const;
     const std::vector<KMime::Types::Mailbox> &senders() const;
 
     bool hasMemento(const QByteArray &tag) const;
     std::shared_ptr<Memento> memento(const QByteArray &tag) const;
     template <typename T>
     std::shared_ptr<T> mementoAs(const QByteArray &tag) const
     {
         return std::dynamic_pointer_cast<T>(this->memento(tag));
     }
     QByteArray registerMemento(const std::shared_ptr<Memento> &mem);
     QByteArray registerMemento(const QByteArray &tag, const std::shared_ptr<Memento> &mem);
     void removeMemento(const QByteArray &tag);
     template <typename T>
     T mementoContent(const QByteArray &tag) const
     {
         if (std::shared_ptr< TypedMemento<T> > m = mementoAs< TypedMemento<T> >(tag)) {
             return m->get();
         } else {
             return T();
         }
     }
 
     bool hasOption(const char *opt) const;
     QVariant option(const char *opt) const;
     const std::map<std::string, QVariant> &options() const;
 
     const std::vector< std::shared_ptr<Input> > &inputs() const;
     const std::vector< std::shared_ptr<Input> > &messages() const;
     const std::vector< std::shared_ptr<Output> > &outputs() const;
 
     QStringList fileNames() const;
     unsigned int numFiles() const;
 
     void sendStatus(const char *keyword, const QString &text);
     void sendStatusEncoded(const char *keyword, const std::string &text);
     void sendData(const QByteArray &data, bool moreToCome = false);
 
     int inquire(const char *keyword, QObject *receiver, const char *slot, unsigned int maxSize = 0);
 
     void done(const GpgME::Error &err = GpgME::Error());
     void done(const GpgME::Error &err, const QString &details);
     void done(int err)
     {
         done(GpgME::Error(err));
     }
     void done(int err, const QString &details)
     {
         done(GpgME::Error(err), details);
     }
 
 private:
     virtual void doCanceled() = 0;
     virtual int doStart() = 0;
 
 private:
     void doApplyWindowID(QWidget *w) const;
 
 private:
     const std::map< QByteArray, std::shared_ptr<Memento> > &mementos() const;
 
 private:
     friend class ::Kleo::AssuanCommandFactory;
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 class AssuanCommandFactory
 {
 public:
     virtual ~AssuanCommandFactory() {}
 
     virtual std::shared_ptr<AssuanCommand> create() const = 0;
     virtual const char *name() const = 0;
 
 #ifndef HAVE_ASSUAN2
     typedef int(*_Handler)(assuan_context_s *, char *);
 #else
-    typedef gpg_error_t(*_Handler)(assuan_context_s *, char *);
+    using _Handler = gpg_error_t (*)(assuan_context_s *, char *);
 #endif
     virtual _Handler _handler() const = 0;
 
 #ifndef HAVE_ASSUAN2
     static int _handle(assuan_context_s *, char *, const char *);
 #else
     static gpg_error_t _handle(assuan_context_s *, char *, const char *);
 #endif
 };
 
 template <typename Command>
 class GenericAssuanCommandFactory : public AssuanCommandFactory
 {
     AssuanCommandFactory::_Handler _handler() const override
     {
         return &GenericAssuanCommandFactory::_handle;
     }
 #ifndef HAVE_ASSUAN2
     static int _handle(assuan_context_s *_ctx, char *_line)
     {
 #else
     static gpg_error_t _handle(assuan_context_s *_ctx, char *_line)
     {
 #endif
         return AssuanCommandFactory::_handle(_ctx, _line, Command::staticName());
     }
     std::shared_ptr<AssuanCommand> create() const override
     {
         return make();
     }
     const char *name() const override
     {
         return Command::staticName();
     }
 public:
     static std::shared_ptr<Command> make()
     {
         return std::shared_ptr<Command>(new Command);
     }
 };
 
 template <typename Derived, typename Base = AssuanCommand>
 class AssuanCommandMixin : public Base
 {
 protected:
     /* reimp */ const char *name() const override
     {
         return Derived::staticName();
     }
 };
 
 }
 
diff --git a/src/uiserver/assuanserverconnection.cpp b/src/uiserver/assuanserverconnection.cpp
index 89d2957af..da9847af7 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/kmime_header_parsing.h>
 
 #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:
-typedef std::shared_ptr<std::remove_pointer<assuan_context_t>::type> AssuanContextBase;
+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;
-    std::map<std::string, std::string>::iterator it = options.begin();
+    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) {
-                Output *out = reinterpret_cast <Output *>(io.get());
+                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 (std::map<std::string, QVariant>::const_iterator it = options.begin(), end = options.end(); it != end; ++it) {
+        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 (std::map< QByteArray, std::shared_ptr<AssuanCommand::Memento> >::const_iterator it = mementos.begin(), end = mementos.end(); it != end; ++it) {
+        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)
 #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);
-        InquiryHandler *this_ = static_cast<InquiryHandler *>(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 std::map<std::string, QVariant>::const_iterator it = d->options.find(opt);
+    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 std::map< QByteArray, std::shared_ptr<Memento> >::const_iterator it = sd->mementos.find(tag);
+        const auto it = sd->mementos.find(tag);
         if (it != sd->mementos.end()) {
             return it->second;
         }
     }
-    const std::map< QByteArray, std::shared_ptr<Memento> >::const_iterator it = mementos().find(tag);
+    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 std::vector< std::shared_ptr<AssuanCommandFactory> >::const_iterator it
+        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 (std::map<std::string, std::string>::const_iterator it = cmdline_options.begin(), end = cmdline_options.end(); it != end; ++it) {
+        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/uiserver/encryptcommand.cpp b/src/uiserver/encryptcommand.cpp
index ac0f4cca2..ce792fb0b 100644
--- a/src/uiserver/encryptcommand.cpp
+++ b/src/uiserver/encryptcommand.cpp
@@ -1,208 +1,208 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/encryptcommand.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 "encryptcommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
 #include <utils/kleo_assert.h>
 #include <utils/input.h>
 #include <utils/output.h>
 
 #include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class EncryptCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::EncryptCommand;
     EncryptCommand *const q;
 public:
     explicit Private(EncryptCommand *qq)
         : q(qq),
           controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private Q_SLOTS:
     void slotDone();
     void slotError(int, const QString &);
     void slotRecipientsResolved();
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 EncryptCommand::EncryptCommand()
     : AssuanCommandMixin<EncryptCommand>(), d(new Private(this))
 {
 
 }
 
 EncryptCommand::~EncryptCommand() {}
 
 void EncryptCommand::Private::checkForErrors() const
 {
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("ENCRYPT is an email mode command, connection seems to be in filmanager mode"));
 
     if (!q->senders().empty() && !q->informativeSenders())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("SENDER may not be given prior to ENCRYPT, except with --info"));
 
     if (q->inputs().empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one INPUT must be present"));
 
     if (q->outputs().empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_OUTPUT),
                         i18n("At least one OUTPUT must be present"));
 
     if (q->outputs().size() != q->inputs().size())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("INPUT/OUTPUT count mismatch"));
 
     if (!q->messages().empty())
         throw Exception(makeError(GPG_ERR_INV_VALUE),
                         i18n("MESSAGE command is not allowed before ENCRYPT"));
 
-    const std::shared_ptr<NewSignEncryptEMailController> m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
+    const auto m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
     kleo_assert(m);
 
     if (m && m->isEncrypting()) {
 
         if (m->protocol() != q->checkProtocol(EMail))
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("Protocol given conflicts with protocol determined by PREP_ENCRYPT"));
 
         if (!q->recipients().empty())
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("New recipients added after PREP_ENCRYPT command"));
         if (!q->senders().empty())
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("New senders added after PREP_ENCRYPT command"));
 
     } else {
 
         if (q->recipients().empty() || q->informativeRecipients())
             throw Exception(makeError(GPG_ERR_MISSING_VALUE),
                             i18n("No recipients given, or only with --info"));
 
     }
 
 }
 
 static void connectController(const QObject *controller, const QObject *d)
 {
 
     QObject::connect(controller, SIGNAL(certificatesResolved()), d, SLOT(slotRecipientsResolved()));
     QObject::connect(controller, SIGNAL(done()), d, SLOT(slotDone()));
     QObject::connect(controller, SIGNAL(error(int,QString)), d, SLOT(slotError(int,QString)));
 
 }
 
 int EncryptCommand::doStart()
 {
 
     d->checkForErrors();
 
-    const std::shared_ptr<NewSignEncryptEMailController> seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
+    const auto seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (seec && seec->isEncrypting()) {
         // reuse the controller from a previous PREP_ENCRYPT, if available:
         d->controller = seec;
         connectController(seec.get(), d.get());
         removeMemento(NewSignEncryptEMailController::mementoName());
         d->controller->setExecutionContext(shared_from_this());
         if (seec->areCertificatesResolved()) {
             QTimer::singleShot(0, d.get(), &Private::slotRecipientsResolved);
         } else {
             kleo_assert(seec->isResolvingInProgress());
         }
     } else {
         // use a new controller
         d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
 
         const QString session = sessionTitle();
         if (!session.isEmpty()) {
             d->controller->setSubject(session);
         }
 
         d->controller->setEncrypting(true);
         d->controller->setSigning(false);
         d->controller->setProtocol(checkProtocol(EMail));
         connectController(d->controller.get(), d.get());
         d->controller->startResolveCertificates(recipients(), senders());
     }
 
     return 0;
 }
 
 void EncryptCommand::Private::slotRecipientsResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont(controller);
 
     try {
         const QString sessionTitle = q->sessionTitle();
         if (!sessionTitle.isEmpty())
             Q_FOREACH (const std::shared_ptr<Input> &i, q->inputs()) {
                 i->setLabel(sessionTitle);
             }
 
         cont->startEncryption(q->inputs(), q->outputs());
 
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in EncryptCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in EncryptCommand::Private::slotRecipientsResolved"));
     }
     cont->cancel();
 }
 
 void EncryptCommand::Private::slotDone()
 {
     q->done();
 }
 
 void EncryptCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void EncryptCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "encryptcommand.moc"
diff --git a/src/uiserver/prepsigncommand.cpp b/src/uiserver/prepsigncommand.cpp
index 7021a2a63..883ada643 100644
--- a/src/uiserver/prepsigncommand.cpp
+++ b/src/uiserver/prepsigncommand.cpp
@@ -1,178 +1,178 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/prepsigncommand.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 "prepsigncommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class PrepSignCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::PrepSignCommand;
     PrepSignCommand *const q;
 public:
     explicit Private(PrepSignCommand *qq)
         : q(qq), controller() {}
 
 private:
     void checkForErrors() const;
 
 public Q_SLOTS:
     void slotSignersResolved();
     void slotError(int, const QString &);
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 PrepSignCommand::PrepSignCommand()
     : AssuanCommandMixin<PrepSignCommand>(), d(new Private(this))
 {
 
 }
 
 PrepSignCommand::~PrepSignCommand() {}
 
 void PrepSignCommand::Private::checkForErrors() const
 {
 
     if (!q->inputs().empty() || !q->outputs().empty() || !q->messages().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("INPUT/OUTPUT/MESSAGE may only be given after PREP_SIGN"));
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("PREP_SIGN is an email mode command, connection seems to be in filemanager mode"));
 
     if (q->senders().empty())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("No SENDER given"));
 
-    const std::shared_ptr<NewSignEncryptEMailController> m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
+    const auto m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (m && m->isSigning()) {
 
         if (q->hasOption("protocol"))
             if (m->protocol() != q->checkProtocol(EMail))
                 throw Exception(makeError(GPG_ERR_CONFLICT),
                                 i18n("Protocol given conflicts with protocol determined by PREP_ENCRYPT in this session"));
 
         // ### check that any SENDER here is the same as the one for PREP_ENCRYPT
 
         // ### ditto RECIPIENT
 
     }
 
 }
 
 static void connectController(const QObject *controller, const QObject *d)
 {
     QObject::connect(controller, SIGNAL(certificatesResolved()), d, SLOT(slotSignersResolved()));
     QObject::connect(controller, SIGNAL(error(int,QString)), d, SLOT(slotError(int,QString)));
 }
 
 int PrepSignCommand::doStart()
 {
 
     d->checkForErrors();
 
-    const std::shared_ptr<NewSignEncryptEMailController> seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
+    const auto seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (seec && seec->isSigning()) {
         // reuse the controller from a previous PREP_ENCRYPT --expect-sign, if available:
         d->controller = seec;
         connectController(seec.get(), d.get());
         seec->setExecutionContext(shared_from_this());
         if (seec->areCertificatesResolved()) {
             QTimer::singleShot(0, d.get(), &Private::slotSignersResolved);
         } else {
             kleo_assert(seec->isResolvingInProgress());
         }
     } else {
         // use a new controller
         d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
 
         const QString session = sessionTitle();
         if (!session.isEmpty()) {
             d->controller->setSubject(session);
         }
 
         if (hasOption("protocol"))
             // --protocol is optional for PREP_SIGN
         {
             d->controller->setProtocol(checkProtocol(EMail));
         }
 
         d->controller->setEncrypting(false);
         d->controller->setSigning(true);
         connectController(d->controller.get(), d.get());
         d->controller->startResolveCertificates(recipients(), senders());
     }
 
     return 0;
 }
 
 void PrepSignCommand::Private::slotSignersResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont = controller;
     QPointer<Private> that(this);
 
     try {
 
         q->sendStatus("PROTOCOL", QLatin1String(controller->protocolAsString()));
         q->registerMemento(NewSignEncryptEMailController::mementoName(),
                            make_typed_memento(controller));
         q->done();
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in PrepSignCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in PrepSignCommand::Private::slotRecipientsResolved"));
     }
     if (that) { // isn't this always deleted here and thus unnecessary?
         q->removeMemento(NewSignEncryptEMailController::mementoName());
     }
     cont->cancel();
 }
 
 void PrepSignCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void PrepSignCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "prepsigncommand.moc"
diff --git a/src/uiserver/sessiondata.cpp b/src/uiserver/sessiondata.cpp
index 6d143f28c..59877d732 100644
--- a/src/uiserver/sessiondata.cpp
+++ b/src/uiserver/sessiondata.cpp
@@ -1,112 +1,112 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/sessiondata.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 "sessiondata.h"
 
 #include "kleopatra_debug.h"
 
 #include <QMutex>
 
 
 using namespace Kleo;
 
 static const int GARBAGE_COLLECTION_INTERVAL = 60000; // 1min
 
 static QMutex mutex;
 
 SessionData::SessionData()
     : mementos(),
       ref(0),
       ripe(false)
 {
 
 }
 
 // static
 std::shared_ptr<SessionDataHandler> SessionDataHandler::instance()
 {
     mutex.lock();
     static SessionDataHandler handler;
     return std::shared_ptr<SessionDataHandler>(&handler, [](SessionDataHandler*) { mutex.unlock(); });
 }
 
 SessionDataHandler::SessionDataHandler()
     : QObject(),
       data(),
       timer()
 {
     timer.setInterval(GARBAGE_COLLECTION_INTERVAL);
     timer.setSingleShot(false);
 }
 
 void SessionDataHandler::enterSession(unsigned int id)
 {
     qCDebug(KLEOPATRA_LOG) << id;
     const std::shared_ptr<SessionData> sd = sessionDataInternal(id);
     Q_ASSERT(sd);
     ++sd->ref;
     sd->ripe = false;
 }
 
 void SessionDataHandler::exitSession(unsigned int id)
 {
     qCDebug(KLEOPATRA_LOG) << id;
     const std::shared_ptr<SessionData> sd = sessionDataInternal(id);
     Q_ASSERT(sd);
     if (--sd->ref <= 0) {
         sd->ref = 0;
         sd->ripe = false;
         if (!timer.isActive()) {
             QMetaObject::invokeMethod(&timer, "start", Qt::QueuedConnection);
         }
     }
 }
 
 std::shared_ptr<SessionData> SessionDataHandler::sessionDataInternal(unsigned int id) const
 {
-    std::map< unsigned int, std::shared_ptr<SessionData> >::iterator
+    auto
     it = data.lower_bound(id);
     if (it == data.end() || it->first != id) {
         const std::shared_ptr<SessionData> sd(new SessionData);
         it = data.insert(it, std::make_pair(id, sd));
     }
     return it->second;
 }
 
 std::shared_ptr<SessionData> SessionDataHandler::sessionData(unsigned int id) const
 {
     return sessionDataInternal(id);
 }
 
 void SessionDataHandler::clear()
 {
     data.clear();
 }
 
 void SessionDataHandler::slotCollectGarbage()
 {
     const QMutexLocker locker(&mutex);
     unsigned int alive = 0;
-    std::map< unsigned int, std::shared_ptr<SessionData> >::iterator it = data.begin(), end = data.end();
+    auto it = data.begin(), end = data.end();
     while (it != end)
         if (it->second->ripe) {
             data.erase(it++);
         } else if (!it->second->ref) {
             it->second->ripe = true;
             ++it;
         } else {
             ++alive;
             ++it;
         }
     if (alive == data.size()) {
         QMetaObject::invokeMethod(&timer, "stop", Qt::QueuedConnection);
     }
 }
diff --git a/src/uiserver/signcommand.cpp b/src/uiserver/signcommand.cpp
index 78e46822e..a2ceeaa34 100644
--- a/src/uiserver/signcommand.cpp
+++ b/src/uiserver/signcommand.cpp
@@ -1,228 +1,228 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     uiserver/signcommand.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 "signcommand.h"
 
 #include <crypto/newsignencryptemailcontroller.h>
 
 #include <utils/kleo_assert.h>
 #include <utils/input.h>
 #include <utils/output.h>
 
 #include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class SignCommand::Private : public QObject
 {
     Q_OBJECT
 private:
     friend class ::Kleo::SignCommand;
     SignCommand *const q;
 public:
     explicit Private(SignCommand *qq)
         : q(qq), controller()
     {
 
     }
 
 private:
     void checkForErrors() const;
 
 private Q_SLOTS:
     void slotSignersResolved();
     void slotMicAlgDetermined(const QString &);
     void slotDone();
     void slotError(int, const QString &);
 
 private:
     std::shared_ptr<NewSignEncryptEMailController> controller;
 };
 
 SignCommand::SignCommand()
     : AssuanCommandMixin<SignCommand>(), d(new Private(this))
 {
 
 }
 
 SignCommand::~SignCommand() {}
 
 void SignCommand::Private::checkForErrors() const
 {
 
     if (q->numFiles())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("SIGN is an email mode command, connection seems to be in filemanager mode"));
 
     if (!q->recipients().empty() && !q->informativeRecipients())
         throw Exception(makeError(GPG_ERR_CONFLICT),
                         i18n("RECIPIENT may not be given prior to SIGN, except with --info"));
 
     if (q->inputs().empty())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("At least one INPUT must be present"));
 
     if (q->outputs().size() != q->inputs().size())
         throw Exception(makeError(GPG_ERR_ASS_NO_INPUT),
                         i18n("INPUT/OUTPUT count mismatch"));
 
     if (!q->messages().empty())
         throw Exception(makeError(GPG_ERR_INV_VALUE),
                         i18n("MESSAGE command is not allowed before SIGN"));
 
-    const std::shared_ptr<NewSignEncryptEMailController> m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
+    const auto m = q->mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (m && m->isSigning()) {
 
         if (m->protocol() != q->checkProtocol(EMail))
             throw Exception(makeError(GPG_ERR_CONFLICT),
                             i18n("Protocol given conflicts with protocol determined by PREP_ENCRYPT in this session"));
 
         // ### check that any SENDER here is the same as the one for PREP_ENCRYPT
 
         // ### ditto RECIPIENT
 
     } else {
 
         // ### support the stupid "default signer" semantics of GpgOL
         // ### where SENDER is missing
         if (false)
             if (q->senders().empty() || q->informativeSenders())
                 throw Exception(makeError(GPG_ERR_MISSING_VALUE),
                                 i18n("No senders given, or only with --info"));
 
     }
 
 }
 
 static void connectController(const QObject *controller, const QObject *d)
 {
     QObject::connect(controller, SIGNAL(certificatesResolved()), d, SLOT(slotSignersResolved()));
     QObject::connect(controller, SIGNAL(reportMicAlg(QString)), d, SLOT(slotMicAlgDetermined(QString)));
     QObject::connect(controller, SIGNAL(done()), d, SLOT(slotDone()));
     QObject::connect(controller, SIGNAL(error(int,QString)), d, SLOT(slotError(int,QString)));
 }
 
 int SignCommand::doStart()
 {
 
     d->checkForErrors();
 
-    const std::shared_ptr<NewSignEncryptEMailController> seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
+    const auto seec = mementoContent< std::shared_ptr<NewSignEncryptEMailController> >(NewSignEncryptEMailController::mementoName());
 
     if (seec && seec->isSigning()) {
         // reuse the controller from a previous PREP_ENCRYPT --expect-sign, if available:
         d->controller = seec;
         connectController(seec.get(), d.get());
         if (!seec->isEncrypting()) {
             removeMemento(NewSignEncryptEMailController::mementoName());
         }
         seec->setExecutionContext(shared_from_this());
         if (seec->areCertificatesResolved()) {
             QTimer::singleShot(0, d.get(), &Private::slotSignersResolved);
         } else {
             kleo_assert(seec->isResolvingInProgress());
         }
     } else {
         // use a new controller
         d->controller.reset(new NewSignEncryptEMailController(shared_from_this()));
 
         const QString session = sessionTitle();
         if (!session.isEmpty()) {
             d->controller->setSubject(session);
         }
 
         d->controller->setSigning(true);
         d->controller->setEncrypting(false);
         d->controller->setProtocol(checkProtocol(EMail, AssuanCommand::AllowProtocolMissing));
         connectController(d->controller.get(), d.get());
         d->controller->startResolveCertificates(recipients(), senders());
     }
 
     return 0;
 }
 
 void SignCommand::Private::slotSignersResolved()
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont(controller);
 
     try {
         const QString sessionTitle = q->sessionTitle();
         if (!sessionTitle.isEmpty())
             Q_FOREACH (const std::shared_ptr<Input> &i, q->inputs()) {
                 i->setLabel(sessionTitle);
             }
 
         cont->setDetachedSignature(q->hasOption("detached"));
         cont->startSigning(q->inputs(), q->outputs());
 
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in SignCommand::Private::slotRecipientsResolved: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in SignCommand::Private::slotRecipientsResolved"));
     }
     cont->cancel();
 }
 
 void SignCommand::Private::slotMicAlgDetermined(const QString &micalg)
 {
     //hold local std::shared_ptr to member as q->done() deletes *this
     const std::shared_ptr<NewSignEncryptEMailController> cont(controller);
 
     try {
 
         q->sendStatus("MICALG", micalg);
         return;
 
     } catch (const Exception &e) {
         q->done(e.error(), e.message());
     } catch (const std::exception &e) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unexpected exception in SignCommand::Private::slotMicAlgDetermined: %1",
                      QString::fromLocal8Bit(e.what())));
     } catch (...) {
         q->done(makeError(GPG_ERR_UNEXPECTED),
                 i18n("Caught unknown exception in SignCommand::Private::slotMicAlgDetermined"));
     }
     cont->cancel();
 }
 
 void SignCommand::Private::slotDone()
 {
     q->done();
 }
 
 void SignCommand::Private::slotError(int err, const QString &details)
 {
     q->done(err, details);
 }
 
 void SignCommand::doCanceled()
 {
     if (d->controller) {
         d->controller->cancel();
     }
 }
 
 #include "signcommand.moc"
diff --git a/src/utils/detail_p.h b/src/utils/detail_p.h
index 8bf4ddf74..403b7ba55 100644
--- a/src/utils/detail_p.h
+++ b/src/utils/detail_p.h
@@ -1,88 +1,88 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/detail_p.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <kleo-assuan.h>
 
 
 #ifdef _WIN32
 #include <io.h>
 #endif
 
 namespace Kleo
 {
 namespace _detail
 {
 
 template <template <typename U> class Op>
 struct ByName {
-    typedef bool result_type;
+    using result_type = bool;
 
     template <typename T>
     bool operator()(const T &lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs->name(), rhs->name()), 0);
     }
     template <typename T>
     bool operator()(const T &lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs->name(), rhs), 0);
     }
     template <typename T>
     bool operator()(const char *lhs, const T &rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs->name()), 0);
     }
     bool operator()(const char *lhs, const char *rhs) const
     {
         return Op<int>()(qstricmp(lhs, rhs), 0);
     }
 };
 
 // inspired by GnuPG's translate_sys2libc_fd, this converts a HANDLE
 // to int fd on Windows, and is a NO-OP on POSIX:
 static inline int translate_sys2libc_fd(assuan_fd_t fd, bool for_write)
 {
     if (fd == ASSUAN_INVALID_FD) {
         return -1;
     }
 #if defined(_WIN32)
     return _open_osfhandle((intptr_t)fd, for_write);
 #else
     (void)for_write;
     return fd;
 #endif
 }
 
 static inline assuan_fd_t translate_libc2sys_fd(int fd)
 {
     if (fd == -1) {
         return ASSUAN_INVALID_FD;
     }
 #if defined(_WIN32)
     return (assuan_fd_t)_get_osfhandle(fd);
 #else
     return fd;
 #endif
 }
 
 //returns an integer representation of the assuan_fd_t,
 //suitable for debug output
 static inline qulonglong assuanFD2int(assuan_fd_t fd)
 {
 #ifdef _WIN32
     return reinterpret_cast<qulonglong>(fd);
 #else
     return static_cast<qulonglong>(fd);
 #endif
 }
 }
 }
 
diff --git a/src/utils/dragqueen.cpp b/src/utils/dragqueen.cpp
index 5da2d7294..e7c5d1794 100644
--- a/src/utils/dragqueen.cpp
+++ b/src/utils/dragqueen.cpp
@@ -1,203 +1,203 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/dragqueen.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 "dragqueen.h"
 
 #include <QDrag>
 #include <QMouseEvent>
 #include <QStringList>
 #include <QVariant>
 #include <QApplication>
 #include <QUrl>
 #include <QStyle>
 
 #include <algorithm>
 
 using namespace Kleo;
 
 namespace
 {
 class MimeDataProxy : public QMimeData
 {
     Q_OBJECT
 public:
     explicit MimeDataProxy(QMimeData *source)
         : QMimeData(), m_source(source)
     {
 
     }
 
     QStringList formats() const override
     {
         if (m_source) {
             return m_source->formats();
         } else {
             return QStringList();
         }
     }
 
     bool hasFormat(const QString &format) const override
     {
         return m_source && m_source->hasFormat(format);
     }
 
 protected:
     QVariant retrieveData(const QString &format, QVariant::Type type) const override
     {
         if (!m_source) {
             return QVariant();
         }
         // Doesn't work, is protected:
         // return m_source->retrieveData( format, type );
 
         switch (type) {
         case QVariant::String:
             if (format == QLatin1String("text/plain")) {
                 return m_source->text();
             }
             if (format == QLatin1String("text/html")) {
                 return m_source->html();
             }
             break;
         case QVariant::Color:
             if (format == QLatin1String("application/x-color")) {
                 return m_source->colorData();
             }
             break;
         case QVariant::Image:
             if (format == QLatin1String("application/x-qt-image")) {
                 return m_source->imageData();
             }
             break;
         case QVariant::List:
         case QVariant::Url:
             if (format == QLatin1String("text/uri-list")) {
                 const QList<QUrl> urls = m_source->urls();
                 if (urls.size() == 1) {
                     return urls.front();
                 }
                 QList<QVariant> result;
                 std::copy(urls.begin(), urls.end(),
                           std::back_inserter(result));
                 return result;
             }
             break;
         default:
             break;
         }
 
         QVariant v = m_source->data(format);
         v.convert(type);
         return v;
     }
 private:
     QPointer<QMimeData> m_source;
 };
 }
 
 DragQueen::DragQueen(QWidget *p, Qt::WindowFlags f)
     : QLabel(p, f),
       m_data(),
       m_dragStartPosition()
 {
 
 }
 
 DragQueen::DragQueen(const QString &t, QWidget *p, Qt::WindowFlags f)
     : QLabel(t, p, f),
       m_data(),
       m_dragStartPosition()
 {
 
 }
 
 DragQueen::~DragQueen()
 {
     delete m_data;
 }
 
 void DragQueen::setUrl(const QString &url)
 {
-    QMimeData *data = new QMimeData;
+    auto data = new QMimeData;
     QList<QUrl> urls;
     urls.push_back(QUrl(url));
     data->setUrls(urls);
     setMimeData(data);
 }
 
 QString DragQueen::url() const
 {
     if (!m_data || !m_data->hasUrls()) {
         return QString();
     }
     const QList<QUrl> urls = m_data->urls();
     if (urls.empty()) {
         return QString();
     }
     return urls.front().toString();
 }
 
 void DragQueen::setMimeData(QMimeData *data)
 {
     if (data == m_data) {
         return;
     }
     delete m_data;
     m_data = data;
 }
 
 QMimeData *DragQueen::mimeData() const
 {
     return m_data;
 }
 
 void DragQueen::mousePressEvent(QMouseEvent *e)
 {
 #ifndef QT_NO_DRAGANDDROP
     if (m_data && e->button() == Qt::LeftButton) {
         m_dragStartPosition = e->pos();
     }
 #endif
     QLabel::mousePressEvent(e);
 }
 
 static QPoint calculate_hot_spot(const QPoint &mouse, const QSize &pix, const QLabel *label)
 {
     const Qt::Alignment align = label->alignment();
     const int margin = label->margin();
     const QRect cr = label->contentsRect().adjusted(margin, margin, -margin, -margin);
     const QRect rect = QStyle::alignedRect(QApplication::layoutDirection(), align, pix, cr);
     return mouse - rect.topLeft();
 }
 
 void DragQueen::mouseMoveEvent(QMouseEvent *e)
 {
 #ifndef QT_NO_DRAGANDDROP
     if (m_data &&
             (e->buttons() & Qt::LeftButton) &&
             (m_dragStartPosition - e->pos()).manhattanLength() > QApplication::startDragDistance()) {
-        QDrag *drag = new QDrag(this);
+        auto drag = new QDrag(this);
         const QPixmap pix = pixmap(Qt::ReturnByValue);
         if (!pix.isNull()) {
             drag->setPixmap(pix);
             drag->setHotSpot(calculate_hot_spot(e->pos(), pix.size(), this));
         }
         drag->setMimeData(new MimeDataProxy(m_data));
         drag->exec();
     } else {
 #endif
         QLabel::mouseMoveEvent(e);
 #ifndef QT_NO_DRAGANDDROP
     }
 #endif
 }
 
 #include "dragqueen.moc"
diff --git a/src/utils/filedialog.cpp b/src/utils/filedialog.cpp
index 8325c3ec1..2a669fb6a 100644
--- a/src/utils/filedialog.cpp
+++ b/src/utils/filedialog.cpp
@@ -1,74 +1,74 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/filedialog.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 "filedialog.h"
 
 #include <QFileDialog>
 #include <QDir>
 #include <QMap>
 
 using namespace Kleo;
 
 namespace
 {
-typedef QMap<QString, QString> Map;
+using Map = QMap<QString, QString>;
 Q_GLOBAL_STATIC(Map, dir_id_2_dir_map)
 }
 
 static QString dir(const QString &id)
 {
     const QString dir = (*dir_id_2_dir_map())[id];
     if (dir.isEmpty()) {
         return QDir::homePath();
     } else {
         return dir;
     }
 }
 
 static void update(const QString &fname, const QString &id)
 {
     if (!fname.isEmpty()) {
         (*dir_id_2_dir_map())[ id ] = QFileInfo(fname).absolutePath();
     }
 }
 
 QString FileDialog::getOpenFileName(QWidget *parent, const QString &caption, const QString &dirID, const QString &filter)
 {
     const QString fname = QFileDialog::getOpenFileName(parent, caption, dir(dirID), filter);
     update(fname, dirID);
     return fname;
 }
 
 QStringList FileDialog::getOpenFileNames(QWidget *parent, const QString &caption, const QString &dirID, const QString &filter)
 {
     const QStringList files = QFileDialog::getOpenFileNames(parent, caption, dir(dirID), filter);
     if (!files.empty()) {
         update(files.front(), dirID);
     }
     return files;
 }
 
 QString FileDialog::getSaveFileName(QWidget *parent, const QString &caption, const QString &dirID, const QString &filter)
 {
     const QString fname = QFileDialog::getSaveFileName(parent, caption, dir(dirID), filter);
     update(fname, dirID);
     return fname;
 }
 
 QString FileDialog::getSaveFileNameEx(QWidget *parent, const QString &caption, const QString &dirID, const QString &proposedFileName, const QString &filter)
 {
     if (proposedFileName.isEmpty()) {
         return getSaveFileName(parent, caption, dirID, filter);
     }
     const QString fname = QFileDialog::getSaveFileName(parent, caption, QDir(dir(dirID)).filePath(proposedFileName), filter);
     update(fname, dirID);
     return fname;
 }
diff --git a/src/utils/kdpipeiodevice.cpp b/src/utils/kdpipeiodevice.cpp
index ed814dc58..b36204b1f 100644
--- a/src/utils/kdpipeiodevice.cpp
+++ b/src/utils/kdpipeiodevice.cpp
@@ -1,1035 +1,1035 @@
 /*
   SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
   SPDX-License-Identifier: LGPL-2.0-or-later
  */
 
 #include <config-kleopatra.h>
 
 #include "kdpipeiodevice.h"
 
 #include <QDebug>
 #include <QMutex>
 #include <QPointer>
 #include <QThread>
 #include <QWaitCondition>
 #include "kleopatra_debug.h"
 
 #include <cstring>
 #include <memory>
 #include <algorithm>
 
 #ifdef Q_OS_WIN32
 # ifndef NOMINMAX
 #  define NOMINMAX
 # endif
 # include <windows.h>
 # include <io.h>
 #else
 # include <unistd.h>
 # include <errno.h>
 #endif
 
 #ifndef KDAB_CHECK_THIS
 # define KDAB_CHECK_CTOR (void)1
 # define KDAB_CHECK_DTOR KDAB_CHECK_CTOR
 # define KDAB_CHECK_THIS KDAB_CHECK_CTOR
 #endif
 
 #define LOCKED( d ) const QMutexLocker locker( &d->mutex )
 #define synchronized( d ) if ( int i = 0 ) {} else for ( const QMutexLocker locker( &d->mutex ) ; !i ; ++i )
 
 const unsigned int BUFFER_SIZE = 4096;
 const bool ALLOW_QIODEVICE_BUFFERING = true;
 
 namespace
 {
 KDPipeIODevice::DebugLevel s_debugLevel = KDPipeIODevice::NoDebug;
 }
 
 #define QDebug if( s_debugLevel == KDPipeIODevice::NoDebug ){}else qDebug
 
 namespace
 {
 
 class Reader : public QThread
 {
     Q_OBJECT
 public:
     Reader(int fd, Qt::HANDLE handle);
     ~Reader() override;
 
     qint64 readData(char *data, qint64 maxSize);
 
     unsigned int bytesInBuffer() const
     {
         return (wptr + sizeof buffer - rptr) % sizeof buffer;
     }
 
     bool bufferFull() const
     {
         return bytesInBuffer() == sizeof buffer - 1;
     }
 
     bool bufferEmpty() const
     {
         return bytesInBuffer() == 0;
     }
 
     bool bufferContains(char ch)
     {
         const unsigned int bib = bytesInBuffer();
         for (unsigned int i = rptr; i < rptr + bib; ++i)
             if (buffer[i % sizeof buffer] == ch) {
                 return true;
             }
         return false;
     }
 
     void notifyReadyRead();
 
 Q_SIGNALS:
     void readyRead();
 
 protected:
     void run() override;
 
 private:
     int fd;
     Qt::HANDLE handle;
 public:
     QMutex mutex;
     QWaitCondition waitForCancelCondition;
     QWaitCondition bufferNotFullCondition;
     QWaitCondition bufferNotEmptyCondition;
     QWaitCondition hasStarted;
     QWaitCondition readyReadSentCondition;
     QWaitCondition blockedConsumerIsDoneCondition;
     bool cancel;
     bool eof;
     bool error;
     bool eofShortCut;
     int errorCode;
     bool isReading;
     bool consumerBlocksOnUs;
 
 private:
     unsigned int rptr, wptr;
     char buffer[BUFFER_SIZE + 1]; // need to keep one byte free to detect empty state
 };
 
 Reader::Reader(int fd_, Qt::HANDLE handle_) : QThread(),
     fd(fd_),
     handle(handle_),
     mutex(),
     bufferNotFullCondition(),
     bufferNotEmptyCondition(),
     hasStarted(),
     cancel(false),
     eof(false),
     error(false),
     eofShortCut(false),
     errorCode(0),
     isReading(false),
     consumerBlocksOnUs(false),
     rptr(0),
     wptr(0)
 {
 
 }
 
 Reader::~Reader() {}
 
 class Writer : public QThread
 {
     Q_OBJECT
 public:
     Writer(int fd, Qt::HANDLE handle);
     ~Writer() override;
 
     qint64 writeData(const char *data, qint64 size);
 
     unsigned int bytesInBuffer() const
     {
         return numBytesInBuffer;
     }
 
     bool bufferFull() const
     {
         return numBytesInBuffer == sizeof buffer;
     }
 
     bool bufferEmpty() const
     {
         return numBytesInBuffer == 0;
     }
 
 Q_SIGNALS:
     void bytesWritten(qint64);
 
 protected:
     void run() override;
 
 private:
     int fd;
     Qt::HANDLE handle;
 public:
     QMutex mutex;
     QWaitCondition bufferEmptyCondition;
     QWaitCondition bufferNotEmptyCondition;
     QWaitCondition hasStarted;
     bool cancel;
     bool error;
     int errorCode;
 private:
     unsigned int numBytesInBuffer;
     char buffer[BUFFER_SIZE];
 };
 }
 
 Writer::Writer(int fd_, Qt::HANDLE handle_) : QThread(),
     fd(fd_),
     handle(handle_),
     mutex(),
     bufferEmptyCondition(),
     bufferNotEmptyCondition(),
     hasStarted(),
     cancel(false),
     error(false),
     errorCode(0),
     numBytesInBuffer(0)
 {
 
 }
 
 Writer::~Writer() {}
 
 class KDPipeIODevice::Private : public QObject
 {
     Q_OBJECT
     friend class ::KDPipeIODevice;
     KDPipeIODevice *const q;
 public:
 
     explicit Private(KDPipeIODevice *qq);
     ~Private();
 
     bool doOpen(int, Qt::HANDLE, OpenMode);
     bool startReaderThread();
     bool startWriterThread();
     void stopThreads();
 
 public Q_SLOTS:
     void emitReadyRead();
 
 private:
     int fd;
     Qt::HANDLE handle;
     Reader *reader;
     Writer *writer;
     bool triedToStartReader;
     bool triedToStartWriter;
 };
 
 KDPipeIODevice::DebugLevel KDPipeIODevice::debugLevel()
 {
     return s_debugLevel;
 }
 
 void KDPipeIODevice::setDebugLevel(KDPipeIODevice::DebugLevel level)
 {
     s_debugLevel = level;
 }
 
 KDPipeIODevice::Private::Private(KDPipeIODevice *qq) : QObject(qq), q(qq),
     fd(-1),
     handle(nullptr),
     reader(nullptr),
     writer(nullptr),
     triedToStartReader(false),
     triedToStartWriter(false)
 {
 
 }
 
 KDPipeIODevice::Private::~Private()
 {
     QDebug("KDPipeIODevice::~Private(): Destroying %p", (void *) q);
 }
 
 KDPipeIODevice::KDPipeIODevice(QObject *p)
     : QIODevice(p), d(new Private(this))
 {
     KDAB_CHECK_CTOR;
 }
 
 KDPipeIODevice::KDPipeIODevice(int fd, OpenMode mode, QObject *p)
     : QIODevice(p), d(new Private(this))
 {
     KDAB_CHECK_CTOR;
     open(fd, mode);
 }
 
 KDPipeIODevice::KDPipeIODevice(Qt::HANDLE handle, OpenMode mode, QObject *p)
     : QIODevice(p), d(new Private(this))
 {
     KDAB_CHECK_CTOR;
     open(handle, mode);
 }
 
 KDPipeIODevice::~KDPipeIODevice()
 {
     KDAB_CHECK_DTOR;
     if (isOpen()) {
         close();
     }
     delete d; d = nullptr;
 }
 
 bool KDPipeIODevice::open(int fd, OpenMode mode)
 {
     KDAB_CHECK_THIS;
 #ifdef Q_OS_WIN32
     return d->doOpen(fd, (HANDLE)_get_osfhandle(fd), mode);
 #else
     return d->doOpen(fd, nullptr, mode);
 #endif
 }
 
 bool KDPipeIODevice::open(Qt::HANDLE h, OpenMode mode)
 {
     KDAB_CHECK_THIS;
 #ifdef Q_OS_WIN32
     return d->doOpen(-1, h, mode);
 #else
     Q_UNUSED(h)
     Q_UNUSED(mode)
     Q_ASSERT(!"KDPipeIODevice::open( Qt::HANDLE, OpenMode ) should never be called except on Windows.");
     return false;
 #endif
 }
 
 bool KDPipeIODevice::Private::startReaderThread()
 {
     if (triedToStartReader) {
         return true;
     }
     triedToStartReader = true;
     if (reader && !reader->isRunning() && !reader->isFinished()) {
         QDebug("KDPipeIODevice::Private::startReaderThread(): locking reader (CONSUMER THREAD)");
         LOCKED(reader);
         QDebug("KDPipeIODevice::Private::startReaderThread(): locked reader (CONSUMER THREAD)");
         reader->start(QThread::HighestPriority);
         QDebug("KDPipeIODevice::Private::startReaderThread(): waiting for hasStarted (CONSUMER THREAD)");
         const bool hasStarted = reader->hasStarted.wait(&reader->mutex, 1000);
         QDebug("KDPipeIODevice::Private::startReaderThread(): returned from hasStarted (CONSUMER THREAD)");
 
         return hasStarted;
     }
     return true;
 }
 
 bool KDPipeIODevice::Private::startWriterThread()
 {
     if (triedToStartWriter) {
         return true;
     }
     triedToStartWriter = true;
     if (writer && !writer->isRunning() && !writer->isFinished()) {
         LOCKED(writer);
 
         writer->start(QThread::HighestPriority);
         if (!writer->hasStarted.wait(&writer->mutex, 1000)) {
             return false;
         }
     }
     return true;
 }
 
 void KDPipeIODevice::Private::emitReadyRead()
 {
     QPointer<Private> thisPointer(this);
     QDebug("KDPipeIODevice::Private::emitReadyRead %p", (void *) this);
 
     Q_EMIT q->readyRead();
 
     if (!thisPointer) {
         return;
     }
     if (reader) {
         QDebug("KDPipeIODevice::Private::emitReadyRead %p: locking reader (CONSUMER THREAD)", (
                    void *) this);
         synchronized(reader) {
             QDebug("KDPipeIODevice::Private::emitReadyRead %p: locked reader (CONSUMER THREAD)", (
                        void *) this);
             reader->readyReadSentCondition.wakeAll();
             QDebug("KDPipeIODevice::Private::emitReadyRead %p: buffer empty: %d reader in ReadFile: %d", (void *)this, reader->bufferEmpty(), reader->isReading);
         }
     }
     QDebug("KDPipeIODevice::Private::emitReadyRead %p leaving", (void *) this);
 
 }
 
 bool KDPipeIODevice::Private::doOpen(int fd_, Qt::HANDLE handle_, OpenMode mode_)
 {
 
     if (q->isOpen()) {
         return false;
     }
 
 #ifdef Q_OS_WIN32
     if (!handle_) {
         return false;
     }
 #else
     if (fd_ < 0) {
         return false;
     }
 #endif
 
     if (!(mode_ & ReadWrite)) {
         return false;    // need to have at least read -or- write
     }
 
     std::unique_ptr<Reader> reader_;
     std::unique_ptr<Writer> writer_;
 
     if (mode_ & ReadOnly) {
-        reader_.reset(new Reader(fd_, handle_));
+        reader_ = std::make_unique<Reader>(fd_, handle_);
         QDebug("KDPipeIODevice::doOpen (%p): created reader (%p) for fd %d", (void *)this,
                (void *)reader_.get(), fd_);
         connect(reader_.get(), &Reader::readyRead, this, &Private::emitReadyRead,
                 Qt::QueuedConnection);
     }
     if (mode_ & WriteOnly) {
-        writer_.reset(new Writer(fd_, handle_));
+        writer_ = std::make_unique<Writer>(fd_, handle_);
         QDebug("KDPipeIODevice::doOpen (%p): created writer (%p) for fd %d",
                (void *)this, (void *)writer_.get(), fd_);
         connect(writer_.get(), &Writer::bytesWritten, q, &QIODevice::bytesWritten,
                 Qt::QueuedConnection);
     }
 
     // commit to *this:
     fd = fd_;
     handle = handle_;
     reader = reader_.release();
     writer = writer_.release();
 
     q->setOpenMode(mode_ | Unbuffered);
     return true;
 }
 
 int KDPipeIODevice::descriptor() const
 {
     KDAB_CHECK_THIS;
     return d->fd;
 }
 
 Qt::HANDLE KDPipeIODevice::handle() const
 {
     KDAB_CHECK_THIS;
     return d->handle;
 }
 
 qint64 KDPipeIODevice::bytesAvailable() const
 {
     KDAB_CHECK_THIS;
     const qint64 base = QIODevice::bytesAvailable();
     if (!d->triedToStartReader) {
         d->startReaderThread();
         return base;
     }
     if (d->reader) {
         synchronized(d->reader) {
             const qint64 inBuffer = d->reader->bytesInBuffer();
             return base + inBuffer;
         }
     }
     return base;
 }
 
 qint64 KDPipeIODevice::bytesToWrite() const
 {
     KDAB_CHECK_THIS;
     d->startWriterThread();
     const qint64 base = QIODevice::bytesToWrite();
     if (d->writer) {
         synchronized(d->writer) return base + d->writer->bytesInBuffer();
     }
     return base;
 }
 
 bool KDPipeIODevice::canReadLine() const
 {
     KDAB_CHECK_THIS;
     d->startReaderThread();
     if (QIODevice::canReadLine()) {
         return true;
     }
     if (d->reader) {
         synchronized(d->reader) return d->reader->bufferContains('\n');
     }
     return true;
 }
 
 bool KDPipeIODevice::isSequential() const
 {
     return true;
 }
 
 bool KDPipeIODevice::atEnd() const
 {
     KDAB_CHECK_THIS;
     d->startReaderThread();
     if (!QIODevice::atEnd()) {
         QDebug("%p: KDPipeIODevice::atEnd returns false since QIODevice::atEnd does (with bytesAvailable=%ld)", (void *)this, static_cast<long>(bytesAvailable()));
         return false;
     }
     if (!isOpen()) {
         return true;
     }
     if (d->reader->eofShortCut) {
         return true;
     }
     LOCKED(d->reader);
     const bool eof = (d->reader->error || d->reader->eof) && d->reader->bufferEmpty();
     if (!eof) {
         if (!d->reader->error && !d->reader->eof) {
             QDebug("%p: KDPipeIODevice::atEnd returns false since !reader->error && !reader->eof",
                    (void *)(this));
         }
         if (!d->reader->bufferEmpty()) {
             QDebug("%p: KDPipeIODevice::atEnd returns false since !reader->bufferEmpty()",
                    (void *)  this);
         }
     }
     return eof;
 }
 
 bool KDPipeIODevice::waitForBytesWritten(int msecs)
 {
     KDAB_CHECK_THIS;
     d->startWriterThread();
     Writer *const w = d->writer;
     if (!w) {
         return true;
     }
     LOCKED(w);
     QDebug("KDPipeIODevice::waitForBytesWritten (%p,w=%p): entered locked area",
            (void *)this, (void *) w);
     return w->bufferEmpty() || w->error || w->bufferEmptyCondition.wait(&w->mutex, msecs);
 }
 
 bool KDPipeIODevice::waitForReadyRead(int msecs)
 {
     KDAB_CHECK_THIS;
     QDebug("KDPipeIODEvice::waitForReadyRead()(%p)", (void *) this);
     d->startReaderThread();
     if (ALLOW_QIODEVICE_BUFFERING) {
         if (bytesAvailable() > 0) {
             return true;
         }
     }
     Reader *const r = d->reader;
     if (!r || r->eofShortCut) {
         return true;
     }
     LOCKED(r);
     if (r->bytesInBuffer() != 0 || r->eof || r->error) {
         return true;
     }
     Q_ASSERT(false);   // ### wtf?
     return r->bufferNotEmptyCondition.wait(&r->mutex, msecs);
 }
 
 template <typename T>
 class TemporaryValue
 {
 public:
     TemporaryValue(T &var_, const T &tv) : var(var_), oldValue(var_)
     {
         var = tv;
     }
     ~TemporaryValue()
     {
         var = oldValue;
     }
 private:
     T &var;
     const T oldValue;
 };
 
 bool KDPipeIODevice::readWouldBlock() const
 {
     d->startReaderThread();
     LOCKED(d->reader);
     return d->reader->bufferEmpty() && !d->reader->eof && !d->reader->error;
 }
 
 bool KDPipeIODevice::writeWouldBlock() const
 {
     d->startWriterThread();
     LOCKED(d->writer);
     return !d->writer->bufferEmpty() && !d->writer->error;
 }
 
 qint64 KDPipeIODevice::readData(char *data, qint64 maxSize)
 {
     KDAB_CHECK_THIS;
     QDebug("%p: KDPipeIODevice::readData: data=%s, maxSize=%lld", (void *)this, data, maxSize);
     d->startReaderThread();
     Reader *const r = d->reader;
 
     Q_ASSERT(r);
 
     //assert( r->isRunning() ); // wrong (might be eof, error)
     Q_ASSERT(data || maxSize == 0);
     Q_ASSERT(maxSize >= 0);
 
     if (r->eofShortCut) {
         QDebug("%p: KDPipeIODevice::readData: hit eofShortCut, returning 0", (void *)this);
         return 0;
     }
 
     if (maxSize < 0) {
         maxSize = 0;
     }
 
     if (ALLOW_QIODEVICE_BUFFERING) {
         if (bytesAvailable() > 0) {
             maxSize = std::min(maxSize, bytesAvailable());    // don't block
         }
     }
     QDebug("%p: KDPipeIODevice::readData: try to lock reader (CONSUMER THREAD)", (void *) this);
     LOCKED(r);
     QDebug("%p: KDPipeIODevice::readData: locked reader (CONSUMER THREAD)", (void *) this);
 
     r->readyReadSentCondition.wakeAll();
     if (/* maxSize > 0 && */ r->bufferEmpty() &&  !r->error && !r->eof) {   // ### block on maxSize == 0?
         QDebug("%p: KDPipeIODevice::readData: waiting for bufferNotEmptyCondition (CONSUMER THREAD)", (void *) this);
         const TemporaryValue<bool> tmp(d->reader->consumerBlocksOnUs, true);
         r->bufferNotEmptyCondition.wait(&r->mutex);
         r->blockedConsumerIsDoneCondition.wakeAll();
         QDebug("%p: KDPipeIODevice::readData: woke up from bufferNotEmptyCondition (CONSUMER THREAD)",
                (void *) this);
     }
 
     if (r->bufferEmpty()) {
         QDebug("%p: KDPipeIODevice::readData: got empty buffer, signal eof", (void *) this);
         // woken with an empty buffer must mean either EOF or error:
         Q_ASSERT(r->eof || r->error);
         r->eofShortCut = true;
         return r->eof ? 0 : -1;
     }
 
     QDebug("%p: KDPipeIODevice::readData: got bufferNotEmptyCondition, trying to read %lld bytes",
            (void *)this, maxSize);
     const qint64 bytesRead = r->readData(data, maxSize);
     QDebug("%p: KDPipeIODevice::readData: read %lld bytes", (void *)this, bytesRead);
     QDebug("%p (fd=%d): KDPipeIODevice::readData: %s", (void *)this, d->fd, data);
 
     return bytesRead;
 }
 
 qint64 Reader::readData(char *data, qint64 maxSize)
 {
     qint64 numRead = rptr < wptr ? wptr - rptr : sizeof buffer - rptr;
     if (numRead > maxSize) {
         numRead = maxSize;
     }
 
     QDebug("%p: KDPipeIODevice::readData: data=%s, maxSize=%lld; rptr=%u, wptr=%u (bytesInBuffer=%u); -> numRead=%lld",
            (void *)this, data, maxSize, rptr, wptr, bytesInBuffer(), numRead);
 
     memcpy(data, buffer + rptr, numRead);
 
     rptr = (rptr + numRead) % sizeof buffer;
 
     if (!bufferFull()) {
         QDebug("%p: KDPipeIODevice::readData: signal bufferNotFullCondition", (void *) this);
         bufferNotFullCondition.wakeAll();
     }
 
     return numRead;
 }
 
 qint64 KDPipeIODevice::writeData(const char *data, qint64 size)
 {
     KDAB_CHECK_THIS;
     d->startWriterThread();
     Writer *const w = d->writer;
 
     Q_ASSERT(w);
     Q_ASSERT(w->error || w->isRunning());
     Q_ASSERT(data || size == 0);
     Q_ASSERT(size >= 0);
 
     LOCKED(w);
 
     while (!w->error && !w->bufferEmpty()) {
         QDebug("%p: KDPipeIODevice::writeData: wait for empty buffer", (void *) this);
         w->bufferEmptyCondition.wait(&w->mutex);
         QDebug("%p: KDPipeIODevice::writeData: empty buffer signaled", (void *) this);
 
     }
     if (w->error) {
         return -1;
     }
 
     Q_ASSERT(w->bufferEmpty());
 
     return w->writeData(data, size);
 }
 
 qint64 Writer::writeData(const char *data, qint64 size)
 {
     Q_ASSERT(bufferEmpty());
 
     if (size > static_cast<qint64>(sizeof buffer)) {
         size = sizeof buffer;
     }
 
     memcpy(buffer, data, size);
 
     numBytesInBuffer = size;
 
     if (!bufferEmpty()) {
         bufferNotEmptyCondition.wakeAll();
     }
     return size;
 }
 
 void KDPipeIODevice::Private::stopThreads()
 {
     if (triedToStartWriter) {
         if (writer && q->bytesToWrite() > 0) {
             q->waitForBytesWritten(-1);
         }
 
         Q_ASSERT(q->bytesToWrite() == 0);
     }
     if (Reader *&r = reader) {
         disconnect(r, &Reader::readyRead, this, &Private::emitReadyRead);
         synchronized(r) {
             // tell thread to cancel:
             r->cancel = true;
             // and wake it, so it can terminate:
             r->waitForCancelCondition.wakeAll();
             r->bufferNotFullCondition.wakeAll();
             r->readyReadSentCondition.wakeAll();
         }
     }
     if (Writer *&w = writer) {
         synchronized(w) {
             // tell thread to cancel:
             w->cancel = true;
             // and wake it, so it can terminate:
             w->bufferNotEmptyCondition.wakeAll();
         }
     }
 }
 
 void KDPipeIODevice::close()
 {
     KDAB_CHECK_THIS;
     QDebug("KDPipeIODevice::close(%p)", (void *) this);
     if (!isOpen()) {
         return;
     }
 
     // tell clients we're about to close:
     Q_EMIT aboutToClose();
     d->stopThreads();
 
 #define waitAndDelete( t ) if ( t ) { t->wait(); QThread* const t2 = t; t = nullptr; delete t2; }
     QDebug("KPipeIODevice::close(%p): wait and closing writer %p", (void *)this, (void *) d->writer);
     waitAndDelete(d->writer);
     QDebug("KPipeIODevice::close(%p): wait and closing reader %p", (void *)this, (void *) d->reader);
     if (d->reader) {
         LOCKED(d->reader);
         d->reader->readyReadSentCondition.wakeAll();
     }
     waitAndDelete(d->reader);
 #undef waitAndDelete
 #ifdef Q_OS_WIN32
     if (d->fd != -1) {
         _close(d->fd);
     } else {
         CloseHandle(d->handle);
     }
 #else
     ::close(d->fd);
 #endif
 
     setOpenMode(NotOpen);
     d->fd = -1;
     d->handle = nullptr;
 }
 
 void Reader::run()
 {
 
     LOCKED(this);
 
     // too bad QThread doesn't have that itself; a signal isn't enough
     hasStarted.wakeAll();
 
     QDebug("%p: Reader::run: started", (void *) this);
 
     while (true) {
         if (!cancel && (eof || error)) {
             //notify the client until the buffer is empty and then once
             //again so he receives eof/error. After that, wait for him
             //to cancel
             const bool wasEmpty = bufferEmpty();
             QDebug("%p: Reader::run: received eof(%d) or error(%d), waking everyone", (void *)this, eof, error);
             notifyReadyRead();
             if (!cancel && wasEmpty) {
                 waitForCancelCondition.wait(&mutex);
             }
         } else if (!cancel && !bufferFull() && !bufferEmpty()) {
             QDebug("%p: Reader::run: buffer no longer empty, waking everyone", (void *) this);
             notifyReadyRead();
         }
 
         while (!cancel && !error && bufferFull()) {
             notifyReadyRead();
             if (!cancel && bufferFull()) {
                 QDebug("%p: Reader::run: buffer is full, going to sleep", (void *)this);
                 bufferNotFullCondition.wait(&mutex);
             }
         }
 
         if (cancel) {
             QDebug("%p: Reader::run: detected cancel", (void *)this);
             goto leave;
         }
 
         if (!eof && !error) {
             if (rptr == wptr) { // optimize for larger chunks in case the buffer is empty
                 rptr = wptr = 0;
             }
 
             unsigned int numBytes = (rptr + sizeof buffer - wptr - 1) % sizeof buffer;
             if (numBytes > sizeof buffer - wptr) {
                 numBytes = sizeof buffer - wptr;
             }
 
             QDebug("%p: Reader::run: rptr=%d, wptr=%d -> numBytes=%d", (void *)this, rptr, wptr, numBytes);
 
             Q_ASSERT(numBytes > 0);
 
             QDebug("%p: Reader::run: trying to read %d bytes from fd %d", (void *)this, numBytes, fd);
 #ifdef Q_OS_WIN32
             isReading = true;
             mutex.unlock();
             DWORD numRead;
             const bool ok = ReadFile(handle, buffer + wptr, numBytes, &numRead, 0);
             mutex.lock();
             isReading = false;
             if (ok) {
                 if (numRead == 0) {
                     QDebug("%p: Reader::run: got eof (numRead==0)", (void *) this);
                     eof = true;
                 }
             } else { // !ok
                 errorCode = static_cast<int>(GetLastError());
                 if (errorCode == ERROR_BROKEN_PIPE) {
                     Q_ASSERT(numRead == 0);
                     QDebug("%p: Reader::run: got eof (broken pipe)", (void *) this);
                     eof = true;
                 } else {
                     Q_ASSERT(numRead == 0);
                     QDebug("%p: Reader::run: got error: %s (%d)", (void *) this, strerror(errorCode), errorCode);
                     error = true;
                 }
             }
 #else
             qint64 numRead;
             mutex.unlock();
             do {
                 numRead = ::read(fd, buffer + wptr, numBytes);
             } while (numRead == -1 && errno == EINTR);
             mutex.lock();
 
             if (numRead < 0) {
                 errorCode = errno;
                 error = true;
                 QDebug("%p: Reader::run: got error: %d", (void *)this, errorCode);
             } else if (numRead == 0) {
                 QDebug("%p: Reader::run: eof detected", (void *)this);
                 eof = true;
             }
 #endif
             QDebug("%p (fd=%d): Reader::run: read %ld bytes", (void *) this, fd, static_cast<long>(numRead));
             QDebug("%p (fd=%d): Reader::run: %s", (void *)this, fd, buffer);
 
             if (numRead > 0) {
                 QDebug("%p: Reader::run: buffer before: rptr=%4d, wptr=%4d", (void *)this, rptr, wptr);
                 wptr = (wptr + numRead) % sizeof buffer;
                 QDebug("%p: Reader::run: buffer after:  rptr=%4d, wptr=%4d", (void *)this, rptr, wptr);
             }
         }
     }
 leave:
     QDebug("%p: Reader::run: terminated", (void *)this);
 }
 
 void Reader::notifyReadyRead()
 {
     QDebug("notifyReadyRead: %d bytes available", bytesInBuffer());
     Q_ASSERT(!cancel);
 
     if (consumerBlocksOnUs) {
         bufferNotEmptyCondition.wakeAll();
         blockedConsumerIsDoneCondition.wait(&mutex);
         return;
     }
     QDebug("notifyReadyRead: Q_EMIT signal");
     Q_EMIT readyRead();
     readyReadSentCondition.wait(&mutex);
     QDebug("notifyReadyRead: returning from waiting, leave");
 }
 
 void Writer::run()
 {
 
     LOCKED(this);
 
     // too bad QThread doesn't have that itself; a signal isn't enough
     hasStarted.wakeAll();
 
     qCDebug(KLEOPATRA_LOG) << this << "Writer::run: started";
 
     while (true) {
 
         while (!cancel && bufferEmpty()) {
             qCDebug(KLEOPATRA_LOG) << this << "Writer::run: buffer is empty, wake bufferEmptyCond listeners";
             bufferEmptyCondition.wakeAll();
             Q_EMIT bytesWritten(0);
             qCDebug(KLEOPATRA_LOG) << this << "Writer::run: buffer is empty, going to sleep";
             bufferNotEmptyCondition.wait(&mutex);
             qCDebug(KLEOPATRA_LOG) << this << "Writer::run: woke up";
         }
 
         if (cancel) {
             qCDebug(KLEOPATRA_LOG) << this <<  "Writer::run: detected cancel";
             goto leave;
         }
 
         Q_ASSERT(numBytesInBuffer > 0);
 
         qCDebug(KLEOPATRA_LOG) << this << "Writer::run: Trying to write " << numBytesInBuffer << "bytes";
         qint64 totalWritten = 0;
         do {
             mutex.unlock();
 #ifdef Q_OS_WIN32
             DWORD numWritten;
             QDebug("%p (fd=%d): Writer::run: buffer before WriteFile (numBytes=%lld): %s:",
                    (void *) this, fd, numBytesInBuffer, buffer);
             QDebug("%p (fd=%d): Writer::run: Going into WriteFile", (void *) this, fd);
             if (!WriteFile(handle, buffer + totalWritten, numBytesInBuffer - totalWritten, &numWritten, 0)) {
                 mutex.lock();
                 errorCode = static_cast<int>(GetLastError());
                 QDebug("%p: Writer::run: got error code: %d", (void *) this, errorCode);
                 error = true;
                 goto leave;
             }
 #else
             qint64 numWritten;
             do {
                 numWritten = ::write(fd, buffer + totalWritten, numBytesInBuffer - totalWritten);
             } while (numWritten == -1 && errno == EINTR);
 
             if (numWritten < 0) {
                 mutex.lock();
                 errorCode = errno;
                 QDebug("%p: Writer::run: got error code: %s (%d)", (void *)this, strerror(errorCode), errorCode);
                 error = true;
                 goto leave;
             }
 #endif
             QDebug("%p (fd=%d): Writer::run: buffer after WriteFile (numBytes=%u): %s:", (void *)this, fd, numBytesInBuffer, buffer);
             totalWritten += numWritten;
             mutex.lock();
         } while (totalWritten < numBytesInBuffer);
 
         qCDebug(KLEOPATRA_LOG) << this << "Writer::run: wrote " << totalWritten << "bytes";
         numBytesInBuffer = 0;
         qCDebug(KLEOPATRA_LOG) << this << "Writer::run: buffer is empty, wake bufferEmptyCond listeners";
         bufferEmptyCondition.wakeAll();
         Q_EMIT bytesWritten(totalWritten);
     }
 leave:
     qCDebug(KLEOPATRA_LOG) << this << "Writer::run: terminating";
     numBytesInBuffer = 0;
     qCDebug(KLEOPATRA_LOG) << this << "Writer::run: buffer is empty, wake bufferEmptyCond listeners";
     bufferEmptyCondition.wakeAll();
     Q_EMIT bytesWritten(0);
 }
 
 // static
 std::pair<KDPipeIODevice *, KDPipeIODevice *> KDPipeIODevice::makePairOfConnectedPipes()
 {
     KDPipeIODevice *read = nullptr;
     KDPipeIODevice *write = nullptr;
 #ifdef Q_OS_WIN32
     HANDLE rh;
     HANDLE wh;
     SECURITY_ATTRIBUTES sa;
     memset(&sa, 0, sizeof(sa));
     sa.nLength = sizeof(sa);
     sa.bInheritHandle = TRUE;
     if (CreatePipe(&rh, &wh, &sa, BUFFER_SIZE)) {
         read = new KDPipeIODevice;
         read->open(rh, ReadOnly);
         write = new KDPipeIODevice;
         write->open(wh, WriteOnly);
     }
 #else
     int fds[2];
     if (pipe(fds) == 0) {
         read = new KDPipeIODevice;
         read->open(fds[0], ReadOnly);
         write = new KDPipeIODevice;
         write->open(fds[1], WriteOnly);
     }
 #endif
     return std::make_pair(read, write);
 }
 
 #ifdef KDAB_DEFINE_CHECKS
 KDAB_DEFINE_CHECKS(KDPipeIODevice)
 {
     if (!isOpen()) {
         Q_ASSERT(openMode() == NotOpen);
         Q_ASSERT(!d->reader);
         Q_ASSERT(!d->writer);
 #ifdef Q_OS_WIN32
         Q_ASSERT(!d->handle);
 #else
         Q_ASSERT(d->fd < 0);
 #endif
     } else {
         Q_ASSERT(openMode() != NotOpen);
         Q_ASSERT(openMode() & ReadWrite);
         if (openMode() & ReadOnly) {
             Q_ASSERT(d->reader);
             synchronized(d->reader)
             Q_ASSERT(d->reader->eof || d->reader->error || d->reader->isRunning());
         }
         if (openMode() & WriteOnly) {
             Q_ASSERT(d->writer);
             synchronized(d->writer)
             Q_ASSERT(d->writer->error || d->writer->isRunning());
         }
 #ifdef Q_OS_WIN32
         Q_ASSERT(d->handle);
 #else
         Q_ASSERT(d->fd >= 0);
 #endif
     }
 }
 #endif // KDAB_DEFINE_CHECKS
 
 #include "kdpipeiodevice.moc"
diff --git a/src/utils/output.cpp b/src/utils/output.cpp
index 8dfe095b7..809e42b93 100644
--- a/src/utils/output.cpp
+++ b/src/utils/output.cpp
@@ -1,762 +1,762 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/output.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 "output.h"
 #include "input_p.h"
 #include "detail_p.h"
 #include "kleo_assert.h"
 #include "kdpipeiodevice.h"
 #include "log.h"
 #include "cached.h"
 
 #include <Libkleo/KleoException>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include "kleopatra_debug.h"
 
 #include <QFileInfo>
 #include <QTemporaryFile>
 #include <QString>
 #include <QClipboard>
 #include <QApplication>
 #include <QBuffer>
 #include <QPointer>
 #include <QWidget>
 #include <QDir>
 #include <QProcess>
 #include <QTimer>
 
 #ifdef Q_OS_WIN
 # include <windows.h>
 #endif
 
 #include <cerrno>
 
 using namespace Kleo;
 using namespace Kleo::_detail;
 
 static const int PROCESS_MAX_RUNTIME_TIMEOUT = -1;     // no timeout
 static const int PROCESS_TERMINATE_TIMEOUT   = 5 * 1000; // 5s
 
 class OverwritePolicy::Private
 {
 public:
     Private(QWidget *p, OverwritePolicy::Policy pol) : policy(pol), widget(p) {}
     OverwritePolicy::Policy policy;
     QWidget *widget;
 };
 
 OverwritePolicy::OverwritePolicy(QWidget *parent, Policy initialPolicy) : d(new Private(parent, initialPolicy))
 {
 }
 
 OverwritePolicy::~OverwritePolicy() {}
 
 OverwritePolicy::Policy OverwritePolicy::policy() const
 {
     return d->policy;
 }
 
 void OverwritePolicy::setPolicy(Policy policy)
 {
     d->policy = policy;
 }
 
 QWidget *OverwritePolicy::parentWidget() const
 {
     return d->widget;
 }
 
 namespace
 {
 
 class TemporaryFile : public QTemporaryFile
 {
 public:
     explicit TemporaryFile() : QTemporaryFile() {}
     explicit TemporaryFile(const QString &templateName) : QTemporaryFile(templateName) {}
     explicit TemporaryFile(QObject *parent) : QTemporaryFile(parent) {}
     explicit TemporaryFile(const QString &templateName, QObject *parent) : QTemporaryFile(templateName, parent) {}
 
     void close() override {
         if (isOpen())
         {
             m_oldFileName = fileName();
         }
         QTemporaryFile::close();
     }
 
     bool openNonInheritable()
     {
         if (!QTemporaryFile::open()) {
             return false;
         }
 #if defined(Q_OS_WIN)
         //QTemporaryFile (tested with 4.3.3) creates the file handle as inheritable.
         //The handle is then inherited by gpgsm, which prevents deletion of the temp file
         //in FileOutput::doFinalize()
         //There are no inheritable handles under wince
         return SetHandleInformation((HANDLE)_get_osfhandle(handle()), HANDLE_FLAG_INHERIT, 0);
 #endif
         return true;
     }
 
     QString oldFileName() const
     {
         return m_oldFileName;
     }
 
 private:
     QString m_oldFileName;
 };
 
 template <typename T_IODevice>
 struct inhibit_close : T_IODevice {
     explicit inhibit_close() : T_IODevice() {}
     template <typename T1>
     explicit inhibit_close(T1 &t1) : T_IODevice(t1) {}
 
     /* reimp */ void close() override {}
     void reallyClose()
     {
         T_IODevice::close();
     }
 };
 
 template <typename T_IODevice>
 struct redirect_close : T_IODevice {
     explicit redirect_close() : T_IODevice(), m_closed(false) {}
     template <typename T1>
     explicit redirect_close(T1 &t1) : T_IODevice(t1), m_closed(false) {}
 
     /* reimp */ void close() override
     {
         this->closeWriteChannel();
         m_closed = true;
     }
 
     bool isClosed() const
     {
         return m_closed;
     }
 private:
     bool m_closed;
 };
 
 class FileOutput;
 class OutputInput : public InputImplBase
 {
 public:
     OutputInput(const std::shared_ptr<FileOutput> &output);
 
     unsigned int classification() const override
     {
         return 0;
     }
 
     void outputFinalized()
     {
         if (!m_ioDevice->open(QIODevice::ReadOnly)) {
             qCCritical(KLEOPATRA_LOG) << "Failed to open file for reading";
         }
     }
 
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_ioDevice;
     }
 
     unsigned long long size() const override
     {
         return 0;
     }
 
 private:
     std::shared_ptr<FileOutput> m_output;
     mutable std::shared_ptr<QIODevice> m_ioDevice = nullptr;
 };
 
 class OutputImplBase : public Output
 {
 public:
     OutputImplBase()
         : Output(),
           m_defaultLabel(),
           m_customLabel(),
           m_errorString(),
           m_isFinalized(false),
           m_isFinalizing(false),
           m_cancelPending(false),
           m_canceled(false),
           m_binaryOpt(false)
     {
 
     }
 
     QString label() const override
     {
         return m_customLabel.isEmpty() ? m_defaultLabel : m_customLabel;
     }
     void setLabel(const QString &label) override {
         m_customLabel = label;
     }
     void setDefaultLabel(const QString &l)
     {
         m_defaultLabel = l;
     }
     void setBinaryOpt(bool value) override {
         m_binaryOpt = value;
     }
     bool binaryOpt() const override
     {
         return m_binaryOpt;
     }
 
     QString errorString() const override
     {
         if (m_errorString.dirty()) {
             m_errorString = doErrorString();
         }
         return m_errorString;
     }
 
     bool isFinalized() const override
     {
         return m_isFinalized;
     }
     void finalize() override {
         qCDebug(KLEOPATRA_LOG) << this;
         if (m_isFinalized || m_isFinalizing)
         {
             return;
         }
         m_isFinalizing = true;
         try {
             doFinalize();
         } catch (...)
         {
             m_isFinalizing = false;
             throw;
         }
         m_isFinalizing = false;
         m_isFinalized = true;
         if (m_cancelPending)
         {
             cancel();
         }
     }
 
     void cancel() override {
         qCDebug(KLEOPATRA_LOG) << this;
         if (m_isFinalizing)
         {
             m_cancelPending = true;
         } else if (!m_canceled)
         {
             m_isFinalizing = true;
             try {
                 doCancel();
             } catch (...) {}
             m_isFinalizing = false;
             m_isFinalized = false;
             m_canceled = true;
         }
     }
 private:
     virtual QString doErrorString() const
     {
         if (std::shared_ptr<QIODevice> io = ioDevice()) {
             return io->errorString();
         } else {
             return i18n("No output device");
         }
     }
     virtual void doFinalize() = 0;
     virtual void doCancel() = 0;
 private:
     QString m_defaultLabel;
     QString m_customLabel;
     mutable cached<QString> m_errorString;
     bool m_isFinalized   : 1;
     bool m_isFinalizing  : 1;
     bool m_cancelPending : 1;
     bool m_canceled      : 1;
     bool m_binaryOpt     : 1;
 };
 
 class PipeOutput : public OutputImplBase
 {
 public:
     explicit PipeOutput(assuan_fd_t fd);
 
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_io;
     }
     void doFinalize() override {
         m_io->reallyClose();
     }
     void doCancel() override {
         doFinalize();
     }
 private:
     std::shared_ptr< inhibit_close<KDPipeIODevice> > m_io;
 };
 
 class ProcessStdInOutput : public OutputImplBase
 {
 public:
     explicit ProcessStdInOutput(const QString &cmd, const QStringList &args, const QDir &wd);
 
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_proc;
     }
     void doFinalize() override {
         /*
           Make sure the data is written in the output here. If this
           is not done the output will be written in small chunks
           trough the eventloop causing an unnecessary delay before
           the process has even a chance to work and finish.
           This delay is mainly noticeable on Windows where it can
           take ~30 seconds to write out a 10MB file in the 512 byte
           chunks gpgme serves. */
         qCDebug(KLEOPATRA_LOG) << "Waiting for " << m_proc->bytesToWrite()
         << " Bytes to be written";
         while (m_proc->waitForBytesWritten(PROCESS_MAX_RUNTIME_TIMEOUT));
 
         if (!m_proc->isClosed())
         {
             m_proc->close();
         }
         m_proc->waitForFinished(PROCESS_MAX_RUNTIME_TIMEOUT);
     }
 
     bool failed() const override
     {
         if (!m_proc) {
             return false;
         }
         return !(m_proc->exitStatus() == QProcess::NormalExit && m_proc->exitCode() == 0);
     }
 
     void doCancel() override {
         m_proc->terminate();
         QTimer::singleShot(PROCESS_TERMINATE_TIMEOUT, m_proc.get(), &QProcess::kill);
     }
     QString label() const override;
 
 private:
     QString doErrorString() const override;
 
 private:
     const QString m_command;
     const QStringList m_arguments;
     const std::shared_ptr< redirect_close<QProcess> > m_proc;
 };
 
 class FileOutput : public OutputImplBase
 {
 public:
     explicit FileOutput(const QString &fileName, const std::shared_ptr<OverwritePolicy> &policy);
     ~FileOutput()
     {
         qCDebug(KLEOPATRA_LOG) << this;
     }
 
     QString label() const override
     {
         return QFileInfo(m_fileName).fileName();
     }
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_tmpFile;
     }
     void doFinalize() override;
     void doCancel() override {
         qCDebug(KLEOPATRA_LOG) << this;
     }
     QString fileName() const
     {
         return m_fileName;
     }
 
     void attachInput(const std::shared_ptr<OutputInput> &input)
     {
         m_attachedInput = std::weak_ptr<OutputInput>(input);
     }
 
 private:
     bool obtainOverwritePermission();
 
 private:
     const QString m_fileName;
     std::shared_ptr< TemporaryFile > m_tmpFile;
     const std::shared_ptr<OverwritePolicy> m_policy;
     std::weak_ptr<OutputInput> m_attachedInput;
 };
 
 #ifndef QT_NO_CLIPBOARD
 class ClipboardOutput : public OutputImplBase
 {
 public:
     explicit ClipboardOutput(QClipboard::Mode mode);
 
     QString label() const override;
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_buffer;
     }
     void doFinalize() override;
     void doCancel() override {}
 
 private:
     QString doErrorString() const override
     {
         return QString();
     }
 private:
     const QClipboard::Mode m_mode;
     std::shared_ptr<QBuffer> m_buffer;
 };
 #endif // QT_NO_CLIPBOARD
 
 class ByteArrayOutput: public OutputImplBase
 {
 public:
     explicit ByteArrayOutput(QByteArray *data):
         m_buffer(std::shared_ptr<QBuffer>(new QBuffer(data)))
     {
         if (!m_buffer->open(QIODevice::WriteOnly))
             throw Exception(gpg_error(GPG_ERR_EIO),
                             QStringLiteral("Could not open bytearray for writing?!"));
     }
 
     QString label() const override
     {
         return m_label;
     }
 
     void setLabel(const QString &label) override
     {
         m_label = label;
     }
 
     std::shared_ptr<QIODevice> ioDevice() const override
     {
         return m_buffer;
     }
 
     void doFinalize() override
     {
         m_buffer->close();
     }
 
     void doCancel() override
     {
         m_buffer->close();
     }
 
 private:
     QString doErrorString() const override
     {
         return QString();
     }
 private:
     QString m_label;
     std::shared_ptr<QBuffer> m_buffer;
 };
 
 }
 
 std::shared_ptr<Output> Output::createFromPipeDevice(assuan_fd_t fd, const QString &label)
 {
     std::shared_ptr<PipeOutput> po(new PipeOutput(fd));
     po->setDefaultLabel(label);
     return po;
 }
 
 PipeOutput::PipeOutput(assuan_fd_t fd)
     : OutputImplBase(),
       m_io(new inhibit_close<KDPipeIODevice>)
 {
     errno = 0;
     if (!m_io->open(fd, QIODevice::WriteOnly))
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not open FD %1 for writing",
                              assuanFD2int(fd)));
 }
 
 std::shared_ptr<Output> Output::createFromFile(const QString &fileName, bool forceOverwrite)
 {
     return createFromFile(fileName, std::shared_ptr<OverwritePolicy>(new OverwritePolicy(nullptr, forceOverwrite ? OverwritePolicy::Allow : OverwritePolicy::Deny)));
 
 }
 std::shared_ptr<Output> Output::createFromFile(const QString &fileName, const std::shared_ptr<OverwritePolicy> &policy)
 {
     std::shared_ptr<FileOutput> fo(new FileOutput(fileName, policy));
     qCDebug(KLEOPATRA_LOG) << fo.get();
     return fo;
 }
 
 FileOutput::FileOutput(const QString &fileName, const std::shared_ptr<OverwritePolicy> &policy)
     : OutputImplBase(),
       m_fileName(fileName),
       m_tmpFile(new TemporaryFile(fileName)),
       m_policy(policy)
 {
     Q_ASSERT(m_policy);
     errno = 0;
     if (!m_tmpFile->openNonInheritable())
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not create temporary file for output \"%1\"", fileName));
 }
 
 bool FileOutput::obtainOverwritePermission()
 {
     if (m_policy->policy() != OverwritePolicy::Ask) {
         return m_policy->policy() == OverwritePolicy::Allow;
     }
     const int sel = KMessageBox::questionYesNoCancel(m_policy->parentWidget(), i18n("The file <b>%1</b> already exists.\n"
                     "Overwrite?", m_fileName),
                     i18n("Overwrite Existing File?"),
                     KStandardGuiItem::overwrite(),
                     KGuiItem(i18n("Overwrite All")),
                     KStandardGuiItem::cancel());
     if (sel == KMessageBox::No) { //Overwrite All
         m_policy->setPolicy(OverwritePolicy::Allow);
     }
     return sel == KMessageBox::Yes || sel == KMessageBox::No;
 }
 
 void FileOutput::doFinalize()
 {
     qCDebug(KLEOPATRA_LOG) << this;
 
     struct Remover {
         QString file;
         ~Remover()
         {
             if (QFile::exists(file)) {
                 QFile::remove(file);
             }
         }
     } remover;
 
     kleo_assert(m_tmpFile);
 
     if (m_tmpFile->isOpen()) {
         m_tmpFile->close();
     }
 
     QString tmpFileName = remover.file = m_tmpFile->oldFileName();
 
     m_tmpFile->setAutoRemove(false);
     QPointer<QObject> guard = m_tmpFile.get();
     m_tmpFile.reset(); // really close the file - needed on Windows for renaming :/
     kleo_assert(!guard);   // if this triggers, we need to audit for holder of std::shared_ptr<QIODevice>s.
 
     const QFileInfo fi(tmpFileName);
     bool qtbug83365_workaround = false;
     if (!fi.exists()) {
         /* QT Bug 83365 since qt 5.13 causes the filename of temporary files
          * in UNC path name directories (unmounted samba shares) to start with
          * UNC/ instead of the // that Qt can actually handle for things like
          * rename and remove. So if we can't find our temporary file we try
          * to workaround that bug. */
         qCDebug(KLEOPATRA_LOG) << "failure to find " << tmpFileName;
         if (tmpFileName.startsWith(QStringLiteral("UNC"))) {
             tmpFileName.replace(QRegExp(QStringLiteral("^UNC")), QStringLiteral("/"));
             qtbug83365_workaround = true;
         }
         const QFileInfo fi2(tmpFileName);
         if (!fi2.exists()) {
             throw Exception(gpg_error(GPG_ERR_EIO),
                     QStringLiteral("Could not find temporary file \"%1\".").arg(tmpFileName));
         }
     }
     qCDebug(KLEOPATRA_LOG) << this << " renaming " << tmpFileName << "->" << m_fileName;
 
     if (QFile::rename(tmpFileName, m_fileName)) {
         qCDebug(KLEOPATRA_LOG) << this << "succeeded";
 
         if (!m_attachedInput.expired()) {
             m_attachedInput.lock()->outputFinalized();
         }
         return;
     }
 
     qCDebug(KLEOPATRA_LOG) << this << "failed";
 
     if (!obtainOverwritePermission())
         throw Exception(gpg_error(GPG_ERR_CANCELED),
                         i18n("Overwriting declined"));
 
     qCDebug(KLEOPATRA_LOG) << this << "going to overwrite" << m_fileName;
 
     if (!QFile::remove(m_fileName))
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not remove file \"%1\" for overwriting.", m_fileName));
 
     qCDebug(KLEOPATRA_LOG) << this << "succeeded, renaming " << tmpFileName << "->" << m_fileName;
 
     if (QFile::rename(tmpFileName, m_fileName)) {
         qCDebug(KLEOPATRA_LOG) << this << "succeeded";
 
         if (!m_attachedInput.expired()) {
             m_attachedInput.lock()->outputFinalized();
         }
         if (qtbug83365_workaround) {
             QFile::remove(tmpFileName);
         }
         return;
     }
 
     qCDebug(KLEOPATRA_LOG) << this << "failed";
 
     throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
-                    i18n("Could not rename file \"%1\" to \"%2\"",
+                    i18n(R"(Could not rename file "%1" to "%2")",
                          tmpFileName, m_fileName));
 }
 
 std::shared_ptr<Output> Output::createFromProcessStdIn(const QString &command)
 {
     return std::shared_ptr<Output>(new ProcessStdInOutput(command, QStringList(), QDir::current()));
 }
 
 std::shared_ptr<Output> Output::createFromProcessStdIn(const QString &command, const QStringList &args)
 {
     return std::shared_ptr<Output>(new ProcessStdInOutput(command, args, QDir::current()));
 }
 
 std::shared_ptr<Output> Output::createFromProcessStdIn(const QString &command, const QStringList &args, const QDir &wd)
 {
     return std::shared_ptr<Output>(new ProcessStdInOutput(command, args, wd));
 }
 
 ProcessStdInOutput::ProcessStdInOutput(const QString &cmd, const QStringList &args, const QDir &wd)
     : OutputImplBase(),
       m_command(cmd),
       m_arguments(args),
       m_proc(new redirect_close<QProcess>)
 {
     qCDebug(KLEOPATRA_LOG) << "cd" << wd.absolutePath() << '\n' << cmd << args;
     if (cmd.isEmpty())
         throw Exception(gpg_error(GPG_ERR_INV_ARG),
                         i18n("Command not specified"));
     m_proc->setWorkingDirectory(wd.absolutePath());
     m_proc->start(cmd, args);
     m_proc->setReadChannel(QProcess::StandardError);
     if (!m_proc->waitForStarted())
         throw Exception(gpg_error(GPG_ERR_EIO),
                         i18n("Could not start %1 process: %2", cmd, m_proc->errorString()));
 }
 
 QString ProcessStdInOutput::label() const
 {
     if (!m_proc) {
         return OutputImplBase::label();
     }
     // output max. 3 arguments
     const QString cmdline = (QStringList(m_command) + m_arguments.mid(0, 3)).join(QLatin1Char(' '));
     if (m_arguments.size() > 3) {
         return i18nc("e.g. \"Input to tar xf - file1 ...\"", "Input to %1 ...", cmdline);
     } else {
         return i18nc("e.g. \"Input to tar xf - file\"",      "Input to %1",     cmdline);
     }
 }
 
 QString ProcessStdInOutput::doErrorString() const
 {
     kleo_assert(m_proc);
     if (m_proc->exitStatus() == QProcess::NormalExit && m_proc->exitCode() == 0) {
         return QString();
     }
     if (m_proc->error() == QProcess::UnknownError)
         return i18n("Error while running %1: %2", m_command,
                     QString::fromLocal8Bit(m_proc->readAllStandardError().trimmed().constData()));
     else {
         return i18n("Failed to execute %1: %2", m_command, m_proc->errorString());
     }
 }
 
 #ifndef QT_NO_CLIPBOARD
 std::shared_ptr<Output> Output::createFromClipboard()
 {
     return std::shared_ptr<Output>(new ClipboardOutput(QClipboard::Clipboard));
 }
 
 ClipboardOutput::ClipboardOutput(QClipboard::Mode mode)
     : OutputImplBase(),
       m_mode(mode),
       m_buffer(new QBuffer)
 {
     errno = 0;
     if (!m_buffer->open(QIODevice::WriteOnly))
         throw Exception(errno ? gpg_error_from_errno(errno) : gpg_error(GPG_ERR_EIO),
                         i18n("Could not write to clipboard"));
 }
 
 QString ClipboardOutput::label() const
 {
     switch (m_mode) {
     case QClipboard::Clipboard:
         return i18n("Clipboard");
     case QClipboard::FindBuffer:
         return i18n("Find buffer");
     case QClipboard::Selection:
         return i18n("Selection");
     }
     return QString();
 }
 
 void ClipboardOutput::doFinalize()
 {
     if (m_buffer->isOpen()) {
         m_buffer->close();
     }
     if (QClipboard *const cb = QApplication::clipboard()) {
         cb->setText(QString::fromUtf8(m_buffer->data()));
     } else
         throw Exception(gpg_error(GPG_ERR_EIO),
                         i18n("Could not find clipboard"));
 }
 #endif // QT_NO_CLIPBOARD
 
 Output::~Output() {}
 
 
 OutputInput::OutputInput(const std::shared_ptr<FileOutput> &output)
     : m_output(output)
     , m_ioDevice(new QFile(output->fileName()))
 {
 }
 
 
 
 std::shared_ptr<Input> Input::createFromOutput(const std::shared_ptr<Output> &output)
 {
     if (auto fo = std::dynamic_pointer_cast<FileOutput>(output)) {
         auto input = std::shared_ptr<OutputInput>(new OutputInput(fo));
         fo->attachInput(input);
         return input;
     } else {
         return {};
     }
 }
 
 std::shared_ptr<Output> Output::createFromByteArray(QByteArray *data, const QString &label)
 {
     auto ret = std::shared_ptr<ByteArrayOutput>(new ByteArrayOutput(data));
     ret->setLabel(label);
     return ret;
 }
diff --git a/src/utils/wsastarter.cpp b/src/utils/wsastarter.cpp
index f1b25cc2a..7939f0b90 100644
--- a/src/utils/wsastarter.cpp
+++ b/src/utils/wsastarter.cpp
@@ -1,44 +1,44 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     utils/wsastarter.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 "wsastarter.h"
 
 using namespace Kleo;
 
 #ifdef _WIN32
 # include <winsock2.h>
 #else
-typedef int WSADATA;
+using WSADATA = int;
 static inline int WSAStartup(int, int *)
 {
     return 0;
 }
 static inline void WSACleanup() {}
 #endif
 
 static int startWSA()
 {
     WSADATA dummy;
     return WSAStartup(0x202, &dummy);
 }
 
 WSAStarter::WSAStarter()
     : startupError(startWSA())
 {
 
 }
 
 WSAStarter::~WSAStarter()
 {
     if (!startupError) {
         WSACleanup();
     }
 }
diff --git a/src/view/keytreeview.cpp b/src/view/keytreeview.cpp
index ccf21af10..f70f3d5ee 100644
--- a/src/view/keytreeview.cpp
+++ b/src/view/keytreeview.cpp
@@ -1,725 +1,725 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     view/keytreeview.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 "keytreeview.h"
 
 #include <Libkleo/KeyList>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/KeyRearrangeColumnsProxyModel>
 #include <Libkleo/Predicates>
 
 #include "utils/headerview.h"
 #include "utils/tags.h"
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyCache>
 
 #include <gpgme++/key.h>
 
 #include "kleopatra_debug.h"
 #include <QTimer>
 #include <QTreeView>
 #include <QHeaderView>
 #include <QItemSelectionModel>
 #include <QItemSelection>
 #include <QLayout>
 #include <QList>
 #include <QMenu>
 #include <QAction>
 #include <QEvent>
 #include <QContextMenuEvent>
 
 #include <KSharedConfig>
 #include <KLocalizedString>
 
 #include <gpgme++/gpgmepp_version.h>
 #if GPGMEPP_VERSION >= 0x10E00 // 1.14.0
 # define GPGME_HAS_REMARKS
 #endif
 
 #define TAGS_COLUMN 13
 
 using namespace Kleo;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 
 namespace
 {
 
 class TreeView : public QTreeView
 {
 public:
     explicit TreeView(QWidget *parent = nullptr) : QTreeView(parent)
     {
         header()->installEventFilter(this);
     }
 
     QSize minimumSizeHint() const override
     {
         const QSize min = QTreeView::minimumSizeHint();
         return QSize(min.width(), min.height() + 5 * fontMetrics().height());
     }
 
 protected:
     bool eventFilter(QObject *watched, QEvent *event) override
     {
         Q_UNUSED(watched)
         if (event->type() == QEvent::ContextMenu) {
-            QContextMenuEvent *e = static_cast<QContextMenuEvent *>(event);
+            auto e = static_cast<QContextMenuEvent *>(event);
 
             if (!mHeaderPopup) {
                 mHeaderPopup = new QMenu(this);
                 mHeaderPopup->setTitle(i18n("View Columns"));
                 for (int i = 0; i < model()->columnCount(); ++i) {
                     QAction *tmp
                         = mHeaderPopup->addAction(model()->headerData(i, Qt::Horizontal).toString());
                     tmp->setData(QVariant(i));
                     tmp->setCheckable(true);
                     mColumnActions << tmp;
                 }
 
                 connect(mHeaderPopup, &QMenu::triggered, this, [this] (QAction *action) {
                     const int col = action->data().toInt();
                     if ((col == TAGS_COLUMN) && action->isChecked()) {
                         Tags::enableTags();
                     }
                     if (action->isChecked()) {
                         showColumn(col);
                     } else {
                         hideColumn(col);
                     }
 
-                    KeyTreeView *tv = qobject_cast<KeyTreeView *> (parent());
+                    auto tv = qobject_cast<KeyTreeView *> (parent());
                     if (tv) {
                         tv->resizeColumns();
                     }
                 });
             }
 
             for (QAction *action : qAsConst(mColumnActions)) {
                 const int column = action->data().toInt();
                 action->setChecked(!isColumnHidden(column));
             }
 
             mHeaderPopup->popup(mapToGlobal(e->pos()));
             return true;
         }
 
         return false;
     }
 
 private:
     QMenu *mHeaderPopup = nullptr;
 
     QList<QAction *> mColumnActions;
 };
 
 const KeyListModelInterface * keyListModel(const QTreeView &view)
 {
     const KeyListModelInterface *const klmi = dynamic_cast<KeyListModelInterface *>(view.model());
     Q_ASSERT(klmi);
     return klmi;
 }
 
 } // anon namespace
 
 KeyTreeView::KeyTreeView(QWidget *parent)
     : QWidget(parent),
       m_proxy(new KeyListSortFilterProxyModel(this)),
       m_additionalProxy(nullptr),
       m_view(new TreeView(this)),
       m_flatModel(nullptr),
       m_hierarchicalModel(nullptr),
       m_stringFilter(),
       m_keyFilter(),
       m_isHierarchical(true)
 {
     init();
 }
 
 KeyTreeView::KeyTreeView(const KeyTreeView &other)
     : QWidget(nullptr),
       m_proxy(new KeyListSortFilterProxyModel(this)),
       m_additionalProxy(other.m_additionalProxy ? other.m_additionalProxy->clone() : nullptr),
       m_view(new TreeView(this)),
       m_flatModel(other.m_flatModel),
       m_hierarchicalModel(other.m_hierarchicalModel),
       m_stringFilter(other.m_stringFilter),
       m_keyFilter(other.m_keyFilter),
       m_group(other.m_group),
       m_isHierarchical(other.m_isHierarchical)
 {
     init();
     setColumnSizes(other.columnSizes());
     setSortColumn(other.sortColumn(), other.sortOrder());
 }
 
 KeyTreeView::KeyTreeView(const QString &text, const std::shared_ptr<KeyFilter> &kf,
                          AbstractKeyListSortFilterProxyModel *proxy, QWidget *parent,
                          const KConfigGroup &group)
     : QWidget(parent),
       m_proxy(new KeyListSortFilterProxyModel(this)),
       m_additionalProxy(proxy),
       m_view(new TreeView(this)),
       m_flatModel(nullptr),
       m_hierarchicalModel(nullptr),
       m_stringFilter(text),
       m_keyFilter(kf),
       m_group(group),
       m_isHierarchical(true),
       m_onceResized(false)
 {
     init();
 }
 
 void KeyTreeView::setColumnSizes(const std::vector<int> &sizes)
 {
     if (sizes.empty()) {
         return;
     }
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     Q_ASSERT(qobject_cast<HeaderView *>(m_view->header()) == static_cast<HeaderView *>(m_view->header()));
-    if (HeaderView *const hv = static_cast<HeaderView *>(m_view->header())) {
+    if (auto const hv = static_cast<HeaderView *>(m_view->header())) {
         hv->setSectionSizes(sizes);
     }
 }
 
 void KeyTreeView::setSortColumn(int sortColumn, Qt::SortOrder sortOrder)
 {
     Q_ASSERT(m_view);
     m_view->sortByColumn(sortColumn, sortOrder);
 }
 
 int KeyTreeView::sortColumn() const
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     return m_view->header()->sortIndicatorSection();
 }
 
 Qt::SortOrder KeyTreeView::sortOrder() const
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     return m_view->header()->sortIndicatorOrder();
 }
 
 std::vector<int> KeyTreeView::columnSizes() const
 {
     Q_ASSERT(m_view);
     Q_ASSERT(m_view->header());
     Q_ASSERT(qobject_cast<HeaderView *>(m_view->header()) == static_cast<HeaderView *>(m_view->header()));
-    if (HeaderView *const hv = static_cast<HeaderView *>(m_view->header())) {
+    if (auto const hv = static_cast<HeaderView *>(m_view->header())) {
         return hv->sectionSizes();
     } else {
         return std::vector<int>();
     }
 }
 
 void KeyTreeView::init()
 {
     KDAB_SET_OBJECT_NAME(m_proxy);
     KDAB_SET_OBJECT_NAME(m_view);
 
     if (m_group.isValid()) {
         // Reopen as non const
         KConfig *conf = m_group.config();
         m_group = conf->group(m_group.name());
     }
 
     if (m_additionalProxy && m_additionalProxy->objectName().isEmpty()) {
         KDAB_SET_OBJECT_NAME(m_additionalProxy);
     }
     QLayout *layout = new QVBoxLayout(this);
     KDAB_SET_OBJECT_NAME(layout);
     layout->setContentsMargins(0, 0, 0, 0);
     layout->addWidget(m_view);
 
-    HeaderView *headerView = new HeaderView(Qt::Horizontal);
+    auto headerView = new HeaderView(Qt::Horizontal);
     KDAB_SET_OBJECT_NAME(headerView);
     headerView->installEventFilter(m_view);
     headerView->setSectionsMovable(true);
     m_view->setHeader(headerView);
 
     m_view->setSelectionBehavior(QAbstractItemView::SelectRows);
     m_view->setSelectionMode(QAbstractItemView::ExtendedSelection);
     //m_view->setAlternatingRowColors( true );
     m_view->setAllColumnsShowFocus(true);
     m_view->setSortingEnabled(true);
 
     if (model()) {
         if (m_additionalProxy) {
             m_additionalProxy->setSourceModel(model());
         } else {
             m_proxy->setSourceModel(model());
         }
     }
     if (m_additionalProxy) {
         m_proxy->setSourceModel(m_additionalProxy);
         if (!m_additionalProxy->parent()) {
             m_additionalProxy->setParent(this);
         }
     }
 
     m_proxy->setFilterFixedString(m_stringFilter);
     m_proxy->setKeyFilter(m_keyFilter);
     m_proxy->setSortCaseSensitivity(Qt::CaseInsensitive);
 
-    KeyRearrangeColumnsProxyModel *rearangingModel = new KeyRearrangeColumnsProxyModel(this);
+    auto rearangingModel = new KeyRearrangeColumnsProxyModel(this);
     rearangingModel->setSourceModel(m_proxy);
     rearangingModel->setSourceColumns(QVector<int>() << KeyList::PrettyName
                                                      << KeyList::PrettyEMail
                                                      << KeyList::Validity
                                                      << KeyList::ValidFrom
                                                      << KeyList::ValidUntil
                                                      << KeyList::TechnicalDetails
                                                      << KeyList::KeyID
                                                      << KeyList::Fingerprint
                                                      << KeyList::OwnerTrust
                                                      << KeyList::Origin
                                                      << KeyList::LastUpdate
                                                      << KeyList::Issuer
                                                      << KeyList::SerialNumber
 #ifdef GPGME_HAS_REMARKS
     // If a column is added before this TAGS_COLUMN define has to be updated accordingly
                                                      << KeyList::Remarks
 #endif
     );
     m_view->setModel(rearangingModel);
 
     /* Handle expansion state */
     if (m_group.isValid()) {
         m_expandedKeys = m_group.readEntry("Expanded", QStringList());
     }
 
     connect(m_view, &QTreeView::expanded, this, [this] (const QModelIndex &index) {
         if (!index.isValid()) {
             return;
         }
         const auto &key = index.data(KeyList::KeyRole).value<GpgME::Key>();
         if (key.isNull()) {
             return;
         }
         const auto fpr = QString::fromLatin1(key.primaryFingerprint());
 
         if (m_expandedKeys.contains(fpr)) {
             return;
         }
         m_expandedKeys << fpr;
         if (m_group.isValid()) {
             m_group.writeEntry("Expanded", m_expandedKeys);
         }
     });
 
     connect(m_view, &QTreeView::collapsed, this, [this] (const QModelIndex &index) {
         if (!index.isValid()) {
             return;
         }
         const auto &key = index.data(KeyList::KeyRole).value<GpgME::Key>();
         if (key.isNull()) {
             return;
         }
         m_expandedKeys.removeAll(QString::fromLatin1(key.primaryFingerprint()));
         if (m_group.isValid()) {
             m_group.writeEntry("Expanded", m_expandedKeys);
         }
     });
 
     connect(KeyCache::instance().get(), &KeyCache::keysMayHaveChanged, this, [this] () {
         /* We use a single shot timer here to ensure that the keysMayHaveChanged
          * handlers are all handled before we restore the expand state so that
          * the model is already populated. */
         QTimer::singleShot(0, [this] () {
             restoreExpandState();
             setUpTagKeys();
             if (!m_onceResized) {
                 m_onceResized = true;
                 resizeColumns();
             }
         });
     });
     resizeColumns();
     if (m_group.isValid()) {
         restoreLayout(m_group);
     }
 }
 
 void KeyTreeView::restoreExpandState()
 {
     if (!KeyCache::instance()->initialized()) {
         qCWarning(KLEOPATRA_LOG) << "Restore expand state before keycache available. Aborting.";
         return;
     }
     for (const auto &fpr: qAsConst(m_expandedKeys)) {
         const KeyListModelInterface *const km = keyListModel(*m_view);
         if (!km) {
             qCWarning(KLEOPATRA_LOG) << "invalid model";
             return;
         }
         const auto key = KeyCache::instance()->findByFingerprint(fpr.toLatin1().constData());
         if (key.isNull()) {
             qCDebug(KLEOPATRA_LOG) << "Cannot find:" << fpr << "anymore in cache";
             m_expandedKeys.removeAll(fpr);
             return;
         }
         const auto idx = km->index(key);
         if (!idx.isValid()) {
             qCDebug(KLEOPATRA_LOG) << "Cannot find:" << fpr << "anymore in model";
             m_expandedKeys.removeAll(fpr);
             return;
         }
         m_view->expand(idx);
     }
 }
 
 void KeyTreeView::setUpTagKeys()
 {
 #ifdef GPGME_HAS_REMARKS
     const auto tagKeys = Tags::tagKeys();
     if (m_hierarchicalModel) {
         m_hierarchicalModel->setRemarkKeys(tagKeys);
     }
     if (m_flatModel) {
         m_flatModel->setRemarkKeys(tagKeys);
     }
 #endif
 }
 
 void KeyTreeView::saveLayout(KConfigGroup &group)
 {
     QHeaderView *header = m_view->header();
 
     QVariantList columnVisibility;
     QVariantList columnOrder;
     QVariantList columnWidths;
     const int headerCount = header->count();
     columnVisibility.reserve(headerCount);
     columnWidths.reserve(headerCount);
     columnOrder.reserve(headerCount);
     for (int i = 0; i < headerCount; ++i) {
         columnVisibility << QVariant(!m_view->isColumnHidden(i));
         columnWidths << QVariant(header->sectionSize(i));
         columnOrder << QVariant(header->visualIndex(i));
     }
 
     group.writeEntry("ColumnVisibility", columnVisibility);
     group.writeEntry("ColumnOrder", columnOrder);
     group.writeEntry("ColumnWidths", columnWidths);
 
     group.writeEntry("SortAscending", (int)header->sortIndicatorOrder());
     if (header->isSortIndicatorShown()) {
         group.writeEntry("SortColumn", header->sortIndicatorSection());
     } else {
         group.writeEntry("SortColumn", -1);
     }
 }
 
 void KeyTreeView::restoreLayout(const KConfigGroup &group)
 {
     QHeaderView *header = m_view->header();
 
     QVariantList columnVisibility = group.readEntry("ColumnVisibility", QVariantList());
     QVariantList columnOrder = group.readEntry("ColumnOrder", QVariantList());
     QVariantList columnWidths = group.readEntry("ColumnWidths", QVariantList());
 
     if (columnVisibility.isEmpty()) {
         // if config is empty then use default settings
         // The numbers have to be in line with the order in
         // setsSourceColumns above
         m_view->hideColumn(5);
 
         for (int i = 7; i < m_view->model()->columnCount(); ++i) {
             m_view->hideColumn(i);
         }
         if (KeyCache::instance()->initialized()) {
             QTimer::singleShot(0, this, &KeyTreeView::resizeColumns);
         }
     } else {
         for (int i = 0; i < header->count(); ++i) {
             if (i >= columnOrder.size() || i >= columnWidths.size() || i >= columnVisibility.size()) {
                 // An additional column that was not around last time we saved.
                 // We default to hidden.
                 m_view->hideColumn(i);
                 continue;
             }
             bool visible = columnVisibility[i].toBool();
             int width = columnWidths[i].toInt();
             int order = columnOrder[i].toInt();
 
             header->resizeSection(i, width ? width : 100);
             header->moveSection(header->visualIndex(i), order);
             if ((i == TAGS_COLUMN) && visible) {
                 Tags::enableTags();
             }
             if (!visible) {
                 m_view->hideColumn(i);
             }
         }
         m_onceResized = true;
     }
 
     int sortOrder = group.readEntry("SortAscending", (int)Qt::AscendingOrder);
     int sortColumn = group.readEntry("SortColumn", 0);
     if (sortColumn >= 0) {
         m_view->sortByColumn(sortColumn, (Qt::SortOrder)sortOrder);
     }
 }
 
 KeyTreeView::~KeyTreeView()
 {
     if (m_group.isValid()) {
         saveLayout(m_group);
     }
 }
 
 static QAbstractProxyModel *find_last_proxy(QAbstractProxyModel *pm)
 {
     Q_ASSERT(pm);
-    while (QAbstractProxyModel *const sm = qobject_cast<QAbstractProxyModel *>(pm->sourceModel())) {
+    while (auto const sm = qobject_cast<QAbstractProxyModel *>(pm->sourceModel())) {
         pm = sm;
     }
     return pm;
 }
 
 void KeyTreeView::setFlatModel(AbstractKeyListModel *model)
 {
     if (model == m_flatModel) {
         return;
     }
     m_flatModel = model;
     if (!m_isHierarchical)
         // TODO: this fails when called after setHierarchicalView( false )...
     {
         find_last_proxy(m_proxy)->setSourceModel(model);
     }
 }
 
 void KeyTreeView::setHierarchicalModel(AbstractKeyListModel *model)
 {
     if (model == m_hierarchicalModel) {
         return;
     }
     m_hierarchicalModel = model;
     if (m_isHierarchical) {
         find_last_proxy(m_proxy)->setSourceModel(model);
         m_view->expandAll();
         for (int column = 0; column < m_view->header()->count(); ++column) {
             m_view->header()->resizeSection(column, qMax(m_view->header()->sectionSize(column), m_view->header()->sectionSizeHint(column)));
         }
     }
 }
 
 void KeyTreeView::setStringFilter(const QString &filter)
 {
     if (filter == m_stringFilter) {
         return;
     }
     m_stringFilter = filter;
     m_proxy->setFilterFixedString(filter);
     Q_EMIT stringFilterChanged(filter);
 }
 
 void KeyTreeView::setKeyFilter(const std::shared_ptr<KeyFilter> &filter)
 {
     if (filter == m_keyFilter || (filter && m_keyFilter && filter->id() == m_keyFilter->id())) {
         return;
     }
     m_keyFilter = filter;
     m_proxy->setKeyFilter(filter);
     Q_EMIT keyFilterChanged(filter);
 }
 
 namespace
 {
 QItemSelection itemSelectionFromKeys(const std::vector<Key> &keys, const QTreeView &view)
 {
     const QModelIndexList indexes = keyListModel(view)->indexes(keys);
     return std::accumulate(
         indexes.cbegin(), indexes.cend(),
         QItemSelection(),
         [] (QItemSelection &selection, const QModelIndex &index) {
             if (index.isValid()) {
                 selection.merge(QItemSelection(index, index), QItemSelectionModel::Select);
             }
             return selection;
         });
 }
 }
 
 void KeyTreeView::selectKeys(const std::vector<Key> &keys)
 {
     m_view->selectionModel()->select(itemSelectionFromKeys(keys, *m_view),
                                      QItemSelectionModel::ClearAndSelect | QItemSelectionModel::Rows);
 }
 
 std::vector<Key> KeyTreeView::selectedKeys() const
 {
     return keyListModel(*m_view)->keys(m_view->selectionModel()->selectedRows());
 }
 
 void KeyTreeView::setHierarchicalView(bool on)
 {
     if (on == m_isHierarchical) {
         return;
     }
     if (on && !hierarchicalModel()) {
         qCWarning(KLEOPATRA_LOG) <<  "hierarchical view requested, but no hierarchical model set";
         return;
     }
     if (!on && !flatModel()) {
         qCWarning(KLEOPATRA_LOG) << "flat view requested, but no flat model set";
         return;
     }
     const std::vector<Key> selectedKeys = this->selectedKeys();
     const Key currentKey = keyListModel(*m_view)->key(m_view->currentIndex());
 
     m_isHierarchical = on;
     find_last_proxy(m_proxy)->setSourceModel(model());
     if (on) {
         m_view->expandAll();
     }
     selectKeys(selectedKeys);
     if (!currentKey.isNull()) {
         const QModelIndex currentIndex = keyListModel(*m_view)->index(currentKey);
         if (currentIndex.isValid()) {
             m_view->selectionModel()->setCurrentIndex(currentIndex, QItemSelectionModel::NoUpdate);
             m_view->scrollTo(currentIndex);
         }
     }
     Q_EMIT hierarchicalChanged(on);
 }
 
 void KeyTreeView::setKeys(const std::vector<Key> &keys)
 {
     std::vector<Key> sorted = keys;
     _detail::sort_by_fpr(sorted);
     _detail::remove_duplicates_by_fpr(sorted);
     m_keys = sorted;
     if (m_flatModel) {
         m_flatModel->setKeys(sorted);
     }
     if (m_hierarchicalModel) {
         m_hierarchicalModel->setKeys(sorted);
     }
 }
 
 void KeyTreeView::addKeysImpl(const std::vector<Key> &keys, bool select)
 {
     if (keys.empty()) {
         return;
     }
     if (m_keys.empty()) {
         setKeys(keys);
         return;
     }
 
     std::vector<Key> sorted = keys;
     _detail::sort_by_fpr(sorted);
     _detail::remove_duplicates_by_fpr(sorted);
 
     std::vector<Key> newKeys = _detail::union_by_fpr(sorted, m_keys);
     m_keys.swap(newKeys);
 
     if (m_flatModel) {
         m_flatModel->addKeys(sorted);
     }
     if (m_hierarchicalModel) {
         m_hierarchicalModel->addKeys(sorted);
     }
 
     if (select) {
         selectKeys(sorted);
     }
 }
 
 void KeyTreeView::addKeysSelected(const std::vector<Key> &keys)
 {
     addKeysImpl(keys, true);
 }
 
 void KeyTreeView::addKeysUnselected(const std::vector<Key> &keys)
 {
     addKeysImpl(keys, false);
 }
 
 void KeyTreeView::removeKeys(const std::vector<Key> &keys)
 {
     if (keys.empty()) {
         return;
     }
     std::vector<Key> sorted = keys;
     _detail::sort_by_fpr(sorted);
     _detail::remove_duplicates_by_fpr(sorted);
     std::vector<Key> newKeys;
     newKeys.reserve(m_keys.size());
     std::set_difference(m_keys.begin(), m_keys.end(),
                         sorted.begin(), sorted.end(),
                         std::back_inserter(newKeys),
                         _detail::ByFingerprint<std::less>());
     m_keys.swap(newKeys);
 
     if (m_flatModel) {
         std::for_each(sorted.cbegin(), sorted.cend(),
                       [this](const Key &key) { m_flatModel->removeKey(key); });
     }
     if (m_hierarchicalModel) {
         std::for_each(sorted.cbegin(), sorted.cend(),
                       [this](const Key &key) { m_hierarchicalModel->removeKey(key); });
     }
 
 }
 
 static const struct {
     const char *signal;
     const char *slot;
 } connections[] = {
     {
         SIGNAL(stringFilterChanged(QString)),
         SLOT(setStringFilter(QString))
     },
     {
         SIGNAL(keyFilterChanged(std::shared_ptr<Kleo::KeyFilter>)),
         SLOT(setKeyFilter(std::shared_ptr<Kleo::KeyFilter>))
     },
 };
 static const unsigned int numConnections = sizeof connections / sizeof * connections;
 
 void KeyTreeView::disconnectSearchBar(const QObject *bar)
 {
     for (unsigned int i = 0; i < numConnections; ++i) {
         disconnect(this, connections[i].signal, bar,  connections[i].slot);
         disconnect(bar,  connections[i].signal, this, connections[i].slot);
     }
 }
 
 bool KeyTreeView::connectSearchBar(const QObject *bar)
 {
     for (unsigned int i = 0; i < numConnections; ++i)
         if (!connect(this, connections[i].signal, bar,  connections[i].slot) ||
                 !connect(bar,  connections[i].signal, this, connections[i].slot)) {
             return false;
         }
     return true;
 }
 
 void KeyTreeView::resizeColumns()
 {
     m_view->setColumnWidth(KeyList::PrettyName, 260);
     m_view->setColumnWidth(KeyList::PrettyEMail, 260);
 
     for (int i = 2; i < m_view->model()->columnCount(); ++i) {
         m_view->resizeColumnToContents(i);
     }
 }
diff --git a/src/view/pgpcardwidget.cpp b/src/view/pgpcardwidget.cpp
index bac1dc256..ea03c0f89 100644
--- a/src/view/pgpcardwidget.cpp
+++ b/src/view/pgpcardwidget.cpp
@@ -1,580 +1,580 @@
 /*  view/pgpcardwiget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "pgpcardwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include "commands/createcsrforcardkeycommand.h"
 #include "commands/createopenpgpkeyfromcardkeyscommand.h"
 
 #include "smartcard/openpgpcard.h"
 #include "smartcard/readerstatus.h"
 
 #include "dialogs/gencardkeydialog.h"
 #include <Libkleo/GnuPG>
 
 #include <QProgressDialog>
 #include <QThread>
 #include <QScrollArea>
 #include <QInputDialog>
 #include <QFileDialog>
 #include <QFileInfo>
 #include <QGridLayout>
 #include <QPushButton>
 #include <QLabel>
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KSeparator>
 
 #include <Libkleo/KeyCache>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/data.h>
 #include <gpgme++/context.h>
 
 #include <QGpgME/DataProvider>
 
 #include <gpgme++/gpggencardkeyinteractor.h>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace Kleo::SmartCard;
 
 namespace {
 class GenKeyThread: public QThread
 {
     Q_OBJECT
 
     public:
         explicit GenKeyThread(const GenCardKeyDialog::KeyParams &params, const std::string &serial):
             mSerial(serial),
             mParams(params)
         {
         }
 
         GpgME::Error error()
         {
             return mErr;
         }
 
         std::string bkpFile()
         {
             return mBkpFile;
         }
     protected:
         void run() override {
-            GpgME::GpgGenCardKeyInteractor *ei = new GpgME::GpgGenCardKeyInteractor(mSerial);
+            auto ei = new GpgME::GpgGenCardKeyInteractor(mSerial);
             ei->setAlgo(GpgME::GpgGenCardKeyInteractor::RSA);
             ei->setKeySize(QByteArray::fromStdString(mParams.algorithm).toInt());
             ei->setNameUtf8(mParams.name.toStdString());
             ei->setEmailUtf8(mParams.email.toStdString());
             ei->setDoBackup(mParams.backup);
 
             const auto ctx = std::shared_ptr<GpgME::Context> (GpgME::Context::createForProtocol(GpgME::OpenPGP));
             QGpgME::QByteArrayDataProvider dp;
             GpgME::Data data(&dp);
 
             mErr = ctx->cardEdit(GpgME::Key(), std::unique_ptr<GpgME::EditInteractor> (ei), data);
             mBkpFile = ei->backupFileName();
         }
 
     private:
         GpgME::Error mErr;
         std::string mSerial;
         GenCardKeyDialog::KeyParams mParams;
 
         std::string mBkpFile;
 };
 
 static void layoutKeyWidgets(QGridLayout *grid, const QString &keyName, const PGPCardWidget::KeyWidgets &keyWidgets)
 {
     int row = grid->rowCount();
     grid->addWidget(new QLabel(keyName), row, 0);
     grid->addWidget(keyWidgets.keyFingerprint, row, 1);
     if (keyWidgets.createCSRButton) {
         grid->addWidget(keyWidgets.createCSRButton, row, 2);
     }
 }
 } // Namespace
 
 PGPCardWidget::PGPCardWidget(QWidget *parent):
     QWidget(parent),
     mSerialNumber(new QLabel(this)),
     mCardHolderLabel(new QLabel(this)),
     mVersionLabel(new QLabel(this)),
     mUrlLabel(new QLabel(this)),
     mCardIsEmpty(false)
 {
     // Set up the scroll area
     auto myLayout = new QVBoxLayout(this);
     myLayout->setContentsMargins(0, 0, 0, 0);
 
     auto area = new QScrollArea;
     area->setFrameShape(QFrame::NoFrame);
     area->setWidgetResizable(true);
     myLayout->addWidget(area);
 
     auto areaWidget = new QWidget;
     area->setWidget(areaWidget);
 
     auto areaVLay = new QVBoxLayout(areaWidget);
 
     auto cardInfoGrid = new QGridLayout;
     {
         int row = 0;
 
         // Version and Serialnumber
         cardInfoGrid->addWidget(mVersionLabel, row, 0, 1, 2);
         mVersionLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
         row++;
 
         cardInfoGrid->addWidget(new QLabel(i18n("Serial number:")), row, 0);
         cardInfoGrid->addWidget(mSerialNumber, row, 1);
         mSerialNumber->setTextInteractionFlags(Qt::TextBrowserInteraction);
         row++;
 
         // Cardholder Row
         cardInfoGrid->addWidget(new QLabel(i18nc("The owner of a smartcard. GnuPG refers to this as cardholder.",
                                                  "Cardholder:")), row, 0);
         cardInfoGrid->addWidget(mCardHolderLabel, row, 1);
         mCardHolderLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
         {
             auto button = new QPushButton;
             button->setIcon(QIcon::fromTheme(QStringLiteral("cell_edit")));
             button->setToolTip(i18n("Change"));
             cardInfoGrid->addWidget(button, row, 2);
             connect(button, &QPushButton::clicked, this, &PGPCardWidget::changeNameRequested);
         }
         row++;
 
         // URL Row
         cardInfoGrid->addWidget(new QLabel(i18nc("The URL under which a public key that "
                                                  "corresponds to a smartcard can be downloaded",
                                                  "Pubkey URL:")), row, 0);
         cardInfoGrid->addWidget(mUrlLabel, row, 1);
         mUrlLabel->setTextInteractionFlags(Qt::TextBrowserInteraction);
         {
             auto button = new QPushButton;
             button->setIcon(QIcon::fromTheme(QStringLiteral("cell_edit")));
             button->setToolTip(i18n("Change"));
             cardInfoGrid->addWidget(button, row, 2);
             connect(button, &QPushButton::clicked, this, &PGPCardWidget::changeUrlRequested);
         }
 
         cardInfoGrid->setColumnStretch(cardInfoGrid->columnCount(), 1);
     }
     areaVLay->addLayout(cardInfoGrid);
 
     areaVLay->addWidget(new KSeparator(Qt::Horizontal));
 
     // The keys
     areaVLay->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Keys:"))));
 
     auto keysGrid = new QGridLayout;
     for (const auto &keyInfo : OpenPGPCard::supportedKeys()) {
         KeyWidgets keyWidgets = createKeyWidgets(keyInfo);
         layoutKeyWidgets(keysGrid, OpenPGPCard::keyDisplayName(keyInfo.keyRef), keyWidgets);
     }
     keysGrid->setColumnStretch(keysGrid->columnCount(), 1);
     areaVLay->addLayout(keysGrid);
 
     areaVLay->addWidget(new KSeparator(Qt::Horizontal));
 
     areaVLay->addWidget(new QLabel(QStringLiteral("<b>%1</b>").arg(i18n("Actions:"))));
 
     auto actionLayout = new QHBoxLayout;
 
     {
         auto generateButton = new QPushButton(i18n("Generate New Keys"));
         generateButton->setToolTip(i18n("Create a new primary key and generate subkeys on the card."));
         actionLayout->addWidget(generateButton);
         connect(generateButton, &QPushButton::clicked, this, &PGPCardWidget::genkeyRequested);
     }
     {
         auto pinButton = new QPushButton(i18n("Change PIN"));
         pinButton->setToolTip(i18n("Change the PIN required for using the keys on the smartcard."));
         actionLayout->addWidget(pinButton);
         connect(pinButton, &QPushButton::clicked, this, [this] () { doChangePin(OpenPGPCard::pinKeyRef()); });
     }
     {
         auto unblockButton = new QPushButton(i18n("Unblock Card"));
         unblockButton->setToolTip(i18n("Unblock the smartcard and set a new PIN."));
         actionLayout->addWidget(unblockButton);
         connect(unblockButton, &QPushButton::clicked, this, [this] () { doChangePin(OpenPGPCard::resetCodeKeyRef()); });
     }
     {
         auto pukButton = new QPushButton(i18n("Change Admin PIN"));
         pukButton->setToolTip(i18n("Change the PIN required for administrative operations."));
         actionLayout->addWidget(pukButton);
         connect(pukButton, &QPushButton::clicked, this, [this] () { doChangePin(OpenPGPCard::adminPinKeyRef()); });
     }
     {
         auto resetCodeButton = new QPushButton(i18n("Change Reset Code"));
         resetCodeButton->setToolTip(i18n("Change the PIN required to unblock the smartcard and set a new PIN."));
         actionLayout->addWidget(resetCodeButton);
         connect(resetCodeButton, &QPushButton::clicked,
                 this, [this] () { doChangePin(OpenPGPCard::resetCodeKeyRef(), ChangePinCommand::ResetMode); });
     }
 
     if (CreateOpenPGPKeyFromCardKeysCommand::isSupported()) {
         mKeyForCardKeysButton = new QPushButton(this);
         mKeyForCardKeysButton->setText(i18n("Create OpenPGP Key"));
         mKeyForCardKeysButton->setToolTip(i18n("Create an OpenPGP key for the keys stored on the card."));
         actionLayout->addWidget(mKeyForCardKeysButton);
         connect(mKeyForCardKeysButton, &QPushButton::clicked, this, &PGPCardWidget::createKeyFromCardKeys);
     }
 
     actionLayout->addStretch(-1);
     areaVLay->addLayout(actionLayout);
 
     areaVLay->addStretch(1);
 }
 
 PGPCardWidget::KeyWidgets PGPCardWidget::createKeyWidgets(const KeyPairInfo &keyInfo)
 {
     const std::string keyRef = keyInfo.keyRef;
     KeyWidgets keyWidgets;
     keyWidgets.keyFingerprint = new QLabel(this);
     keyWidgets.keyFingerprint->setTextInteractionFlags(Qt::TextBrowserInteraction);
     if (keyInfo.canCertify() || keyInfo.canSign() || keyInfo.canAuthenticate())
     {
         keyWidgets.createCSRButton = new QPushButton(i18nc("@action:button", "Create CSR"), this);
         keyWidgets.createCSRButton->setToolTip(i18nc("@info:tooltip", "Create a certificate signing request for this key"));
         keyWidgets.createCSRButton->setEnabled(false);
         connect(keyWidgets.createCSRButton, &QPushButton::clicked,
                 this, [this, keyRef] () { createCSR(keyRef); });
     }
     mKeyWidgets.insert(keyRef, keyWidgets);
     return keyWidgets;
 }
 
 void PGPCardWidget::setCard(const OpenPGPCard *card)
 {
     const QString version = card->displayAppVersion();
 
     mIs21 = card->appVersion() >= 0x0201;
     const QString manufacturer = QString::fromStdString(card->manufacturer());
     const bool manufacturerIsUnknown = manufacturer.isEmpty() || manufacturer == QLatin1String("unknown");
     mVersionLabel->setText(manufacturerIsUnknown ?
         i18nc("Placeholder is a version number", "Unknown OpenPGP v%1 card", version) :
         i18nc("First placeholder is manufacturer, second placeholder is a version number",
               "%1 OpenPGP v%2 card", manufacturer, version));
     mSerialNumber->setText(card->displaySerialNumber());
     mRealSerial = card->serialNumber();
 
     const auto holder = card->cardHolder();
     const auto url = QString::fromStdString(card->pubkeyUrl());
     mCardHolderLabel->setText(holder.isEmpty() ? i18n("not set") : holder);
     mUrl = url;
     mUrlLabel->setText(url.isEmpty() ? i18n("not set") :
                        QStringLiteral("<a href=\"%1\">%1</a>").arg(url.toHtmlEscaped()));
     mUrlLabel->setOpenExternalLinks(true);
 
     updateKeyWidgets(OpenPGPCard::pgpSigKeyRef(), card);
     updateKeyWidgets(OpenPGPCard::pgpEncKeyRef(), card);
     updateKeyWidgets(OpenPGPCard::pgpAuthKeyRef(), card);
     mCardIsEmpty = card->keyFingerprint(OpenPGPCard::pgpSigKeyRef()).empty()
         && card->keyFingerprint(OpenPGPCard::pgpEncKeyRef()).empty()
         && card->keyFingerprint(OpenPGPCard::pgpAuthKeyRef()).empty();
 
     if (mKeyForCardKeysButton) {
         mKeyForCardKeysButton->setEnabled(card->hasSigningKey() && card->hasEncryptionKey());
     }
 }
 
 void PGPCardWidget::doChangePin(const std::string &keyRef, ChangePinCommand::ChangePinMode mode)
 {
     auto cmd = new ChangePinCommand(mRealSerial, OpenPGPCard::AppName, this);
     this->setEnabled(false);
     connect(cmd, &ChangePinCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->setKeyRef(keyRef);
     cmd->setMode(mode);
     cmd->start();
 }
 
 void PGPCardWidget::doGenKey(GenCardKeyDialog *dlg)
 {
     const GpgME::Error err = ReaderStatus::switchCardAndApp(mRealSerial, OpenPGPCard::AppName);
     if (err) {
         return;
     }
 
     const auto params = dlg->getKeyParams();
 
     auto progress = new QProgressDialog(this, Qt::CustomizeWindowHint | Qt::WindowTitleHint | Qt::Dialog);
     progress->setAutoClose(true);
     progress->setMinimumDuration(0);
     progress->setMaximum(0);
     progress->setMinimum(0);
     progress->setModal(true);
     progress->setCancelButton(nullptr);
     progress->setWindowTitle(i18nc("@title:window", "Generating Keys"));
     progress->setLabel(new QLabel(i18n("This may take several minutes...")));
-    GenKeyThread *workerThread = new GenKeyThread(params, mRealSerial);
+    auto workerThread = new GenKeyThread(params, mRealSerial);
     connect(workerThread, &QThread::finished, this, [this, workerThread, progress] {
             progress->accept();
             progress->deleteLater();
             genKeyDone(workerThread->error(), workerThread->bkpFile());
             delete workerThread;
         });
     workerThread->start();
     progress->exec();
 }
 
 void PGPCardWidget::genKeyDone(const GpgME::Error &err, const std::string &backup)
 {
     if (err) {
         KMessageBox::error(this, i18nc("@info",
                            "Failed to generate new key: %1", QString::fromLatin1(err.asString())),
                            i18nc("@title", "Error"));
         return;
     }
     if (err.isCanceled()) {
         return;
     }
     if (!backup.empty()) {
         const auto bkpFile = QString::fromStdString(backup);
         QFileInfo fi(bkpFile);
         const auto target = QFileDialog::getSaveFileName(this, i18n("Save backup of encryption key"),
                                                          fi.fileName(),
                                                          QStringLiteral("%1 (*.gpg)").arg(i18n("Backup Key")));
         if (!target.isEmpty() && !QFile::copy(bkpFile, target)) {
             KMessageBox::error(this, i18nc("@info",
                                "Failed to move backup. The backup key is still stored under: %1", bkpFile),
                                i18nc("@title", "Error"));
         } else if (!target.isEmpty()) {
             QFile::remove(bkpFile);
         }
     }
 
     KMessageBox::information(this, i18nc("@info",
                              "Successfully generated a new key for this card."),
                              i18nc("@title", "Success"));
     ReaderStatus::mutableInstance()->updateStatus();
 }
 
 void PGPCardWidget::genkeyRequested()
 {
     if (!mCardIsEmpty) {
         auto ret = KMessageBox::warningContinueCancel(this,
                 i18n("The existing keys on this card will be <b>deleted</b> "
                      "and replaced by new keys.") + QStringLiteral("<br/><br/>") +
                 i18n("It will no longer be possible to decrypt past communication "
                      "encrypted for the existing key."),
                 i18n("Secret Key Deletion"),
                 KStandardGuiItem::guiItem(KStandardGuiItem::Delete),
                 KStandardGuiItem::cancel(), QString(), KMessageBox::Notify | KMessageBox::Dangerous);
 
         if (ret != KMessageBox::Continue) {
             return;
         }
     }
 
-    GenCardKeyDialog *dlg = new GenCardKeyDialog(GenCardKeyDialog::AllKeyAttributes, this);
+    auto dlg = new GenCardKeyDialog(GenCardKeyDialog::AllKeyAttributes, this);
     std::vector<std::pair<std::string, QString>> algos = {
         { "1024", QStringLiteral("RSA 1024") },
         { "2048", QStringLiteral("RSA 2048") },
         { "3072", QStringLiteral("RSA 3072") }
     };
     // There is probably a better way to check for capabilities
     if (mIs21) {
         algos.push_back({"4096", QStringLiteral("RSA 4096")});
     }
     dlg->setSupportedAlgorithms(algos, "2048");
     connect(dlg, &QDialog::accepted, this, [this, dlg] () {
             doGenKey(dlg);
             dlg->deleteLater();
         });
     dlg->setModal(true);
     dlg->show();
 }
 
 void PGPCardWidget::changeNameRequested()
 {
     QString text = mCardHolderLabel->text();
     while (true) {
         bool ok = false;
         text = QInputDialog::getText(this, i18n("Change cardholder"),
                                      i18n("New name:"), QLineEdit::Normal,
                                      text, &ok, Qt::WindowFlags(),
                                      Qt::ImhLatinOnly);
         if (!ok) {
             return;
         }
         // Some additional restrictions imposed by gnupg
         if (text.contains(QLatin1Char('<'))) {
             KMessageBox::error(this, i18nc("@info",
                                "The \"<\" character may not be used."),
                                i18nc("@title", "Error"));
             continue;
         }
         if (text.contains(QLatin1String("  "))) {
             KMessageBox::error(this, i18nc("@info",
                                "Double spaces are not allowed"),
                                i18nc("@title", "Error"));
             continue;
         }
         if (text.size() > 38) {
             KMessageBox::error(this, i18nc("@info",
                                "The size of the name may not exceed 38 characters."),
                                i18nc("@title", "Error"));
         }
         break;
     }
     auto parts = text.split(QLatin1Char(' '));
     const auto lastName = parts.takeLast();
     const QString formatted = lastName + QStringLiteral("<<") + parts.join(QLatin1Char('<'));
 
     const auto pgpCard = ReaderStatus::instance()->getCard<OpenPGPCard>(mRealSerial);
     if (!pgpCard) {
         KMessageBox::error(this, i18n("Failed to find the OpenPGP card with the serial number: %1", QString::fromStdString(mRealSerial)));
         return;
     }
 
     const QByteArray command = QByteArrayLiteral("SCD SETATTR DISP-NAME ") + formatted.toUtf8();
     ReaderStatus::mutableInstance()->startSimpleTransaction(pgpCard, command, this, "changeNameResult");
 }
 
 void PGPCardWidget::changeNameResult(const GpgME::Error &err)
 {
     if (err) {
         KMessageBox::error(this, i18nc("@info",
                            "Name change failed: %1", QString::fromLatin1(err.asString())),
                            i18nc("@title", "Error"));
         return;
     }
     if (!err.isCanceled()) {
         KMessageBox::information(this, i18nc("@info",
                     "Name successfully changed."),
                 i18nc("@title", "Success"));
         ReaderStatus::mutableInstance()->updateStatus();
     }
 }
 
 void PGPCardWidget::changeUrlRequested()
 {
     QString text = mUrl;
     while (true) {
         bool ok = false;
         text = QInputDialog::getText(this, i18n("Change the URL where the pubkey can be found"),
                                      i18n("New pubkey URL:"), QLineEdit::Normal,
                                      text, &ok, Qt::WindowFlags(),
                                      Qt::ImhLatinOnly);
         if (!ok) {
             return;
         }
         // Some additional restrictions imposed by gnupg
         if (text.size() > 254) {
             KMessageBox::error(this, i18nc("@info",
                                "The size of the URL may not exceed 254 characters."),
                                i18nc("@title", "Error"));
         }
         break;
     }
 
     const auto pgpCard = ReaderStatus::instance()->getCard<OpenPGPCard>(mRealSerial);
     if (!pgpCard) {
         KMessageBox::error(this, i18n("Failed to find the OpenPGP card with the serial number: %1", QString::fromStdString(mRealSerial)));
         return;
     }
 
     const QByteArray command = QByteArrayLiteral("SCD SETATTR PUBKEY-URL ") + text.toUtf8();
     ReaderStatus::mutableInstance()->startSimpleTransaction(pgpCard, command, this, "changeUrlResult");
 }
 
 void PGPCardWidget::changeUrlResult(const GpgME::Error &err)
 {
     if (err) {
         KMessageBox::error(this, i18nc("@info",
                            "URL change failed: %1", QString::fromLatin1(err.asString())),
                            i18nc("@title", "Error"));
         return;
     }
     if (!err.isCanceled()) {
         KMessageBox::information(this, i18nc("@info",
                     "URL successfully changed."),
                 i18nc("@title", "Success"));
         ReaderStatus::mutableInstance()->updateStatus();
     }
 }
 
 void PGPCardWidget::createKeyFromCardKeys()
 {
     auto cmd = new CreateOpenPGPKeyFromCardKeysCommand(mRealSerial, OpenPGPCard::AppName, this);
     this->setEnabled(false);
     connect(cmd, &CreateOpenPGPKeyFromCardKeysCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->start();
 }
 
 void PGPCardWidget::createCSR(const std::string &keyref)
 {
     auto cmd = new CreateCSRForCardKeyCommand(keyref, mRealSerial, OpenPGPCard::AppName, this);
     this->setEnabled(false);
     connect(cmd, &CreateCSRForCardKeyCommand::finished,
             this, [this]() {
                 this->setEnabled(true);
             });
     cmd->start();
 }
 
 void PGPCardWidget::updateKeyWidgets(const std::string &keyRef, const OpenPGPCard *card)
 {
     KeyWidgets widgets = mKeyWidgets.value(keyRef);
     const std::string grip = card ? card->keyInfo(keyRef).grip : widgets.keyGrip;
     widgets.keyGrip = grip;
     if (grip.empty()) {
         widgets.keyFingerprint->setText(i18n("Slot empty"));
         if (widgets.createCSRButton) {
             widgets.createCSRButton->setEnabled(false);
         }
     } else {
         if (card) {
             // update information if called with card
             std::string fpr = card->keyFingerprint(keyRef);
             widgets.keyFingerprint->setText(QString::fromStdString(fpr));
 
             std::string keyid = fpr;
             keyid.erase(0, keyid.size() - 16);
             const auto subkeys = KeyCache::instance()->findSubkeysByKeyID({keyid});
             if (subkeys.empty() || subkeys[0].isNull()) {
                 widgets.keyFingerprint->setToolTip(i18n("Public key not found."));
             } else {
                 QStringList toolTips;
                 toolTips.reserve(subkeys.size());
                 for (const auto &sub: subkeys) {
                     // Yep you can have one subkey associated with multiple
                     // primary keys.
                     toolTips << Formatting::toolTip(sub.parent(), Formatting::Validity |
                                                     Formatting::StorageLocation |
                                                     Formatting::ExpiryDates |
                                                     Formatting::UserIDs |
                                                     Formatting::Fingerprint);
                 }
                 widgets.keyFingerprint->setToolTip(toolTips.join(QLatin1String("<br/>")));
             }
         }
         if (widgets.createCSRButton) {
             widgets.createCSRButton->setEnabled(true);
         }
     }
 }
 
 #include "pgpcardwidget.moc"
diff --git a/src/view/searchbar.cpp b/src/view/searchbar.cpp
index e5fd37a4b..f7239b395 100644
--- a/src/view/searchbar.cpp
+++ b/src/view/searchbar.cpp
@@ -1,211 +1,211 @@
 /* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; -*-
     view/searchbar.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 "searchbar.h"
 
 #include <Libkleo/KeyFilter>
 #include <Libkleo/KeyFilterManager>
 
 #include <KLocalizedString>
 #include <QLineEdit>
 
 #include <QComboBox>
 #include <QHBoxLayout>
 #include <QPushButton>
 #include <QSortFilterProxyModel>
 
 #include <Libkleo/GnuPG>
 #include <qgpgme/keylistjob.h>
 #include <qgpgme/protocol.h>
 #include <gpgme++/keylistresult.h>
 
 using namespace Kleo;
 
 namespace
 {
 
 class ProxyModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 
 public:
     using QSortFilterProxyModel::QSortFilterProxyModel;
 
 protected:
     bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override
     {
         const QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
         const auto matchContexts = qvariant_cast<KeyFilter::MatchContexts>(sourceModel()->data(index, KeyFilterManager::FilterMatchContextsRole));
         return matchContexts & KeyFilter::Filtering;
     }
 };
 
 }
 
 class SearchBar::Private
 {
     friend class ::Kleo::SearchBar;
     SearchBar *const q;
 public:
     explicit Private(SearchBar *qq);
     ~Private();
 
 private:
     void slotKeyFilterChanged(int idx)
     {
         Q_EMIT q->keyFilterChanged(keyFilter(idx));
     }
 
     std::shared_ptr<KeyFilter> keyFilter(int idx) const
     {
         const QModelIndex mi = proxyModel->mapToSource(proxyModel->index(idx, 0));
         return KeyFilterManager::instance()->fromModelIndex(mi);
     }
 
     std::shared_ptr<KeyFilter> currentKeyFilter() const
     {
         return keyFilter(combo->currentIndex());
     }
 
     QString currentKeyFilterID() const
     {
         if (const std::shared_ptr<KeyFilter> f = currentKeyFilter()) {
             return f->id();
         } else {
             return QString();
         }
     }
 
     void listNotCertifiedKeys() const
     {
         lineEdit->clear();
         combo->setCurrentIndex(combo->findData(QStringLiteral("not-validated-certificates")));
         Q_EMIT q->keyFilterChanged(keyFilter(combo->currentIndex()));
     }
 
     /* List all OpenPGP keys and see if we find one with a UID that is
      * not at least fully valid.  If we find one, show the certify
      * button.  */
     /* XXX: It would be nice to do this every time the user certifies
      * a key.  */
     void showOrHideCertifyButton() const
     {
         QGpgME::KeyListJob *job = QGpgME::openpgp()->keyListJob();
         connect(job, &QGpgME::KeyListJob::result, job,
                 [this](const GpgME::KeyListResult&, const std::vector<GpgME::Key> &keys, const QString&, const GpgME::Error&)
                 {
                     for (const auto &key: keys) {
                         if (Kleo::keyValidity(key) < GpgME::UserID::Validity::Full) {
                             certifyButton->show();
                             return;
                         }
                     }
                     certifyButton->hide();
                 });
         job->start(QStringList());
     }
 
 private:
     ProxyModel *proxyModel;
     QLineEdit *lineEdit;
     QComboBox *combo;
     QPushButton *certifyButton;
 };
 
 SearchBar::Private::Private(SearchBar *qq)
     : q(qq)
 {
-    QHBoxLayout *layout = new QHBoxLayout(q);
+    auto layout = new QHBoxLayout(q);
     layout->setContentsMargins(0, 0, 0, 0);
     lineEdit = new QLineEdit(q);
     lineEdit->setClearButtonEnabled(true);
     lineEdit->setPlaceholderText(i18n("Search..."));
     layout->addWidget(lineEdit, /*stretch=*/1);
     combo = new QComboBox(q);
     layout->addWidget(combo);
     certifyButton = new QPushButton(q);
     certifyButton->setIcon(QIcon::fromTheme(QStringLiteral("security-medium")));
     certifyButton->setToolTip(i18n("Some certificates are not yet certified. "
                                    "Click here to see a list of these certificates."
                                    "<br/><br/>"
                                    "Certification is required to make sure that the certificates "
                                    "actually belong to the identity they claim to belong to."));
     certifyButton->hide();
     layout->addWidget(certifyButton);
     showOrHideCertifyButton();
 
     proxyModel = new ProxyModel{q};
     proxyModel->setSourceModel(KeyFilterManager::instance()->model());
     proxyModel->sort(0, Qt::AscendingOrder);
     combo->setModel(proxyModel);
 
     KDAB_SET_OBJECT_NAME(layout);
     KDAB_SET_OBJECT_NAME(lineEdit);
     KDAB_SET_OBJECT_NAME(combo);
     KDAB_SET_OBJECT_NAME(certifyButton);
 
     connect(lineEdit, &QLineEdit::textChanged, q, &SearchBar::stringFilterChanged);
     connect(combo, SIGNAL(currentIndexChanged(int)), q, SLOT(slotKeyFilterChanged(int)));
     connect(certifyButton, SIGNAL(clicked()), q, SLOT(listNotCertifiedKeys()));
 }
 
 SearchBar::Private::~Private() {}
 
 SearchBar::SearchBar(QWidget *parent, Qt::WindowFlags f)
     : QWidget(parent, f), d(new Private(this))
 {
 
 }
 
 SearchBar::~SearchBar() {}
 
 void SearchBar::updateClickMessage(const QString &shortcutStr)
 {
     d->lineEdit->setPlaceholderText(i18n("Search...<%1>", shortcutStr));
 }
 
 // slot
 void SearchBar::setStringFilter(const QString &filter)
 {
     d->lineEdit->setText(filter);
 }
 
 // slot
 void SearchBar::setKeyFilter(const std::shared_ptr<KeyFilter> &kf)
 {
     const QModelIndex sourceIndex = KeyFilterManager::instance()->toModelIndex(kf);
     const QModelIndex proxyIndex = d->proxyModel->mapFromSource(sourceIndex);
     if (proxyIndex.isValid()) {
         d->combo->setCurrentIndex(proxyIndex.row());
     } else {
         d->combo->setCurrentIndex(0);
     }
 }
 
 // slot
 void SearchBar::setChangeStringFilterEnabled(bool on)
 {
     d->lineEdit->setEnabled(on);
 }
 
 // slot
 void SearchBar::setChangeKeyFilterEnabled(bool on)
 {
     d->combo->setEnabled(on);
 }
 
 QLineEdit *SearchBar::lineEdit() const
 {
     return d->lineEdit;
 }
 
 #include "moc_searchbar.cpp"
 #include "searchbar.moc"
diff --git a/src/view/smartcardwidget.cpp b/src/view/smartcardwidget.cpp
index 5dfa74731..50e1e47bf 100644
--- a/src/view/smartcardwidget.cpp
+++ b/src/view/smartcardwidget.cpp
@@ -1,199 +1,199 @@
 /*  view/smartcardwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2017 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
     SPDX-FileCopyrightText: 2020 g10 Code GmbH
     SPDX-FileContributor: Ingo Klöcker <dev@ingo-kloecker.de>
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "smartcardwidget.h"
 
 #include "smartcard/readerstatus.h"
 #include "smartcard/openpgpcard.h"
 #include "smartcard/netkeycard.h"
 #include "smartcard/p15card.h"
 #include "smartcard/pivcard.h"
 #include "smartcard/utils.h"
 
 #include "view/pgpcardwidget.h"
 #include "view/netkeywidget.h"
 #include "view/pivcardwidget.h"
 #include "view/p15cardwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include <KLocalizedString>
 
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QPointer>
 #include <QPushButton>
 #include <QTabWidget>
 #include <QVBoxLayout>
 #include <QStackedWidget>
 
 using namespace Kleo;
 using namespace Kleo::SmartCard;
 
 namespace {
 class PlaceHolderWidget: public QWidget
 {
     Q_OBJECT
 public:
     explicit PlaceHolderWidget(QWidget *parent = nullptr)
         : QWidget(parent)
     {
         auto lay = new QVBoxLayout;
         lay->addStretch(-1);
 
         const QStringList supported = QStringList() << i18nc("OpenPGP refers to a smartcard protocol", "OpenPGP v2.0 - v3.3")
                                                     << i18nc("Gnuk is a cryptographic token for GnuPG", "Gnuk")
                                                     << i18nc("NetKey refers to a smartcard protocol", "NetKey v3")
                                                     << i18nc("PIV refers to a smartcard protocol", "PIV (requires GnuPG 2.3 or later)")
                                                     << i18nc("CardOS is a smartcard operating system", "CardOS 5 (various apps)");
         lay->addWidget(new QLabel(QStringLiteral("\t\t<h3>") +
                                   i18n("Please insert a compatible smartcard.") + QStringLiteral("</h3>"), this));
         lay->addSpacing(10);
         lay->addWidget(new QLabel(QStringLiteral("\t\t") +
                        i18n("Kleopatra currently supports the following card types:") +
                             QStringLiteral("<ul><li>") + supported.join(QLatin1String("</li><li>")) +
                             QStringLiteral("</li></ul>"), this));
         lay->addSpacing(10);
         lay->addWidget(new QLabel(i18n("Refresh the view (F5) to update the smartcard status."), this));
         lay->addStretch(-1);
 
         auto hLay = new QHBoxLayout(this);
         hLay->addStretch(-1);
         hLay->addLayout(lay);
         hLay->addStretch(-1);
         lay->addStretch(-1);
     }
 };
 } // namespace
 
 class SmartCardWidget::Private
 {
 public:
     Private(SmartCardWidget *qq);
 
     void cardAddedOrChanged(const std::string &serialNumber, const std::string &appName);
     void cardRemoved(const std::string &serialNumber, const std::string &appName);
 
 private:
     template <typename C, typename W>
     void cardAddedOrChanged(const std::string &serialNumber);
 
 private:
     SmartCardWidget *const q;
     QMap<std::pair<std::string, std::string>, QPointer<QWidget> > mCardWidgets;
     PlaceHolderWidget *mPlaceHolderWidget;
     QStackedWidget *mStack;
     QTabWidget *mTabWidget;
 };
 
 SmartCardWidget::Private::Private(SmartCardWidget *qq)
     : q(qq)
 {
-    QVBoxLayout *vLay = new QVBoxLayout(q);
+    auto vLay = new QVBoxLayout(q);
 
     vLay->addWidget(new QLabel(QStringLiteral("<h2>") + i18n("Smartcard Management") +
                                QStringLiteral("</h2>")));
 
     mStack = new QStackedWidget;
     vLay->addWidget(mStack);
 
     mPlaceHolderWidget = new PlaceHolderWidget;
     mStack->addWidget(mPlaceHolderWidget);
 
     mTabWidget = new QTabWidget;
     mStack->addWidget(mTabWidget);
 
     mStack->setCurrentWidget(mPlaceHolderWidget);
 
     connect(ReaderStatus::instance(), &ReaderStatus::cardAdded,
             q, [this] (const std::string &serialNumber, const std::string &appName) { cardAddedOrChanged(serialNumber, appName); });
     connect(ReaderStatus::instance(), &ReaderStatus::cardChanged,
             q, [this] (const std::string &serialNumber, const std::string &appName) { cardAddedOrChanged(serialNumber, appName); });
     connect(ReaderStatus::instance(), &ReaderStatus::cardRemoved,
             q, [this] (const std::string &serialNumber, const std::string &appName) { cardRemoved(serialNumber, appName); });
 }
 
 void SmartCardWidget::Private::cardAddedOrChanged(const std::string &serialNumber, const std::string &appName)
 {
     if (appName == SmartCard::NetKeyCard::AppName) {
         cardAddedOrChanged<NetKeyCard, NetKeyWidget>(serialNumber);
     } else if (appName == SmartCard::OpenPGPCard::AppName) {
         cardAddedOrChanged<OpenPGPCard, PGPCardWidget>(serialNumber);
     } else if (appName == SmartCard::PIVCard::AppName) {
         cardAddedOrChanged<PIVCard, PIVCardWidget>(serialNumber);
     } else if (appName == SmartCard::P15Card::AppName) {
         cardAddedOrChanged<P15Card, P15CardWidget>(serialNumber);
     } else {
         qCWarning(KLEOPATRA_LOG) << "SmartCardWidget::Private::cardAddedOrChanged:"
             << "App" << appName.c_str() << "is not supported";
     }
 }
 
 namespace {
 static QString getCardLabel(const std::shared_ptr<Card> &card) {
     if (!card->cardHolder().isEmpty()) {
         return i18nc("@title:tab smartcard application - name of card holder - serial number of smartcard", "%1 - %2 - %3",
                      displayAppName(card->appName()), card->cardHolder(), card->displaySerialNumber());
     } else {
         return i18nc("@title:tab smartcard application - serial number of smartcard", "%1 - %2",
                      displayAppName(card->appName()), card->displaySerialNumber());
     }
 }
 }
 
 template <typename C, typename W>
 void SmartCardWidget::Private::cardAddedOrChanged(const std::string &serialNumber)
 {
     const auto card = ReaderStatus::instance()->getCard<C>(serialNumber);
     if (!card) {
         qCWarning(KLEOPATRA_LOG) << "SmartCardWidget::Private::cardAddedOrChanged:"
                                  << "New or changed card" << serialNumber.c_str() << "with app" << C::AppName.c_str() << "not found";
         return;
     }
     W *cardWidget = dynamic_cast<W *>(mCardWidgets.value({serialNumber, C::AppName}).data());
     if (!cardWidget) {
         cardWidget = new W;
         mCardWidgets.insert({serialNumber, C::AppName}, cardWidget);
         mTabWidget->addTab(cardWidget, getCardLabel(card));
         if (mCardWidgets.size() == 1) {
             mStack->setCurrentWidget(mTabWidget);
         }
     }
     cardWidget->setCard(card.get());
 }
 
 void SmartCardWidget::Private::cardRemoved(const std::string &serialNumber, const std::string &appName)
 {
     QWidget * cardWidget = mCardWidgets.take({serialNumber, appName});
     if (cardWidget) {
         const int index = mTabWidget->indexOf(cardWidget);
         if (index != -1) {
             mTabWidget->removeTab(index);
         }
         delete cardWidget;
     }
     if (mCardWidgets.empty()) {
         mStack->setCurrentWidget(mPlaceHolderWidget);
     }
 }
 
 SmartCardWidget::SmartCardWidget(QWidget *parent):
     QWidget(parent),
     d(new Private(this))
 {
 }
 
 void SmartCardWidget::reload()
 {
     ReaderStatus::mutableInstance()->updateStatus();
 }
 
 #include "smartcardwidget.moc"
diff --git a/src/view/tabwidget.cpp b/src/view/tabwidget.cpp
index ab56ca1f6..13c3faf8d 100644
--- a/src/view/tabwidget.cpp
+++ b/src/view/tabwidget.cpp
@@ -1,959 +1,959 @@
 /* -*- 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;
     }
-    QToolButton *b = new QToolButton;
+    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;
     }
-    QAbstractProxyModel *const proxy = qobject_cast<QAbstractProxyModel *>(view->model());
+    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);
+        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) {
-        KActionCollection *coll = new KActionCollection(q);
+        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 : qAsConst(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)) {
         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"
diff --git a/tests/test_verify.cpp b/tests/test_verify.cpp
index eb96e4fb5..df3d128f2 100644
--- a/tests/test_verify.cpp
+++ b/tests/test_verify.cpp
@@ -1,210 +1,210 @@
 /*
     This file is part of Kleopatra's test suite.
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "kleo_test.h"
 
 #include <QGpgME/Protocol>
 #include <QGpgME/VerifyDetachedJob>
 #include <QGpgME/KeyListJob>
 #include <QGpgME/DecryptVerifyJob>
 
 
 #include <gpgme++/error.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 #include <gpgme++/key.h>
 #include <QTimer>
 #include <QObject>
 #include <QSignalSpy>
 
 // Replace this with a gpgme version check once GnuPG Bug #2092
 // ( https://bugs.gnupg.org/gnupg/issue2092 ) is fixed.
 #define GPGME_MULTITHREADED_KEYLIST_BROKEN
 
 Q_DECLARE_METATYPE(GpgME::VerificationResult)
 
 class VerifyTest : public QObject
 {
     Q_OBJECT
 private:
 
     // Data shared with all tests
     QByteArray mSignature;
     QByteArray mSignedData;
     const QGpgME::Protocol *mBackend;
     QEventLoop mEventLoop;
 
     // Data for testParallelVerifyAndKeyListJobs()
     QList<QGpgME::VerifyDetachedJob *> mParallelVerifyJobs;
     QList<QGpgME::KeyListJob *> mParallelKeyListJobs;
 
     // Data for testMixedParallelJobs()
     QList<QGpgME::Job *> mRunningJobs;
     int mJobsStarted;
 
 public Q_SLOTS:
     void slotParallelKeyListJobFinished()
     {
         mParallelKeyListJobs.removeAll(static_cast<QGpgME::KeyListJob *>(sender()));
 
         // When all jobs are done, quit the event loop
         if (mParallelVerifyJobs.isEmpty() && mParallelKeyListJobs.isEmpty()) {
             mEventLoop.quit();
         }
     }
 
     void slotParallelVerifyJobFinished(const GpgME::VerificationResult &result)
     {
         // Verify the result of the job is correct
         QVERIFY(mParallelVerifyJobs.contains(static_cast<QGpgME::VerifyDetachedJob *>(sender())));
         QCOMPARE(result.signature(0).validity(), GpgME::Signature::Full);
         mParallelVerifyJobs.removeAll(static_cast<QGpgME::VerifyDetachedJob *>(sender()));
 
         // Start a key list job
         QGpgME::KeyListJob *job = mBackend->keyListJob();
         mParallelKeyListJobs.append(job);
         connect(job, &QGpgME::Job::done,
                 this, &VerifyTest::slotParallelKeyListJobFinished);
         QVERIFY(!job->start(QStringList()));
     }
 
     void someJobDone()
     {
         // Don't bother checking any results here
         mRunningJobs.removeAll(static_cast<QGpgME::Job *>(sender()));
     }
 
     void startAnotherJob()
     {
         static int counter = 0;
         counter++;
 
         // Randomly kill a running job
         if (counter % 10 == 0 && !mRunningJobs.isEmpty()) {
             mRunningJobs.at(counter % mRunningJobs.size())->slotCancel();
         }
 
         // Randomly either start a keylist or a verify job
         QGpgME::Job *job;
         if (counter % 2 == 0) {
             QGpgME::VerifyDetachedJob *vdj = mBackend->verifyDetachedJob();
             QVERIFY(!vdj->start(mSignature, mSignedData));
             job = vdj;
         } else {
             QGpgME::KeyListJob *klj = mBackend->keyListJob();
             QVERIFY(!klj->start(QStringList()));
             job = klj;
         }
         mRunningJobs.append(job);
         connect(job, &QGpgME::Job::done, this, &VerifyTest::someJobDone);
 
         // Quit after 2500 jobs, that should be enough
         mJobsStarted++;
         if (mJobsStarted >= 2500) {
             QTimer::singleShot(1000, &mEventLoop, &QEventLoop::quit);
         } else {
             QTimer::singleShot(0, this, &VerifyTest::startAnotherJob);
         }
     }
 
 private Q_SLOTS:
     void initTestCase()
     {
         qRegisterMetaType<GpgME::VerificationResult>();
 
         const QString sigFileName = QLatin1String(KLEO_TEST_DATADIR) + QLatin1String("/test.data.sig");
         const QString dataFileName = QLatin1String(KLEO_TEST_DATADIR) + QLatin1String("/test.data");
 
         QFile sigFile(sigFileName);
         QVERIFY(sigFile.open(QFile::ReadOnly));
         QFile dataFile(dataFileName);
         QVERIFY(dataFile.open(QFile::ReadOnly));
 
         mSignature = sigFile.readAll();
         mSignedData = dataFile.readAll();
 
         mBackend = QGpgME::openpgp();
     }
 
     void testVerify()
     {
         QGpgME::VerifyDetachedJob *job = mBackend->verifyDetachedJob();
         QSignalSpy spy(job, &QGpgME::VerifyDetachedJob::result);
         QVERIFY(spy.isValid());
         GpgME::Error err = job->start(mSignature, mSignedData);
         QVERIFY(!err);
         QTest::qWait(1000);   // ### we need to enter the event loop, can be done nicer though
 
         QCOMPARE(spy.count(), 1);
-        GpgME::VerificationResult result = spy.takeFirst().at(0).value<GpgME::VerificationResult>();
+        auto result = spy.takeFirst().at(0).value<GpgME::VerificationResult>();
         QCOMPARE(result.numSignatures(), 1U);
 
         GpgME::Signature sig = result.signature(0);
         QCOMPARE(sig.summary() & GpgME::Signature::KeyMissing, 0);
         QCOMPARE((quint64) sig.creationTime(), Q_UINT64_C(1530524124));
         QCOMPARE(sig.validity(), GpgME::Signature::Full);
     }
 
     /* Test that the decrypt verify job also works with signed only, not
      * encrypted PGP messages */
     void testDecryptVerifyOpaqueSigned()
     {
         const QString sigFileName = QLatin1String(KLEO_TEST_DATADIR) +
                                     QLatin1String("/test.data.signed-opaque.asc");
         std::pair<GpgME::DecryptionResult, GpgME::VerificationResult> result;
         QByteArray plaintext;
         QFile sigFile(sigFileName);
         QVERIFY(sigFile.open(QFile::ReadOnly));
         const QByteArray ciphertext = sigFile.readAll();
 
         QGpgME::DecryptVerifyJob *job = mBackend->decryptVerifyJob();
         result = job->exec(ciphertext, plaintext);
         QVERIFY(result.first.error().code());
 
         QVERIFY(result.second.numSignatures());
         GpgME::Signature sig = result.second.signature(0);
         QVERIFY(sig.validity() == GpgME::Signature::Validity::Full);
         QVERIFY(!sig.status().code());
         QVERIFY(QString::fromUtf8(plaintext).startsWith(
                     QLatin1String("/* -*- mode: c++; c-basic-offset:4 -*-")));
     }
 
 #ifndef GPGME_MULTITHREADED_KEYLIST_BROKEN
     // The following two tests are disabled because they trigger an
     // upstream bug in gpgme. See: https://bugs.gnupg.org/gnupg/issue2092
     // Which has a testcase attached that does similar things using gpgme
     // directly and triggers various problems.
     void testParallelVerifyAndKeyListJobs()
     {
         // ### Increasing 10 to 500 makes the verify jobs fail!
         // ^ This should also be reevaluated if the underlying bug in gpgme
         // is fixed.
         for (int i = 0; i < 10; ++i) {
             QGpgME::VerifyDetachedJob *job = mBackend->verifyDetachedJob();
             mParallelVerifyJobs.append(job);
             QVERIFY(!job->start(mSignature, mSignedData));
             connect(job, SIGNAL(result(GpgME::VerificationResult)),
                     this, SLOT(slotParallelVerifyJobFinished(GpgME::VerificationResult)));
         }
 
         mEventLoop.exec();
     }
 
     void testMixedParallelJobs()
     {
         mJobsStarted = 0;
         QTimer::singleShot(0, this, SLOT(startAnotherJob()));
         mEventLoop.exec();
     }
 #endif
 };
 
 QTEST_KLEOMAIN(VerifyTest)
 
 #include "test_verify.moc"