diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
index f1ccb58d3..3a63cab49 100644
--- a/src/crypto/decryptverifytask.cpp
+++ b/src/crypto/decryptverifytask.cpp
@@ -1,1604 +1,1604 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifytask.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 "decryptverifytask.h"
 
 #include <QGpgME/Protocol>
 #include <QGpgME/VerifyOpaqueJob>
 #include <QGpgME/VerifyDetachedJob>
 #include <QGpgME/DecryptJob>
 #include <QGpgME/DecryptVerifyJob>
 
 #include <Libkleo/Dn>
 #include <Libkleo/KleoException>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Classify>
 
 #include <utils/detail_p.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 #include <Libkleo/GnuPG>
 
 #include <KMime/HeaderParsing>
 
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 #include <gpgme++/context.h>
 
 #include <gpg-error.h>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 #include <QLocale>
 
 #include <QByteArray>
 #include <QDateTime>
 #include <QIODevice>
 #include <QStringList>
 #include <QTextDocument> // Qt::escape
 
 #include <algorithm>
 #include <sstream>
 
 using namespace Kleo::Crypto;
 using namespace Kleo;
 using namespace GpgME;
 using namespace KMime::Types;
 
 namespace
 {
 
 static AuditLog auditLogFromSender(QObject *sender)
 {
     return AuditLog::fromJob(qobject_cast<const QGpgME::Job *>(sender));
 }
 
 static bool addrspec_equal(const AddrSpec &lhs, const AddrSpec &rhs, Qt::CaseSensitivity cs)
 {
     return lhs.localPart.compare(rhs.localPart, cs) == 0 && lhs.domain.compare(rhs.domain, Qt::CaseInsensitive) == 0;
 }
 
 static bool mailbox_equal(const Mailbox &lhs, const Mailbox &rhs, Qt::CaseSensitivity cs)
 {
     return addrspec_equal(lhs.addrSpec(), rhs.addrSpec(), cs);
 }
 
 static std::string stripAngleBrackets(const std::string &str)
 {
     if (str.empty()) {
         return str;
     }
     if (str[0] == '<' && str[str.size() - 1] == '>') {
         return str.substr(1, str.size() - 2);
     }
     return str;
 }
 
 static std::string email(const UserID &uid)
 {
 
     if (uid.parent().protocol() == OpenPGP) {
         if (const char *const email = uid.email()) {
             return stripAngleBrackets(email);
         } else {
             return std::string();
         }
     }
 
     Q_ASSERT(uid.parent().protocol() == CMS);
 
     if (const char *const id = uid.id())
         if (*id == '<') {
             return stripAngleBrackets(id);
         } else {
             return DN(id)[QStringLiteral("EMAIL")].trimmed().toUtf8().constData();
         }
     else {
         return std::string();
     }
 }
 
 static Mailbox mailbox(const UserID &uid)
 {
     const std::string e = email(uid);
     Mailbox mbox;
     if (!e.empty()) {
         mbox.setAddress(e.c_str());
     }
     return mbox;
 }
 
 static std::vector<Mailbox> extractMailboxes(const Key &key)
 {
     std::vector<Mailbox> res;
     const auto userIDs{key.userIDs()};
     for (const UserID &id : userIDs) {
         const Mailbox mbox = mailbox(id);
         if (!mbox.addrSpec().isEmpty()) {
             res.push_back(mbox);
         }
     }
     return res;
 }
 
 static std::vector<Mailbox> extractMailboxes(const std::vector<Key> &signers)
 {
     std::vector<Mailbox> res;
     for (const Key &i : signers) {
         const std::vector<Mailbox> bxs = extractMailboxes(i);
         res.insert(res.end(), bxs.begin(), bxs.end());
     }
     return res;
 }
 
 static bool keyContainsMailbox(const Key &key, const Mailbox &mbox)
 {
     const std::vector<Mailbox> mbxs = extractMailboxes(key);
     return std::find_if(mbxs.cbegin(), mbxs.cend(), 
                         [mbox](const Mailbox &m) {
                             return mailbox_equal(mbox, m, Qt::CaseInsensitive);
                         }) != mbxs.cend();
 }
 
 static bool keysContainMailbox(const std::vector<Key> &keys, const Mailbox &mbox)
 {
     return std::find_if(keys.cbegin(), keys.cend(), 
                         [mbox](const Key &key) {
                             return keyContainsMailbox(key, mbox);
                         }) != keys.cend();
 }
 
 static bool relevantInDecryptVerifyContext(const VerificationResult &r)
 {
     // for D/V operations, we ignore verification results which are not errors and contain
     // no signatures (which means that the data was just not signed)
 
     return (r.error() && r.error().code() != GPG_ERR_DECRYPT_FAILED) || r.numSignatures() > 0;
 }
 
 static QString signatureSummaryToString(int summary)
 {
     if (summary & Signature::None) {
         return i18n("Error: Signature not verified");
     } else if (summary & Signature::Valid || summary & Signature::Green) {
         return i18n("Good signature");
     } else if (summary & Signature::KeyRevoked) {
         return i18n("Signing certificate was revoked");
     } else if (summary & Signature::KeyExpired) {
         return i18n("Signing certificate is expired");
     } else if (summary & Signature::KeyMissing) {
         return i18n("Certificate is not available");
     } else if (summary & Signature::SigExpired) {
         return i18n("Signature expired");
     } else if (summary & Signature::CrlMissing) {
         return i18n("CRL missing");
     } else if (summary & Signature::CrlTooOld) {
         return i18n("CRL too old");
     } else if (summary & Signature::BadPolicy) {
         return i18n("Bad policy");
     } else if (summary & Signature::SysError) {
         return i18n("System error");    //### retrieve system error details?
     } else if (summary & Signature::Red) {
         return i18n("Bad signature");
     }return QString();
 }
 
 static QString formatValidSignatureWithTrustLevel(const UserID &id)
 {
     if (id.isNull()) {
         return QString();
     }
     switch (id.validity()) {
     case UserID::Marginal:
         return i18n("The signature is valid but the trust in the certificate's validity is only marginal.");
     case UserID::Full:
         return i18n("The signature is valid and the certificate's validity is fully trusted.");
     case UserID::Ultimate:
         return i18n("The signature is valid and the certificate's validity is ultimately trusted.");
     case UserID::Never:
         return i18n("The signature is valid but the certificate's validity is <em>not trusted</em>.");
     case UserID::Unknown:
         return i18n("The signature is valid but the certificate's validity is unknown.");
     case UserID::Undefined:
     default:
         return i18n("The signature is valid but the certificate's validity is undefined.");
     }
 }
 
 static QString renderKeyLink(const QString &fpr, const QString &text)
 {
     return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(fpr, text);
 }
 
 static QString renderKey(const Key &key)
 {
     if (key.isNull()) {
         return i18n("Unknown certificate");
     }
 
     if (key.primaryFingerprint() && strlen(key.primaryFingerprint()) > 16 && key.numUserIDs()) {
         const QString text = QStringLiteral("%1 (%2)").arg(Formatting::prettyNameAndEMail(key).toHtmlEscaped()).arg(
             Formatting::prettyID(QString::fromLocal8Bit(key.primaryFingerprint()).right(16).toLatin1().constData()));
         return renderKeyLink(QLatin1String(key.primaryFingerprint()), text);
     }
 
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), Formatting::prettyID(key.primaryFingerprint()));
 }
 
 static QString renderKeyEMailOnlyNameAsFallback(const Key &key)
 {
     if (key.isNull()) {
         return i18n("Unknown certificate");
     }
     const QString email = Formatting::prettyEMail(key);
     const QString user = !email.isEmpty() ? email : Formatting::prettyName(key);
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), user);
 }
 
 static QString formatDate(const QDateTime &dt)
 {
     return QLocale().toString(dt);
 }
 static QString formatSigningInformation(const Signature &sig)
 {
     if (sig.isNull()) {
         return QString();
     }
     const QDateTime dt = sig.creationTime() != 0 ? QDateTime::fromSecsSinceEpoch(sig.creationTime()) : QDateTime();
     QString text;
     Key key = sig.key();
     if (dt.isValid()) {
         text = i18nc("1 is a date", "Signature created on %1", formatDate(dt)) + QStringLiteral("<br>");
     }
     if (key.isNull()) {
         return text += i18n("With unavailable certificate:") + QStringLiteral("<br>ID: 0x%1").arg(QString::fromLatin1(sig.fingerprint()).toUpper());
     }
     text += i18n("With certificate:") + QStringLiteral("<br>") + renderKey(key);
 
     if (Kleo::gnupgIsDeVsCompliant()) {
         text +=
             (QStringLiteral("<br/>")
-             + (IS_DE_VS(sig)
+             + (sig.isDeVs()
                 ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "The signature is %1", Formatting::deVsString())
                 : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                         "The signature <b>is not</b> %1.", Formatting::deVsString())));
     }
 
     return text;
 }
 
 static QString strikeOut(const QString &str, bool strike)
 {
     return QString(strike ? QStringLiteral("<s>%1</s>") : QStringLiteral("%1")).arg(str.toHtmlEscaped());
 }
 
 static QString formatInputOutputLabel(const QString &input, const QString &output, bool inputDeleted, bool outputDeleted)
 {
     if (output.isEmpty()) {
         return strikeOut(input, inputDeleted);
     }
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  strikeOut(input, inputDeleted),
                  strikeOut(output, outputDeleted));
 }
 
 static bool IsErrorOrCanceled(const GpgME::Error &err)
 {
     return err || err.isCanceled();
 }
 
 static bool IsErrorOrCanceled(const Result &res)
 {
     return IsErrorOrCanceled(res.error());
 }
 
 static bool IsBad(const Signature &sig)
 {
     return sig.summary() & Signature::Red;
 }
 
 static bool IsGoodOrValid(const Signature &sig)
 {
     return (sig.summary() & Signature::Valid) || (sig.summary() & Signature::Green);
 }
 
 static UserID findUserIDByMailbox(const Key &key, const Mailbox &mbox)
 {
     const auto userIDs{key.userIDs()};
     for (const UserID &id : userIDs)
         if (mailbox_equal(mailbox(id), mbox, Qt::CaseInsensitive)) {
             return id;
         }
     return UserID();
 }
 
 static void updateKeys(const VerificationResult &result) {
     // This little hack works around the problem that GnuPG / GpgME does not
     // provide Key information in a verification result. The Key object is
     // a dummy just holding the KeyID. This hack ensures that all available
     // keys are fetched from the backend and are populated
     for (const auto &sig: result.signatures()) {
         // Update key information
         sig.key(true, true);
     }
 }
 
 }
 
 class DecryptVerifyResult::SenderInfo
 {
 public:
     explicit SenderInfo(const Mailbox &infSender, const std::vector<Key> &signers_) : informativeSender(infSender), signers(signers_) {}
     const Mailbox informativeSender;
     const std::vector<Key> signers;
     bool hasInformativeSender() const
     {
         return !informativeSender.addrSpec().isEmpty();
     }
     bool conflicts() const
     {
         return hasInformativeSender() && hasKeys() && !keysContainMailbox(signers, informativeSender);
     }
     bool hasKeys() const
     {
         return std::any_of(signers.cbegin(), signers.cend(), [](const Key &key) { return !key.isNull(); });
     }
     std::vector<Mailbox> signerMailboxes() const
     {
         return extractMailboxes(signers);
     }
 };
 
 namespace
 {
 
 static Task::Result::VisualCode codeForVerificationResult(const VerificationResult &res)
 {
     if (res.isNull()) {
         return Task::Result::NeutralSuccess;
     }
 
     const std::vector<Signature> sigs = res.signatures();
     if (sigs.empty()) {
         return Task::Result::Warning;
     }
 
     if (std::find_if(sigs.begin(), sigs.end(), IsBad) != sigs.end()) {
         return Task::Result::Danger;
     }
 
     if ((size_t)std::count_if(sigs.begin(), sigs.end(), IsGoodOrValid) == sigs.size()) {
         return Task::Result::AllGood;
     }
 
     return Task::Result::Warning;
 }
 
 static QString formatVerificationResultOverview(const VerificationResult &res, const DecryptVerifyResult::SenderInfo &info)
 {
     if (res.isNull()) {
         return QString();
     }
 
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("<b>Verification canceled.</b>");
     } else if (err) {
         return i18n("<b>Verification failed: %1.</b>", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     const std::vector<Signature> sigs = res.signatures();
 
     if (sigs.empty()) {
         return i18n("<b>No signatures found.</b>");
     }
 
     const uint bad = std::count_if(sigs.cbegin(), sigs.cend(), IsBad);
     if (bad > 0) {
         return i18np("<b>Invalid signature.</b>", "<b>%1 invalid signatures.</b>", bad);
     }
     const uint warn = std::count_if(sigs.cbegin(), sigs.cend(), [](const Signature &sig) { return !IsGoodOrValid(sig); });
     if (warn == sigs.size()) {
         return i18np("<b>The data could not be verified.</b>", "<b>%1 signatures could not be verified.</b>", warn);
     }
 
     //Good signature:
     QString text;
     if (sigs.size() == 1) {
         text = i18n("<b>Valid signature by %1</b>", renderKeyEMailOnlyNameAsFallback(sigs[0].key()));
         if (info.conflicts())
             text += i18n("<br/><b>Warning:</b> The sender's mail address is not stored in the %1 used for signing.",
                          renderKeyLink(QLatin1String(sigs[0].key().primaryFingerprint()), i18n("certificate")));
     } else {
         text = i18np("<b>Valid signature.</b>", "<b>%1 valid signatures.</b>", sigs.size());
         if (info.conflicts()) {
             text += i18n("<br/><b>Warning:</b> The sender's mail address is not stored in the certificates used for signing.");
         }
     }
 
     return text;
 }
 
 static QString formatDecryptionResultOverview(const DecryptionResult &result, const QString &errorString = QString())
 {
     const Error err = result.error();
 
     if (err.isCanceled()) {
         return i18n("<b>Decryption canceled.</b>");
     }
     else if (result.isLegacyCipherNoMDC()) {
         return i18n("<b>Decryption failed: %1.</b>", i18n("No integrity protection (MDC)."));
     }
     else if (!errorString.isEmpty()) {
         return i18n("<b>Decryption failed: %1.</b>", errorString.toHtmlEscaped());
     } else if (err) {
         return i18n("<b>Decryption failed: %1.</b>", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
     return i18n("<b>Decryption succeeded.</b>");
 }
 
 static QString formatSignature(const Signature &sig, const DecryptVerifyResult::SenderInfo &info)
 {
     if (sig.isNull()) {
         return QString();
     }
 
     const QString text = formatSigningInformation(sig) + QLatin1String("<br/>");
     const Key key = sig.key();
 
     // Green
     if (sig.summary() & Signature::Valid) {
         const UserID id = findUserIDByMailbox(key, info.informativeSender);
         return text + formatValidSignatureWithTrustLevel(!id.isNull() ? id : key.userID(0));
     }
 
     // Red
     if ((sig.summary() & Signature::Red)) {
         const QString ret = text + i18n("The signature is invalid: %1", signatureSummaryToString(sig.summary()));
         if (sig.summary() & Signature::SysError) {
             return ret + QStringLiteral(" (%1)").arg(QString::fromLocal8Bit(sig.status().asString()));
         }
         return ret;
     }
 
     // Key missing
     if ((sig.summary() & Signature::KeyMissing)) {
         return text + i18n("You can search the certificate on a keyserver or import it from a file.");
     }
 
     // Yellow
     if ((sig.validity() & Signature::Validity::Undefined) ||
         (sig.validity() & Signature::Validity::Unknown) ||
         (sig.summary() == Signature::Summary::None)) {
         return text + (key.protocol() == OpenPGP ? i18n("The used key is not certified by you or any trusted person.") :
                i18n("The used certificate is not certified by a trustworthy Certificate Authority or the Certificate Authority is unknown."));
     }
 
     // Catch all fall through
     const QString ret = text + i18n("The signature is invalid: %1", signatureSummaryToString(sig.summary()));
     if (sig.summary() & Signature::SysError) {
         return ret + QStringLiteral(" (%1)").arg(QString::fromLocal8Bit(sig.status().asString()));
     }
     return ret;
 }
 
 static QStringList format(const std::vector<Mailbox> &mbxs)
 {
     QStringList res;
     std::transform(mbxs.cbegin(), mbxs.cend(), std::back_inserter(res),
                    [](const Mailbox &mbox) {
                        return mbox.prettyAddress();
                    });
     return res;
 }
 
 static QString formatVerificationResultDetails(const VerificationResult &res, const DecryptVerifyResult::SenderInfo &info, const QString &errorString)
 {
     if ((res.error().code() == GPG_ERR_EIO || res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
         return i18n("Input error: %1", errorString);
     }
 
     const std::vector<Signature> sigs = res.signatures();
     QString details;
     for (const Signature &sig : sigs) {
         details += formatSignature(sig, info) + QLatin1Char('\n');
     }
     details = details.trimmed();
     details.replace(QLatin1Char('\n'), QStringLiteral("<br/><br/>"));
     if (info.conflicts()) {
         details += i18n("<p>The sender's address %1 is not stored in the certificate. Stored: %2</p>", info.informativeSender.prettyAddress(), format(info.signerMailboxes()).join(i18nc("separator for a list of e-mail addresses", ", ")));
     }
     return details;
 }
 
 static QString formatRecipientsDetails(const std::vector<Key> &knownRecipients, unsigned int numRecipients)
 {
     if (numRecipients == 0) {
         return {};
     }
 
     if (knownRecipients.empty()) {
         return QLatin1String("<i>") +
                i18np("One unknown recipient.", "%1 unknown recipients.", numRecipients) +
                QLatin1String("</i>");
     }
 
     QString details = i18np("Recipient:", "Recipients:", numRecipients);
 
     if (numRecipients == 1) {
         details += QLatin1Char(' ') + renderKey(knownRecipients.front());
     } else {
         details += QLatin1String("<ul>");
         for (const Key &key : knownRecipients) {
             details += QLatin1String("<li>") + renderKey(key) + QLatin1String("</li>");
         }
         if (knownRecipients.size() < numRecipients) {
             details += QLatin1String("<li><i>") +
                        i18np("One unknown recipient", "%1 unknown recipients",
                              numRecipients - knownRecipients.size()) +
                        QLatin1String("</i></li>");
         }
         details += QLatin1String("</ul>");
     }
 
     return details;
 }
 
 static QString formatDecryptionResultDetails(const DecryptionResult &res, const std::vector<Key> &recipients,
                                              const QString &errorString, bool isSigned, const QPointer<Task> &task)
 {
     if ((res.error().code() == GPG_ERR_EIO || res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
         return i18n("Input error: %1", errorString);
     }
 
     if (res.isNull() || res.error() || res.error().isCanceled()) {
         return formatRecipientsDetails(recipients, res.numRecipients());
     }
 
     QString details;
 
     if (Kleo::gnupgIsDeVsCompliant()) {
-        details += ((IS_DE_VS(res)
+        details += ((res.isDeVs()
                      ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                              "The decryption is %1.", Formatting::deVsString())
                      : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
                              "The decryption <b>is not</b> %1.", Formatting::deVsString()))
                     + QStringLiteral("<br/>"));
     }
 
     if (res.fileName()) {
         const auto decVerifyTask = qobject_cast<AbstractDecryptVerifyTask*> (task.data());
         if (decVerifyTask) {
             const auto embedFileName = QString::fromUtf8(res.fileName()).toHtmlEscaped();
 
             if (embedFileName != decVerifyTask->outputLabel()) {
                 details += i18n("Embedded file name: '%1'", embedFileName);
                 details += QStringLiteral("<br/>");
             }
         }
     }
 
     if (!isSigned) {
         details += i18n("<b>Note:</b> You cannot be sure who encrypted this message as it is not signed.")
                    + QLatin1String("<br/>");
     }
 
     if (res.isLegacyCipherNoMDC()) {
         details += i18nc("Integrity protection was missing because an old cipher was used.",
                          "<b>Hint:</b> If this file was encrypted before the year 2003 it is "
                          "likely that the file is legitimate.  This is because back "
                          "then integrity protection was not widely used.") + QStringLiteral("<br/><br/>") +
                    i18nc("The user is offered to force decrypt a non integrity protected message. With the strong advice to re-encrypt it.",
                          "If you are confident that the file was not manipulated you should re-encrypt it after you have forced the decryption.") +
                    QStringLiteral("<br/><br/>");
     }
 
     details += formatRecipientsDetails(recipients, res.numRecipients());
 
     return details;
 }
 
 static QString formatDecryptVerifyResultOverview(const DecryptionResult &dr, const VerificationResult &vr, const  DecryptVerifyResult::SenderInfo &info)
 {
     if (IsErrorOrCanceled(dr) || !relevantInDecryptVerifyContext(vr)) {
         return formatDecryptionResultOverview(dr);
     }
     return formatVerificationResultOverview(vr, info);
 }
 
 static QString formatDecryptVerifyResultDetails(const DecryptionResult &dr,
         const VerificationResult &vr,
         const std::vector<Key> &recipients,
         const DecryptVerifyResult::SenderInfo &info,
         const QString &errorString,
         const QPointer<Task> &task)
 {
     const QString drDetails = formatDecryptionResultDetails(dr, recipients, errorString, relevantInDecryptVerifyContext(vr), task);
     if (IsErrorOrCanceled(dr) || !relevantInDecryptVerifyContext(vr)) {
         return drDetails;
     }
     return drDetails + (drDetails.isEmpty() ? QString() : QStringLiteral("<br/>")) + formatVerificationResultDetails(vr, info, errorString);
 }
 
 } // anon namespace
 
 class DecryptVerifyResult::Private
 {
     DecryptVerifyResult *const q;
 public:
     Private(DecryptVerifyOperation type,
             const VerificationResult &vr,
             const DecryptionResult &dr,
             const QByteArray &stuff,
             int errCode,
             const QString &errString,
             const QString &input,
             const QString &output,
             const AuditLog &auditLog,
             Task *parentTask,
             const Mailbox &informativeSender,
             DecryptVerifyResult *qq) :
         q(qq),
         m_type(type),
         m_verificationResult(vr),
         m_decryptionResult(dr),
         m_stuff(stuff),
         m_error(errCode),
         m_errorString(errString),
         m_inputLabel(input),
         m_outputLabel(output),
         m_auditLog(auditLog),
         m_parentTask(QPointer<Task>(parentTask)),
         m_informativeSender(informativeSender)
     {
     }
 
     QString label() const
     {
         return formatInputOutputLabel(m_inputLabel, m_outputLabel, false, q->hasError());
     }
 
     DecryptVerifyResult::SenderInfo makeSenderInfo() const;
 
     bool isDecryptOnly() const
     {
         return m_type == Decrypt;
     }
     bool isVerifyOnly() const
     {
         return m_type == Verify;
     }
     bool isDecryptVerify() const
     {
         return m_type == DecryptVerify;
     }
     DecryptVerifyOperation m_type;
     VerificationResult m_verificationResult;
     DecryptionResult m_decryptionResult;
     QByteArray m_stuff;
     int m_error;
     QString m_errorString;
     QString m_inputLabel;
     QString m_outputLabel;
     const AuditLog m_auditLog;
     QPointer <Task> m_parentTask;
     const Mailbox m_informativeSender;
 };
 
 DecryptVerifyResult::SenderInfo DecryptVerifyResult::Private::makeSenderInfo() const
 {
     return SenderInfo(m_informativeSender, KeyCache::instance()->findSigners(m_verificationResult));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const DecryptionResult &dr, const QByteArray &plaintext, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             dr,
             plaintext,
             0,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const GpgME::Error &err, const QString &what, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             err.code(),
             what,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog)
 {
     int err = dr.error() ? dr.error().code() : vr.error().code();
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             vr,
             dr,
             plaintext,
             err,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             err.code(),
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             plaintext,
             0,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             err.code(),
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const VerificationResult &vr, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             QByteArray(),
             0,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             err.code(),
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 DecryptVerifyResult::DecryptVerifyResult(DecryptVerifyOperation type,
         const VerificationResult &vr,
         const DecryptionResult &dr,
         const QByteArray &stuff,
         int errCode,
         const QString &errString,
         const QString &inputLabel,
         const QString &outputLabel,
         const AuditLog &auditLog,
         Task *parentTask,
         const Mailbox &informativeSender)
     : Task::Result(), d(new Private(type, vr, dr, stuff, errCode, errString, inputLabel, outputLabel, auditLog, parentTask, informativeSender, this))
 {
 }
 
 QString DecryptVerifyResult::overview() const
 {
     QString ov;
     if (d->isDecryptOnly()) {
         ov += formatDecryptionResultOverview(d->m_decryptionResult);
     } else if (d->isVerifyOnly()) {
         ov += formatVerificationResultOverview(d->m_verificationResult, d->makeSenderInfo());
     } else {
         ov += formatDecryptVerifyResultOverview(d->m_decryptionResult, d->m_verificationResult, d->makeSenderInfo());
     }
     if (ov.size() + d->label().size() > 120) {
         // Avoid ugly breaks
         ov = QStringLiteral("<br>") + ov;
     }
     return i18nc("label: result example: foo.sig: Verification failed. ", "%1: %2", d->label(), ov);
 }
 
 QString DecryptVerifyResult::details() const
 {
     if (d->isDecryptOnly()) {
         return formatDecryptionResultDetails(d->m_decryptionResult,
                 KeyCache::instance()->findRecipients(d->m_decryptionResult),
                 errorString(), false, d->m_parentTask);
     }
     if (d->isVerifyOnly()) {
         return formatVerificationResultDetails(d->m_verificationResult, d->makeSenderInfo(), errorString());
     }
     return formatDecryptVerifyResultDetails(d->m_decryptionResult,
                                             d->m_verificationResult, KeyCache::instance()->findRecipients(
                                                     d->m_decryptionResult), d->makeSenderInfo(), errorString(),
                                             d->m_parentTask);
 }
 
 bool DecryptVerifyResult::hasError() const
 {
     return d->m_error != 0;
 }
 
 int DecryptVerifyResult::errorCode() const
 {
     return d->m_error;
 }
 
 QString DecryptVerifyResult::errorString() const
 {
     return d->m_errorString;
 }
 
 AuditLog DecryptVerifyResult::auditLog() const
 {
     return d->m_auditLog;
 }
 
 QPointer<Task> DecryptVerifyResult::parentTask() const
 {
     return d->m_parentTask;
 }
 
 Task::Result::VisualCode DecryptVerifyResult::code() const
 {
     if ((d->m_type == DecryptVerify || d->m_type == Verify) && relevantInDecryptVerifyContext(verificationResult())) {
         return codeForVerificationResult(verificationResult());
     }
     return hasError() ? NeutralError : NeutralSuccess;
 }
 
 GpgME::VerificationResult DecryptVerifyResult::verificationResult() const
 {
     return d->m_verificationResult;
 }
 
 GpgME::DecryptionResult DecryptVerifyResult::decryptionResult() const
 {
     return d->m_decryptionResult;
 }
 
 class AbstractDecryptVerifyTask::Private
 {
 public:
     Mailbox informativeSender;
 };
 
 AbstractDecryptVerifyTask::AbstractDecryptVerifyTask(QObject *parent) : Task(parent), d(new Private) {}
 
 AbstractDecryptVerifyTask::~AbstractDecryptVerifyTask() {}
 
 Mailbox AbstractDecryptVerifyTask::informativeSender() const
 {
     return d->informativeSender;
 }
 
 void AbstractDecryptVerifyTask::setInformativeSender(const Mailbox &sender)
 {
     d->informativeSender = sender;
 }
 
 class DecryptVerifyTask::Private
 {
     DecryptVerifyTask *const q;
 public:
     explicit Private(DecryptVerifyTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol), m_ignoreMDCError(false)  {}
 
     void slotResult(const DecryptionResult &, const VerificationResult &, const QByteArray &);
 
     void registerJob(QGpgME::DecryptVerifyJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::DecryptionResult,GpgME::VerificationResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::DecryptionResult,GpgME::VerificationResult,QByteArray)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
     bool m_ignoreMDCError;
 };
 
 void DecryptVerifyTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void DecryptVerifyTask::Private::slotResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plainText)
 {
     updateKeys(vr);
     {
         std::stringstream ss;
         ss << dr << '\n' << vr;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     if (dr.error().code() || vr.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!dr.isNull() || !vr.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
     const int drErr = dr.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(drErr ? dr.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     emitResult(q->fromDecryptVerifyResult(dr, vr, plainText, auditLog));
 }
 
 DecryptVerifyTask::DecryptVerifyTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 DecryptVerifyTask::~DecryptVerifyTask()
 {
 }
 
 void DecryptVerifyTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void DecryptVerifyTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void DecryptVerifyTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = prot == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void DecryptVerifyTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature/ciphertext - maybe it is neither ciphertext nor a signature?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString DecryptVerifyTask::label() const
 {
     return i18n("Decrypting: %1...", d->m_input->label());
 }
 
 unsigned long long DecryptVerifyTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString DecryptVerifyTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString DecryptVerifyTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol DecryptVerifyTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void DecryptVerifyTask::cancel()
 {
 
 }
 
 static void ensureIOOpen(QIODevice *input, QIODevice *output)
 {
     if (input && !input->isOpen()) {
         input->open(QIODevice::ReadOnly);
     }
     if (output && !output->isOpen()) {
         output->open(QIODevice::WriteOnly);
     }
 }
 
 void DecryptVerifyTask::setIgnoreMDCError(bool value)
 {
     d->m_ignoreMDCError = value;
 }
 
 void DecryptVerifyTask::doStart()
 {
     kleo_assert(d->m_backend);
     try {
         QGpgME::DecryptVerifyJob *const job = d->m_backend->decryptVerifyJob();
 
         if (d->m_ignoreMDCError) {
             qCDebug(KLEOPATRA_LOG) << "Modifying job to ignore MDC errors.";
             auto ctx = QGpgME::Job::context(job);
             if (!ctx) {
                 qCWarning(KLEOPATRA_LOG) << "Failed to get context for job";
             } else {
                 const auto err = ctx->setFlag("ignore-mdc-error", "1");
                 if (err) {
                     qCWarning(KLEOPATRA_LOG) << "Failed to set ignore mdc errors" << err.asString();
                 }
             }
         }
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
         job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromDecryptVerifyResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 
 }
 
 class DecryptTask::Private
 {
     DecryptTask *const q;
 public:
     explicit Private(DecryptTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol)  {}
 
     void slotResult(const DecryptionResult &, const QByteArray &);
 
     void registerJob(QGpgME::DecryptJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::DecryptionResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::DecryptionResult,QByteArray)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
 };
 
 void DecryptTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void DecryptTask::Private::slotResult(const DecryptionResult &result, const QByteArray &plainText)
 {
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     if (result.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     emitResult(q->fromDecryptResult(result, plainText, auditLog));
 }
 
 DecryptTask::DecryptTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 DecryptTask::~DecryptTask()
 {
 }
 
 void DecryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void DecryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void DecryptTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void DecryptTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this was S/MIME- or OpenPGP-encrypted - maybe it is not ciphertext at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString DecryptTask::label() const
 {
     return i18n("Decrypting: %1...", d->m_input->label());
 }
 
 unsigned long long DecryptTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString DecryptTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString DecryptTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol DecryptTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void DecryptTask::cancel()
 {
 
 }
 
 void DecryptTask::doStart()
 {
     kleo_assert(d->m_backend);
 
     try {
         QGpgME::DecryptJob *const job = d->m_backend->decryptJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
         job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 }
 
 class VerifyOpaqueTask::Private
 {
     VerifyOpaqueTask *const q;
 public:
     explicit Private(VerifyOpaqueTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol)  {}
 
     void slotResult(const VerificationResult &, const QByteArray &);
 
     void registerJob(QGpgME::VerifyOpaqueJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::VerificationResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::VerificationResult,QByteArray)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
 };
 
 void VerifyOpaqueTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void VerifyOpaqueTask::Private::slotResult(const VerificationResult &result, const QByteArray &plainText)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     if (result.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     emitResult(q->fromVerifyOpaqueResult(result, plainText, auditLog));
 }
 
 VerifyOpaqueTask::VerifyOpaqueTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 VerifyOpaqueTask::~VerifyOpaqueTask()
 {
 }
 
 void VerifyOpaqueTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void VerifyOpaqueTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void VerifyOpaqueTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void VerifyOpaqueTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString VerifyOpaqueTask::label() const
 {
     return i18n("Verifying: %1...", d->m_input->label());
 }
 
 unsigned long long VerifyOpaqueTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString VerifyOpaqueTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString VerifyOpaqueTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol VerifyOpaqueTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyOpaqueTask::cancel()
 {
 
 }
 
 void VerifyOpaqueTask::doStart()
 {
     kleo_assert(d->m_backend);
 
     try {
         QGpgME::VerifyOpaqueJob *const job = d->m_backend->verifyOpaqueJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output ? d->m_output->ioDevice().get() : nullptr);
         job->start(d->m_input->ioDevice(), d->m_output ? d->m_output->ioDevice() : std::shared_ptr<QIODevice>());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 }
 
 class VerifyDetachedTask::Private
 {
     VerifyDetachedTask *const q;
 public:
     explicit Private(VerifyDetachedTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol) {}
 
     void slotResult(const VerificationResult &);
 
     void registerJob(QGpgME::VerifyDetachedJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::VerificationResult)),
                    q, SLOT(slotResult(GpgME::VerificationResult)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input, m_signedData;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
 };
 
 void VerifyDetachedTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void VerifyDetachedTask::Private::slotResult(const VerificationResult &result)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     try {
         kleo_assert(!result.isNull());
         emitResult(q->fromVerifyDetachedResult(result, auditLog));
     } catch (const GpgME::Exception &e) {
         emitResult(q->fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
     } catch (const std::exception &e) {
         emitResult(q->fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
     } catch (...) {
         emitResult(q->fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
     }
 }
 
 VerifyDetachedTask::VerifyDetachedTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 VerifyDetachedTask::~VerifyDetachedTask()
 {
 }
 
 void VerifyDetachedTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void VerifyDetachedTask::setSignedData(const std::shared_ptr<Input> &signedData)
 {
     d->m_signedData = signedData;
     kleo_assert(d->m_signedData && d->m_signedData->ioDevice());
 }
 
 void VerifyDetachedTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void VerifyDetachedTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 unsigned long long VerifyDetachedTask::inputSize() const
 {
     return d->m_signedData ? d->m_signedData->size() : 0;
 }
 
 QString VerifyDetachedTask::label() const
 {
     if (d->m_signedData) {
         return xi18nc("Verification of a detached signature in progress. The first file contains the data."
                       "The second file is the signature file.",
                       "Verifying: <filename>%1</filename> with <filename>%2</filename>...",
                       d->m_signedData->label(),
                       d->m_input->label());
 
     }
     return i18n("Verifying signature: %1...", d->m_input->label());
 }
 
 QString VerifyDetachedTask::inputLabel() const
 {
     if (d->m_signedData && d->m_input) {
         return xi18nc("Verification of a detached signature summary. The first file contains the data."
                       "The second file is signature.",
                       "Verified <filename>%1</filename> with <filename>%2</filename>",
                       d->m_signedData->label(),
                       d->m_input->label());
 
     }
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString VerifyDetachedTask::outputLabel() const
 {
     return QString();
 }
 
 Protocol VerifyDetachedTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyDetachedTask::cancel()
 {
 
 }
 
 void VerifyDetachedTask::doStart()
 {
     kleo_assert(d->m_backend);
     try {
         QGpgME::VerifyDetachedJob *const job = d->m_backend->verifyDetachedJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), nullptr);
         ensureIOOpen(d->m_signedData->ioDevice().get(), nullptr);
         job->start(d->m_input->ioDevice(), d->m_signedData->ioDevice());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 }
 
 #include "moc_decryptverifytask.cpp"
diff --git a/src/crypto/gui/signencryptemailconflictdialog.cpp b/src/crypto/gui/signencryptemailconflictdialog.cpp
index 866af10e4..b522270df 100644
--- a/src/crypto/gui/signencryptemailconflictdialog.cpp
+++ b/src/crypto/gui/signencryptemailconflictdialog.cpp
@@ -1,645 +1,645 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptemailconflictdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptemailconflictdialog.h"
 
 #include <crypto/sender.h>
 #include <crypto/recipient.h>
 
 #include "dialogs/certificateselectiondialog.h"
 #include "certificateselectionline.h"
 
 #include <Libkleo/GnuPG>
 #include "utils/gui-helper.h"
 #include "utils/kleo_assert.h"
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Formatting>
 
 #include <gpgme++/key.h>
 
 #include <KMime/HeaderParsing>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 
 #include <QLabel>
 #include <QLayout>
 #include <QGroupBox>
 #include <QDialogButtonBox>
 #include <QCheckBox>
 #include <QRadioButton>
 #include <QPushButton>
 #include <QPointer>
 #include <QSignalBlocker>
 #include <QToolButton>
 
 #include <algorithm>
 #include <iterator>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 Q_DECLARE_METATYPE(GpgME::UserID)
 
 static CertificateSelectionDialog *
 create_certificate_selection_dialog(QWidget *parent, Protocol proto)
 {
     auto const dlg = new CertificateSelectionDialog(parent);
     dlg->setOptions(proto == OpenPGP ? CertificateSelectionDialog::OpenPGPFormat :
                     proto == CMS     ? CertificateSelectionDialog::CMSFormat : CertificateSelectionDialog::AnyFormat);
     return dlg;
 }
 
 static CertificateSelectionDialog *
 create_encryption_certificate_selection_dialog(QWidget *parent, Protocol proto, const QString &mailbox)
 {
     CertificateSelectionDialog *const dlg = create_certificate_selection_dialog(parent, proto);
     dlg->setCustomLabelText(i18n("Please select an encryption certificate for recipient \"%1\"", mailbox));
     dlg->setOptions(CertificateSelectionDialog::SingleSelection |
                     CertificateSelectionDialog::EncryptOnly |
                     dlg->options());
     return dlg;
 }
 
 static CertificateSelectionDialog *
 create_signing_certificate_selection_dialog(QWidget *parent, Protocol proto, const QString &mailbox)
 {
     CertificateSelectionDialog *const dlg = create_certificate_selection_dialog(parent, proto);
     dlg->setCustomLabelText(i18n("Please select a signing certificate for sender \"%1\"", mailbox));
     dlg->setOptions(CertificateSelectionDialog::SingleSelection |
                     CertificateSelectionDialog::SignOnly |
                     CertificateSelectionDialog::SecretKeys |
                     dlg->options());
     return dlg;
 }
 
 static QString make_top_label_conflict_text(bool sign, bool enc)
 {
     return
         sign && enc ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for all recipients/senders of the message.\n"
                            "Please select the correct certificates for each recipient:") :
         sign        ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for the sender of the message.\n"
                            "Please select the correct certificates for the sender:") :
         enc         ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for all recipients of the message.\n"
                            "Please select the correct certificates for each recipient:") :
         /* else */ (kleo_assert_fail(sign || enc), QString());
 }
 
 static QString make_top_label_quickmode_text(bool sign, bool enc)
 {
     return
         enc    ? i18n("Please verify that correct certificates have been selected for each recipient:") :
         sign   ? i18n("Please verify that the correct certificate has been selected for the sender:") :
         /*else*/ (kleo_assert_fail(sign || enc), QString());
 }
 
 class SignEncryptEMailConflictDialog::Private
 {
     friend class ::Kleo::Crypto::Gui::SignEncryptEMailConflictDialog;
     SignEncryptEMailConflictDialog *const q;
 public:
     explicit Private(SignEncryptEMailConflictDialog *qq)
         : q(qq),
           senders(),
           recipients(),
           sign(true),
           encrypt(true),
           presetProtocol(UnknownProtocol),
           ui(q)
     {
 
     }
 
 private:
     void updateTopLabelText()
     {
         ui.conflictTopLB.setText(make_top_label_conflict_text(sign, encrypt));
         ui.quickModeTopLB.setText(make_top_label_quickmode_text(sign, encrypt));
     }
 
     void showHideWidgets()
     {
         const Protocol proto = q->selectedProtocol();
         const bool quickMode = q->isQuickMode();
 
         const bool needProtocolSelection = presetProtocol == UnknownProtocol;
 
         const bool needShowAllRecipientsCB =
             quickMode             ? false :
             needProtocolSelection ? needShowAllRecipients(OpenPGP) || needShowAllRecipients(CMS) :
             /* else */              needShowAllRecipients(proto)
             ;
 
         ui.showAllRecipientsCB.setVisible(needShowAllRecipientsCB);
 
         ui.pgpRB.setVisible(needProtocolSelection);
         ui.cmsRB.setVisible(needProtocolSelection);
 
         const bool showAll = !needShowAllRecipientsCB || ui.showAllRecipientsCB.isChecked();
 
         bool first;
         first = true;
         for (const CertificateSelectionLine &line : std::as_const(ui.signers)) {
             line.showHide(proto, first, showAll, sign);
         }
         ui.selectSigningCertificatesGB.setVisible(sign && (showAll || !first));
 
         first = true;
         for (const CertificateSelectionLine &line : std::as_const(ui.recipients)) {
             line.showHide(proto, first, showAll, encrypt);
         }
         ui.selectEncryptionCertificatesGB.setVisible(encrypt && (showAll || !first));
     }
 
     bool needShowAllRecipients(Protocol proto) const
     {
         if (sign) {
             if (const unsigned int num = std::count_if(ui.signers.cbegin(), ui.signers.cend(),
                                                        [proto](const CertificateSelectionLine &l) {
                                                            return l.wasInitiallyAmbiguous(proto);
                                                        })) {
                 if (num != ui.signers.size()) {
                     return true;
                 }
             }
         }
         if (encrypt) {
             if (const unsigned int num = std::count_if(ui.recipients.cbegin(), ui.recipients.cend(),
                                                       [proto](const CertificateSelectionLine &l) {
                                                           return l.wasInitiallyAmbiguous(proto);
                                                       })) {
                 if (num != ui.recipients.size()) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     void createSendersAndRecipients()
     {
         ui.clearSendersAndRecipients();
 
         ui.addSelectSigningCertificatesGB();
         for (const Sender &s : std::as_const(senders)) {
             addSigner(s);
         }
 
         ui.addSelectEncryptionCertificatesGB();
         for (const Sender &s : std::as_const(senders)) {
             addRecipient(s);
         }
         for (const Recipient &r : std::as_const(recipients)) {
             addRecipient(r);
         }
     }
 
     void addSigner(const Sender &s)
     {
         ui.addSigner(s.mailbox().prettyAddress(),
                      s.signingCertificateCandidates(OpenPGP),
                      s.isSigningAmbiguous(OpenPGP),
                      s.signingCertificateCandidates(CMS),
                      s.isSigningAmbiguous(CMS),
                      q);
     }
 
     void addRecipient(const Sender &s)
     {
         ui.addRecipient(s.mailbox().prettyAddress(),
                         s.encryptToSelfCertificateCandidates(OpenPGP),
                         s.isEncryptionAmbiguous(OpenPGP),
                         s.encryptToSelfCertificateCandidates(CMS),
                         s.isEncryptionAmbiguous(CMS),
                         q);
     }
 
     void addRecipient(const Recipient &r)
     {
         ui.addRecipient(r.mailbox().prettyAddress(),
                         r.encryptionCertificateCandidates(OpenPGP),
                         r.isEncryptionAmbiguous(OpenPGP),
                         r.encryptionCertificateCandidates(CMS),
                         r.isEncryptionAmbiguous(CMS),
                         q);
     }
 
     bool isComplete(Protocol proto) const;
 
 private:
 
     void updateComplianceStatus()
     {
         if (!Kleo::gnupgIsDeVsCompliant()) {
             return;
         }
         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) {
+            if (!key.isDeVs() || 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) {
+                if (!key.isDeVs() || 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("QPushButton { background-color: %1; }").arg(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());
         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;
         for (const CertificateSelectionLine &l : std::as_const(ui.signers))
             if (s == l.toolButton()) {
                 dlg = create_signing_certificate_selection_dialog(q, proto, l.mailboxText());
                 if (dlg->exec()) {
                     l.addAndSelectCertificate(dlg->selectedCertificate());
                 }
                 // ### switch to key.protocol(), in case proto == UnknownProtocol
                 break;
             }
         for (const CertificateSelectionLine &l : std::as_const(ui.recipients))
             if (s == l.toolButton()) {
                 dlg = create_encryption_certificate_selection_dialog(q, proto, l.mailboxText());
                 if (dlg->exec()) {
                     l.addAndSelectCertificate(dlg->selectedCertificate());
                 }
                 // ### switch to key.protocol(), in case proto == UnknownProtocol
                 break;
             }
 #ifndef Q_OS_WIN
         // This leads to a crash on Windows. We don't really
         // leak memory here anyway because the destruction of the
         // dialog happens when the parent (q) is destroyed anyway.
         delete dlg;
 #endif
     }
 
 private:
     std::vector<Sender> senders;
     std::vector<Recipient> recipients;
 
     bool sign : 1;
     bool encrypt : 1;
     Protocol presetProtocol;
 
 private:
     struct Ui {
         QLabel conflictTopLB, quickModeTopLB;
         QCheckBox showAllRecipientsCB;
         QRadioButton pgpRB, cmsRB;
         QGroupBox selectSigningCertificatesGB;
         QGroupBox selectEncryptionCertificatesGB;
         QCheckBox quickModeCB;
         QDialogButtonBox buttonBox;
         QVBoxLayout vlay;
         QHBoxLayout  hlay;
         QHBoxLayout  hlay2;
         QGridLayout  glay;
         std::vector<CertificateSelectionLine> signers, recipients;
         QLabel complianceLB;
 
         void setOkButtonEnabled(bool enable)
         {
             return buttonBox.button(QDialogButtonBox::Ok)->setEnabled(enable);
         }
 
         explicit Ui(SignEncryptEMailConflictDialog *q)
             : conflictTopLB(make_top_label_conflict_text(true, true), q),
               quickModeTopLB(make_top_label_quickmode_text(true, true), q),
               showAllRecipientsCB(i18n("Show all recipients"), q),
               pgpRB(i18n("OpenPGP"), q),
               cmsRB(i18n("S/MIME"), q),
               selectSigningCertificatesGB(i18n("Select Signing Certificate"), q),
               selectEncryptionCertificatesGB(i18n("Select Encryption Certificate"), q),
               quickModeCB(i18n("Only show this dialog in case of conflicts (experimental)"), q),
               buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, q),
               vlay(q),
               hlay(),
               glay(),
               signers(),
               recipients()
         {
             KDAB_SET_OBJECT_NAME(conflictTopLB);
             KDAB_SET_OBJECT_NAME(quickModeTopLB);
             KDAB_SET_OBJECT_NAME(showAllRecipientsCB);
             KDAB_SET_OBJECT_NAME(pgpRB);
             KDAB_SET_OBJECT_NAME(cmsRB);
             KDAB_SET_OBJECT_NAME(selectSigningCertificatesGB);
             KDAB_SET_OBJECT_NAME(selectEncryptionCertificatesGB);
             KDAB_SET_OBJECT_NAME(quickModeCB);
             KDAB_SET_OBJECT_NAME(buttonBox);
             KDAB_SET_OBJECT_NAME(hlay);
             KDAB_SET_OBJECT_NAME(glay);
             KDAB_SET_OBJECT_NAME(vlay);
 
             q->setWindowTitle(i18nc("@title:window", "Select Certificates for Message"));
 
             conflictTopLB.hide();
 
             selectSigningCertificatesGB.setFlat(true);
             selectEncryptionCertificatesGB.setFlat(true);
             selectSigningCertificatesGB.setAlignment(Qt::AlignCenter);
             selectEncryptionCertificatesGB.setAlignment(Qt::AlignCenter);
 
             glay.setColumnStretch(2, 1);
             glay.setColumnStretch(3, 1);
 
             vlay.setSizeConstraint(QLayout::SetMinimumSize);
 
             vlay.addWidget(&conflictTopLB);
             vlay.addWidget(&quickModeTopLB);
 
             hlay.addWidget(&showAllRecipientsCB);
             hlay.addStretch(1);
             hlay.addWidget(&pgpRB);
             hlay.addWidget(&cmsRB);
             vlay.addLayout(&hlay);
 
             addSelectSigningCertificatesGB();
             addSelectEncryptionCertificatesGB();
             vlay.addLayout(&glay);
 
             vlay.addStretch(1);
 
             complianceLB.setVisible(false);
             hlay2.addStretch(1);
             hlay2.addWidget(&complianceLB, 0, Qt::AlignRight);
             hlay2.addWidget(&buttonBox, 0, Qt::AlignRight);
 
             vlay.addWidget(&quickModeCB, 0, Qt::AlignRight);
             vlay.addLayout(&hlay2);
 
 
             connect(&buttonBox, &QDialogButtonBox::accepted, q, &SignEncryptEMailConflictDialog::accept);
             connect(&buttonBox, &QDialogButtonBox::rejected, q, &SignEncryptEMailConflictDialog::reject);
 
             connect(&showAllRecipientsCB, SIGNAL(toggled(bool)), q, SLOT(slotShowAllRecipientsToggled(bool)));
             connect(&pgpRB, SIGNAL(toggled(bool)),
                     q, SLOT(slotProtocolChanged()));
             connect(&cmsRB, SIGNAL(toggled(bool)),
                     q, SLOT(slotProtocolChanged()));
         }
 
         void clearSendersAndRecipients()
         {
             std::vector<CertificateSelectionLine> sig, enc;
             sig.swap(signers);
             enc.swap(recipients);
             std::for_each(sig.begin(), sig.end(), std::mem_fn(&CertificateSelectionLine::kill));
             std::for_each(enc.begin(), enc.end(), std::mem_fn(&CertificateSelectionLine::kill));
             glay.removeWidget(&selectSigningCertificatesGB);
             glay.removeWidget(&selectEncryptionCertificatesGB);
         }
 
         void addSelectSigningCertificatesGB()
         {
             glay.addWidget(&selectSigningCertificatesGB,    glay.rowCount(), 0, 1, CertificateSelectionLine::NumColumns);
         }
         void addSelectEncryptionCertificatesGB()
         {
             glay.addWidget(&selectEncryptionCertificatesGB, glay.rowCount(), 0, 1, CertificateSelectionLine::NumColumns);
         }
 
         void addSigner(const QString &mailbox,
                        const std::vector<Key> &pgp, bool pgpAmbiguous,
                        const std::vector<Key> &cms, bool cmsAmbiguous, QWidget *q)
         {
             CertificateSelectionLine line(i18n("From:"), mailbox, pgp, pgpAmbiguous, cms, cmsAmbiguous, q, glay);
             signers.push_back(line);
         }
 
         void addRecipient(const QString &mailbox,
                           const std::vector<Key> &pgp, bool pgpAmbiguous,
                           const std::vector<Key> &cms, bool cmsAmbiguous, QWidget *q)
         {
             CertificateSelectionLine line(i18n("To:"), mailbox, pgp, pgpAmbiguous, cms, cmsAmbiguous, q, glay);
             recipients.push_back(line);
         }
 
     } ui;
 };
 
 SignEncryptEMailConflictDialog::SignEncryptEMailConflictDialog(QWidget *parent)
     : QDialog(parent), d(new Private(this))
 {
 
 }
 
 SignEncryptEMailConflictDialog::~SignEncryptEMailConflictDialog() {}
 
 void SignEncryptEMailConflictDialog::setPresetProtocol(Protocol p)
 {
     if (p == d->presetProtocol) {
         return;
     }
     const QSignalBlocker pgpBlocker(d->ui.pgpRB);
     const QSignalBlocker cmsBlocker(d->ui.cmsRB);
     really_check(d->ui.pgpRB, p == OpenPGP);
     really_check(d->ui.cmsRB, p == CMS);
     d->presetProtocol = p;
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 Protocol SignEncryptEMailConflictDialog::selectedProtocol() const
 {
     if (d->presetProtocol != UnknownProtocol) {
         return d->presetProtocol;
     }
     if (d->ui.pgpRB.isChecked()) {
         return OpenPGP;
     }
     if (d->ui.cmsRB.isChecked()) {
         return CMS;
     }
     return UnknownProtocol;
 }
 
 void SignEncryptEMailConflictDialog::setSubject(const QString &subject)
 {
     setWindowTitle(i18nc("@title:window", "Select Certificates for Message \"%1\"", subject));
 }
 
 void SignEncryptEMailConflictDialog::setSign(bool sign)
 {
     if (sign == d->sign) {
         return;
     }
     d->sign = sign;
     d->updateTopLabelText();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setEncrypt(bool encrypt)
 {
     if (encrypt == d->encrypt) {
         return;
     }
     d->encrypt = encrypt;
     d->updateTopLabelText();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setSenders(const std::vector<Sender> &senders)
 {
     if (senders == d->senders) {
         return;
     }
     d->senders = senders;
     d->createSendersAndRecipients();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setRecipients(const std::vector<Recipient> &recipients)
 {
     if (d->recipients == recipients) {
         return;
     }
     d->recipients = recipients;
     d->createSendersAndRecipients();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::pickProtocol()
 {
 
     if (selectedProtocol() != UnknownProtocol) {
         return;    // already picked
     }
 
     const bool pgp = d->isComplete(OpenPGP);
     const bool cms = d->isComplete(CMS);
 
     if (pgp && !cms) {
         d->ui.pgpRB.setChecked(true);
     } else if (cms && !pgp) {
         d->ui.cmsRB.setChecked(true);
     }
 }
 
 bool SignEncryptEMailConflictDialog::isComplete() const
 {
     const Protocol proto = selectedProtocol();
     return proto != UnknownProtocol && d->isComplete(proto);
 }
 
 bool SignEncryptEMailConflictDialog::Private::isComplete(Protocol proto) const
 {
     return (!sign || std::none_of(ui.signers.cbegin(), ui.signers.cend(),
                                   [proto](const CertificateSelectionLine &l) {
                                       return l.isStillAmbiguous(proto);
                                   }))
            && (!encrypt || std::none_of(ui.recipients.cbegin(), ui.recipients.cend(),
                                         [proto](const CertificateSelectionLine &l) {
                                             return l.isStillAmbiguous(proto);
                                         }));
 }
 
 static std::vector<Key> get_keys(const std::vector<CertificateSelectionLine> &lines, Protocol proto)
 {
     if (proto == UnknownProtocol) {
         return std::vector<Key>();
     }
     Q_ASSERT(proto == OpenPGP || proto == CMS);
 
     std::vector<Key> keys;
     keys.reserve(lines.size());
     std::transform(lines.cbegin(), lines.cend(), std::back_inserter(keys),
                    [proto](const CertificateSelectionLine &l) {
                        return l.key(proto);
                    });
     return keys;
 }
 
 std::vector<Key> SignEncryptEMailConflictDialog::resolvedSigningKeys() const
 {
     return d->sign    ? get_keys(d->ui.signers,    selectedProtocol()) : std::vector<Key>();
 }
 
 std::vector<Key> SignEncryptEMailConflictDialog::resolvedEncryptionKeys() const
 {
     return d->encrypt ? get_keys(d->ui.recipients, selectedProtocol()) : std::vector<Key>();
 }
 
 void SignEncryptEMailConflictDialog::setQuickMode(bool on)
 {
     d->ui.quickModeCB.setChecked(on);
 }
 
 bool SignEncryptEMailConflictDialog::isQuickMode() const
 {
     return d->ui.quickModeCB.isChecked();
 }
 
 void SignEncryptEMailConflictDialog::setConflict(bool conflict)
 {
     d->ui.conflictTopLB.setVisible(conflict);
     d->ui.quickModeTopLB.setVisible(!conflict);
 }
 
 #include "moc_signencryptemailconflictdialog.cpp"
diff --git a/src/crypto/gui/signencryptwidget.cpp b/src/crypto/gui/signencryptwidget.cpp
index 54210bb3d..bd1e59a8f 100644
--- a/src/crypto/gui/signencryptwidget.cpp
+++ b/src/crypto/gui/signencryptwidget.cpp
@@ -1,690 +1,690 @@
 /*  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 "fileoperationspreferences.h"
 #include "kleopatraapplication.h"
 #include "settings.h"
 #include "unknownrecipientwidget.h"
 
 #include "dialogs/certificateselectiondialog.h"
 
 #include <QVBoxLayout>
 #include <QHBoxLayout>
 #include <QGroupBox>
 #include <QCheckBox>
 #include <QScrollArea>
 #include <QScrollBar>
 
 #include <Libkleo/DefaultKeyFilter>
 #include <Libkleo/KeyCache>
 #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)),
       mIsExclusive(sigEncExclusive)
 {
     auto lay = new QVBoxLayout(this);
     lay->setContentsMargins(0, 0, 0, 0);
 
     mModel->useKeyCache(true, KeyList::IncludeGroups);
 
     const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
     const bool havePublicKeys = !KeyCache::instance()->keys().empty();
     const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
 
     /* The signature selection */
     auto sigLay = new QHBoxLayout;
     auto sigGrp = new QGroupBox(i18nc("@title:group", "Prove authenticity (sign)"));
     mSigChk = new QCheckBox(i18n("Sign as:"));
     mSigChk->setEnabled(haveSecretKeys);
     mSigChk->setChecked(haveSecretKeys);
 
     mSigSelect = new KeySelectionCombo();
     mSigSelect->setEnabled(mSigChk->isChecked());
 
     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
     auto encBoxLay = new QVBoxLayout;
     auto encBox = new QGroupBox(i18nc("@title:group", "Encrypt"));
     encBox->setLayout(encBoxLay);
     auto recipientGrid = new QGridLayout;
 
     // Own key
     mEncSelfChk = new QCheckBox(i18n("Encrypt for me:"));
     mEncSelfChk->setEnabled(haveSecretKeys && !symmetricOnly);
     mEncSelfChk->setChecked(haveSecretKeys && !symmetricOnly);
     mSelfSelect = new KeySelectionCombo();
     mSelfSelect->setEnabled(mEncSelfChk->isChecked());
     recipientGrid->addWidget(mEncSelfChk, 0, 0);
     recipientGrid->addWidget(mSelfSelect, 0, 1);
 
     // Checkbox for other keys
     mEncOtherChk = new QCheckBox(i18n("Encrypt for others:"));
     mEncOtherChk->setEnabled(havePublicKeys && !symmetricOnly);
     mEncOtherChk->setChecked(havePublicKeys && !symmetricOnly);
     recipientGrid->addWidget(mEncOtherChk, 1, 0, Qt::AlignTop);
     connect(mEncOtherChk, &QCheckBox::toggled, this,
         [this](bool toggled) {
             for (CertificateLineEdit *edit : std::as_const(mRecpWidgets)) {
                 edit->setEnabled(toggled);
             }
             updateOp();
         });
     mRecpLayout = new QVBoxLayout;
     recipientGrid->addLayout(mRecpLayout, 1, 1);
     recipientGrid->setRowStretch(2, 1);
 
     // Scroll area for other keys
     auto recipientWidget = new QWidget;
     auto recipientScroll = new QScrollArea;
     recipientWidget->setLayout(recipientGrid);
     recipientScroll->setWidget(recipientWidget);
     recipientScroll->setWidgetResizable(true);
     recipientScroll->setSizeAdjustPolicy(QAbstractScrollArea::AdjustToContentsOnFirstShow);
     recipientScroll->setFrameStyle(QFrame::NoFrame);
     recipientScroll->setFocusPolicy(Qt::NoFocus);
     recipientGrid->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);
         });
 
     addRecipientWidget();
 
     // 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 symmetric 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."));
     mSymmetric->setChecked(symmetricOnly || !havePublicKeys);
     encBoxLay->addWidget(mSymmetric);
 
     // Connect it
     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);
 
     connect(KeyCache::instance().get(), &Kleo::KeyCache::keysMayHaveChanged,
             this, &SignEncryptWidget::updateCheckBoxes);
     connect(KleopatraApplication::instance(), &KleopatraApplication::configurationChanged,
             this, &SignEncryptWidget::updateCheckBoxes);
 
     loadKeys();
     onProtocolChanged();
     updateOp();
 }
 
 void SignEncryptWidget::setSignAsText(const QString &text)
 {
     mSigChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptForMeText(const QString &text)
 {
     mEncSelfChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptForOthersText(const QString &text)
 {
     mEncOtherChk->setText(text);
 }
 
 void SignEncryptWidget::setEncryptWithPasswordText(const QString& text)
 {
     mSymmetric->setText(text);
 }
 
 CertificateLineEdit *SignEncryptWidget::addRecipientWidget()
 {
     return insertRecipientWidget(nullptr);
 }
 
 CertificateLineEdit *SignEncryptWidget::insertRecipientWidget(CertificateLineEdit *after)
 {
     Q_ASSERT(!after || mRecpLayout->indexOf(after) != -1);
 
     const auto index = after ? mRecpLayout->indexOf(after) + 1 : mRecpLayout->count();
 
     auto certSel = new CertificateLineEdit(mModel,
                                            new EncryptCertificateFilter(mCurrentProto),
                                            this);
     certSel->setAccessibleNameOfLineEdit(i18nc("text for screen readers", "recipient key"));
     certSel->setEnabled(mEncOtherChk->isChecked());
     mRecpWidgets.insert(index, certSel);
 
     if (mRecpLayout->count() > 0) {
         auto prevWidget = after ? after : mRecpLayout->itemAt(mRecpLayout->count() - 1)->widget();
         setTabOrder(prevWidget, certSel);
     }
     mRecpLayout->insertWidget(index, certSel);
 
     connect(certSel, &CertificateLineEdit::keyChanged,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::editingStarted,
             this, &SignEncryptWidget::recipientsChanged);
     connect(certSel, &CertificateLineEdit::certificateSelectionRequested,
             this, [this, certSel]() { certificateSelectionRequested(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::certificateSelectionRequested(CertificateLineEdit *certificateLineEdit)
 {
     CertificateSelectionDialog dlg{this};
 
     dlg.setOptions(CertificateSelectionDialog::Options(
         CertificateSelectionDialog::MultiSelection |
         CertificateSelectionDialog::EncryptOnly |
         CertificateSelectionDialog::optionsFromProtocol(mCurrentProto) |
         CertificateSelectionDialog::IncludeGroups));
 
     if (!certificateLineEdit->key().isNull()) {
         const auto key = certificateLineEdit->key();
         const auto name = QString::fromUtf8(key.userID(0).name());
         const auto email = QString::fromUtf8(key.userID(0).email());
         dlg.setStringFilter(!name.isEmpty() ? name : email);
     } else if (!certificateLineEdit->group().isNull()) {
         dlg.setStringFilter(certificateLineEdit->group().name());
     } else {
         dlg.setStringFilter(certificateLineEdit->text());
     }
 
     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;
         }
         CertificateLineEdit *certWidget = nullptr;
         for (const Key &key : keys) {
             if (!certWidget) {
                 certWidget = certificateLineEdit;
             } else {
                 certWidget = insertRecipientWidget(certWidget);
             }
             certWidget->setKey(key);
         }
         for (const KeyGroup &group : groups) {
             if (!certWidget) {
                 certWidget = certificateLineEdit;
             } else {
                 certWidget = insertRecipientWidget(certWidget);
             }
             certWidget->setGroup(group);
         }
     }
 
     recipientsChanged();
 }
 
 void SignEncryptWidget::clearAddedRecipients()
 {
     for (auto w: std::as_const(mUnknownWidgets)) {
         mRecpLayout->removeWidget(w);
         delete w;
     }
 
     for (auto &key: std::as_const(mAddedKeys)) {
         removeRecipient(key);
     }
 
     for (auto &group: std::as_const(mAddedGroups)) {
         removeRecipient(group);
     }
 }
 
 void SignEncryptWidget::addUnknownRecipient(const char *keyID)
 {
     auto unknownWidget = new UnknownRecipientWidget(keyID);
     mUnknownWidgets << unknownWidget;
 
     if (mRecpLayout->count() > 0) {
         auto lastWidget = mRecpLayout->itemAt(mRecpLayout->count() - 1)->widget();
         setTabOrder(lastWidget, unknownWidget);
     }
     mRecpLayout->addWidget(unknownWidget);
 
     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()
 {
     const bool hasEmptyRecpWidget =
         std::any_of(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                     [](auto w) { return w->isEmpty(); });
     if (!hasEmptyRecpWidget) {
         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 : std::as_const(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)) {
+        && (!signKey().isDeVs() || keyValidity(signKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     if (!selfKey().isNull()
-        && (!IS_DE_VS(selfKey()) || keyValidity(selfKey()) < GpgME::UserID::Validity::Full)) {
+        && (!selfKey().isDeVs() || keyValidity(selfKey()) < GpgME::UserID::Validity::Full)) {
         return false;
     }
 
     for (const auto &key: recipients()) {
-        if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
+        if (!key.isDeVs() || 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;
 }
 
 namespace
 {
 bool recipientWidgetHasFocus(CertificateLineEdit *w)
 {
     // check if w (or its focus proxy) or a child widget of w has focus
     return w->hasFocus() || w->isAncestorOf(qApp->focusWidget());
 }
 }
 
 void SignEncryptWidget::recpRemovalRequested(CertificateLineEdit *w)
 {
     if (!w) {
         return;
     }
     const int emptyEdits =
         std::count_if(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                       [](auto w) { return w->isEmpty(); });
     if (emptyEdits > 1) {
         if (recipientWidgetHasFocus(w)) {
             const int index = mRecpLayout->indexOf(w);
             const auto focusWidget = (index < mRecpLayout->count() - 1) ?
                 mRecpLayout->itemAt(index + 1)->widget() :
                 mRecpLayout->itemAt(mRecpLayout->count() - 2)->widget();
             focusWidget->setFocus();
         }
         mRecpLayout->removeWidget(w);
         mRecpWidgets.removeAll(w);
         w->deleteLater();
     }
 }
 
 void SignEncryptWidget::removeRecipient(const GpgME::Key &key)
 {
     for (CertificateLineEdit *edit: std::as_const(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: std::as_const(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 && !KeyCache::instance()->secretKeys().empty());
 }
 
 void SignEncryptWidget::setEncryptionChecked(bool checked)
 {
     if (checked) {
         const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
         const bool havePublicKeys = !KeyCache::instance()->keys().empty();
         const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
         mEncSelfChk->setChecked(haveSecretKeys && !symmetricOnly);
         mEncOtherChk->setChecked(havePublicKeys && !symmetricOnly);
         mSymmetric->setChecked(symmetricOnly || !havePublicKeys);
     } else {
         mEncSelfChk->setChecked(false);
         mEncOtherChk->setChecked(false);
         mSymmetric->setChecked(false);
     }
 }
 
 void SignEncryptWidget::setProtocol(GpgME::Protocol proto)
 {
     if (mCurrentProto == proto) {
         return;
     }
     mCurrentProto = proto;
     onProtocolChanged();
 }
 
 void Kleo::SignEncryptWidget::onProtocolChanged()
 {
     mSigSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new SignCertificateFilter(mCurrentProto)));
     mSelfSelect->setKeyFilter(std::shared_ptr<KeyFilter>(new EncryptSelfCertificateFilter(mCurrentProto)));
     const auto encFilter = std::shared_ptr<KeyFilter>(new EncryptCertificateFilter(mCurrentProto));
     for (CertificateLineEdit *edit : std::as_const(mRecpWidgets)) {
         edit->setKeyFilter(encFilter);
     }
 
     if (mIsExclusive) {
         mSymmetric->setDisabled(mCurrentProto == GpgME::CMS);
         if (mSymmetric->isChecked() && mCurrentProto == GpgME::CMS) {
             mSymmetric->setChecked(false);
         }
         if (mSigChk->isChecked() && mCurrentProto == GpgME::CMS &&
                 (mEncSelfChk->isChecked() || mEncOtherChk->isChecked())) {
             mSigChk->setChecked(false);
         }
     }
 }
 
 bool SignEncryptWidget::isComplete() const
 {
     return !currentOp().isEmpty()
         && std::all_of(std::cbegin(mRecpWidgets), std::cend(mRecpWidgets),
                         [](auto w) { return !w->isEnabled() || w->hasAcceptableInput(); });
 }
 
 bool SignEncryptWidget::validate()
 {
     CertificateLineEdit *firstUnresolvedRecipient = nullptr;
     QStringList unresolvedRecipients;
     for (const auto edit: std::as_const(mRecpWidgets)) {
         if (edit->isEnabled() && !edit->hasAcceptableInput()) {
             if (!firstUnresolvedRecipient) {
                 firstUnresolvedRecipient = edit;
             }
             unresolvedRecipients.push_back(edit->text().toHtmlEscaped());
         }
     }
     if (!unresolvedRecipients.isEmpty()) {
         KMessageBox::errorList(this,
                                i18n("Could not find a key for the following recipients:"),
                                unresolvedRecipients,
                                i18n("Failed to find some keys"));
     }
     if (firstUnresolvedRecipient) {
         firstUnresolvedRecipient->setFocus();
     }
     return unresolvedRecipients.isEmpty();
 }
 
 void SignEncryptWidget::updateCheckBoxes()
 {
     const bool haveSecretKeys = !KeyCache::instance()->secretKeys().empty();
     const bool havePublicKeys = !KeyCache::instance()->keys().empty();
     const bool symmetricOnly = FileOperationsPreferences().symmetricEncryptionOnly();
     mSigChk->setEnabled(haveSecretKeys);
     mEncSelfChk->setEnabled(haveSecretKeys && !symmetricOnly);
     mEncOtherChk->setEnabled(havePublicKeys && !symmetricOnly);
     if (symmetricOnly) {
         mEncSelfChk->setChecked(false);
         mEncOtherChk->setChecked(false);
         mSymmetric->setChecked(true);
     }
 }
diff --git a/src/crypto/newsignencryptemailcontroller.cpp b/src/crypto/newsignencryptemailcontroller.cpp
index b978f43f2..712e85f1a 100644
--- a/src/crypto/newsignencryptemailcontroller.cpp
+++ b/src/crypto/newsignencryptemailcontroller.cpp
@@ -1,633 +1,633 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/newsignencryptemailcontroller.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009, 2010 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "newsignencryptemailcontroller.h"
 #include "kleopatra_debug.h"
 #include "encryptemailtask.h"
 #include "signemailtask.h"
 #include "taskcollection.h"
 #include "sender.h"
 #include "recipient.h"
 
 #include "emailoperationspreferences.h"
 
 #include <crypto/gui/signencryptemailconflictdialog.h>
 
 #include "utils/input.h"
 #include "utils/output.h"
 #include <Libkleo/GnuPG>
 #include "utils/kleo_assert.h"
 
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 
 #include <gpgme++/key.h>
 
 #include <KMime/HeaderParsing>
 
 #include <KLocalizedString>
 
 #include <KMessageBox>
 
 #include <QPointer>
 #include <QTimer>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace GpgME;
 using namespace KMime::Types;
 
 //
 // BEGIN Conflict Detection
 //
 
 /*
   This code implements the following conflict detection algorithm:
 
   1. There is no conflict if and only if we have a Perfect Match.
   2. A Perfect Match is defined as:
     a. either a Perfect OpenPGP-Match and not even a Partial S/MIME Match
     b. or a Perfect S/MIME-Match and not even a Partial OpenPGP-Match
     c. or a Perfect OpenPGP-Match and preselected protocol=OpenPGP
     d. or a Perfect S/MIME-Match and preselected protocol=S/MIME
   3. For Protocol \in {OpenPGP,S/MIME}, a Perfect Protocol-Match is defined as:
     a. If signing, \foreach Sender, there is exactly one
          Matching Protocol-Certificate with
      i. can-sign=true
      ii. has-secret=true
     b. and, if encrypting, \foreach Recipient, there is exactly one
          Matching Protocol-Certificate with
      i. can-encrypt=true
      ii. (validity is not considered, cf. msg 24059)
   4. For Protocol \in {OpenPGP,S/MIME}, a Partial Protocol-Match is defined as:
     a. If signing, \foreach Sender, there is at least one
          Matching Protocol-Certificate with
      i. can-sign=true
      ii. has-secret=true
     b. and, if encrypting, \foreach Recipient, there is at least
      one Matching Protocol-Certificate with
      i. can-encrypt=true
      ii. (validity is not considered, cf. msg 24059)
   5. For Protocol \in {OpenPGP,S/MIME}, a Matching Protocol-Certificate is
      defined as matching by email-address. A revoked, disabled, or expired
      certificate is not considered a match.
   6. Sender is defined as those mailboxes that have been set with the SENDER
      command.
   7. Recipient is defined as those mailboxes that have been set with either the
      SENDER or the RECIPIENT commands.
 */
 
 namespace
 {
 
 static size_t count_signing_certificates(Protocol proto, const Sender &sender)
 {
     const size_t result = sender.signingCertificateCandidates(proto).size();
     qDebug("count_signing_certificates( %9s %20s ) == %2lu",
             proto == OpenPGP ? "OpenPGP," : proto == CMS ? "CMS," : "<unknown>,",
             qPrintable(sender.mailbox().prettyAddress()), result);
     return result;
 }
 
 static size_t count_encrypt_certificates(Protocol proto, const Sender &sender)
 {
     const size_t result = sender.encryptToSelfCertificateCandidates(proto).size();
     qDebug("count_encrypt_certificates( %9s %20s ) == %2lu",
             proto == OpenPGP ? "OpenPGP," : proto == CMS ? "CMS," : "<unknown>,",
             qPrintable(sender.mailbox().prettyAddress()), result);
     return result;
 }
 
 static size_t count_encrypt_certificates(Protocol proto, const Recipient &recipient)
 {        const size_t result = recipient.encryptionCertificateCandidates(proto).size();
     qDebug("count_encrypt_certificates( %9s %20s ) == %2lu",
             proto == OpenPGP ? "OpenPGP," : proto == CMS ? "CMS," : "<unknown>,",
             qPrintable(recipient.mailbox().prettyAddress()), result);
     return result;
 }
 
 }
 
 static bool has_perfect_match(bool sign, bool encrypt, Protocol proto, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients)
 {
     if (sign)
         if (!std::all_of(senders.cbegin(), senders.cend(),
                          [proto](const Sender &sender) { return count_signing_certificates(proto, sender) == 1; })) {
             return false;
         }
     if (encrypt)
         if (!std::all_of(senders.cbegin(), senders.cend(),
                          [proto](const Sender &sender) { return count_encrypt_certificates(proto, sender) == 1; })
             || !std::all_of(recipients.cbegin(), recipients.cend(),
                            [proto](const Recipient &rec) { return count_encrypt_certificates(proto, rec) == 1; })) {
             return false;
         }
     return true;
 }
 
 static bool has_partial_match(bool sign, bool encrypt, Protocol proto, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients)
 {
     if (sign)
         if (std::all_of(senders.cbegin(), senders.cend(),
                         [proto](const Sender &sender) { return count_signing_certificates(proto, sender) >= 1; })) {
             return false;
         }
     if (encrypt)
         if (!std::all_of(senders.cbegin(), senders.cend(),
                          [proto](const Sender &sender) { return count_encrypt_certificates(proto, sender) >= 1; })
             || !std::all_of(recipients.cbegin(), recipients.cend(),
                             [proto](const Recipient &rec) { return count_encrypt_certificates(proto, rec) >= 1; })) {
             return false;
         }
     return true;
 }
 
 static bool has_perfect_overall_match(bool sign, bool encrypt, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients, Protocol presetProtocol)
 {
     return (presetProtocol == OpenPGP   &&   has_perfect_match(sign, encrypt, OpenPGP, senders, recipients))
            || (presetProtocol == CMS    &&   has_perfect_match(sign, encrypt, CMS,     senders, recipients))
            || (has_perfect_match(sign, encrypt, OpenPGP, senders, recipients)   &&   !has_partial_match(sign, encrypt, CMS,     senders, recipients))
            || (has_perfect_match(sign, encrypt, CMS,     senders, recipients)   &&   !has_partial_match(sign, encrypt, OpenPGP, senders, recipients));
 }
 
 static bool has_conflict(bool sign, bool encrypt, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients, Protocol presetProtocol)
 {
     return !has_perfect_overall_match(sign, encrypt, senders, recipients, presetProtocol);
 }
 
 static bool is_de_vs_compliant(bool sign, bool encrypt, const std::vector<Sender> &senders, const std::vector<Recipient> &recipients, Protocol presetProtocol)
 {
     if (presetProtocol == Protocol::UnknownProtocol) {
         return false;
     }
     if (sign) {
         for (const auto &sender: senders) {
             const auto &key = sender.resolvedSigningKey(presetProtocol);
-            if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
+            if (!key.isDeVs() || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 return false;
             }
         }
     }
 
     if (encrypt) {
         for (const auto &sender: senders) {
             const auto &key = sender.resolvedSigningKey(presetProtocol);
-            if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
+            if (!key.isDeVs() || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 return false;
             }
         }
 
         for (const auto &recipient: recipients) {
             const auto &key = recipient.resolvedEncryptionKey(presetProtocol);
-            if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
+            if (!key.isDeVs() || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 return false;
             }
         }
     }
 
     return true;
 }
 
 //
 // END Conflict Detection
 //
 
 static std::vector<Sender> mailbox2sender(const std::vector<Mailbox> &mbs)
 {
     std::vector<Sender> senders;
     senders.reserve(mbs.size());
     for (const Mailbox &mb : mbs) {
         senders.push_back(Sender(mb));
     }
     return senders;
 }
 
 static std::vector<Recipient> mailbox2recipient(const std::vector<Mailbox> &mbs)
 {
     std::vector<Recipient> recipients;
     recipients.reserve(mbs.size());
     for (const Mailbox &mb : mbs) {
         recipients.push_back(Recipient(mb));
     }
     return recipients;
 }
 
 class NewSignEncryptEMailController::Private
 {
     friend class ::Kleo::Crypto::NewSignEncryptEMailController;
     NewSignEncryptEMailController *const q;
 public:
     explicit Private(NewSignEncryptEMailController *qq);
     ~Private();
 
 private:
     void slotDialogAccepted();
     void slotDialogRejected();
 
 private:
     void ensureDialogVisible();
     void cancelAllTasks();
 
     void startSigning();
     void startEncryption();
     void schedule();
     std::shared_ptr<Task> takeRunnable(GpgME::Protocol proto);
 
 private:
     bool sign : 1;
     bool encrypt : 1;
     bool resolvingInProgress : 1;
     bool certificatesResolved : 1;
     bool detached : 1;
     Protocol presetProtocol;
     std::vector<Key> signers, recipients;
     std::vector< std::shared_ptr<Task> > runnable, completed;
     std::shared_ptr<Task> cms, openpgp;
     QPointer<SignEncryptEMailConflictDialog> dialog;
 };
 
 NewSignEncryptEMailController::Private::Private(NewSignEncryptEMailController *qq)
     : q(qq),
       sign(false),
       encrypt(false),
       resolvingInProgress(false),
       certificatesResolved(false),
       detached(false),
       presetProtocol(UnknownProtocol),
       signers(),
       recipients(),
       runnable(),
       cms(),
       openpgp(),
       dialog(new SignEncryptEMailConflictDialog)
 {
     connect(dialog, SIGNAL(accepted()), q, SLOT(slotDialogAccepted()));
     connect(dialog, SIGNAL(rejected()), q, SLOT(slotDialogRejected()));
 }
 
 NewSignEncryptEMailController::Private::~Private()
 {
     delete dialog;
 }
 
 NewSignEncryptEMailController::NewSignEncryptEMailController(const std::shared_ptr<ExecutionContext> &xc, QObject *p)
     : Controller(xc, p), d(new Private(this))
 {
 
 }
 
 NewSignEncryptEMailController::NewSignEncryptEMailController(QObject *p)
     : Controller(p), d(new Private(this))
 {
 
 }
 
 NewSignEncryptEMailController::~NewSignEncryptEMailController()
 {
     qCDebug(KLEOPATRA_LOG);
 }
 
 void NewSignEncryptEMailController::setSubject(const QString &subject)
 {
     d->dialog->setSubject(subject);
 }
 
 void NewSignEncryptEMailController::setProtocol(Protocol proto)
 {
     d->presetProtocol = proto;
     d->dialog->setPresetProtocol(proto);
 }
 
 Protocol NewSignEncryptEMailController::protocol() const
 {
     return d->dialog->selectedProtocol();
 }
 
 const char *NewSignEncryptEMailController::protocolAsString() const
 {
     switch (protocol()) {
     case OpenPGP: return "OpenPGP";
     case CMS:     return "CMS";
     default:
         throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                               i18n("Call to NewSignEncryptEMailController::protocolAsString() is ambiguous."));
     }
 }
 
 void NewSignEncryptEMailController::setSigning(bool sign)
 {
     d->sign = sign;
     d->dialog->setSign(sign);
 }
 
 bool NewSignEncryptEMailController::isSigning() const
 {
     return d->sign;
 }
 
 void NewSignEncryptEMailController::setEncrypting(bool encrypt)
 {
     d->encrypt = encrypt;
     d->dialog->setEncrypt(encrypt);
 }
 
 bool NewSignEncryptEMailController::isEncrypting() const
 {
     return d->encrypt;
 }
 
 void NewSignEncryptEMailController::setDetachedSignature(bool detached)
 {
     d->detached = detached;
 }
 
 bool NewSignEncryptEMailController::isResolvingInProgress() const
 {
     return d->resolvingInProgress;
 }
 
 bool NewSignEncryptEMailController::areCertificatesResolved() const
 {
     return d->certificatesResolved;
 }
 
 static bool is_dialog_quick_mode(bool sign, bool encrypt)
 {
     const EMailOperationsPreferences prefs;
     return (!sign    || prefs.quickSignEMail())
            && (!encrypt || prefs.quickEncryptEMail())
            ;
 }
 
 static void save_dialog_quick_mode(bool on)
 {
     EMailOperationsPreferences prefs;
     prefs.setQuickSignEMail(on);
     prefs.setQuickEncryptEMail(on);
     prefs.save();
 }
 
 void NewSignEncryptEMailController::startResolveCertificates(const std::vector<Mailbox> &r, const std::vector<Mailbox> &s)
 {
     d->certificatesResolved = false;
     d->resolvingInProgress = true;
 
     const std::vector<Sender> senders = mailbox2sender(s);
     const std::vector<Recipient> recipients = mailbox2recipient(r);
     const bool quickMode = is_dialog_quick_mode(d->sign, d->encrypt);
 
     const bool conflict = quickMode && has_conflict(d->sign, d->encrypt, senders, recipients, d->presetProtocol);
 
     d->dialog->setQuickMode(quickMode);
     d->dialog->setSenders(senders);
     d->dialog->setRecipients(recipients);
     d->dialog->pickProtocol();
     d->dialog->setConflict(conflict);
 
     const bool compliant = !Kleo::gnupgUsesDeVsCompliance() ||
                            (Kleo::gnupgIsDeVsCompliant() && is_de_vs_compliant(d->sign,
                                                                                d->encrypt,
                                                                                senders,
                                                                                recipients,
                                                                                d->presetProtocol));
 
     if (quickMode && !conflict && compliant) {
         QMetaObject::invokeMethod(this, "slotDialogAccepted", Qt::QueuedConnection);
     } else {
         d->ensureDialogVisible();
     }
 }
 
 void NewSignEncryptEMailController::Private::slotDialogAccepted()
 {
     if (dialog->isQuickMode() != is_dialog_quick_mode(sign, encrypt)) {
         save_dialog_quick_mode(dialog->isQuickMode());
     }
     resolvingInProgress = false;
     certificatesResolved = true;
     signers = dialog->resolvedSigningKeys();
     recipients = dialog->resolvedEncryptionKeys();
     QMetaObject::invokeMethod(q, "certificatesResolved", Qt::QueuedConnection);
 }
 
 void NewSignEncryptEMailController::Private::slotDialogRejected()
 {
     resolvingInProgress = false;
     certificatesResolved = false;
     QMetaObject::invokeMethod(q, "error", Qt::QueuedConnection,
                               Q_ARG(int, gpg_error(GPG_ERR_CANCELED)),
                               Q_ARG(QString, i18n("User cancel")));
 }
 
 void NewSignEncryptEMailController::startEncryption(const std::vector< std::shared_ptr<Input> > &inputs, const std::vector< std::shared_ptr<Output> > &outputs)
 {
 
     kleo_assert(d->encrypt);
     kleo_assert(!d->resolvingInProgress);
 
     kleo_assert(!inputs.empty());
     kleo_assert(outputs.size() == inputs.size());
 
     std::vector< std::shared_ptr<Task> > tasks;
     tasks.reserve(inputs.size());
 
     kleo_assert(!d->recipients.empty());
 
     for (unsigned int i = 0, end = inputs.size(); i < end; ++i) {
 
         const std::shared_ptr<EncryptEMailTask> task(new EncryptEMailTask);
 
         task->setInput(inputs[i]);
         task->setOutput(outputs[i]);
         task->setRecipients(d->recipients);
 
         tasks.push_back(task);
     }
 
     // append to runnable stack
     d->runnable.insert(d->runnable.end(), tasks.begin(), tasks.end());
 
     d->startEncryption();
 }
 
 void NewSignEncryptEMailController::Private::startEncryption()
 {
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task> > tmp;
     tmp.reserve(runnable.size());
     std::copy(runnable.cbegin(), runnable.cend(), std::back_inserter(tmp));
     coll->setTasks(tmp);
 #if 0
 #warning use a new result dialog
     // ### use a new result dialog
     dialog->setTaskCollection(coll);
 #endif
     for (const std::shared_ptr<Task> &t : std::as_const(tmp)) {
         q->connectTask(t);
     }
     schedule();
 }
 
 void NewSignEncryptEMailController::startSigning(const std::vector< std::shared_ptr<Input> > &inputs, const std::vector< std::shared_ptr<Output> > &outputs)
 {
 
     kleo_assert(d->sign);
     kleo_assert(!d->resolvingInProgress);
 
     kleo_assert(!inputs.empty());
     kleo_assert(!outputs.empty());
 
     std::vector< std::shared_ptr<Task> > tasks;
     tasks.reserve(inputs.size());
 
     kleo_assert(!d->signers.empty());
     kleo_assert(std::none_of(d->signers.cbegin(), d->signers.cend(), std::mem_fn(&Key::isNull)));
 
     for (unsigned int i = 0, end = inputs.size(); i < end; ++i) {
 
         const std::shared_ptr<SignEMailTask> task(new SignEMailTask);
 
         task->setInput(inputs[i]);
         task->setOutput(outputs[i]);
         task->setSigners(d->signers);
         task->setDetachedSignature(d->detached);
 
         tasks.push_back(task);
     }
 
     // append to runnable stack
     d->runnable.insert(d->runnable.end(), tasks.begin(), tasks.end());
 
     d->startSigning();
 }
 
 void NewSignEncryptEMailController::Private::startSigning()
 {
     std::shared_ptr<TaskCollection> coll(new TaskCollection);
     std::vector<std::shared_ptr<Task> > tmp;
     tmp.reserve(runnable.size());
     std::copy(runnable.cbegin(), runnable.cend(), std::back_inserter(tmp));
     coll->setTasks(tmp);
 #if 0
 #warning use a new result dialog
     // ### use a new result dialog
     dialog->setTaskCollection(coll);
 #endif
     for (const std::shared_ptr<Task> &t : std::as_const(tmp)) {
         q->connectTask(t);
     }
     schedule();
 }
 
 void NewSignEncryptEMailController::Private::schedule()
 {
 
     if (!cms)
         if (const std::shared_ptr<Task> t = takeRunnable(CMS)) {
             t->start();
             cms = t;
         }
 
     if (!openpgp)
         if (const std::shared_ptr<Task> t = takeRunnable(OpenPGP)) {
             t->start();
             openpgp = t;
         }
 
     if (cms || openpgp) {
         return;
     }
     kleo_assert(runnable.empty());
     q->emitDoneOrError();
 }
 
 std::shared_ptr<Task> NewSignEncryptEMailController::Private::takeRunnable(GpgME::Protocol proto)
 {
     const auto it = std::find_if(runnable.begin(), runnable.end(),
                                  [proto](const std::shared_ptr<Task> &task) { return task->protocol() == proto; });
     if (it == runnable.end()) {
         return std::shared_ptr<Task>();
     }
 
     const std::shared_ptr<Task> result = *it;
     runnable.erase(it);
     return result;
 }
 
 void NewSignEncryptEMailController::doTaskDone(const Task *task, const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(task);
 
     if (result && result->hasError()) {
         QPointer<QObject> that = this;
         if (result->details().isEmpty())
             KMessageBox::        sorry(nullptr,
                                        result->overview(),
                                        i18nc("@title:window", "Error"));
         else
             KMessageBox::detailedSorry(nullptr,
                                        result->overview(),
                                        result->details(),
                                        i18nc("@title:window", "Error"));
         if (!that) {
             return;
         }
     }
 
     // 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->cms.get()) {
         d->completed.push_back(d->cms);
         d->cms.reset();
     } else if (task == d->openpgp.get()) {
         d->completed.push_back(d->openpgp);
         d->openpgp.reset();
     }
 
     QTimer::singleShot(0, this, SLOT(schedule()));
 }
 
 void NewSignEncryptEMailController::cancel()
 {
     try {
         d->dialog->close();
         d->cancelAllTasks();
     } catch (const std::exception &e) {
         qCDebug(KLEOPATRA_LOG) << "Caught exception: " << e.what();
     }
 }
 
 void NewSignEncryptEMailController::Private::cancelAllTasks()
 {
 
     // we just kill all runnable tasks - this will not result in
     // signal emissions.
     runnable.clear();
 
     // a cancel() will result in a call to
     if (cms) {
         cms->cancel();
     }
     if (openpgp) {
         openpgp->cancel();
     }
 }
 
 void NewSignEncryptEMailController::Private::ensureDialogVisible()
 {
     q->bringToForeground(dialog, true);
 }
 
 #include "moc_newsignencryptemailcontroller.cpp"