diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
index 2dafad135..212956f0e 100644
--- a/src/crypto/decryptverifytask.cpp
+++ b/src/crypto/decryptverifytask.cpp
@@ -1,1698 +1,1708 @@
 /* -*- 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>
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 #include <QGpgME/DecryptVerifyArchiveJob>
 #endif
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Compliance>
 #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 <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 AuditLogEntry auditLogFromSender(QObject *sender)
 {
     return AuditLogEntry::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(quint32(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 (DeVSCompliance::isCompliant()) {
         text +=
             (QStringLiteral("<br/>")
              + (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", DeVSCompliance::name(true))
                 : 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.", DeVSCompliance::name(true))));
     }
 
     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 (DeVSCompliance::isCompliant()) {
         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.", DeVSCompliance::name(true))
                      : 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.", DeVSCompliance::name(true)))
                     + 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,
             const QString &fileName,
             const GpgME::Error &error,
             const QString &errString,
             const QString &input,
             const QString &output,
             const AuditLogEntry &auditLog,
             Task *parentTask,
             const Mailbox &informativeSender,
             DecryptVerifyResult *qq) :
         q(qq),
         m_type(type),
         m_verificationResult(vr),
         m_decryptionResult(dr),
         m_stuff(stuff),
         m_fileName(fileName),
         m_error(error),
         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;
     QString m_fileName;
     GpgME::Error m_error;
     QString m_errorString;
     QString m_inputLabel;
     QString m_outputLabel;
     const AuditLogEntry 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 AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             dr,
             plaintext,
             {},
             {},
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const GpgME::Error &err, const QString &what, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             {},
             err,
             what,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plaintext, const QString &fileName, const AuditLogEntry &auditLog)
 {
     const auto err = dr.error().code() ? dr.error() : vr.error();
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             vr,
             dr,
             plaintext,
             fileName,
             err,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const GpgME::Error &err, const QString &details, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             {},
             err,
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const VerificationResult &vr, const QByteArray &plaintext, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             plaintext,
             {},
             {},
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const GpgME::Error &err, const QString &details, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             {},
             err,
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const VerificationResult &vr, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             QByteArray(),
             {},
             {},
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const GpgME::Error &err, const QString &details, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             {},
             err,
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 DecryptVerifyResult::DecryptVerifyResult(DecryptVerifyOperation type,
         const VerificationResult &vr,
         const DecryptionResult &dr,
         const QByteArray &stuff,
         const QString &fileName,
         const GpgME::Error &error,
         const QString &errString,
         const QString &inputLabel,
         const QString &outputLabel,
         const AuditLogEntry &auditLog,
         Task *parentTask,
         const Mailbox &informativeSender)
     : Task::Result(), d(new Private(type, vr, dr, stuff, fileName, error, 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);
 }
 
 GpgME::Error DecryptVerifyResult::error() const
 {
     return d->m_error;
 }
 
 QString DecryptVerifyResult::errorString() const
 {
     return d->m_errorString;
 }
 
 AuditLogEntry 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;
 }
 
 QString DecryptVerifyResult::fileName() const
 {
     return d->m_fileName;
 }
 
 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}
     {
     }
 
     void startDecryptVerifyJob();
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     void startDecryptVerifyArchiveJob();
 #endif
 
     void slotResult(const DecryptionResult &, const VerificationResult &, const QByteArray & = {});
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
     bool m_ignoreMDCError = false;
     bool m_extractArchive = false;
     QString m_outputDirectory;
 };
 
 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 AuditLogEntry auditLog = auditLogFromSender(q->sender());
     if (m_output) {
         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) {
                 q->emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
                 return;
             } catch (const std::exception &e) {
                 q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
                 return;
             } catch (...) {
                 q->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 ? m_output->errorString() : QString{};
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           (m_output && m_output->failed())) {
         q->emitResult(q->fromDecryptResult(drErr ? dr.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     q->emitResult(q->fromDecryptVerifyResult(dr, vr, plainText, m_output ? m_output->fileName() : QString{}, 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() : d->m_outputDirectory;
 }
 
 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::setExtractArchive(bool extract)
 {
     d->m_extractArchive = extract;
 }
 
 void DecryptVerifyTask::setOutputDirectory(const QString &directory)
 {
     d->m_outputDirectory = directory;
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 static bool archiveJobsCanBeUsed(GpgME::Protocol protocol)
 {
     return (protocol == GpgME::OpenPGP) && QGpgME::DecryptVerifyArchiveJob::isSupported();
 }
 #endif
 
 void DecryptVerifyTask::doStart()
 {
     kleo_assert(d->m_backend);
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     if (d->m_extractArchive && archiveJobsCanBeUsed(d->m_protocol)) {
         d->startDecryptVerifyArchiveJob();
     } else
 #endif
     {
         d->startDecryptVerifyJob();
     }
 }
 
 static void setIgnoreMDCErrorFlag(QGpgME::Job *job, bool ignoreMDCError)
 {
     if (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();
             }
         }
     }
 }
 
 void DecryptVerifyTask::Private::startDecryptVerifyJob()
 {
     try {
         QGpgME::DecryptVerifyJob *const job = m_backend->decryptVerifyJob();
         kleo_assert(job);
         setIgnoreMDCErrorFlag(job, m_ignoreMDCError);
         QObject::connect(job, &QGpgME::DecryptVerifyJob::result, q, [this](const GpgME::DecryptionResult &decryptResult, const GpgME::VerificationResult &verifyResult, const QByteArray &plainText) {
             slotResult(decryptResult, verifyResult, plainText);
         });
-        QObject::connect(job, &QGpgME::DecryptVerifyJob::progress, q, &DecryptVerifyTask::setProgress);
+        QObject::connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+            q->setProgress(processed, total);
+        });
         ensureIOOpen(m_input->ioDevice().get(), m_output->ioDevice().get());
         job->start(m_input->ioDevice(), m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         q->emitResult(q->fromDecryptVerifyResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         q->emitResult(q->fromDecryptVerifyResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 void DecryptVerifyTask::Private::startDecryptVerifyArchiveJob()
 {
     auto *const job = m_backend->decryptVerifyArchiveJob();
     kleo_assert(job);
     setIgnoreMDCErrorFlag(job, m_ignoreMDCError);
     job->setOutputDirectory(m_outputDirectory);
     connect(job, &QGpgME::DecryptVerifyArchiveJob::result, q, [this](const GpgME::DecryptionResult &decryptResult, const GpgME::VerificationResult &verifyResult) {
         slotResult(decryptResult, verifyResult);
     });
-    connect(job, &QGpgME::DecryptVerifyJob::progress, q, &DecryptVerifyTask::setProgress);
+    connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     ensureIOOpen(m_input->ioDevice().get(), nullptr);
     const auto err = job->start(m_input->ioDevice());
     if (err) {
         q->emitResult(q->fromDecryptVerifyResult(err, {}, {}));
     }
 }
 #endif
 
 class DecryptTask::Private
 {
     DecryptTask *const q;
 public:
     explicit Private(DecryptTask *qq)
         : q{qq}
     {
     }
 
     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)));
+        q->connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+            q->setProgress(processed, total);
+        });
     }
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
 };
 
 void DecryptTask::Private::slotResult(const DecryptionResult &result, const QByteArray &plainText)
 {
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLogEntry 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) {
             q->emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             q->emitResult(q->fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             q->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()) {
         q->emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     q->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) {
         emitResult(fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         emitResult(fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         emitResult(fromDecryptResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 class VerifyOpaqueTask::Private
 {
     VerifyOpaqueTask *const q;
 public:
     explicit Private(VerifyOpaqueTask *qq)
         : q{qq}
     {
     }
 
     void startVerifyOpaqueJob();
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     void startDecryptVerifyArchiveJob();
 #endif
 
     void slotResult(const VerificationResult &, const QByteArray & = {});
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
     bool m_extractArchive = false;
     QString m_outputDirectory;
 };
 
 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 AuditLogEntry auditLog = auditLogFromSender(q->sender());
     if (m_output) {
         if (result.error().code()) {
             m_output->cancel();
         } else {
             try {
                 kleo_assert(!result.isNull());
                 m_output->finalize();
             } catch (const GpgME::Exception &e) {
                 q->emitResult(q->fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
                 return;
             } catch (const std::exception &e) {
                 q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
                 return;
             } catch (...) {
                 q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
                 return;
             }
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output ? m_output->errorString() : QString{};
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           (m_output && m_output->failed())) {
         q->emitResult(q->fromVerifyOpaqueResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     q->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() : d->m_outputDirectory;
 }
 
 Protocol VerifyOpaqueTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyOpaqueTask::setExtractArchive(bool extract)
 {
     d->m_extractArchive = extract;
 }
 
 void VerifyOpaqueTask::setOutputDirectory(const QString &directory)
 {
     d->m_outputDirectory = directory;
 }
 
 void VerifyOpaqueTask::cancel()
 {
 
 }
 
 void VerifyOpaqueTask::doStart()
 {
     kleo_assert(d->m_backend);
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     if (d->m_extractArchive && archiveJobsCanBeUsed(d->m_protocol)) {
         d->startDecryptVerifyArchiveJob();
     } else
 #endif
     {
         d->startVerifyOpaqueJob();
     }
 }
 
 void VerifyOpaqueTask::Private::startVerifyOpaqueJob()
 {
     try {
         QGpgME::VerifyOpaqueJob *const job = m_backend->verifyOpaqueJob();
         kleo_assert(job);
         connect(job, &QGpgME::VerifyOpaqueJob::result, q, [this](const GpgME::VerificationResult &result, const QByteArray &plainText) {
             slotResult(result, plainText);
         });
-        connect(job, &QGpgME::VerifyOpaqueJob::progress, q, &VerifyOpaqueTask::setProgress);
+        connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+            q->setProgress(processed, total);
+        });
         ensureIOOpen(m_input->ioDevice().get(), m_output ? m_output->ioDevice().get() : nullptr);
         job->start(m_input->ioDevice(), m_output ? m_output->ioDevice() : std::shared_ptr<QIODevice>());
     } catch (const GpgME::Exception &e) {
         q->emitResult(q->fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         q->emitResult(q->fromVerifyOpaqueResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 void VerifyOpaqueTask::Private::startDecryptVerifyArchiveJob()
 {
     auto *const job = m_backend->decryptVerifyArchiveJob();
     kleo_assert(job);
     job->setOutputDirectory(m_outputDirectory);
     connect(job, &QGpgME::DecryptVerifyArchiveJob::result, q, [this](const DecryptionResult &, const VerificationResult &verifyResult) {
         slotResult(verifyResult);
     });
-    connect(job, &QGpgME::DecryptVerifyJob::progress, q, &VerifyOpaqueTask::setProgress);
+    connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     ensureIOOpen(m_input->ioDevice().get(), nullptr);
     const auto err = job->start(m_input->ioDevice());
     if (err) {
         q->emitResult(q->fromVerifyOpaqueResult(err, {}, {}));
     }
 }
 #endif
 
 class VerifyDetachedTask::Private
 {
     VerifyDetachedTask *const q;
 public:
     explicit Private(VerifyDetachedTask *qq)
         : q{qq}
     {
     }
 
     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)));
+        q->connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+            q->setProgress(processed, total);
+        });
     }
 
     std::shared_ptr<Input> m_input, m_signedData;
     const QGpgME::Protocol *m_backend = nullptr;
     Protocol m_protocol = UnknownProtocol;
 };
 
 void VerifyDetachedTask::Private::slotResult(const VerificationResult &result)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLogEntry auditLog = auditLogFromSender(q->sender());
     try {
         kleo_assert(!result.isNull());
         q->emitResult(q->fromVerifyDetachedResult(result, auditLog));
     } catch (const GpgME::Exception &e) {
         q->emitResult(q->fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
     } catch (const std::exception &e) {
         q->emitResult(q->fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
     } catch (...) {
         q->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) {
         emitResult(fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLogEntry()));
     } catch (const std::exception &e) {
         emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLogEntry()));
     } catch (...) {
         emitResult(fromVerifyDetachedResult(Error::fromCode(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLogEntry()));
     }
 }
 
 #include "moc_decryptverifytask.cpp"
diff --git a/src/crypto/encryptemailtask.cpp b/src/crypto/encryptemailtask.cpp
index 28e6f7870..a014c915f 100644
--- a/src/crypto/encryptemailtask.cpp
+++ b/src/crypto/encryptemailtask.cpp
@@ -1,232 +1,233 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/encryptemailtask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "encryptemailtask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Stl_Util>
 #include <QGpgME/Protocol>
 #include <QGpgME/EncryptJob>
 
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class EncryptEMailResult : public Task::Result
 {
     const EncryptionResult m_result;
     const AuditLogEntry m_auditLog;
 public:
     EncryptEMailResult(const EncryptionResult &r, const AuditLogEntry &auditLog)
         : Task::Result(), m_result(r), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLogEntry auditLog() const override;
 };
 
 QString makeResultString(const EncryptionResult &res)
 {
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed: %1", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     return i18n("Encryption succeeded.");
 }
 
 }
 
 class EncryptEMailTask::Private
 {
     friend class ::Kleo::Crypto::EncryptEMailTask;
     EncryptEMailTask *const q;
 public:
     explicit Private(EncryptEMailTask *qq);
 
 private:
     std::unique_ptr<QGpgME::EncryptJob> createJob(GpgME::Protocol proto);
 
 private:
     void slotResult(const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     std::vector<Key> recipients;
 
     QPointer<QGpgME::EncryptJob> job;
 };
 
 EncryptEMailTask::Private::Private(EncryptEMailTask *qq)
     : q(qq),
       input(),
       output(),
       job(nullptr)
 {
 
 }
 
 EncryptEMailTask::EncryptEMailTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 EncryptEMailTask::~EncryptEMailTask() {}
 
 void EncryptEMailTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void EncryptEMailTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void EncryptEMailTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     kleo_assert(!recipients.empty());
     d->recipients = recipients;
 }
 
 Protocol EncryptEMailTask::protocol() const
 {
     kleo_assert(!d->recipients.empty());
     return d->recipients.front().protocol();
 }
 
 QString EncryptEMailTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 unsigned long long EncryptEMailTask::inputSize() const
 {
     return d->input ? d->input->size() : 0;
 }
 
 void EncryptEMailTask::doStart()
 {
     kleo_assert(!d->job);
     kleo_assert(d->input);
     kleo_assert(d->output);
     kleo_assert(!d->recipients.empty());
 
     std::unique_ptr<QGpgME::EncryptJob> job = d->createJob(protocol());
     kleo_assert(job.get());
 
     job->start(d->recipients,
                d->input->ioDevice(), d->output->ioDevice(),
                /*alwaysTrust=*/true);
 
     d->job = job.release();
 }
 
 void EncryptEMailTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::EncryptJob> EncryptEMailTask::Private::createJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     bool shouldArmor = (proto == OpenPGP || q->asciiArmor()) && !output->binaryOpt();
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(shouldArmor, /*textmode=*/false));
     kleo_assert(encryptJob.get());
     if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
         encryptJob->setOutputIsBase64Encoded(true);
     }
-    connect(encryptJob.get(), SIGNAL(progress(QString,int,int)),
-            q, SLOT(setProgress(QString,int,int)));
+    connect(encryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 void EncryptEMailTask::Private::slotResult(const EncryptionResult &result)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     if (result.error().code()) {
         output->cancel();
     } else {
         output->finalize();
     }
     q->emitResult(std::shared_ptr<Result>(new EncryptEMailResult(result, AuditLogEntry::fromJob(job))));
 }
 
 QString EncryptEMailResult::overview() const
 {
     return makeOverview(makeResultString(m_result));
 }
 
 QString EncryptEMailResult::details() const
 {
     return QString();
 }
 
 GpgME::Error EncryptEMailResult::error() const
 {
     return m_result.error();
 }
 
 QString EncryptEMailResult::errorString() const
 {
     return hasError() ? makeResultString(m_result) : QString();
 }
 
 AuditLogEntry EncryptEMailResult::auditLog() const
 {
     return m_auditLog;
 }
 
 Task::Result::VisualCode EncryptEMailResult::code() const
 {
     if (m_result.error().isCanceled()) {
         return Warning;
     }
     return m_result.error().code() ? NeutralError : NeutralSuccess;
 }
 
 #include "moc_encryptemailtask.cpp"
 
diff --git a/src/crypto/gui/decryptverifyfilesdialog.cpp b/src/crypto/gui/decryptverifyfilesdialog.cpp
index 7df1a1fee..544f9d6d7 100644
--- a/src/crypto/gui/decryptverifyfilesdialog.cpp
+++ b/src/crypto/gui/decryptverifyfilesdialog.cpp
@@ -1,243 +1,242 @@
 /* crypto/gui/decryptverifyfilesdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include "decryptverifyfilesdialog.h"
 
 #include "kleopatra_debug.h"
 
 #include "crypto/taskcollection.h"
 #include "crypto/decryptverifytask.h"
 #include "crypto/gui/resultpage.h"
 #include "crypto/gui/resultlistwidget.h"
 
 #include <Libkleo/FileNameRequester>
 
 #include <QWindow>
 #include <QVBoxLayout>
 #include <QProgressBar>
 #include <QLabel>
 #include <QPushButton>
 
 #include <vector>
 
 #include <KLocalizedString>
 #include <KMessageBox>
 #include <KConfigGroup>
 #include <KSharedConfig>
 #include <KWindowConfig>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 DecryptVerifyFilesDialog::DecryptVerifyFilesDialog(const std::shared_ptr<TaskCollection> &coll, QWidget *parent)
     : QDialog(parent), m_tasks(coll), m_buttonBox(new QDialogButtonBox)
 {
     readConfig();
     auto vLay = new QVBoxLayout(this);
     auto labels = new QWidget;
     auto outputLayout = new QHBoxLayout;
 
     m_outputLocationFNR = new FileNameRequester;
     auto outLabel = new QLabel(i18n("&Output folder:"));
     outLabel->setBuddy(m_outputLocationFNR);
     outputLayout->addWidget(outLabel);
     outputLayout->addWidget(m_outputLocationFNR);
     m_outputLocationFNR->setFilter(QDir::Dirs);
 
     vLay->addLayout(outputLayout);
 
     m_progressLabelLayout = new QVBoxLayout(labels);
     vLay->addWidget(labels);
     m_progressBar = new QProgressBar;
     vLay->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     vLay->addWidget(m_resultList);
 
     m_tasks = coll;
     Q_ASSERT(m_tasks);
     m_resultList->setTaskCollection(coll);
     connect(m_tasks.get(), &TaskCollection::progress, this, &DecryptVerifyFilesDialog::progress);
     connect(m_tasks.get(), &TaskCollection::done, this, &DecryptVerifyFilesDialog::allDone);
     connect(m_tasks.get(), &TaskCollection::started, this, &DecryptVerifyFilesDialog::started);
 
     connect(m_buttonBox, &QDialogButtonBox::rejected, this, &QDialog::reject);
     connect(m_buttonBox, &QDialogButtonBox::clicked, this, &DecryptVerifyFilesDialog::btnClicked);
 
     layout()->addWidget(m_buttonBox);
 
     bool hasOutputs = false;
     for (const auto &t: coll->tasks()) {
         if (!qobject_cast<VerifyDetachedTask *>(t.get())) {
             hasOutputs = true;
             break;
         }
     }
     if (hasOutputs) {
         setWindowTitle(i18nc("@title:window", "Decrypt/Verify Files"));
         m_saveButton = QDialogButtonBox::SaveAll;
         m_buttonBox->addButton(QDialogButtonBox::Discard);
         connect(m_buttonBox, &QDialogButtonBox::accepted, this, &DecryptVerifyFilesDialog::checkAccept);
     } else {
         outLabel->setVisible(false);
         m_outputLocationFNR->setVisible(false);
         setWindowTitle(i18nc("@title:window", "Verify Files"));
         m_buttonBox->addButton(QDialogButtonBox::Close);
         connect(m_buttonBox, &QDialogButtonBox::accepted, this, &QDialog::accept);
     }
     if (m_saveButton) {
         m_buttonBox->addButton(m_saveButton);
         m_buttonBox->button(m_saveButton)->setEnabled(false);
     }
 }
 
 DecryptVerifyFilesDialog::~DecryptVerifyFilesDialog()
 {
     qCDebug(KLEOPATRA_LOG);
     writeConfig();
 }
 
 void DecryptVerifyFilesDialog::allDone()
 {
     qCDebug(KLEOPATRA_LOG) << "All done";
     Q_ASSERT(m_tasks);
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     for (const auto &i: m_progressLabelByTag.keys()) {
         if (!i.isEmpty()) {
             m_progressLabelByTag.value(i)->setText(i18n("%1: All operations completed.", i));
         } else {
             m_progressLabelByTag.value(i)->setText(i18n("All operations completed."));
         }
     }
 
     if (m_tasks->allTasksHaveErrors()) {
         return;
     }
     if (m_saveButton != QDialogButtonBox::NoButton) {
         m_buttonBox->button(m_saveButton)->setEnabled(true);
     } else {
         m_buttonBox->removeButton(m_buttonBox->button(QDialogButtonBox::Close));
         m_buttonBox->addButton(QDialogButtonBox::Ok);
     }
 }
 
 void DecryptVerifyFilesDialog::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const auto tag = task->tag();
     auto label = labelForTag(tag);
     Q_ASSERT(label);
     if (tag.isEmpty()) {
         label->setText(i18nc("number, operation description", "Operation %1: %2", m_tasks->numberOfCompletedTasks() + 1, task->label()));
     } else {
         label->setText(i18nc(R"(tag( "OpenPGP" or "CMS"),  operation description)", "%1: %2", tag, task->label()));
     }
     if (m_saveButton != QDialogButtonBox::NoButton) {
         m_buttonBox->button(m_saveButton)->setEnabled(false);
     } else if (m_buttonBox->button(QDialogButtonBox::Ok)) {
         m_buttonBox->removeButton(m_buttonBox->button(QDialogButtonBox::Ok));
         m_buttonBox->addButton(QDialogButtonBox::Close);
     }
 }
 
 QLabel *DecryptVerifyFilesDialog::labelForTag(const QString &tag)
 {
     if (QLabel *const label = m_progressLabelByTag.value(tag)) {
         return label;
     }
     auto label = new QLabel;
     label->setTextFormat(Qt::RichText);
     label->setWordWrap(true);
     m_progressLabelLayout->addWidget(label);
     m_progressLabelByTag.insert(tag, label);
     return label;
 }
 
-void DecryptVerifyFilesDialog::progress(const QString &msg, int progress, int total)
+void DecryptVerifyFilesDialog::progress(int progress, int total)
 {
-    Q_UNUSED(msg)
     Q_ASSERT(progress >= 0);
     Q_ASSERT(total >= 0);
     m_progressBar->setRange(0, total);
     m_progressBar->setValue(progress);
 }
 
 void DecryptVerifyFilesDialog::setOutputLocation(const QString &dir)
 {
     m_outputLocationFNR->setFileName(dir);
 }
 
 QString DecryptVerifyFilesDialog::outputLocation() const
 {
     return m_outputLocationFNR->fileName();
 }
 
 void DecryptVerifyFilesDialog::btnClicked(QAbstractButton *btn)
 {
     if (m_buttonBox->buttonRole(btn) == QDialogButtonBox::DestructiveRole) {
         close();
     }
 }
 
 void DecryptVerifyFilesDialog::checkAccept() {
     const auto outLoc = outputLocation();
     if (outLoc.isEmpty()) {
         KMessageBox::information(this, i18n("Please select an output folder."),
                                  i18n("No output folder."));
         return;
     }
     const QFileInfo fi(outLoc);
 
     if (fi.exists() && fi.isDir() && fi.isWritable()) {
         accept();
         return;
     }
 
     if (!fi.exists()) {
         qCDebug(KLEOPATRA_LOG) << "Output dir does not exist. Trying to create.";
         const QDir dir(outLoc);
         if (!dir.mkdir(outLoc)) {
             KMessageBox::information(this, i18n("Please select a different output folder."),
                                      i18n("Failed to create output folder."));
             return;
         } else {
             accept();
             return;
         }
     }
 
     KMessageBox::information(this, i18n("Please select a different output folder."),
                              i18n("Invalid output folder."));
 }
 
 void DecryptVerifyFilesDialog::readConfig()
 {
     winId(); // ensure there's a window created
 
     // set default window size
     windowHandle()->resize(640, 480);
 
     // restore size from config file
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "DecryptVerifyFilesDialog");
     KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
 
     // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
     // window was created -> QTBUG-40584. We therefore copy the size here.
     // TODO: remove once this was resolved in QWidget QPA
     resize(windowHandle()->size());
 }
 
 void DecryptVerifyFilesDialog::writeConfig()
 {
     KConfigGroup cfgGroup(KSharedConfig::openStateConfig(), "DecryptVerifyFilesDialog");
     KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
     cfgGroup.sync();
 }
diff --git a/src/crypto/gui/decryptverifyfilesdialog.h b/src/crypto/gui/decryptverifyfilesdialog.h
index 457d0fc0b..c752e3164 100644
--- a/src/crypto/gui/decryptverifyfilesdialog.h
+++ b/src/crypto/gui/decryptverifyfilesdialog.h
@@ -1,76 +1,76 @@
 /* crypto/gui/decryptverifyfilesdialog.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #pragma once
 
 #include <QDialog>
 #include <QString>
 #include <QDialogButtonBox>
 #include <QHash>
 #include "crypto/task.h"
 
 #include <memory>
 
 class QVBoxLayout;
 class QProgressBar;
 template <typename K, typename U> class QHash;
 class QLabel;
 
 namespace Kleo
 {
 class FileNameRequester;
 namespace Crypto
 {
 class TaskCollection;
 
 namespace Gui
 {
 class ResultListWidget;
 
 class DecryptVerifyFilesDialog : public QDialog
 {
     Q_OBJECT
 public:
     explicit DecryptVerifyFilesDialog(const std::shared_ptr<TaskCollection> &coll,
                                       QWidget *parent = nullptr);
     ~DecryptVerifyFilesDialog() override;
 
     void setOutputLocation(const QString &dir);
     QString outputLocation() const;
 
 protected Q_SLOTS:
-    void progress(const QString &msg, int progress, int total);
+    void progress(int progress, int total);
     void started(const std::shared_ptr<Task> &result);
     void allDone();
     void btnClicked(QAbstractButton *btn);
     void checkAccept();
 
 protected:
     void readConfig();
     void writeConfig();
 
 protected:
     QLabel *labelForTag(const QString &tag);
 
 private:
     std::shared_ptr<TaskCollection> m_tasks;
     QProgressBar *m_progressBar;
     QHash<QString, QLabel *> m_progressLabelByTag;
     QVBoxLayout *m_progressLabelLayout;
     int m_lastErrorItemIndex;
     ResultListWidget *m_resultList;
     FileNameRequester *m_outputLocationFNR;
     QDialogButtonBox::StandardButton m_saveButton = QDialogButtonBox::NoButton;
     QDialogButtonBox *const m_buttonBox;
 };
 
 } // namespace Gui
 } //namespace Crypto;
 } // namespace Kleo
 
diff --git a/src/crypto/gui/newresultpage.cpp b/src/crypto/gui/newresultpage.cpp
index 478eb8ce3..9c73fbae3 100644
--- a/src/crypto/gui/newresultpage.cpp
+++ b/src/crypto/gui/newresultpage.cpp
@@ -1,186 +1,186 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "newresultpage.h"
 
 #include "resultlistwidget.h"
 #include "resultitemwidget.h"
 
 #include <crypto/taskcollection.h>
 
 #include <Libkleo/Stl_Util>
 
 #include <KLocalizedString>
 
 #include <QCheckBox>
 #include <QHash>
 #include <QLabel>
 #include <QProgressBar>
 #include <QVBoxLayout>
 #include <QTimer>
 
 
 static const int ProgressBarHideDelay = 2000; // 2 secs
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class NewResultPage::Private
 {
     NewResultPage *const q;
 public:
     explicit Private(NewResultPage *qq);
 
-    void progress(const QString &msg, int progress, int total);
+    void progress(int progress, int total);
     void result(const std::shared_ptr<const Task::Result> &result);
     void started(const std::shared_ptr<Task> &result);
     void allDone();
     QLabel *labelForTag(const QString &tag);
 
     std::vector< std::shared_ptr<TaskCollection> > m_collections;
     QTimer m_hideProgressTimer;
     QProgressBar *m_progressBar;
     QHash<QString, QLabel *> m_progressLabelByTag;
     QVBoxLayout *m_progressLabelLayout;
     int m_lastErrorItemIndex;
     ResultListWidget *m_resultList;
 };
 
 NewResultPage::Private::Private(NewResultPage *qq) : q(qq), m_lastErrorItemIndex(0)
 {
     m_hideProgressTimer.setInterval(ProgressBarHideDelay);
     m_hideProgressTimer.setSingleShot(true);
 
     QBoxLayout *const layout = new QVBoxLayout(q);
     auto const labels = new QWidget;
     m_progressLabelLayout = new QVBoxLayout(labels);
     layout->addWidget(labels);
     m_progressBar = new QProgressBar;
     layout->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     connect(m_resultList, &ResultListWidget::linkActivated, q, &NewResultPage::linkActivated);
     layout->addWidget(m_resultList, 1);
 
     connect(&m_hideProgressTimer, &QTimer::timeout, m_progressBar, &QProgressBar::hide);
 }
 
-void NewResultPage::Private::progress(const QString &msg, int progress, int total)
+void NewResultPage::Private::progress(int progress, int total)
 {
-    Q_UNUSED(msg)
     Q_ASSERT(progress >= 0);
     Q_ASSERT(total >= 0);
     m_progressBar->setRange(0, total);
     m_progressBar->setValue(progress);
 }
 
 void NewResultPage::Private::allDone()
 {
     Q_ASSERT(!m_collections.empty());
     if (!m_resultList->isComplete()) {
         return;
     }
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     m_collections.clear();
     const auto progressLabelByTagKeys{m_progressLabelByTag.keys()};
     for (const QString &i : progressLabelByTagKeys) {
         if (!i.isEmpty()) {
             m_progressLabelByTag.value(i)->setText(i18n("%1: All operations completed.", i));
         } else {
             m_progressLabelByTag.value(i)->setText(i18n("All operations completed."));
         }
     }
     if (QAbstractButton *cancel = q->wizard()->button(QWizard::CancelButton)) {
         cancel->setEnabled(false);
     }
     Q_EMIT q->completeChanged();
     m_hideProgressTimer.start();
 }
 
 void NewResultPage::Private::result(const std::shared_ptr<const Task::Result> &)
 {
 }
 
 void NewResultPage::Private::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const QString tag = task->tag();
     QLabel *const label = labelForTag(tag);
     Q_ASSERT(label);
     if (tag.isEmpty()) {
         label->setText(i18nc("number, operation description", "Operation %1: %2", m_resultList->numberOfCompletedTasks() + 1, task->label()));
     } else {
         label->setText(i18nc(R"(tag( "OpenPGP" or "CMS"),  operation description)", "%1: %2", tag, task->label()));
     }
 }
 
 NewResultPage::NewResultPage(QWidget *parent) : QWizardPage(parent), d(new Private(this))
 {
     setTitle(i18n("<b>Results</b>"));
 }
 
 NewResultPage::~NewResultPage()
 {
 }
 
 void NewResultPage::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     //clear(); ### PENDING(marc) implement
     addTaskCollection(coll);
 }
 
 void NewResultPage::addTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     Q_ASSERT(coll);
     if (std::find(d->m_collections.cbegin(), d->m_collections.cend(), coll) != d->m_collections.cend()) {
         return;
     }
     d->m_hideProgressTimer.stop();
     d->m_progressBar->show();
     d->m_collections.push_back(coll);
     d->m_resultList->addTaskCollection(coll);
-    connect(coll.get(), SIGNAL(progress(QString,int,int)),
-            this, SLOT(progress(QString,int,int)));
+    connect(coll.get(), &TaskCollection::progress, this, [this](int current, int total) {
+        d->progress(current, total);
+    });
     connect(coll.get(), SIGNAL(done()),
             this, SLOT(allDone()));
     connect(coll.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
             this, SLOT(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
     connect(coll.get(), SIGNAL(started(std::shared_ptr<Kleo::Crypto::Task>)),
             this, SLOT(started(std::shared_ptr<Kleo::Crypto::Task>)));
 
     for (const std::shared_ptr<Task> &i : coll->tasks()) {    // create labels for all tags in collection
         Q_ASSERT(i);
         QLabel *l = d->labelForTag(i->tag());
         Q_ASSERT(l); (void)l;
     }
     Q_EMIT completeChanged();
 }
 
 QLabel *NewResultPage::Private::labelForTag(const QString &tag)
 {
     if (QLabel *const label = m_progressLabelByTag.value(tag)) {
         return label;
     }
     auto label = new QLabel;
     label->setTextFormat(Qt::RichText);
     label->setWordWrap(true);
     m_progressLabelLayout->addWidget(label);
     m_progressLabelByTag.insert(tag, label);
     return label;
 }
 
 bool NewResultPage::isComplete() const
 {
     return d->m_resultList->isComplete();
 }
 
 #include "moc_newresultpage.cpp"
diff --git a/src/crypto/gui/newresultpage.h b/src/crypto/gui/newresultpage.h
index 236c1723d..75591c3f7 100644
--- a/src/crypto/gui/newresultpage.h
+++ b/src/crypto/gui/newresultpage.h
@@ -1,61 +1,60 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/newresultpage.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008, 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QWizardPage>
 
 #include <utils/pimpl_ptr.h>
 
 #include <memory>
 
 namespace Kleo
 {
 namespace Crypto
 {
 class TaskCollection;
 class Task;
 }
 }
 
 namespace Kleo
 {
 namespace Crypto
 {
 namespace Gui
 {
 
 class NewResultPage : public QWizardPage
 {
     Q_OBJECT
 public:
     explicit NewResultPage(QWidget *parent = nullptr);
     ~NewResultPage() override;
 
     void setTaskCollection(const std::shared_ptr<TaskCollection> &coll);
     void addTaskCollection(const std::shared_ptr<TaskCollection> &coll);
 
     bool isComplete() const override;
 
 Q_SIGNALS:
     void linkActivated(const QString &link);
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
-    Q_PRIVATE_SLOT(d, void progress(QString, int, int))
     Q_PRIVATE_SLOT(d, void result(std::shared_ptr<const Kleo::Crypto::Task::Result>))
     Q_PRIVATE_SLOT(d, void started(std::shared_ptr<Kleo::Crypto::Task>))
     Q_PRIVATE_SLOT(d, void allDone())
 };
 
 }
 }
 }
 
diff --git a/src/crypto/gui/resultpage.cpp b/src/crypto/gui/resultpage.cpp
index 5ee5718f3..b69c6e45f 100644
--- a/src/crypto/gui/resultpage.cpp
+++ b/src/crypto/gui/resultpage.cpp
@@ -1,176 +1,176 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultpage.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "resultpage.h"
 #include "resultlistwidget.h"
 #include "resultitemwidget.h"
 
 #include <crypto/taskcollection.h>
 
 #include <utils/scrollarea.h>
 
 #include <KLocalizedString>
 
 #include <QCheckBox>
 #include <QHash>
 #include <QLabel>
 #include <QProgressBar>
 #include <QVBoxLayout>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 class ResultPage::Private
 {
     ResultPage *const q;
 public:
     explicit Private(ResultPage *qq);
 
-    void progress(const QString &msg, int progress, int total);
+    void progress(int progress, int total);
     void result(const std::shared_ptr<const Task::Result> &result);
     void started(const std::shared_ptr<Task> &result);
     void allDone();
     QLabel *labelForTag(const QString &tag);
 
     std::shared_ptr<TaskCollection> m_tasks;
     QProgressBar *m_progressBar;
     QHash<QString, QLabel *> m_progressLabelByTag;
     QVBoxLayout *m_progressLabelLayout;
     int m_lastErrorItemIndex = 0;
     ResultListWidget *m_resultList;
     QCheckBox *m_keepOpenCB;
 };
 
 ResultPage::Private::Private(ResultPage *qq) : q(qq)
 {
     QBoxLayout *const layout = new QVBoxLayout(q);
     auto const labels = new QWidget;
     m_progressLabelLayout = new QVBoxLayout(labels);
     layout->addWidget(labels);
     m_progressBar = new QProgressBar;
     layout->addWidget(m_progressBar);
     m_resultList = new ResultListWidget;
     layout->addWidget(m_resultList);
     m_keepOpenCB = new QCheckBox;
     m_keepOpenCB->setText(i18n("Keep open after operation completed"));
     m_keepOpenCB->setChecked(true);
     layout->addWidget(m_keepOpenCB);
 }
 
-void ResultPage::Private::progress(const QString &msg, int progress, int total)
+void ResultPage::Private::progress(int progress, int total)
 {
-    Q_UNUSED(msg)
     Q_ASSERT(progress >= 0);
     Q_ASSERT(total >= 0);
     m_progressBar->setRange(0, total);
     m_progressBar->setValue(progress);
 }
 
 void ResultPage::Private::allDone()
 {
     Q_ASSERT(m_tasks);
     q->setAutoAdvance(!m_keepOpenCB->isChecked() && !m_tasks->errorOccurred());
     m_progressBar->setRange(0, 100);
     m_progressBar->setValue(100);
     m_tasks.reset();
     const auto progressLabelByTagKeys{m_progressLabelByTag.keys()};
     for (const QString &i : progressLabelByTagKeys) {
         if (!i.isEmpty()) {
             m_progressLabelByTag.value(i)->setText(i18n("%1: All operations completed.", i));
         } else {
             m_progressLabelByTag.value(i)->setText(i18n("All operations completed."));
         }
     }
     Q_EMIT q->completeChanged();
 }
 
 void ResultPage::Private::result(const std::shared_ptr<const Task::Result> &)
 {
 }
 
 void ResultPage::Private::started(const std::shared_ptr<Task> &task)
 {
     Q_ASSERT(task);
     const QString tag = task->tag();
     QLabel *const label = labelForTag(tag);
     Q_ASSERT(label);
     if (tag.isEmpty()) {
         label->setText(i18nc("number, operation description", "Operation %1: %2", m_tasks->numberOfCompletedTasks() + 1, task->label()));
     } else {
         label->setText(i18nc(R"(tag( "OpenPGP" or "CMS"),  operation description)", "%1: %2", tag, task->label()));
     }
 }
 
 ResultPage::ResultPage(QWidget *parent, Qt::WindowFlags flags) : WizardPage(parent, flags), d(new Private(this))
 {
     setTitle(i18n("<b>Results</b>"));
 }
 
 ResultPage::~ResultPage()
 {
 }
 
 bool ResultPage::keepOpenWhenDone() const
 {
     return d->m_keepOpenCB->isChecked();
 }
 
 void ResultPage::setKeepOpenWhenDone(bool keep)
 {
     d->m_keepOpenCB->setChecked(keep);
 }
 
 void ResultPage::setTaskCollection(const std::shared_ptr<TaskCollection> &coll)
 {
     Q_ASSERT(!d->m_tasks);
     if (d->m_tasks == coll) {
         return;
     }
     d->m_tasks = coll;
     Q_ASSERT(d->m_tasks);
     d->m_resultList->setTaskCollection(coll);
-    connect(d->m_tasks.get(), SIGNAL(progress(QString,int,int)),
-            this, SLOT(progress(QString,int,int)));
+    connect(d->m_tasks.get(), &TaskCollection::progress, this, [this](int current, int total) {
+        d->progress(current, total);
+    });
     connect(d->m_tasks.get(), SIGNAL(done()),
             this, SLOT(allDone()));
     connect(d->m_tasks.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
             this, SLOT(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
     connect(d->m_tasks.get(), SIGNAL(started(std::shared_ptr<Kleo::Crypto::Task>)),
             this, SLOT(started(std::shared_ptr<Kleo::Crypto::Task>)));
 
     for (const std::shared_ptr<Task> &i : d->m_tasks->tasks()) {    // create labels for all tags in collection
         Q_ASSERT(i && d->labelForTag(i->tag()));
         Q_UNUSED(i)
     }
     Q_EMIT completeChanged();
 }
 
 QLabel *ResultPage::Private::labelForTag(const QString &tag)
 {
     if (QLabel *const label = m_progressLabelByTag.value(tag)) {
         return label;
     }
     auto label = new QLabel;
     label->setTextFormat(Qt::RichText);
     label->setWordWrap(true);
     m_progressLabelLayout->addWidget(label);
     m_progressLabelByTag.insert(tag, label);
     return label;
 }
 
 bool ResultPage::isComplete() const
 {
     return d->m_tasks ? d->m_tasks->allTasksCompleted() : true;
 }
 
 #include "moc_resultpage.cpp"
diff --git a/src/crypto/gui/resultpage.h b/src/crypto/gui/resultpage.h
index 63d0c89e0..751f3830e 100644
--- a/src/crypto/gui/resultpage.h
+++ b/src/crypto/gui/resultpage.h
@@ -1,56 +1,55 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/resultpage.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <crypto/gui/wizardpage.h>
 #include <crypto/task.h>
 
 #include <utils/pimpl_ptr.h>
 
 #include <memory>
 
 namespace Kleo
 {
 namespace Crypto
 {
 
 class TaskCollection;
 
 namespace Gui
 {
 
 class ResultPage : public WizardPage
 {
     Q_OBJECT
 
 public:
     explicit ResultPage(QWidget *parent = nullptr, Qt::WindowFlags flags = {});
     ~ResultPage() override;
 
     void setTaskCollection(const std::shared_ptr<TaskCollection> &coll);
 
     bool isComplete() const override;
 
     bool keepOpenWhenDone() const;
     void setKeepOpenWhenDone(bool keep);
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
-    Q_PRIVATE_SLOT(d, void progress(QString, int, int))
     Q_PRIVATE_SLOT(d, void result(std::shared_ptr<const Kleo::Crypto::Task::Result>))
     Q_PRIVATE_SLOT(d, void started(std::shared_ptr<Kleo::Crypto::Task>))
     Q_PRIVATE_SLOT(d, void allDone())
 };
 
 }
 }
 }
 
diff --git a/src/crypto/signemailtask.cpp b/src/crypto/signemailtask.cpp
index f6ce40c09..5a7fed171 100644
--- a/src/crypto/signemailtask.cpp
+++ b/src/crypto/signemailtask.cpp
@@ -1,284 +1,285 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signemailtask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signemailtask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Stl_Util>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 #include <algorithm>
 #include <functional>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class SignEMailResult : public Task::Result
 {
     const SigningResult m_result;
     const AuditLogEntry m_auditLog;
 public:
     explicit SignEMailResult(const SigningResult &r, const AuditLogEntry &auditLog)
         : Task::Result(), m_result(r), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLogEntry auditLog() const override;
 };
 
 QString makeResultString(const SigningResult &res)
 {
     const Error err = res.error();
 
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed: %1", QString::fromLocal8Bit(err.asString()).toHtmlEscaped());
     }
 
     return i18n("Signing succeeded.");
 }
 }
 
 class SignEMailTask::Private
 {
     friend class ::Kleo::Crypto::SignEMailTask;
     SignEMailTask *const q;
 public:
     explicit Private(SignEMailTask *qq);
 
 private:
     std::unique_ptr<QGpgME::SignJob> createJob(GpgME::Protocol proto);
 
 private:
     void slotResult(const SigningResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     std::vector<Key> signers;
     bool detached;
     bool clearsign;
 
     QString micAlg;
 
     QPointer<QGpgME::SignJob> job;
 };
 
 SignEMailTask::Private::Private(SignEMailTask *qq)
     : q(qq),
       input(),
       output(),
       signers(),
       detached(false),
       clearsign(false),
       micAlg(),
       job(nullptr)
 {
 
 }
 
 SignEMailTask::SignEMailTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEMailTask::~SignEMailTask() {}
 
 void SignEMailTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEMailTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEMailTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     kleo_assert(!signers.empty());
     kleo_assert(std::none_of(signers.cbegin(), signers.cend(), std::mem_fn(&Key::isNull)));
     d->signers = signers;
 }
 
 void SignEMailTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
     d->clearsign = false;
 }
 
 void SignEMailTask::setClearsign(bool clear)
 {
     kleo_assert(!d->job);
     d->clearsign = clear;
     d->detached = false;
 }
 
 Protocol SignEMailTask::protocol() const
 {
     kleo_assert(!d->signers.empty());
     return d->signers.front().protocol();
 }
 
 QString SignEMailTask::label() const
 {
     return d->input ? d->input->label() : QString();
 }
 
 unsigned long long SignEMailTask::inputSize() const
 {
     return d->input ? d->input->size() : 0;
 }
 
 void SignEMailTask::doStart()
 {
     kleo_assert(!d->job);
     kleo_assert(d->input);
     kleo_assert(d->output);
     kleo_assert(!d->signers.empty());
 
     d->micAlg.clear();
 
     std::unique_ptr<QGpgME::SignJob> job = d->createJob(protocol());
     kleo_assert(job.get());
 
     job->start(d->signers,
                d->input->ioDevice(), d->output->ioDevice(),
                d->clearsign ? GpgME::Clearsigned : d->detached ? GpgME::Detached : GpgME::NormalSignatureMode);
 
     d->job = job.release();
 }
 
 void SignEMailTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEMailTask::Private::createJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     bool shouldArmor = (proto == OpenPGP || q->asciiArmor()) && !output->binaryOpt();
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(/*armor=*/ shouldArmor, /*textmode=*/false));
     kleo_assert(signJob.get());
     if (proto == CMS && !q->asciiArmor() && !output->binaryOpt()) {
         signJob->setOutputIsBase64Encoded(true);
     }
-    connect(signJob.get(), SIGNAL(progress(QString,int,int)),
-            q, SLOT(setProgress(QString,int,int)));
+    connect(signJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 static QString collect_micalgs(const GpgME::SigningResult &result, GpgME::Protocol proto)
 {
     const std::vector<GpgME::CreatedSignature> css = result.createdSignatures();
     QStringList micalgs;
     std::transform(css.begin(), css.end(),
                    std::back_inserter(micalgs),
                    [](const GpgME::CreatedSignature &sig) {
                        return QString::fromLatin1(sig.hashAlgorithmAsString()).toLower();
                    });
     if (proto == GpgME::OpenPGP)
         for (QStringList::iterator it = micalgs.begin(), end = micalgs.end(); it != end; ++it) {
             it->prepend(QLatin1String("pgp-"));
         }
     micalgs.sort();
     micalgs.erase(std::unique(micalgs.begin(), micalgs.end()), micalgs.end());
     return micalgs.join(QLatin1Char(','));
 }
 
 void SignEMailTask::Private::slotResult(const SigningResult &result)
 {
     const auto *const job = qobject_cast<const QGpgME::Job *>(q->sender());
     if (result.error().code()) {
         output->cancel();
     } else {
         output->finalize();
         micAlg = collect_micalgs(result, q->protocol());
     }
     q->emitResult(std::shared_ptr<Result>(new SignEMailResult(result, AuditLogEntry::fromJob(job))));
 }
 
 QString SignEMailTask::micAlg() const
 {
     return d->micAlg;
 }
 
 QString SignEMailResult::overview() const
 {
     return makeOverview(makeResultString(m_result));
 }
 
 QString SignEMailResult::details() const
 {
     return QString();
 }
 
 GpgME::Error SignEMailResult::error() const
 {
     return m_result.error();
 }
 
 QString SignEMailResult::errorString() const
 {
     return hasError() ? makeResultString(m_result) : QString();
 }
 
 Task::Result::VisualCode SignEMailResult::code() const
 {
     if (m_result.error().isCanceled()) {
         return Warning;
     }
     return m_result.error().code() ? NeutralError : NeutralSuccess;
 }
 
 AuditLogEntry SignEMailResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signemailtask.cpp"
 
diff --git a/src/crypto/signencrypttask.cpp b/src/crypto/signencrypttask.cpp
index ef47c7d15..444f7b5f0 100644
--- a/src/crypto/signencrypttask.cpp
+++ b/src/crypto/signencrypttask.cpp
@@ -1,797 +1,806 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/signencrypttask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencrypttask.h"
 
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/path-helper.h>
 #include <utils/kleo_assert.h>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/Formatting>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KleoException>
 
 #include <QGpgME/Protocol>
 #include <QGpgME/SignJob>
 #include <QGpgME/SignEncryptJob>
 #include <QGpgME/EncryptJob>
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 #include <QGpgME/EncryptArchiveJob>
 #include <QGpgME/SignArchiveJob>
 #include <QGpgME/SignEncryptArchiveJob>
 #endif
 
 #include <gpgme++/signingresult.h>
 #include <gpgme++/encryptionresult.h>
 #include <gpgme++/key.h>
 
 #include <KLocalizedString>
 
 #include "kleopatra_debug.h"
 #include <QFileInfo>
 #include <QPointer>
 #include <QTextDocument> // for Qt::escape
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 QString formatInputOutputLabel(const QString &input, const QString &output, bool outputDeleted)
 {
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  input.toHtmlEscaped(),
                  outputDeleted ? QStringLiteral("<s>%1</s>").arg(output.toHtmlEscaped()) : output.toHtmlEscaped());
 }
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(bool sign, bool encrypt, const Error &err, const QString &errStr, const QString &input, const QString &output, const AuditLogEntry &auditLog)
         : Task::Result(), m_sign(sign), m_encrypt(encrypt), m_error(err), m_errString(errStr), m_inputLabel(input), m_outputLabel(output), m_auditLog(auditLog) {}
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override
     {
         return m_error;
     }
     QString errorString() const override
     {
         return m_errString;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLogEntry auditLog() const override
     {
         return m_auditLog;
     }
 private:
     const bool m_sign;
     const bool m_encrypt;
     const Error m_error;
     const QString m_errString;
     const QString m_inputLabel;
     const QString m_outputLabel;
     const AuditLogEntry m_auditLog;
 };
 
 namespace
 {
 struct LabelAndError
 {
     QString label;
     QString errorString;
 };
 }
 
 class SignEncryptFilesResult : public Task::Result
 {
 public:
     SignEncryptFilesResult(const SigningResult &sr, const LabelAndError &input, const LabelAndError &output, bool outputCreated, const AuditLogEntry &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_input{input},
           m_output{output},
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString
                                << "\noutputError:" << m_output.errorString;
         Q_ASSERT(!m_sresult.isNull());
     }
     SignEncryptFilesResult(const EncryptionResult &er, const LabelAndError &input, const LabelAndError &output, bool outputCreated, const AuditLogEntry &auditLog)
         : Task::Result(),
           m_eresult(er),
           m_input{input},
           m_output{output},
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString
                                << "\noutputError:" << m_output.errorString;
         Q_ASSERT(!m_eresult.isNull());
     }
     SignEncryptFilesResult(const SigningResult &sr, const EncryptionResult &er, const LabelAndError &input, const LabelAndError &output, bool outputCreated,  const AuditLogEntry &auditLog)
         : Task::Result(),
           m_sresult(sr),
           m_eresult(er),
           m_input{input},
           m_output{output},
           m_outputCreated(outputCreated),
           m_auditLog(auditLog)
     {
         qCDebug(KLEOPATRA_LOG) << "\ninputError :" << m_input.errorString
                                << "\noutputError:" << m_output.errorString;
         Q_ASSERT(!m_sresult.isNull() || !m_eresult.isNull());
     }
 
     QString overview() const override;
     QString details() const override;
     GpgME::Error error() const override;
     QString errorString() const override;
     VisualCode code() const override;
     AuditLogEntry auditLog() const override;
 
 private:
     const SigningResult m_sresult;
     const EncryptionResult m_eresult;
     const LabelAndError m_input;
     const LabelAndError m_output;
     const bool m_outputCreated;
     const AuditLogEntry m_auditLog;
 };
 
 static QString makeSigningOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Signing canceled.");
     }
 
     if (err) {
         return i18n("Signing failed.");
     }
     return i18n("Signing succeeded.");
 }
 
 static QString makeResultOverview(const SigningResult &result)
 {
     return makeSigningOverview(result.error());
 }
 
 static QString makeEncryptionOverview(const Error &err)
 {
     if (err.isCanceled()) {
         return i18n("Encryption canceled.");
     }
 
     if (err) {
         return i18n("Encryption failed.");
     }
 
     return i18n("Encryption succeeded.");
 }
 
 static QString makeResultOverview(const EncryptionResult &result)
 {
     return makeEncryptionOverview(result.error());
 }
 
 static QString makeResultOverview(const SigningResult &sr, const EncryptionResult &er)
 {
     if (er.isNull() && sr.isNull()) {
         return QString();
     }
     if (er.isNull()) {
         return makeResultOverview(sr);
     }
     if (sr.isNull()) {
         return makeResultOverview(er);
     }
     if (sr.error().isCanceled() || sr.error()) {
         return makeResultOverview(sr);
     }
     if (er.error().isCanceled() || er.error()) {
         return makeResultOverview(er);
     }
     return i18n("Signing and encryption succeeded.");
 }
 
 static QString escape(QString s)
 {
     s = s.toHtmlEscaped();
     s.replace(QLatin1Char('\n'), QStringLiteral("<br>"));
     return s;
 }
 
 static QString makeResultDetails(const SigningResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err || err.isCanceled()) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return QString();
 }
 
 static QString makeResultDetails(const EncryptionResult &result, const QString &inputError, const QString &outputError)
 {
     const Error err = result.error();
     if (err.code() == GPG_ERR_EIO) {
         if (!inputError.isEmpty()) {
             return i18n("Input error: %1", escape(inputError));
         } else if (!outputError.isEmpty()) {
             return i18n("Output error: %1", escape(outputError));
         }
     }
 
     if (err || err.isCanceled()) {
         return QString::fromLocal8Bit(err.asString()).toHtmlEscaped();
     }
     return i18n(" Encryption succeeded.");
 }
 
 }
 
 QString ErrorResult::overview() const
 {
     Q_ASSERT(m_error || m_error.isCanceled());
     Q_ASSERT(m_sign || m_encrypt);
     const QString label = formatInputOutputLabel(m_inputLabel, m_outputLabel, true);
     const bool canceled = m_error.isCanceled();
     if (m_sign && m_encrypt) {
         return canceled ? i18n("%1: <b>Sign/encrypt canceled.</b>", label) : i18n(" %1: Sign/encrypt failed.", label);
     }
     return i18nc("label: result. Example: foo -> foo.gpg: Encryption failed.", "%1: <b>%2</b>", label,
                  m_sign ? makeSigningOverview(m_error) : makeEncryptionOverview(m_error));
 }
 
 QString ErrorResult::details() const
 {
     return m_errString;
 }
 
 class SignEncryptTask::Private
 {
     friend class ::Kleo::Crypto::SignEncryptTask;
     SignEncryptTask *const q;
 public:
     explicit Private(SignEncryptTask *qq);
 
 private:
     void startSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignJob> createSignJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptJob> createSignEncryptJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptJob> createEncryptJob(GpgME::Protocol proto);
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     void startSignEncryptArchiveJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignArchiveJob> createSignArchiveJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::SignEncryptArchiveJob> createSignEncryptArchiveJob(GpgME::Protocol proto);
     std::unique_ptr<QGpgME::EncryptArchiveJob> createEncryptArchiveJob(GpgME::Protocol proto);
 #endif
 
     std::shared_ptr<const Task::Result> makeErrorResult(const Error &err, const QString &errStr, const AuditLogEntry &auditLog);
 
 private:
     void slotResult(const SigningResult &);
     void slotResult(const SigningResult &, const EncryptionResult &);
     void slotResult(const EncryptionResult &);
 
     void slotResult(const QGpgME::Job *, const SigningResult &, const EncryptionResult &);
 
 private:
     std::shared_ptr<Input> input;
     std::shared_ptr<Output> output;
     QStringList inputFileNames;
     QString outputFileName;
     std::vector<Key> signers;
     std::vector<Key> recipients;
 
     bool sign     : 1;
     bool encrypt  : 1;
     bool detached : 1;
     bool symmetric: 1;
     bool clearsign: 1;
     bool archive  : 1;
 
     QPointer<QGpgME::Job> job;
     std::shared_ptr<OverwritePolicy> m_overwritePolicy;
 };
 
 SignEncryptTask::Private::Private(SignEncryptTask *qq)
     : q{qq}
     , sign{true}
     , encrypt{true}
     , detached{false}
     , clearsign{false}
     , archive{false}
     , m_overwritePolicy{new OverwritePolicy{nullptr}}
 {
     q->setAsciiArmor(true);
 }
 
 std::shared_ptr<const Task::Result> SignEncryptTask::Private::makeErrorResult(const Error &err, const QString &errStr, const AuditLogEntry &auditLog)
 {
     return std::shared_ptr<const ErrorResult>(new ErrorResult(sign, encrypt, err, errStr, q->label(), output ? output->label() : QString{}, auditLog));
 }
 
 SignEncryptTask::SignEncryptTask(QObject *p)
     : Task(p), d(new Private(this))
 {
 
 }
 
 SignEncryptTask::~SignEncryptTask() {}
 
 void SignEncryptTask::setInputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->inputFileNames = QStringList(fileName);
 }
 
 void SignEncryptTask::setInputFileNames(const QStringList &fileNames)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileNames.empty());
     d->inputFileNames = fileNames;
 }
 
 void SignEncryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     kleo_assert(!d->job);
     kleo_assert(input);
     d->input = input;
 }
 
 void SignEncryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     kleo_assert(!d->job);
     kleo_assert(output);
     d->output = output;
 }
 
 void SignEncryptTask::setOutputFileName(const QString &fileName)
 {
     kleo_assert(!d->job);
     kleo_assert(!fileName.isEmpty());
     d->outputFileName = fileName;
 }
 
 void SignEncryptTask::setSigners(const std::vector<Key> &signers)
 {
     kleo_assert(!d->job);
     d->signers = signers;
 }
 
 void SignEncryptTask::setRecipients(const std::vector<Key> &recipients)
 {
     kleo_assert(!d->job);
     d->recipients = recipients;
 }
 
 void SignEncryptTask::setOverwritePolicy(const std::shared_ptr<OverwritePolicy> &policy)
 {
     kleo_assert(!d->job);
     d->m_overwritePolicy = policy;
 }
 
 void SignEncryptTask::setSign(bool sign)
 {
     kleo_assert(!d->job);
     d->sign = sign;
 }
 
 void SignEncryptTask::setEncrypt(bool encrypt)
 {
     kleo_assert(!d->job);
     d->encrypt = encrypt;
 }
 
 void SignEncryptTask::setDetachedSignature(bool detached)
 {
     kleo_assert(!d->job);
     d->detached = detached;
 }
 
 void SignEncryptTask::setEncryptSymmetric(bool symmetric)
 {
     kleo_assert(!d->job);
     d->symmetric = symmetric;
 }
 
 void SignEncryptTask::setClearsign(bool clearsign)
 {
     kleo_assert(!d->job);
     d->clearsign = clearsign;
 }
 
 void SignEncryptTask::setCreateArchive(bool archive)
 {
     kleo_assert(!d->job);
     d->archive = archive;
 }
 
 Protocol SignEncryptTask::protocol() const
 {
     if (d->sign && !d->signers.empty()) {
         return d->signers.front().protocol();
     }
     if (d->encrypt || d->symmetric) {
         if (!d->recipients.empty()) {
             return d->recipients.front().protocol();
         } else {
             return GpgME::OpenPGP;    // symmetric OpenPGP encryption
         }
     }
     throw Kleo::Exception(gpg_error(GPG_ERR_INTERNAL),
                           i18n("Cannot determine protocol for task"));
 }
 
 QString SignEncryptTask::label() const
 {
     if (d->input) {
         return d->input->label();
     } else if (!d->inputFileNames.empty()) {
         const auto firstFile = QFileInfo{d->inputFileNames.front()}.fileName();
         return d->inputFileNames.size() == 1 ? firstFile : i18nc("<name of first file>, ...", "%1, ...", firstFile);
     }
     return {};
 }
 
 QString SignEncryptTask::tag() const
 {
     return Formatting::displayName(protocol());
 }
 
 unsigned long long SignEncryptTask::inputSize() const
 {
     return d->input ? d->input->size() : 0U;
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 static bool archiveJobsCanBeUsed(GpgME::Protocol protocol)
 {
     return (protocol == GpgME::OpenPGP) && QGpgME::SignEncryptArchiveJob::isSupported();
 }
 #endif
 
 void SignEncryptTask::doStart()
 {
     kleo_assert(!d->job);
     if (d->sign) {
         kleo_assert(!d->signers.empty());
         if (d->archive) {
             kleo_assert(!d->detached && !d->clearsign);
         }
     }
 
     if (!d->output) {
         d->output = Output::createFromFile(d->outputFileName, d->m_overwritePolicy);
     }
 
     const auto proto = protocol();
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
     if (d->archive && archiveJobsCanBeUsed(proto)) {
         d->startSignEncryptArchiveJob(proto);
     } else
 #endif
     {
         d->startSignEncryptJob(proto);
     }
 }
 
 void SignEncryptTask::Private::startSignEncryptJob(GpgME::Protocol proto)
 {
     kleo_assert(input);
 
     if (encrypt || symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (sign) {
             std::unique_ptr<QGpgME::SignEncryptJob> job = createSignEncryptJob(proto);
             kleo_assert(job.get());
 #if QGPGME_SUPPORTS_SET_FILENAME
             if (inputFileNames.size() == 1) {
                 job->setFileName(inputFileNames.front());
             }
 #endif
 
             job->start(signers, recipients,
                        input->ioDevice(), output->ioDevice(), flags);
 
             this->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptJob> job = createEncryptJob(proto);
             kleo_assert(job.get());
 #if QGPGME_SUPPORTS_SET_FILENAME
             if (inputFileNames.size() == 1) {
                 job->setFileName(inputFileNames.front());
             }
 #endif
 
             job->start(recipients, input->ioDevice(), output->ioDevice(), flags);
 
             this->job = job.release();
         }
     } else if (sign) {
         std::unique_ptr<QGpgME::SignJob> job = createSignJob(proto);
         kleo_assert(job.get());
         kleo_assert(! (detached && clearsign));
 
         job->start(signers,
                    input->ioDevice(), output->ioDevice(),
                    detached ? GpgME::Detached : clearsign ?
                               GpgME::Clearsigned : GpgME::NormalSignatureMode);
 
         this->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 void SignEncryptTask::cancel()
 {
     if (d->job) {
         d->job->slotCancel();
     }
 }
 
 std::unique_ptr<QGpgME::SignJob> SignEncryptTask::Private::createSignJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignJob> signJob(backend->signJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signJob.get());
-    connect(signJob.get(), SIGNAL(progress(QString,int,int)),
-            q, SLOT(setProgress(QString,int,int)));
+    connect(signJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(signJob.get(), SIGNAL(result(GpgME::SigningResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult)));
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptJob> SignEncryptTask::Private::createSignEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptJob> signEncryptJob(backend->signEncryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(signEncryptJob.get());
-    connect(signEncryptJob.get(), SIGNAL(progress(QString,int,int)),
-            q, SLOT(setProgress(QString,int,int)));
+    connect(signEncryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(signEncryptJob.get(), SIGNAL(result(GpgME::SigningResult,GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::SigningResult,GpgME::EncryptionResult)));
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptJob> SignEncryptTask::Private::createEncryptJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptJob> encryptJob(backend->encryptJob(q->asciiArmor(), /*textmode=*/false));
     kleo_assert(encryptJob.get());
-    connect(encryptJob.get(), SIGNAL(progress(QString,int,int)),
-            q, SLOT(setProgress(QString,int,int)));
+    connect(encryptJob.get(), &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(encryptJob.get(), SIGNAL(result(GpgME::EncryptionResult,QByteArray)),
             q, SLOT(slotResult(GpgME::EncryptionResult)));
     return encryptJob;
 }
 
 #if QGPGME_SUPPORTS_ARCHIVE_JOBS
 void SignEncryptTask::Private::startSignEncryptArchiveJob(GpgME::Protocol proto)
 {
     kleo_assert(!input);
 
     const auto baseDirectory = heuristicBaseDirectory(inputFileNames);
     if (baseDirectory.isEmpty()) {
         throw Kleo::Exception(GPG_ERR_CONFLICT, i18n("Cannot find common base directory for these files:\n%1", inputFileNames.join(QLatin1Char('\n'))));
     }
     qCDebug(KLEOPATRA_LOG) << "heuristicBaseDirectory(" << inputFileNames << ") ->" << baseDirectory;
     const auto tempPaths = makeRelativeTo(baseDirectory, inputFileNames);
     const auto relativePaths = std::vector<QString>{tempPaths.begin(), tempPaths.end()};
     qCDebug(KLEOPATRA_LOG) << "relative paths:" << relativePaths;
 
     if (encrypt || symmetric) {
         Context::EncryptionFlags flags = Context::AlwaysTrust;
         if (symmetric) {
             flags = static_cast<Context::EncryptionFlags>(flags | Context::Symmetric);
             qCDebug(KLEOPATRA_LOG) << "Adding symmetric flag";
         }
         if (sign) {
             std::unique_ptr<QGpgME::SignEncryptArchiveJob> job = createSignEncryptArchiveJob(proto);
             kleo_assert(job.get());
             job->setBaseDirectory(baseDirectory);
 
             job->start(signers, recipients, relativePaths, output->ioDevice(), flags);
 
             this->job = job.release();
         } else {
             std::unique_ptr<QGpgME::EncryptArchiveJob> job = createEncryptArchiveJob(proto);
             kleo_assert(job.get());
             job->setBaseDirectory(baseDirectory);
 
             job->start(recipients, relativePaths, output->ioDevice(), flags);
 
             this->job = job.release();
         }
     } else if (sign) {
         std::unique_ptr<QGpgME::SignArchiveJob> job = createSignArchiveJob(proto);
         kleo_assert(job.get());
         job->setBaseDirectory(baseDirectory);
 
         job->start(signers, relativePaths, output->ioDevice());
 
         this->job = job.release();
     } else {
         kleo_assert(!"Either 'sign' or 'encrypt' or 'symmetric' must be set!");
     }
 }
 
 std::unique_ptr<QGpgME::SignArchiveJob> SignEncryptTask::Private::createSignArchiveJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignArchiveJob> signJob(backend->signArchiveJob(q->asciiArmor()));
     auto job = signJob.get();
     kleo_assert(job);
-    connect(job, &QGpgME::SignArchiveJob::progress, q, &SignEncryptTask::setProgress);
+    connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(job, &QGpgME::SignArchiveJob::result, q, [this, job](const GpgME::SigningResult &signResult) {
         slotResult(job, signResult, EncryptionResult{});
     });
     return signJob;
 }
 
 std::unique_ptr<QGpgME::SignEncryptArchiveJob> SignEncryptTask::Private::createSignEncryptArchiveJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::SignEncryptArchiveJob> signEncryptJob(backend->signEncryptArchiveJob(q->asciiArmor()));
     auto job = signEncryptJob.get();
     kleo_assert(job);
-    connect(job, &QGpgME::SignEncryptArchiveJob::progress, q, &SignEncryptTask::setProgress);
+    connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(job, &QGpgME::SignEncryptArchiveJob::result, q, [this, job](const GpgME::SigningResult &signResult, const GpgME::EncryptionResult &encryptResult) {
         slotResult(job, signResult, encryptResult);
     });
     return signEncryptJob;
 }
 
 std::unique_ptr<QGpgME::EncryptArchiveJob> SignEncryptTask::Private::createEncryptArchiveJob(GpgME::Protocol proto)
 {
     const QGpgME::Protocol *const backend = (proto == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(backend);
     std::unique_ptr<QGpgME::EncryptArchiveJob> encryptJob(backend->encryptArchiveJob(q->asciiArmor()));
     auto job = encryptJob.get();
     kleo_assert(job);
-    connect(job, &QGpgME::EncryptArchiveJob::progress, q, &SignEncryptTask::setProgress);
+    connect(job, &QGpgME::Job::progress, q, [this](const QString &, int processed, int total) {
+        q->setProgress(processed, total);
+    });
     connect(job, &QGpgME::EncryptArchiveJob::result, q, [this, job](const GpgME::EncryptionResult &encryptResult) {
         slotResult(job, SigningResult{}, encryptResult);
     });
     return encryptJob;
 }
 #endif
 
 void SignEncryptTask::Private::slotResult(const SigningResult &result)
 {
     slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), result, EncryptionResult{});
 }
 
 void SignEncryptTask::Private::slotResult(const SigningResult &sresult, const EncryptionResult &eresult)
 {
     slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), sresult, eresult);
 }
 
 void SignEncryptTask::Private::slotResult(const EncryptionResult &result)
 {
     slotResult(qobject_cast<const QGpgME::Job *>(q->sender()), SigningResult{}, result);
 }
 
 void SignEncryptTask::Private::slotResult(const QGpgME::Job *job, const SigningResult &sresult, const EncryptionResult &eresult)
 {
     const AuditLogEntry auditLog = AuditLogEntry::fromJob(job);
     bool outputCreated = false;
     if (input && input->failed()) {
         output->cancel();
         q->emitResult(makeErrorResult(Error::fromCode(GPG_ERR_EIO),
                                       i18n("Input error: %1", escape( input->errorString())),
                                       auditLog));
         return;
     } else if (sresult.error().code() || eresult.error().code()) {
         output->cancel();
     } else {
         try {
             kleo_assert(!sresult.isNull() || !eresult.isNull());
             output->finalize();
             outputCreated = true;
             if (input) {
                 input->finalize();
             }
         } catch (const GpgME::Exception &e) {
             q->emitResult(makeErrorResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         }
     }
 
     const LabelAndError inputInfo{q->label(), input ? input->errorString() : QString{}};
     const LabelAndError outputInfo{output->label(), output->errorString()};
     q->emitResult(std::shared_ptr<Result>(new SignEncryptFilesResult(sresult, eresult, inputInfo, outputInfo, outputCreated, auditLog)));
 }
 
 QString SignEncryptFilesResult::overview() const
 {
     const QString files = formatInputOutputLabel(m_input.label, m_output.label, !m_outputCreated);
     return files + QLatin1String(": ") + makeOverview(makeResultOverview(m_sresult, m_eresult));
 }
 
 QString SignEncryptFilesResult::details() const
 {
     return errorString();
 }
 
 GpgME::Error SignEncryptFilesResult::error() const
 {
     if (m_sresult.error().code()) {
         return m_sresult.error();
     }
     if (m_eresult.error().code()) {
         return m_eresult.error();
     }
     return {};
 }
 
 QString SignEncryptFilesResult::errorString() const
 {
     const bool sign = !m_sresult.isNull();
     const bool encrypt = !m_eresult.isNull();
 
     kleo_assert(sign || encrypt);
 
     if (sign && encrypt) {
         return
             m_sresult.error().code() ? makeResultDetails(m_sresult, m_input.errorString, m_output.errorString) :
             m_eresult.error().code() ? makeResultDetails(m_eresult, m_input.errorString, m_output.errorString) :
             QString();
     }
 
     return
         sign   ? makeResultDetails(m_sresult, m_input.errorString, m_output.errorString) :
         /*else*/ makeResultDetails(m_eresult, m_input.errorString, m_output.errorString);
 }
 
 Task::Result::VisualCode SignEncryptFilesResult::code() const
 {
     if (m_sresult.error().isCanceled() || m_eresult.error().isCanceled()) {
         return Warning;
     }
     return (m_sresult.error().code() || m_eresult.error().code()) ? NeutralError : NeutralSuccess;
 }
 
 AuditLogEntry SignEncryptFilesResult::auditLog() const
 {
     return m_auditLog;
 }
 
 #include "moc_signencrypttask.cpp"
diff --git a/src/crypto/task.cpp b/src/crypto/task.cpp
index 26925663c..b1eed7f7b 100644
--- a/src/crypto/task.cpp
+++ b/src/crypto/task.cpp
@@ -1,235 +1,228 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/task.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 #include "task.h"
 #include "task_p.h"
 #include "kleopatra_debug.h"
 
 #include <Libkleo/KleoException>
 
 #include <Libkleo/AuditLogEntry>
 #include <Libkleo/GnuPG>
 
 #include <gpgme++/exception.h>
 
 #include <gpg-error.h>
 
 #include <KIconLoader>
 #include <KLocalizedString>
 
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace GpgME;
 
 namespace
 {
 
 class ErrorResult : public Task::Result
 {
 public:
     ErrorResult(const GpgME::Error &error, const QString &details)
         : Task::Result(), m_error(error), m_details(details) {}
 
     QString overview() const override
     {
         return makeOverview(m_details);
     }
     QString details() const override
     {
         return QString();
     }
     GpgME::Error error() const override
     {
         return m_error;
     }
     QString errorString() const override
     {
         return m_details;
     }
     VisualCode code() const override
     {
         return NeutralError;
     }
     AuditLogEntry auditLog() const override
     {
         return AuditLogEntry();
     }
 private:
     const GpgME::Error m_error;
     const QString m_details;
 };
 }
 
 class Task::Private
 {
     friend class ::Kleo::Crypto::Task;
     Task *const q;
 public:
     explicit Private(Task *qq);
 
 private:
-    QString m_progressLabel;
     int m_progress;
     int m_totalProgress;
     bool m_asciiArmor;
     int m_id;
 };
 
 namespace
 {
 static int nextTaskId = 0;
 }
 
 Task::Private::Private(Task *qq)
-    : q(qq), m_progressLabel(), m_progress(0), m_totalProgress(0), m_asciiArmor(false), m_id(nextTaskId++)
+    : q(qq), m_progress(0), m_totalProgress(0), m_asciiArmor(false), m_id(nextTaskId++)
 {
 
 }
 
 Task::Task(QObject *p)
     : QObject(p), d(new Private(this))
 {
 
 }
 
 Task::~Task() {}
 
 void Task::setAsciiArmor(bool armor)
 {
     d->m_asciiArmor = armor;
 }
 
 bool Task::asciiArmor() const
 {
     return d->m_asciiArmor;
 }
 
 std::shared_ptr<Task> Task::makeErrorTask(const GpgME::Error &error, const QString &details, const QString &label)
 {
     const std::shared_ptr<SimpleTask> t(new SimpleTask(label));
     t->setResult(t->makeErrorResult(error, details));
     return t;
 }
 
 int Task::id() const
 {
     return d->m_id;
 }
 
 int Task::currentProgress() const
 {
     return d->m_progress;
 }
 
 int Task::totalProgress() const
 {
     return d->m_totalProgress;
 }
 
 QString Task::tag() const
 {
     return QString();
 }
 
-QString Task::progressLabel() const
-{
-    return d->m_progressLabel;
-}
-
-void Task::setProgress(const QString &label, int processed, int total)
+void Task::setProgress(int processed, int total)
 {
     d->m_progress = processed;
     d->m_totalProgress = total;
-    d->m_progressLabel = label;
-    Q_EMIT progress(label, processed, total, QPrivateSignal());
+    Q_EMIT progress(processed, total, QPrivateSignal());
 }
 
 void Task::start()
 {
     try {
         doStart();
     } catch (const Kleo::Exception &e) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(GpgME::Error, e.error()), Q_ARG(QString, e.message()));
     } catch (const GpgME::Exception &e) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(GpgME::Error, e.error()), Q_ARG(QString, QString::fromLocal8Bit(e.what())));
     } catch (const std::exception &e) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(GpgME::Error, Error::fromCode(GPG_ERR_UNEXPECTED)), Q_ARG(QString, QString::fromLocal8Bit(e.what())));
     } catch (...) {
         QMetaObject::invokeMethod(this, "emitError", Qt::QueuedConnection, Q_ARG(GpgME::Error, Error::fromCode(GPG_ERR_UNEXPECTED)), Q_ARG(QString, i18n("Unknown exception in Task::start()")));
     }
     Q_EMIT started(QPrivateSignal());
 }
 
 void Task::emitError(const GpgME::Error &error, const QString &details)
 {
     emitResult(makeErrorResult(error, details));
 }
 
 void Task::emitResult(const std::shared_ptr<const Task::Result> &r)
 {
     d->m_progress = d->m_totalProgress;
-    Q_EMIT progress(progressLabel(), currentProgress(), totalProgress(), QPrivateSignal());
+    Q_EMIT progress(currentProgress(), totalProgress(), QPrivateSignal());
     Q_EMIT result(r, QPrivateSignal());
 }
 
 std::shared_ptr<Task::Result> Task::makeErrorResult(const GpgME::Error &error, const QString &details)
 {
     return std::shared_ptr<Task::Result>(new ErrorResult(error, details));
 }
 
 class Task::Result::Private
 {
 public:
     Private() {}
 };
 
 Task::Result::Result() : d(new Private()) {}
 Task::Result::~Result() {}
 
 bool Task::Result::hasError() const
 {
     return error().code() != 0;
 }
 
 static QString image(const char *img)
 {
     // ### escape?
     return KIconLoader::global()->iconPath(QLatin1String(img), KIconLoader::Small);
 }
 
 QString Task::Result::makeOverview(const QString &msg)
 {
     return QLatin1String("<b>") + msg + QLatin1String("</b>");
 }
 
 QString Task::Result::iconPath(VisualCode code)
 {
     switch (code) {
     case Danger:
         return image("dialog-error");
     case AllGood:
         return image("dialog-ok");
     case Warning:
         return image("dialog-warning");
     case NeutralError:
     case NeutralSuccess:
     default:
         return QString();
 
     }
 }
 
 QString Task::Result::icon() const
 {
     return iconPath(code());
 }
 
 #include "moc_task_p.cpp"
diff --git a/src/crypto/task.h b/src/crypto/task.h
index 7f6dfbae5..664a063f3 100644
--- a/src/crypto/task.h
+++ b/src/crypto/task.h
@@ -1,131 +1,131 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/task.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QObject>
 #include <QString>
 
 #include <utils/pimpl_ptr.h>
 
 #include <gpgme++/global.h>
 
 #include <memory>
 #include <QPointer>
 
 namespace Kleo
 {
 class AuditLogEntry;
 }
 
 namespace Kleo
 {
 namespace Crypto
 {
 
 class Task : public QObject
 {
     Q_OBJECT
 public:
     explicit Task(QObject *parent = nullptr);
     ~Task() override;
 
     class Result;
 
     void setAsciiArmor(bool armor);
     bool asciiArmor() const;
 
     virtual GpgME::Protocol protocol() const = 0;
 
     void start();
 
     virtual QString label() const = 0;
 
     virtual QString tag() const;
 
     QString progressLabel() const;
     int currentProgress() const;
     int totalProgress() const;
 
     int id() const;
 
     static std::shared_ptr<Task> makeErrorTask(const GpgME::Error &error, const QString &details, const QString &label);
 
 public Q_SLOTS:
     virtual void cancel() = 0;
 
 Q_SIGNALS:
-    void progress(const QString &what, int processed, int total, QPrivateSignal);
+    void progress(int processed, int total, QPrivateSignal);
     void result(const std::shared_ptr<const Kleo::Crypto::Task::Result> &, QPrivateSignal);
     void started(QPrivateSignal);
 
 protected:
     std::shared_ptr<Result> makeErrorResult(const GpgME::Error &error, const QString &details);
 
     void emitResult(const std::shared_ptr<const Task::Result> &result);
 
 protected Q_SLOTS:
-    void setProgress(const QString &msg, int processed, int total);
+    void setProgress(int processed, int total);
 
 private Q_SLOTS:
     void emitError(const GpgME::Error &error, const QString &details);
 
 private:
     virtual void doStart() = 0;
     virtual unsigned long long inputSize() const = 0;
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 class Task::Result
 {
     const QString m_nonce;
 public:
     Result();
     virtual ~Result();
 
     const QString &nonce() const
     {
         return m_nonce;
     }
 
     bool hasError() const;
 
     enum VisualCode {
         AllGood,
         Warning,
         Danger,
         NeutralSuccess,
         NeutralError
     };
 
     virtual QString icon() const;
     virtual QString overview() const = 0;
     virtual QString details() const = 0;
     virtual GpgME::Error error() const = 0;
     virtual QString errorString() const = 0;
     virtual VisualCode code() const = 0;
     virtual AuditLogEntry auditLog() const = 0;
     virtual QPointer<Task> parentTask() const {return QPointer<Task>();}
 
 protected:
     static QString iconPath(VisualCode code);
     static QString makeOverview(const QString &msg);
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
 };
 
 }
 }
 
 
diff --git a/src/crypto/taskcollection.cpp b/src/crypto/taskcollection.cpp
index e183c033e..8753b0b03 100644
--- a/src/crypto/taskcollection.cpp
+++ b/src/crypto/taskcollection.cpp
@@ -1,227 +1,225 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/taskcollection.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "taskcollection.h"
 #include "task.h"
 #include "kleopatra_debug.h"
 
 #include <Libkleo/GnuPG>
 
 #include <algorithm>
 #include <map>
 
 #include <cmath>
 
 #include <KLocalizedString>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 
 class TaskCollection::Private
 {
     TaskCollection *const q;
 public:
     explicit Private(TaskCollection *qq);
 
-    void taskProgress(const QString &, int, int);
+    void taskProgress();
     void taskResult(const std::shared_ptr<const Task::Result> &);
     void taskStarted();
     void calculateAndEmitProgress();
 
     std::map<int, std::shared_ptr<Task> > m_tasks;
     mutable quint64 m_totalProgress;
     mutable quint64 m_progress;
     unsigned int m_nCompleted;
     unsigned int m_nErrors;
-    QString m_lastProgressMessage;
     bool m_errorOccurred;
     bool m_doneEmitted;
 };
 
 TaskCollection::Private::Private(TaskCollection *qq):
     q(qq),
     m_totalProgress(0),
     m_progress(0),
     m_nCompleted(0),
     m_nErrors(0),
     m_errorOccurred(false),
     m_doneEmitted(false)
 {
 }
 
 int TaskCollection::numberOfCompletedTasks() const
 {
     return d->m_nCompleted;
 }
 
 size_t TaskCollection::size() const
 {
     return d->m_tasks.size();
 }
 
 bool TaskCollection::allTasksCompleted() const
 {
     Q_ASSERT(d->m_nCompleted <= d->m_tasks.size());
     return d->m_nCompleted == d->m_tasks.size();
 }
 
-void TaskCollection::Private::taskProgress(const QString &msg, int, int)
+void TaskCollection::Private::taskProgress()
 {
-    m_lastProgressMessage = msg;
     calculateAndEmitProgress();
 }
 
 void TaskCollection::Private::taskResult(const std::shared_ptr<const Task::Result> &result)
 {
     Q_ASSERT(result);
     ++m_nCompleted;
 
     if (result->hasError()) {
         m_errorOccurred = true;
         ++m_nErrors;
     }
-    m_lastProgressMessage.clear();
     calculateAndEmitProgress();
     Q_EMIT q->result(result);
     if (!m_doneEmitted && q->allTasksCompleted()) {
         Q_EMIT q->done();
         m_doneEmitted = true;
     }
 }
 
 void TaskCollection::Private::taskStarted()
 {
     const Task *const task = qobject_cast<Task *>(q->sender());
     Q_ASSERT(task);
     Q_ASSERT(m_tasks.find(task->id()) != m_tasks.end());
     Q_EMIT q->started(m_tasks[task->id()]);
     calculateAndEmitProgress(); // start Knight-Rider-Mode right away (gpgsm doesn't report _any_ progress).
     if (m_doneEmitted) {
         // We are not done anymore, one task restarted.
         m_nCompleted--;
         m_nErrors--;
         m_doneEmitted = false;
     }
 }
 
 void TaskCollection::Private::calculateAndEmitProgress()
 {
     quint64 total = 0;
     quint64 processed = 0;
 
     static bool haveWorkingProgress = engineIsVersion(2, 1, 15);
     if (!haveWorkingProgress) {
         // GnuPG before 2.1.15 would overflow on progress values > max int.
         // and did not emit a total for our Qt data types.
         // As we can't know if it overflowed or what the total is we just knight
         // rider in that case
         if (m_doneEmitted) {
-            Q_EMIT q->progress(m_lastProgressMessage, 1, 1);
+            Q_EMIT q->progress(1, 1);
         } else {
-            Q_EMIT q->progress(m_lastProgressMessage, 0, 0);
+            Q_EMIT q->progress(0, 0);
         }
         return;
     }
 
     bool unknowable = false;
     for (auto it = m_tasks.begin(), end = m_tasks.end(); it != end; ++it) {
         // Sum up progress and totals
         const std::shared_ptr<Task> &i = it->second;
         Q_ASSERT(i);
         if (!i->totalProgress()) {
             // There still might be jobs for which we don't know the progress.
             qCDebug(KLEOPATRA_LOG) << "Task: " << i->label() << " has no total progress set. ";
             unknowable = true;
             break;
         }
         processed += i->currentProgress();
         total += i->totalProgress();
     }
 
     m_totalProgress = total;
     m_progress = processed;
     if (!unknowable && processed && total >= processed) {
         // Scale down to avoid range issues.
         int scaled = 1000 * (m_progress / static_cast<double>(m_totalProgress));
         qCDebug(KLEOPATRA_LOG) << "Collection Progress: " << scaled << " total: " << 1000;
         if (total == processed) {
             // This can happen when an output is finalizing, e.g. extracting an
             // archive.
-            Q_EMIT q->progress(i18n("Finalizing output..."), 0, 0);
+            Q_EMIT q->progress(0, 0);
         } else {
-            Q_EMIT q->progress(m_lastProgressMessage, scaled, 1000);
+            Q_EMIT q->progress(scaled, 1000);
         }
     } else {
         if (total < processed) {
             qCDebug(KLEOPATRA_LOG) << "Total progress is smaller then current progress.";
         }
         // Knight rider.
-        Q_EMIT q->progress(m_lastProgressMessage, 0, 0);
+        Q_EMIT q->progress(0, 0);
     }
 }
 
 TaskCollection::TaskCollection(QObject *parent) : QObject(parent), d(new Private(this))
 {
 }
 
 TaskCollection::~TaskCollection()
 {
 }
 
 bool TaskCollection::isEmpty() const
 {
     return d->m_tasks.empty();
 }
 
 bool TaskCollection::errorOccurred() const
 {
     return d->m_errorOccurred;
 }
 
 bool TaskCollection::allTasksHaveErrors() const
 {
     return d->m_nErrors == d->m_nCompleted;
 }
 
 std::shared_ptr<Task> TaskCollection::taskById(int id) const
 {
     const auto it = d->m_tasks.find(id);
     return it != d->m_tasks.end() ? it->second : std::shared_ptr<Task>();
 }
 
 std::vector<std::shared_ptr<Task> > TaskCollection::tasks() const
 {
     std::vector<std::shared_ptr<Task> > res;
     res.reserve(d->m_tasks.size());
     for (auto it = d->m_tasks.begin(), end = d->m_tasks.end(); it != end; ++it) {
         res.push_back(it->second);
     }
     return res;
 }
 
 void TaskCollection::setTasks(const std::vector<std::shared_ptr<Task> > &tasks)
 {
     for (const std::shared_ptr<Task> &i : tasks) {
         Q_ASSERT(i);
         d->m_tasks[i->id()] = i;
-        connect(i.get(), SIGNAL(progress(QString,int,int)),
-                this, SLOT(taskProgress(QString,int,int)));
+        connect(i.get(), &Task::progress, this, [this]() {
+            d->taskProgress();
+        });
         connect(i.get(), SIGNAL(result(std::shared_ptr<const Kleo::Crypto::Task::Result>)),
                 this, SLOT(taskResult(std::shared_ptr<const Kleo::Crypto::Task::Result>)));
         connect(i.get(), SIGNAL(started()),
                 this, SLOT(taskStarted()));
     }
 }
 
 #include "moc_taskcollection.cpp"
diff --git a/src/crypto/taskcollection.h b/src/crypto/taskcollection.h
index 444c323e4..3b4ac5996 100644
--- a/src/crypto/taskcollection.h
+++ b/src/crypto/taskcollection.h
@@ -1,62 +1,61 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/taskcollection.h
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #pragma once
 
 #include <QObject>
 
 #include <crypto/task.h>
 
 #include <utils/pimpl_ptr.h>
 
 #include <memory>
 
 #include <vector>
 
 namespace Kleo
 {
 namespace Crypto
 {
 
 class TaskCollection : public QObject
 {
     Q_OBJECT
 public:
     explicit TaskCollection(QObject *parent = nullptr);
     ~TaskCollection() override;
 
     std::vector<std::shared_ptr<Task> > tasks() const;
     std::shared_ptr<Task> taskById(int id) const;
 
     void setTasks(const std::vector<std::shared_ptr<Task> > &tasks);
 
     bool isEmpty() const;
     size_t size() const;
 
     int numberOfCompletedTasks() const;
     bool allTasksCompleted() const;
     bool errorOccurred() const;
     bool allTasksHaveErrors() const;
 
 Q_SIGNALS:
-    void progress(const QString &msg, int processed, int total);
+    void progress(int processed, int total);
     void result(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result);
     void started(const std::shared_ptr<Kleo::Crypto::Task> &task);
     void done();
 
 private:
     class Private;
     kdtools::pimpl_ptr<Private> d;
-    Q_PRIVATE_SLOT(d, void taskProgress(QString, int, int))
     Q_PRIVATE_SLOT(d, void taskResult(std::shared_ptr<const Kleo::Crypto::Task::Result>))
     Q_PRIVATE_SLOT(d, void taskStarted())
 };
 }
 }