diff --git a/CMakeLists.txt b/CMakeLists.txt
index f686edf24..f93d9fbe8 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,159 +1,159 @@
 set(kleopatra_version 3.1.12)
 # The following is for Windows. Keep in line with kleopatra_version.
 set(kleopatra_fileversion 3,1,12,0)
 cmake_minimum_required(VERSION 3.5)
 project(kleopatra VERSION ${kleopatra_version})
 
 # The RELEASE_SERVICE_VERSION is used by Gpg4win to add the Gpg4win version
 if (NOT RELEASE_SERVICE_VERSION)
     set (RELEASE_SERVICE_VERSION "20.11.80")
 endif()
 
 option(FORCE_DISABLE_KCMUTILS "Force building Kleopatra without KCMUtils. Doing this will disable configuration KCM Plugins. [default=OFF]" OFF)
 option(DISABLE_KWATCHGNUPG "Don't build the kwatchgnupg tool [default=OFF]" OFF)
 
 # Standalone build. Find / include everything necessary.
 set(KF5_MIN_VERSION "5.74.0")
 set(KMIME_VERSION "5.15.40")
-set(LIBKLEO_VERSION "5.15.40")
+set(LIBKLEO_VERSION "5.15.41")
 set(QT_REQUIRED_VERSION "5.13.0")
 set(GPGME_REQUIRED_VERSION "1.11.1")
 
 find_package(ECM ${KF5_MIN_VERSION} CONFIG REQUIRED)
 set(CMAKE_MODULE_PATH ${ECM_MODULE_PATH})
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
 
 
 include(ECMInstallIcons)
 include(ECMSetupVersion)
 include(ECMAddTests)
 
 include(GenerateExportHeader)
 include(ECMGenerateHeaders)
 
 include(FeatureSummary)
 include(CheckFunctionExists)
 include(ECMGeneratePriFile)
 
 include(KDEInstallDirs)
 include(KDECMakeSettings)
 include(KDEFrameworkCompilerSettings NO_POLICY_SCOPE)
 include(ECMAddAppIcon)
 include(ECMQtDeclareLoggingCategory)
 
 # Find KF5 packages
 if (NOT FORCE_DISABLE_KCMUTILS)
   find_package(KF5KCMUtils ${KF5_MIN_VERSION} CONFIG REQUIRED)
 endif()
 find_package(KF5WidgetsAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ConfigWidgets ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5CoreAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5Codecs ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5Config ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5I18n ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5IconThemes ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5ItemModels ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5XmlGui ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5WindowSystem ${KF5_MIN_VERSION} CONFIG REQUIRED)
 find_package(KF5DocTools ${KF5_MIN_VERSION} CONFIG)
 find_package(KF5Crash ${KF5_MIN_VERSION} REQUIRED)
 
 set_package_properties(KF5DocTools PROPERTIES DESCRIPTION "Documentation tools" TYPE OPTIONAL PURPOSE "Required to generate Kleopatra documentation.")
 
 # Optional packages
 if (WIN32)
   # Only a replacement available for Windows so this
   # is required on other platforms.
   find_package(KF5DBusAddons ${KF5_MIN_VERSION} CONFIG)
   set_package_properties(KF5DBusAddons PROPERTIES DESCRIPTION "Support library to work with DBus"
                          PURPOSE "DBus session integration"
                          URL "https://inqlude.org/libraries/kdbusaddons.html"
                          TYPE OPTIONAL)
 else()
   find_package(KF5DBusAddons ${KF5_MIN_VERSION} CONFIG REQUIRED)
   set(_kleopatra_dbusaddons_libs KF5::DBusAddons)
 endif()
 
 set(HAVE_QDBUS ${Qt5DBus_FOUND})
 
 find_package(Gpgmepp ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 find_package(QGpgme ${GPGME_REQUIRED_VERSION} CONFIG REQUIRED)
 
 # Kdepimlibs packages
 find_package(KF5Libkleo ${LIBKLEO_VERSION} CONFIG REQUIRED)
 find_package(KF5Mime ${KMIME_VERSION} CONFIG REQUIRED)
 
 find_package(Qt5 ${QT_REQUIRED_VERSION} CONFIG REQUIRED Widgets Test Network PrintSupport)
 
 find_package(Assuan2 REQUIRED)
 
 set(HAVE_KCMUTILS ${KF5KCMUtils_FOUND})
 set(CMAKE_CXX_STANDARD 14)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 
 
 find_package(Boost 1.34.0 REQUIRED)
 
 find_path(Boost_TOPOLOGICAL_SORT_DIR NAMES boost/graph/topological_sort.hpp PATHS ${Boost_INCLUDE_DIRS})
 if(NOT Boost_TOPOLOGICAL_SORT_DIR)
     message(FATAL_ERROR "The Boost Topological_sort header was NOT found. Should be part of Boost graph module.")
 endif()
 
 set(kleopatra_release FALSE)
 
 if(NOT kleopatra_release)
     if(GIT_FOUND)
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%h ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_REVISION)
         string(REGEX REPLACE "\n" "" Kleopatra_WC_REVISION "${Kleopatra_WC_REVISION}")
 
         execute_process(COMMAND ${GIT_EXECUTABLE} log -1 --oneline --format=%ci ${CMAKE_CURRENT_SOURCE_DIR}
             WORKING_DIRECTORY ${kdepim_SOURCE_DIR}/kleopatra
             OUTPUT_VARIABLE Kleopatra_WC_LAST_CHANGED_DATE)
         string(REGEX REPLACE " [-0-9:+ ]*\n" "" Kleopatra_WC_LAST_CHANGED_DATE "${Kleopatra_WC_LAST_CHANGED_DATE}")
 
         set(kleopatra_version "${kleopatra_version}-git${Kleopatra_WC_REVISION} (${Kleopatra_WC_LAST_CHANGED_DATE})")
     endif()
 endif()
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/version-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/version-kleopatra.h)
 
 include (ConfigureChecks.cmake)
 
 configure_file(${CMAKE_CURRENT_SOURCE_DIR}/config-kleopatra.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/config-kleopatra.h)
 include_directories(
     ${CMAKE_CURRENT_BINARY_DIR}
     ${CMAKE_CURRENT_SOURCE_DIR}
     ${Boost_INCLUDE_DIR}
     ${ASSUAN2_INCLUDES}
     )
 
 add_definitions(-D_ASSUAN_ONLY_GPG_ERRORS)
 #add_definitions(-DQT_DISABLE_DEPRECATED_BEFORE=0x050f00)
 add_definitions(-DKF_DISABLE_DEPRECATED_BEFORE_AND_AT=0x054B00)
 if(CMAKE_COMPILER_IS_GNUCXX)
     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-braces -Wno-parentheses -Wno-ignored-qualifiers")
 endif()
 add_definitions(-DQT_NO_EMIT)
 
 kde_enable_exceptions()
 
 
 add_subdirectory(pics)
 add_subdirectory(src)
 
 if(BUILD_TESTING)
     add_subdirectory(tests)
     add_subdirectory(autotests)
 endif()
 
 ecm_qt_install_logging_categories(
         EXPORT KLEOPATRA
         FILE kleopatra.categories
         DESTINATION ${KDE_INSTALL_LOGGINGCATEGORIESDIR}
         )
 
 if(KF5DocTools_FOUND)
     add_subdirectory(doc)
 endif()
diff --git a/src/crypto/decryptverifytask.cpp b/src/crypto/decryptverifytask.cpp
index 889061a2d..fde3d4bf9 100644
--- a/src/crypto/decryptverifytask.cpp
+++ b/src/crypto/decryptverifytask.cpp
@@ -1,1601 +1,1601 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     decryptverifytask.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2008 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "decryptverifytask.h"
 
 #include <QGpgME/Protocol>
 #include <QGpgME/VerifyOpaqueJob>
 #include <QGpgME/VerifyDetachedJob>
 #include <QGpgME/DecryptJob>
 #include <QGpgME/DecryptVerifyJob>
 
 #include <Libkleo/Dn>
 #include <Libkleo/Exception>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/KeyCache>
 #include <Libkleo/Predicates>
 #include <Libkleo/Formatting>
 #include <Libkleo/Classify>
 
 #include <utils/detail_p.h>
 #include <utils/input.h>
 #include <utils/output.h>
 #include <utils/kleo_assert.h>
 #include <utils/auditlog.h>
 #include <Libkleo/GnuPG>
 
 #include <kmime/kmime_header_parsing.h>
 
 #include <gpgme++/error.h>
 #include <gpgme++/key.h>
 #include <gpgme++/verificationresult.h>
 #include <gpgme++/decryptionresult.h>
 #include <gpgme++/gpgmepp_version.h>
 #include <gpgme++/context.h>
 
 #include <gpg-error.h>
 
 #include "kleopatra_debug.h"
 #include <KLocalizedString>
 #include <QLocale>
 
 #include <QByteArray>
 #include <QDateTime>
 #include <QStringList>
 #include <QTextDocument> // Qt::escape
 
 #include <algorithm>
 #include <sstream>
 
 #if GPGMEPP_VERSION > 0x10B01 // > 1.11.1
 # define GPGME_HAS_LEGACY_NOMDC
 #endif
 
 using namespace Kleo::Crypto;
 using namespace Kleo;
 using namespace GpgME;
 using namespace KMime::Types;
 
 namespace
 {
 
 static Error make_error(const gpg_err_code_t code)
 {
     return Error(gpg_error(code));
 }
 
 static AuditLog auditLogFromSender(QObject *sender)
 {
     return AuditLog::fromJob(qobject_cast<const QGpgME::Job *>(sender));
 }
 
 static bool addrspec_equal(const AddrSpec &lhs, const AddrSpec &rhs, Qt::CaseSensitivity cs)
 {
     return lhs.localPart.compare(rhs.localPart, cs) == 0 && lhs.domain.compare(rhs.domain, Qt::CaseInsensitive) == 0;
 }
 
 static bool mailbox_equal(const Mailbox &lhs, const Mailbox &rhs, Qt::CaseSensitivity cs)
 {
     return addrspec_equal(lhs.addrSpec(), rhs.addrSpec(), cs);
 }
 
 static std::string stripAngleBrackets(const std::string &str)
 {
     if (str.empty()) {
         return str;
     }
     if (str[0] == '<' && str[str.size() - 1] == '>') {
         return str.substr(1, str.size() - 2);
     }
     return str;
 }
 
 static std::string email(const UserID &uid)
 {
 
     if (uid.parent().protocol() == OpenPGP) {
         if (const char *const email = uid.email()) {
             return stripAngleBrackets(email);
         } else {
             return std::string();
         }
     }
 
     Q_ASSERT(uid.parent().protocol() == CMS);
 
     if (const char *const id = uid.id())
         if (*id == '<') {
             return stripAngleBrackets(id);
         } else {
             return DN(id)[QStringLiteral("EMAIL")].trimmed().toUtf8().constData();
         }
     else {
         return std::string();
     }
 }
 
 static Mailbox mailbox(const UserID &uid)
 {
     const std::string e = email(uid);
     Mailbox mbox;
     if (!e.empty()) {
         mbox.setAddress(e.c_str());
     }
     return mbox;
 }
 
 static std::vector<Mailbox> extractMailboxes(const Key &key)
 {
     std::vector<Mailbox> res;
     Q_FOREACH (const UserID &id, key.userIDs()) {
         const Mailbox mbox = mailbox(id);
         if (!mbox.addrSpec().isEmpty()) {
             res.push_back(mbox);
         }
     }
     return res;
 }
 
 static std::vector<Mailbox> extractMailboxes(const std::vector<Key> &signers)
 {
     std::vector<Mailbox> res;
     for (const Key &i : signers) {
         const std::vector<Mailbox> bxs = extractMailboxes(i);
         res.insert(res.end(), bxs.begin(), bxs.end());
     }
     return res;
 }
 
 static bool keyContainsMailbox(const Key &key, const Mailbox &mbox)
 {
     const std::vector<Mailbox> mbxs = extractMailboxes(key);
     return std::find_if(mbxs.cbegin(), mbxs.cend(), 
                         [mbox](const Mailbox &m) {
                             return mailbox_equal(mbox, m, Qt::CaseInsensitive);
                         }) != mbxs.cend();
 }
 
 static bool keysContainMailbox(const std::vector<Key> &keys, const Mailbox &mbox)
 {
     return std::find_if(keys.cbegin(), keys.cend(), 
                         [mbox](const Key &key) {
                             return keyContainsMailbox(key, mbox);
                         }) != keys.cend();
 }
 
 static bool relevantInDecryptVerifyContext(const VerificationResult &r)
 {
     // for D/V operations, we ignore verification results which are not errors and contain
     // no signatures (which means that the data was just not signed)
 
     return (r.error() && r.error().code() != GPG_ERR_DECRYPT_FAILED) || r.numSignatures() > 0;
 }
 
 static QString signatureSummaryToString(int summary)
 {
     if (summary & Signature::None) {
         return i18n("Error: Signature not verified");
     } else if (summary & Signature::Valid || summary & Signature::Green) {
         return i18n("Good signature");
     } else if (summary & Signature::KeyRevoked) {
         return i18n("Signing certificate was revoked");
     } else if (summary & Signature::KeyExpired) {
         return i18n("Signing certificate is expired");
     } else if (summary & Signature::KeyMissing) {
         return i18n("Certificate is not available");
     } else if (summary & Signature::SigExpired) {
         return i18n("Signature expired");
     } else if (summary & Signature::CrlMissing) {
         return i18n("CRL missing");
     } else if (summary & Signature::CrlTooOld) {
         return i18n("CRL too old");
     } else if (summary & Signature::BadPolicy) {
         return i18n("Bad policy");
     } else if (summary & Signature::SysError) {
         return i18n("System error");    //### retrieve system error details?
     } else if (summary & Signature::Red) {
         return i18n("Bad signature");
     }return QString();
 }
 
 static QString formatValidSignatureWithTrustLevel(const UserID &id)
 {
     if (id.isNull()) {
         return QString();
     }
     switch (id.validity()) {
     case UserID::Marginal:
         return i18n("The signature is valid but the trust in the certificate's validity is only marginal.");
     case UserID::Full:
         return i18n("The signature is valid and the certificate's validity is fully trusted.");
     case UserID::Ultimate:
         return i18n("The signature is valid and the certificate's validity is ultimately trusted.");
     case UserID::Never:
         return i18n("The signature is valid but the certificate's validity is <em>not trusted</em>.");
     case UserID::Unknown:
         return i18n("The signature is valid but the certificate's validity is unknown.");
     case UserID::Undefined:
     default:
         return i18n("The signature is valid but the certificate's validity is undefined.");
     }
 }
 
 static QString renderKeyLink(const QString &fpr, const QString &text)
 {
     return QStringLiteral("<a href=\"key:%1\">%2</a>").arg(fpr, text);
 }
 
 static QString renderKey(const Key &key)
 {
     if (key.isNull()) {
         return i18n("Unknown certificate");
     }
 
     if (key.primaryFingerprint() && strlen(key.primaryFingerprint()) > 16 && key.numUserIDs()) {
         const QString text = QStringLiteral("%1 (%2)").arg(Formatting::prettyNameAndEMail(key).toHtmlEscaped()).arg(
             Formatting::prettyID(QString::fromLocal8Bit(key.primaryFingerprint()).right(16).toLatin1().constData()));
         return renderKeyLink(QLatin1String(key.primaryFingerprint()), text);
     }
 
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), Formatting::prettyID(key.primaryFingerprint()));
 }
 
 static QString renderKeyEMailOnlyNameAsFallback(const Key &key)
 {
     if (key.isNull()) {
         return i18n("Unknown certificate");
     }
     const QString email = Formatting::prettyEMail(key);
     const QString user = !email.isEmpty() ? email : Formatting::prettyName(key);
     return renderKeyLink(QLatin1String(key.primaryFingerprint()), user);
 }
 
 static QString formatDate(const QDateTime &dt)
 {
     return QLocale().toString(dt);
 }
 static QString formatSigningInformation(const Signature &sig)
 {
     if (sig.isNull()) {
         return QString();
     }
     const QDateTime dt = sig.creationTime() != 0 ? QDateTime::fromSecsSinceEpoch(sig.creationTime()) : QDateTime();
     QString text;
     Key key = sig.key();
     if (dt.isValid()) {
         text = i18nc("1 is a date", "Signature created on %1", formatDate(dt)) + QStringLiteral("<br>");
     }
     if (key.isNull()) {
         return text += i18n("With unavailable certificate:") + QStringLiteral("<br>ID: 0x%1").arg(QString::fromLatin1(sig.fingerprint()).toUpper());
     }
     text += i18n("With certificate:") + QStringLiteral("<br>") + renderKey(key);
 
     if (Kleo::gpgComplianceP("de-vs")) {
         text +=
             (QStringLiteral("<br/>")
              + (IS_DE_VS(sig)
-                ? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that a signature is compliant with that.",
-                        "The signature is VS-NfD-compliant.")
-                : i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that a signature is not compliant with that.",
-                        "The signature <b>is not</b> VS-NfD-compliant.")));
+                ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                        "The signature is %1", Formatting::deVsString())
+                : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                        "The signature <b>is not</b> %1.", Formatting::deVsString())));
     }
 
     return text;
 }
 
 static QString strikeOut(const QString &str, bool strike)
 {
     return QString(strike ? QStringLiteral("<s>%1</s>") : QStringLiteral("%1")).arg(str.toHtmlEscaped());
 }
 
 static QString formatInputOutputLabel(const QString &input, const QString &output, bool inputDeleted, bool outputDeleted)
 {
     if (output.isEmpty()) {
         return strikeOut(input, inputDeleted);
     }
     return i18nc("Input file --> Output file (rarr is arrow", "%1 &rarr; %2",
                  strikeOut(input, inputDeleted),
                  strikeOut(output, outputDeleted));
 }
 
 static bool IsErrorOrCanceled(const GpgME::Error &err)
 {
     return err || err.isCanceled();
 }
 
 static bool IsErrorOrCanceled(const Result &res)
 {
     return IsErrorOrCanceled(res.error());
 }
 
 static bool IsBad(const Signature &sig)
 {
     return sig.summary() & Signature::Red;
 }
 
 static bool IsGoodOrValid(const Signature &sig)
 {
     return (sig.summary() & Signature::Valid) || (sig.summary() & Signature::Green);
 }
 
 static UserID findUserIDByMailbox(const Key &key, const Mailbox &mbox)
 {
     Q_FOREACH (const UserID &id, key.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>");
     }
 #ifdef GPGME_HAS_LEGACY_NOMDC
     else if (result.isLegacyCipherNoMDC()) {
         return i18n("<b>Decryption failed: %1.</b>", i18n("No integrity protection (MDC)."));
     }
 #endif
     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 formatDecryptionResultDetails(const DecryptionResult &res, const std::vector<Key> &recipients,
                                              const QString &errorString, bool isSigned, const QPointer<Task> &task)
 {
     QString details;
 
     if ((res.error().code() == GPG_ERR_EIO || res.error().code() == GPG_ERR_NO_DATA) && !errorString.isEmpty()) {
         return i18n("Input error: %1", errorString);
     }
 
     if (Kleo::gpgComplianceP("de-vs")) {
         details += ((IS_DE_VS(res)
-                     ? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that the decryption is compliant with that.",
-                             "The decryption is VS-NfD-compliant.")
-                     : i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that the decryption is compliant with that.",
-                             "The decryption <b>is not</b> VS-NfD-compliant."))
+                     ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                             "The decryption is %1.", Formatting::deVsString())
+                     : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                             "The decryption <b>is not</b> %1."), Formatting::deVsString())
                     + QStringLiteral("<br/>"));
     }
 
     if (res.fileName()) {
         const auto decVerifyTask = qobject_cast<AbstractDecryptVerifyTask*> (task.data());
         if (decVerifyTask) {
             const auto embedFileName = QString::fromUtf8(res.fileName()).toHtmlEscaped();
 
             if (embedFileName != decVerifyTask->outputLabel()) {
                 details += i18n("Embedded file name: '%1'", embedFileName);
                 details += QStringLiteral("<br/>");
             }
         }
     }
 
     if (res.isNull() || !res.error() || res.error().isCanceled()) {
         if (!isSigned) {
             return details + i18n("<b>Note:</b> You cannot be sure who encrypted this message as it is not signed.");
         }
         return details;
     }
 
     if (recipients.empty() && res.numRecipients() > 0) {
         return details + QLatin1String("<i>") + i18np("One unknown recipient.", "%1 unknown recipients.", res.numRecipients()) + QLatin1String("</i>");
     }
 
 #ifdef GPGME_HAS_LEGACY_NOMDC
     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/>");
     }
 #endif
 
     if (!recipients.empty()) {
         details += i18np("Recipient:", "Recipients:", res.numRecipients());
         if (res.numRecipients() == 1) {
             return details + QLatin1Char(' ') + renderKey(recipients.front());
         }
 
         details += QLatin1String("<ul>");
         for (const Key &key : recipients) {
             details += QLatin1String("<li>") + renderKey(key) + QLatin1String("</li>");
         }
         if (recipients.size() < res.numRecipients())
             details += QLatin1String("<li><i>") + i18np("One unknown recipient", "%1 unknown recipients",
                        res.numRecipients() - recipients.size()) + QLatin1String("</i></li>");
 
         details += QLatin1String("</ul>");
     }
 
     return details;
 }
 
 static QString formatDecryptVerifyResultOverview(const DecryptionResult &dr, const VerificationResult &vr, const  DecryptVerifyResult::SenderInfo &info)
 {
     if (IsErrorOrCanceled(dr) || !relevantInDecryptVerifyContext(vr)) {
         return formatDecryptionResultOverview(dr);
     }
     return formatVerificationResultOverview(vr, info);
 }
 
 static QString formatDecryptVerifyResultDetails(const DecryptionResult &dr,
         const VerificationResult &vr,
         const std::vector<Key> &recipients,
         const DecryptVerifyResult::SenderInfo &info,
         const QString &errorString,
         const QPointer<Task> &task)
 {
     const QString drDetails = formatDecryptionResultDetails(dr, recipients, errorString, relevantInDecryptVerifyContext(vr), task);
     if (IsErrorOrCanceled(dr) || !relevantInDecryptVerifyContext(vr)) {
         return drDetails;
     }
     return drDetails + (drDetails.isEmpty() ? QString() : QStringLiteral("<br/>")) + formatVerificationResultDetails(vr, info, errorString);
 }
 
 } // anon namespace
 
 class DecryptVerifyResult::Private
 {
     DecryptVerifyResult *const q;
 public:
     Private(DecryptVerifyOperation type,
             const VerificationResult &vr,
             const DecryptionResult &dr,
             const QByteArray &stuff,
             int errCode,
             const QString &errString,
             const QString &input,
             const QString &output,
             const AuditLog &auditLog,
             Task *parentTask,
             const Mailbox &informativeSender,
             DecryptVerifyResult *qq) :
         q(qq),
         m_type(type),
         m_verificationResult(vr),
         m_decryptionResult(dr),
         m_stuff(stuff),
         m_error(errCode),
         m_errorString(errString),
         m_inputLabel(input),
         m_outputLabel(output),
         m_auditLog(auditLog),
         m_parentTask(QPointer<Task>(parentTask)),
         m_informativeSender(informativeSender)
     {
     }
 
     QString label() const
     {
         return formatInputOutputLabel(m_inputLabel, m_outputLabel, false, q->hasError());
     }
 
     DecryptVerifyResult::SenderInfo makeSenderInfo() const;
 
     bool isDecryptOnly() const
     {
         return m_type == Decrypt;
     }
     bool isVerifyOnly() const
     {
         return m_type == Verify;
     }
     bool isDecryptVerify() const
     {
         return m_type == DecryptVerify;
     }
     DecryptVerifyOperation m_type;
     VerificationResult m_verificationResult;
     DecryptionResult m_decryptionResult;
     QByteArray m_stuff;
     int m_error;
     QString m_errorString;
     QString m_inputLabel;
     QString m_outputLabel;
     const AuditLog m_auditLog;
     QPointer <Task> m_parentTask;
     const Mailbox m_informativeSender;
 };
 
 DecryptVerifyResult::SenderInfo DecryptVerifyResult::Private::makeSenderInfo() const
 {
     return SenderInfo(m_informativeSender, KeyCache::instance()->findSigners(m_verificationResult));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const DecryptionResult &dr, const QByteArray &plaintext, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             dr,
             plaintext,
             0,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptResult(const GpgME::Error &err, const QString &what, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Decrypt,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             err.code(),
             what,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog)
 {
     int err = dr.error() ? dr.error().code() : vr.error().code();
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             vr,
             dr,
             plaintext,
             err,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromDecryptVerifyResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             DecryptVerify,
             VerificationResult(),
             DecryptionResult(err),
             QByteArray(),
             err.code(),
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const VerificationResult &vr, const QByteArray &plaintext, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             plaintext,
             0,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyOpaqueResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             err.code(),
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const VerificationResult &vr, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             vr,
             DecryptionResult(),
             QByteArray(),
             0,
             QString(),
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 std::shared_ptr<DecryptVerifyResult> AbstractDecryptVerifyTask::fromVerifyDetachedResult(const GpgME::Error &err, const QString &details, const AuditLog &auditLog)
 {
     return std::shared_ptr<DecryptVerifyResult>(new DecryptVerifyResult(
             Verify,
             VerificationResult(err),
             DecryptionResult(),
             QByteArray(),
             err.code(),
             details,
             inputLabel(),
             outputLabel(),
             auditLog,
             this,
             informativeSender()));
 }
 
 DecryptVerifyResult::DecryptVerifyResult(DecryptVerifyOperation type,
         const VerificationResult &vr,
         const DecryptionResult &dr,
         const QByteArray &stuff,
         int errCode,
         const QString &errString,
         const QString &inputLabel,
         const QString &outputLabel,
         const AuditLog &auditLog,
         Task *parentTask,
         const Mailbox &informativeSender)
     : Task::Result(), d(new Private(type, vr, dr, stuff, errCode, errString, inputLabel, outputLabel, auditLog, parentTask, informativeSender, this))
 {
 }
 
 QString DecryptVerifyResult::overview() const
 {
     QString ov;
     if (d->isDecryptOnly()) {
         ov += formatDecryptionResultOverview(d->m_decryptionResult);
     } else if (d->isVerifyOnly()) {
         ov += formatVerificationResultOverview(d->m_verificationResult, d->makeSenderInfo());
     } else {
         ov += formatDecryptVerifyResultOverview(d->m_decryptionResult, d->m_verificationResult, d->makeSenderInfo());
     }
     if (ov.size() + d->label().size() > 120) {
         // Avoid ugly breaks
         ov = QStringLiteral("<br>") + ov;
     }
     return i18nc("label: result example: foo.sig: Verification failed. ", "%1: %2", d->label(), ov);
 }
 
 QString DecryptVerifyResult::details() const
 {
     if (d->isDecryptOnly()) {
         return formatDecryptionResultDetails(d->m_decryptionResult,
                 KeyCache::instance()->findRecipients(d->m_decryptionResult),
                 errorString(), false, d->m_parentTask);
     }
     if (d->isVerifyOnly()) {
         return formatVerificationResultDetails(d->m_verificationResult, d->makeSenderInfo(), errorString());
     }
     return formatDecryptVerifyResultDetails(d->m_decryptionResult,
                                             d->m_verificationResult, KeyCache::instance()->findRecipients(
                                                     d->m_decryptionResult), d->makeSenderInfo(), errorString(),
                                             d->m_parentTask);
 }
 
 bool DecryptVerifyResult::hasError() const
 {
     return d->m_error != 0;
 }
 
 int DecryptVerifyResult::errorCode() const
 {
     return d->m_error;
 }
 
 QString DecryptVerifyResult::errorString() const
 {
     return d->m_errorString;
 }
 
 AuditLog DecryptVerifyResult::auditLog() const
 {
     return d->m_auditLog;
 }
 
 QPointer<Task> DecryptVerifyResult::parentTask() const
 {
     return d->m_parentTask;
 }
 
 Task::Result::VisualCode DecryptVerifyResult::code() const
 {
     if ((d->m_type == DecryptVerify || d->m_type == Verify) && relevantInDecryptVerifyContext(verificationResult())) {
         return codeForVerificationResult(verificationResult());
     }
     return hasError() ? NeutralError : NeutralSuccess;
 }
 
 GpgME::VerificationResult DecryptVerifyResult::verificationResult() const
 {
     return d->m_verificationResult;
 }
 
 GpgME::DecryptionResult DecryptVerifyResult::decryptionResult() const
 {
     return d->m_decryptionResult;
 }
 
 class AbstractDecryptVerifyTask::Private
 {
 public:
     Mailbox informativeSender;
 };
 
 AbstractDecryptVerifyTask::AbstractDecryptVerifyTask(QObject *parent) : Task(parent), d(new Private) {}
 
 AbstractDecryptVerifyTask::~AbstractDecryptVerifyTask() {}
 
 Mailbox AbstractDecryptVerifyTask::informativeSender() const
 {
     return d->informativeSender;
 }
 
 void AbstractDecryptVerifyTask::setInformativeSender(const Mailbox &sender)
 {
     d->informativeSender = sender;
 }
 
 class DecryptVerifyTask::Private
 {
     DecryptVerifyTask *const q;
 public:
     explicit Private(DecryptVerifyTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol), m_ignoreMDCError(false)  {}
 
     void slotResult(const DecryptionResult &, const VerificationResult &, const QByteArray &);
 
     void registerJob(QGpgME::DecryptVerifyJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::DecryptionResult,GpgME::VerificationResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::DecryptionResult,GpgME::VerificationResult,QByteArray)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
     bool m_ignoreMDCError;
 };
 
 void DecryptVerifyTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void DecryptVerifyTask::Private::slotResult(const DecryptionResult &dr, const VerificationResult &vr, const QByteArray &plainText)
 {
     updateKeys(vr);
     {
         std::stringstream ss;
         ss << dr << '\n' << vr;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     if (dr.error().code() || vr.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!dr.isNull() || !vr.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
     const int drErr = dr.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(drErr ? dr.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     emitResult(q->fromDecryptVerifyResult(dr, vr, plainText, auditLog));
 }
 
 DecryptVerifyTask::DecryptVerifyTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 DecryptVerifyTask::~DecryptVerifyTask()
 {
 }
 
 void DecryptVerifyTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void DecryptVerifyTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void DecryptVerifyTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = prot == GpgME::OpenPGP ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void DecryptVerifyTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature/ciphertext - maybe it is neither ciphertext nor a signature?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString DecryptVerifyTask::label() const
 {
     return i18n("Decrypting: %1...", d->m_input->label());
 }
 
 unsigned long long DecryptVerifyTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString DecryptVerifyTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString DecryptVerifyTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol DecryptVerifyTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void DecryptVerifyTask::cancel()
 {
 
 }
 
 static void ensureIOOpen(QIODevice *input, QIODevice *output)
 {
     if (input && !input->isOpen()) {
         input->open(QIODevice::ReadOnly);
     }
     if (output && !output->isOpen()) {
         output->open(QIODevice::WriteOnly);
     }
 }
 
 void DecryptVerifyTask::setIgnoreMDCError(bool value)
 {
     d->m_ignoreMDCError = value;
 }
 
 void DecryptVerifyTask::doStart()
 {
     kleo_assert(d->m_backend);
     try {
         QGpgME::DecryptVerifyJob *const job = d->m_backend->decryptVerifyJob();
 
 #ifdef GPGME_HAS_LEGACY_NOMDC
         if (d->m_ignoreMDCError) {
             qCDebug(KLEOPATRA_LOG) << "Modifying job to ignore MDC errors.";
             auto ctx = QGpgME::Job::context(job);
             if (!ctx) {
                 qCWarning(KLEOPATRA_LOG) << "Failed to get context for job";
             } else {
                 const auto err = ctx->setFlag("ignore-mdc-error", "1");
                 if (err) {
                     qCWarning(KLEOPATRA_LOG) << "Failed to set ignore mdc errors" << err.asString();
                 }
             }
         }
 #endif
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
         job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromDecryptVerifyResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromDecryptVerifyResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromDecryptVerifyResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 
 }
 
 class DecryptTask::Private
 {
     DecryptTask *const q;
 public:
     explicit Private(DecryptTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol)  {}
 
     void slotResult(const DecryptionResult &, const QByteArray &);
 
     void registerJob(QGpgME::DecryptJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::DecryptionResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::DecryptionResult,QByteArray)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
 };
 
 void DecryptTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void DecryptTask::Private::slotResult(const DecryptionResult &result, const QByteArray &plainText)
 {
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     if (result.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     emitResult(q->fromDecryptResult(result, plainText, auditLog));
 }
 
 DecryptTask::DecryptTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 DecryptTask::~DecryptTask()
 {
 }
 
 void DecryptTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void DecryptTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void DecryptTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void DecryptTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this was S/MIME- or OpenPGP-encrypted - maybe it is not ciphertext at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString DecryptTask::label() const
 {
     return i18n("Decrypting: %1...", d->m_input->label());
 }
 
 unsigned long long DecryptTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString DecryptTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString DecryptTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol DecryptTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void DecryptTask::cancel()
 {
 
 }
 
 void DecryptTask::doStart()
 {
     kleo_assert(d->m_backend);
 
     try {
         QGpgME::DecryptJob *const job = d->m_backend->decryptJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output->ioDevice().get());
         job->start(d->m_input->ioDevice(), d->m_output->ioDevice());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 }
 
 class VerifyOpaqueTask::Private
 {
     VerifyOpaqueTask *const q;
 public:
     explicit Private(VerifyOpaqueTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol)  {}
 
     void slotResult(const VerificationResult &, const QByteArray &);
 
     void registerJob(QGpgME::VerifyOpaqueJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::VerificationResult,QByteArray)),
                    q, SLOT(slotResult(GpgME::VerificationResult,QByteArray)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input;
     std::shared_ptr<Output> m_output;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
 };
 
 void VerifyOpaqueTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void VerifyOpaqueTask::Private::slotResult(const VerificationResult &result, const QByteArray &plainText)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     if (result.error().code()) {
         m_output->cancel();
     } else {
         try {
             kleo_assert(!result.isNull());
             m_output->finalize();
         } catch (const GpgME::Exception &e) {
             emitResult(q->fromDecryptResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
             return;
         } catch (const std::exception &e) {
             emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
             return;
         } catch (...) {
             emitResult(q->fromDecryptResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
             return;
         }
     }
 
     const int drErr = result.error().code();
     const QString errorString = m_output->errorString();
     if (((drErr == GPG_ERR_EIO || drErr == GPG_ERR_NO_DATA) && !errorString.isEmpty()) ||
           m_output->failed()) {
         emitResult(q->fromDecryptResult(result.error() ? result.error() : Error::fromCode(GPG_ERR_EIO),
                     errorString, auditLog));
         return;
     }
 
     emitResult(q->fromVerifyOpaqueResult(result, plainText, auditLog));
 }
 
 VerifyOpaqueTask::VerifyOpaqueTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 VerifyOpaqueTask::~VerifyOpaqueTask()
 {
 }
 
 void VerifyOpaqueTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void VerifyOpaqueTask::setOutput(const std::shared_ptr<Output> &output)
 {
     d->m_output = output;
     kleo_assert(d->m_output && d->m_output->ioDevice());
 }
 
 void VerifyOpaqueTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void VerifyOpaqueTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 QString VerifyOpaqueTask::label() const
 {
     return i18n("Verifying: %1...", d->m_input->label());
 }
 
 unsigned long long VerifyOpaqueTask::inputSize() const
 {
     return d->m_input ? d->m_input->size() : 0;
 }
 
 QString VerifyOpaqueTask::inputLabel() const
 {
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString VerifyOpaqueTask::outputLabel() const
 {
     return d->m_output ? d->m_output->label() : QString();
 }
 
 Protocol VerifyOpaqueTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyOpaqueTask::cancel()
 {
 
 }
 
 void VerifyOpaqueTask::doStart()
 {
     kleo_assert(d->m_backend);
 
     try {
         QGpgME::VerifyOpaqueJob *const job = d->m_backend->verifyOpaqueJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), d->m_output ? d->m_output->ioDevice().get() : nullptr);
         job->start(d->m_input->ioDevice(), d->m_output ? d->m_output->ioDevice() : std::shared_ptr<QIODevice>());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromVerifyOpaqueResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromVerifyOpaqueResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromVerifyOpaqueResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 }
 
 class VerifyDetachedTask::Private
 {
     VerifyDetachedTask *const q;
 public:
     explicit Private(VerifyDetachedTask *qq) : q(qq), m_backend(nullptr), m_protocol(UnknownProtocol) {}
 
     void slotResult(const VerificationResult &);
 
     void registerJob(QGpgME::VerifyDetachedJob *job)
     {
         q->connect(job, SIGNAL(result(GpgME::VerificationResult)),
                    q, SLOT(slotResult(GpgME::VerificationResult)));
         q->connect(job, SIGNAL(progress(QString,int,int)),
                    q, SLOT(setProgress(QString,int,int)));
     }
 
     void emitResult(const std::shared_ptr<DecryptVerifyResult> &result);
 
     std::shared_ptr<Input> m_input, m_signedData;
     const QGpgME::Protocol *m_backend;
     Protocol m_protocol;
 };
 
 void VerifyDetachedTask::Private::emitResult(const std::shared_ptr<DecryptVerifyResult> &result)
 {
     q->emitResult(result);
     Q_EMIT q->decryptVerifyResult(result);
 }
 
 void VerifyDetachedTask::Private::slotResult(const VerificationResult &result)
 {
     updateKeys(result);
     {
         std::stringstream ss;
         ss << result;
         qCDebug(KLEOPATRA_LOG) << ss.str().c_str();
     }
     const AuditLog auditLog = auditLogFromSender(q->sender());
     try {
         kleo_assert(!result.isNull());
         emitResult(q->fromVerifyDetachedResult(result, auditLog));
     } catch (const GpgME::Exception &e) {
         emitResult(q->fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), auditLog));
     } catch (const std::exception &e) {
         emitResult(q->fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), auditLog));
     } catch (...) {
         emitResult(q->fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), auditLog));
     }
 }
 
 VerifyDetachedTask::VerifyDetachedTask(QObject *parent) : AbstractDecryptVerifyTask(parent), d(new Private(this))
 {
 }
 
 VerifyDetachedTask::~VerifyDetachedTask()
 {
 }
 
 void VerifyDetachedTask::setInput(const std::shared_ptr<Input> &input)
 {
     d->m_input = input;
     kleo_assert(d->m_input && d->m_input->ioDevice());
 }
 
 void VerifyDetachedTask::setSignedData(const std::shared_ptr<Input> &signedData)
 {
     d->m_signedData = signedData;
     kleo_assert(d->m_signedData && d->m_signedData->ioDevice());
 }
 
 void VerifyDetachedTask::setProtocol(Protocol prot)
 {
     kleo_assert(prot != UnknownProtocol);
     d->m_protocol = prot;
     d->m_backend = (prot == GpgME::OpenPGP) ? QGpgME::openpgp() : QGpgME::smime();
     kleo_assert(d->m_backend);
 }
 
 void VerifyDetachedTask::autodetectProtocolFromInput()
 {
     if (!d->m_input) {
         return;
     }
     const Protocol p = findProtocol(d->m_input->classification());
     if (p == UnknownProtocol) {
         throw Exception(gpg_error(GPG_ERR_NOTHING_FOUND), i18n("Could not determine whether this is an S/MIME or an OpenPGP signature - maybe it is not a signature at all?"), Exception::MessageOnly);
     }
     setProtocol(p);
 }
 
 unsigned long long VerifyDetachedTask::inputSize() const
 {
     return d->m_signedData ? d->m_signedData->size() : 0;
 }
 
 QString VerifyDetachedTask::label() const
 {
     if (d->m_signedData) {
         return xi18nc("Verification of a detached signature in progress. The first file contains the data."
                       "The second file is the signature file.",
                       "Verifying: <filename>%1</filename> with <filename>%2</filename>...",
                       d->m_signedData->label(),
                       d->m_input->label());
 
     }
     return i18n("Verifying signature: %1...", d->m_input->label());
 }
 
 QString VerifyDetachedTask::inputLabel() const
 {
     if (d->m_signedData && d->m_input) {
         return xi18nc("Verification of a detached signature summary. The first file contains the data."
                       "The second file is signature.",
                       "Verified <filename>%1</filename> with <filename>%2</filename>",
                       d->m_signedData->label(),
                       d->m_input->label());
 
     }
     return d->m_input ? d->m_input->label() : QString();
 }
 
 QString VerifyDetachedTask::outputLabel() const
 {
     return QString();
 }
 
 Protocol VerifyDetachedTask::protocol() const
 {
     return d->m_protocol;
 }
 
 void VerifyDetachedTask::cancel()
 {
 
 }
 
 void VerifyDetachedTask::doStart()
 {
     kleo_assert(d->m_backend);
     try {
         QGpgME::VerifyDetachedJob *const job = d->m_backend->verifyDetachedJob();
         kleo_assert(job);
         d->registerJob(job);
         ensureIOOpen(d->m_input->ioDevice().get(), nullptr);
         ensureIOOpen(d->m_signedData->ioDevice().get(), nullptr);
         job->start(d->m_input->ioDevice(), d->m_signedData->ioDevice());
     } catch (const GpgME::Exception &e) {
         d->emitResult(fromVerifyDetachedResult(e.error(), QString::fromLocal8Bit(e.what()), AuditLog()));
     } catch (const std::exception &e) {
         d->emitResult(fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught exception: %1", QString::fromLocal8Bit(e.what())), AuditLog()));
     } catch (...) {
         d->emitResult(fromVerifyDetachedResult(make_error(GPG_ERR_INTERNAL), i18n("Caught unknown exception"), AuditLog()));
     }
 }
 
 #include "moc_decryptverifytask.cpp"
diff --git a/src/crypto/gui/signencryptemailconflictdialog.cpp b/src/crypto/gui/signencryptemailconflictdialog.cpp
index d282e2d79..2a2eb9816 100644
--- a/src/crypto/gui/signencryptemailconflictdialog.cpp
+++ b/src/crypto/gui/signencryptemailconflictdialog.cpp
@@ -1,643 +1,644 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     crypto/gui/signencryptemailconflictdialog.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptemailconflictdialog.h"
 
 #include <crypto/sender.h>
 #include <crypto/recipient.h>
 
 #include "dialogs/certificateselectiondialog.h"
 #include "certificateselectionline.h"
 
 #include <Libkleo/GnuPG>
 #include "utils/gui-helper.h"
 #include "utils/kleo_assert.h"
 
 #include <Libkleo/Stl_Util>
+#include <Libkleo/Formatting>
 
 #include <gpgme++/key.h>
 
 #include <kmime/kmime_header_parsing.h>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 
 #include <QLabel>
 #include <QLayout>
 #include <QGroupBox>
 #include <QDialogButtonBox>
 #include <QCheckBox>
 #include <QRadioButton>
 #include <QPushButton>
 #include <QPointer>
 #include <QSignalBlocker>
 #include <QToolButton>
 
 #include <algorithm>
 #include <iterator>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 using namespace Kleo::Dialogs;
 using namespace GpgME;
 
 Q_DECLARE_METATYPE(GpgME::Key)
 Q_DECLARE_METATYPE(GpgME::UserID)
 
 static CertificateSelectionDialog *
 create_certificate_selection_dialog(QWidget *parent, Protocol proto)
 {
     CertificateSelectionDialog *const dlg = new CertificateSelectionDialog(parent);
     dlg->setOptions(proto == OpenPGP ? CertificateSelectionDialog::OpenPGPFormat :
                     proto == CMS     ? CertificateSelectionDialog::CMSFormat : CertificateSelectionDialog::AnyFormat);
     return dlg;
 }
 
 static CertificateSelectionDialog *
 create_encryption_certificate_selection_dialog(QWidget *parent, Protocol proto, const QString &mailbox)
 {
     CertificateSelectionDialog *const dlg = create_certificate_selection_dialog(parent, proto);
     dlg->setCustomLabelText(i18n("Please select an encryption certificate for recipient \"%1\"", mailbox));
     dlg->setOptions(CertificateSelectionDialog::SingleSelection |
                     CertificateSelectionDialog::EncryptOnly |
                     dlg->options());
     return dlg;
 }
 
 static CertificateSelectionDialog *
 create_signing_certificate_selection_dialog(QWidget *parent, Protocol proto, const QString &mailbox)
 {
     CertificateSelectionDialog *const dlg = create_certificate_selection_dialog(parent, proto);
     dlg->setCustomLabelText(i18n("Please select a signing certificate for sender \"%1\"", mailbox));
     dlg->setOptions(CertificateSelectionDialog::SingleSelection |
                     CertificateSelectionDialog::SignOnly |
                     CertificateSelectionDialog::SecretKeys |
                     dlg->options());
     return dlg;
 }
 
 static QString make_top_label_conflict_text(bool sign, bool enc)
 {
     return
         sign && enc ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for all recipients/senders of the message.\n"
                            "Please select the correct certificates for each recipient:") :
         sign        ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for the sender of the message.\n"
                            "Please select the correct certificates for the sender:") :
         enc         ? i18n("Kleopatra cannot unambiguously determine matching certificates "
                            "for all recipients of the message.\n"
                            "Please select the correct certificates for each recipient:") :
         /* else */ (kleo_assert_fail(sign || enc), QString());
 }
 
 static QString make_top_label_quickmode_text(bool sign, bool enc)
 {
     return
         enc    ? i18n("Please verify that correct certificates have been selected for each recipient:") :
         sign   ? i18n("Please verify that the correct certificate has been selected for the sender:") :
         /*else*/ (kleo_assert_fail(sign || enc), QString());
 }
 
 class SignEncryptEMailConflictDialog::Private
 {
     friend class ::Kleo::Crypto::Gui::SignEncryptEMailConflictDialog;
     SignEncryptEMailConflictDialog *const q;
 public:
     explicit Private(SignEncryptEMailConflictDialog *qq)
         : q(qq),
           senders(),
           recipients(),
           sign(true),
           encrypt(true),
           presetProtocol(UnknownProtocol),
           ui(q)
     {
 
     }
 
 private:
     void updateTopLabelText()
     {
         ui.conflictTopLB.setText(make_top_label_conflict_text(sign, encrypt));
         ui.quickModeTopLB.setText(make_top_label_quickmode_text(sign, encrypt));
     }
 
     void showHideWidgets()
     {
         const Protocol proto = q->selectedProtocol();
         const bool quickMode = q->isQuickMode();
 
         const bool needProtocolSelection = presetProtocol == UnknownProtocol;
 
         const bool needShowAllRecipientsCB =
             quickMode             ? false :
             needProtocolSelection ? needShowAllRecipients(OpenPGP) || needShowAllRecipients(CMS) :
             /* else */              needShowAllRecipients(proto)
             ;
 
         ui.showAllRecipientsCB.setVisible(needShowAllRecipientsCB);
 
         ui.pgpRB.setVisible(needProtocolSelection);
         ui.cmsRB.setVisible(needProtocolSelection);
 
         const bool showAll = !needShowAllRecipientsCB || ui.showAllRecipientsCB.isChecked();
 
         bool first;
         first = true;
         Q_FOREACH (const CertificateSelectionLine &line, ui.signers) {
             line.showHide(proto, first, showAll, sign);
         }
         ui.selectSigningCertificatesGB.setVisible(sign && (showAll || !first));
 
         first = true;
         Q_FOREACH (const CertificateSelectionLine &line, ui.recipients) {
             line.showHide(proto, first, showAll, encrypt);
         }
         ui.selectEncryptionCertificatesGB.setVisible(encrypt && (showAll || !first));
     }
 
     bool needShowAllRecipients(Protocol proto) const
     {
         if (sign) {
             if (const unsigned int num = std::count_if(ui.signers.cbegin(), ui.signers.cend(),
                                                        [proto](const CertificateSelectionLine &l) {
                                                            return l.wasInitiallyAmbiguous(proto);
                                                        })) {
                 if (num != ui.signers.size()) {
                     return true;
                 }
             }
         }
         if (encrypt) {
             if (const unsigned int num = std::count_if(ui.recipients.cbegin(), ui.recipients.cend(),
                                                       [proto](const CertificateSelectionLine &l) {
                                                           return l.wasInitiallyAmbiguous(proto);
                                                       })) {
                 if (num != ui.recipients.size()) {
                     return true;
                 }
             }
         }
         return false;
     }
 
     void createSendersAndRecipients()
     {
         ui.clearSendersAndRecipients();
 
         ui.addSelectSigningCertificatesGB();
         for (const Sender &s : qAsConst(senders)) {
             addSigner(s);
         }
 
         ui.addSelectEncryptionCertificatesGB();
         for (const Sender &s : qAsConst(senders)) {
             addRecipient(s);
         }
         for (const Recipient &r : qAsConst(recipients)) {
             addRecipient(r);
         }
     }
 
     void addSigner(const Sender &s)
     {
         ui.addSigner(s.mailbox().prettyAddress(),
                      s.signingCertificateCandidates(OpenPGP),
                      s.isSigningAmbiguous(OpenPGP),
                      s.signingCertificateCandidates(CMS),
                      s.isSigningAmbiguous(CMS),
                      q);
     }
 
     void addRecipient(const Sender &s)
     {
         ui.addRecipient(s.mailbox().prettyAddress(),
                         s.encryptToSelfCertificateCandidates(OpenPGP),
                         s.isEncryptionAmbiguous(OpenPGP),
                         s.encryptToSelfCertificateCandidates(CMS),
                         s.isEncryptionAmbiguous(CMS),
                         q);
     }
 
     void addRecipient(const Recipient &r)
     {
         ui.addRecipient(r.mailbox().prettyAddress(),
                         r.encryptionCertificateCandidates(OpenPGP),
                         r.isEncryptionAmbiguous(OpenPGP),
                         r.encryptionCertificateCandidates(CMS),
                         r.isEncryptionAmbiguous(CMS),
                         q);
     }
 
     bool isComplete(Protocol proto) const;
 
 private:
 
     void updateComplianceStatus()
     {
         if (q->selectedProtocol() == UnknownProtocol ||
             (q->resolvedSigningKeys().empty() && q->resolvedEncryptionKeys().empty())) {
             return;
         }
         // Handle compliance
         bool de_vs = true;
         for (const auto &key: q->resolvedSigningKeys()) {
             if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                 de_vs = false;
                 break;
             }
         }
         if (de_vs) {
             for (const auto &key: q->resolvedEncryptionKeys()) {
                 if (!IS_DE_VS(key) || keyValidity(key) < GpgME::UserID::Validity::Full) {
                     de_vs = false;
                     break;
                 }
             }
         }
 
         auto btn = ui.buttonBox.button(QDialogButtonBox::Ok);
 
         btn->setIcon(QIcon::fromTheme(de_vs
                     ? QStringLiteral("security-high")
                     : QStringLiteral("security-medium")));
         btn->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                     ? KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                     : KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
         ui.complianceLB.setText(de_vs
-                ? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
-                    "VS-NfD-compliant communication possible.")
-                : i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
-                    "VS-NfD-compliant communication not possible."));
+                ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                    "%1 communication possible.", Formatting::deVsString())
+                : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                    "%1 communication not possible.", Formatting::deVsString()));
         ui.complianceLB.setVisible(true);
     }
 
     void updateDialogStatus()
     {
         ui.setOkButtonEnabled(q->isComplete());
         if (Kleo::gpgComplianceP("de-vs")) {
             updateComplianceStatus();
         }
     }
     void slotCompleteChanged()
     {
         updateDialogStatus();
     }
     void slotShowAllRecipientsToggled(bool)
     {
         showHideWidgets();
     }
     void slotProtocolChanged()
     {
         showHideWidgets();
         updateDialogStatus();
     }
     void slotCertificateSelectionDialogRequested()
     {
         const QObject *const s = q->sender();
         const Protocol proto = q->selectedProtocol();
         QPointer<CertificateSelectionDialog> dlg;
         Q_FOREACH (const CertificateSelectionLine &l, ui.signers)
             if (s == l.toolButton()) {
                 dlg = create_signing_certificate_selection_dialog(q, proto, l.mailboxText());
                 if (dlg->exec()) {
                     l.addAndSelectCertificate(dlg->selectedCertificate());
                 }
                 // ### switch to key.protocol(), in case proto == UnknownProtocol
                 break;
             }
         Q_FOREACH (const CertificateSelectionLine &l, ui.recipients)
             if (s == l.toolButton()) {
                 dlg = create_encryption_certificate_selection_dialog(q, proto, l.mailboxText());
                 if (dlg->exec()) {
                     l.addAndSelectCertificate(dlg->selectedCertificate());
                 }
                 // ### switch to key.protocol(), in case proto == UnknownProtocol
                 break;
             }
 #ifndef Q_OS_WIN
         // This leads to a crash on Windows. We don't really
         // leak memory here anyway because the destruction of the
         // dialog happens when the parent (q) is destroyed anyway.
         delete dlg;
 #endif
     }
 
 private:
     std::vector<Sender> senders;
     std::vector<Recipient> recipients;
 
     bool sign : 1;
     bool encrypt : 1;
     Protocol presetProtocol;
 
 private:
     struct Ui {
         QLabel conflictTopLB, quickModeTopLB;
         QCheckBox showAllRecipientsCB;
         QRadioButton pgpRB, cmsRB;
         QGroupBox selectSigningCertificatesGB;
         QGroupBox selectEncryptionCertificatesGB;
         QCheckBox quickModeCB;
         QDialogButtonBox buttonBox;
         QVBoxLayout vlay;
         QHBoxLayout  hlay;
         QHBoxLayout  hlay2;
         QGridLayout  glay;
         std::vector<CertificateSelectionLine> signers, recipients;
         QLabel complianceLB;
 
         void setOkButtonEnabled(bool enable)
         {
             return buttonBox.button(QDialogButtonBox::Ok)->setEnabled(enable);
         }
 
         explicit Ui(SignEncryptEMailConflictDialog *q)
             : conflictTopLB(make_top_label_conflict_text(true, true), q),
               quickModeTopLB(make_top_label_quickmode_text(true, true), q),
               showAllRecipientsCB(i18n("Show all recipients"), q),
               pgpRB(i18n("OpenPGP"), q),
               cmsRB(i18n("S/MIME"), q),
               selectSigningCertificatesGB(i18n("Select Signing Certificate"), q),
               selectEncryptionCertificatesGB(i18n("Select Encryption Certificate"), q),
               quickModeCB(i18n("Only show this dialog in case of conflicts (experimental)"), q),
               buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, q),
               vlay(q),
               hlay(),
               glay(),
               signers(),
               recipients()
         {
             KDAB_SET_OBJECT_NAME(conflictTopLB);
             KDAB_SET_OBJECT_NAME(quickModeTopLB);
             KDAB_SET_OBJECT_NAME(showAllRecipientsCB);
             KDAB_SET_OBJECT_NAME(pgpRB);
             KDAB_SET_OBJECT_NAME(cmsRB);
             KDAB_SET_OBJECT_NAME(selectSigningCertificatesGB);
             KDAB_SET_OBJECT_NAME(selectEncryptionCertificatesGB);
             KDAB_SET_OBJECT_NAME(quickModeCB);
             KDAB_SET_OBJECT_NAME(buttonBox);
             KDAB_SET_OBJECT_NAME(hlay);
             KDAB_SET_OBJECT_NAME(glay);
             KDAB_SET_OBJECT_NAME(vlay);
 
             q->setWindowTitle(i18nc("@title:window", "Select Certificates for Message"));
 
             conflictTopLB.hide();
 
             selectSigningCertificatesGB.setFlat(true);
             selectEncryptionCertificatesGB.setFlat(true);
             selectSigningCertificatesGB.setAlignment(Qt::AlignCenter);
             selectEncryptionCertificatesGB.setAlignment(Qt::AlignCenter);
 
             glay.setColumnStretch(2, 1);
             glay.setColumnStretch(3, 1);
 
             vlay.setSizeConstraint(QLayout::SetMinimumSize);
 
             vlay.addWidget(&conflictTopLB);
             vlay.addWidget(&quickModeTopLB);
 
             hlay.addWidget(&showAllRecipientsCB);
             hlay.addStretch(1);
             hlay.addWidget(&pgpRB);
             hlay.addWidget(&cmsRB);
             vlay.addLayout(&hlay);
 
             addSelectSigningCertificatesGB();
             addSelectEncryptionCertificatesGB();
             vlay.addLayout(&glay);
 
             vlay.addStretch(1);
 
             complianceLB.setVisible(false);
             hlay2.addStretch(1);
             hlay2.addWidget(&complianceLB, 0, Qt::AlignRight);
             hlay2.addWidget(&buttonBox, 0, Qt::AlignRight);
 
             vlay.addWidget(&quickModeCB, 0, Qt::AlignRight);
             vlay.addLayout(&hlay2);
 
 
             connect(&buttonBox, &QDialogButtonBox::accepted, q, &SignEncryptEMailConflictDialog::accept);
             connect(&buttonBox, &QDialogButtonBox::rejected, q, &SignEncryptEMailConflictDialog::reject);
 
             connect(&showAllRecipientsCB, SIGNAL(toggled(bool)), q, SLOT(slotShowAllRecipientsToggled(bool)));
             connect(&pgpRB, SIGNAL(toggled(bool)),
                     q, SLOT(slotProtocolChanged()));
             connect(&cmsRB, SIGNAL(toggled(bool)),
                     q, SLOT(slotProtocolChanged()));
         }
 
         void clearSendersAndRecipients()
         {
             std::vector<CertificateSelectionLine> sig, enc;
             sig.swap(signers);
             enc.swap(recipients);
             std::for_each(sig.begin(), sig.end(), std::mem_fn(&CertificateSelectionLine::kill));
             std::for_each(enc.begin(), enc.end(), std::mem_fn(&CertificateSelectionLine::kill));
             glay.removeWidget(&selectSigningCertificatesGB);
             glay.removeWidget(&selectEncryptionCertificatesGB);
         }
 
         void addSelectSigningCertificatesGB()
         {
             glay.addWidget(&selectSigningCertificatesGB,    glay.rowCount(), 0, 1, CertificateSelectionLine::NumColumns);
         }
         void addSelectEncryptionCertificatesGB()
         {
             glay.addWidget(&selectEncryptionCertificatesGB, glay.rowCount(), 0, 1, CertificateSelectionLine::NumColumns);
         }
 
         void addSigner(const QString &mailbox,
                        const std::vector<Key> &pgp, bool pgpAmbiguous,
                        const std::vector<Key> &cms, bool cmsAmbiguous, QWidget *q)
         {
             CertificateSelectionLine line(i18n("From:"), mailbox, pgp, pgpAmbiguous, cms, cmsAmbiguous, q, glay);
             signers.push_back(line);
         }
 
         void addRecipient(const QString &mailbox,
                           const std::vector<Key> &pgp, bool pgpAmbiguous,
                           const std::vector<Key> &cms, bool cmsAmbiguous, QWidget *q)
         {
             CertificateSelectionLine line(i18n("To:"), mailbox, pgp, pgpAmbiguous, cms, cmsAmbiguous, q, glay);
             recipients.push_back(line);
         }
 
     } ui;
 };
 
 SignEncryptEMailConflictDialog::SignEncryptEMailConflictDialog(QWidget *parent)
     : QDialog(parent), d(new Private(this))
 {
 
 }
 
 SignEncryptEMailConflictDialog::~SignEncryptEMailConflictDialog() {}
 
 void SignEncryptEMailConflictDialog::setPresetProtocol(Protocol p)
 {
     if (p == d->presetProtocol) {
         return;
     }
     const QSignalBlocker pgpBlocker(d->ui.pgpRB);
     const QSignalBlocker cmsBlocker(d->ui.cmsRB);
     really_check(d->ui.pgpRB, p == OpenPGP);
     really_check(d->ui.cmsRB, p == CMS);
     d->presetProtocol = p;
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 Protocol SignEncryptEMailConflictDialog::selectedProtocol() const
 {
     if (d->presetProtocol != UnknownProtocol) {
         return d->presetProtocol;
     }
     if (d->ui.pgpRB.isChecked()) {
         return OpenPGP;
     }
     if (d->ui.cmsRB.isChecked()) {
         return CMS;
     }
     return UnknownProtocol;
 }
 
 void SignEncryptEMailConflictDialog::setSubject(const QString &subject)
 {
     setWindowTitle(i18nc("@title:window", "Select Certificates for Message \"%1\"", subject));
 }
 
 void SignEncryptEMailConflictDialog::setSign(bool sign)
 {
     if (sign == d->sign) {
         return;
     }
     d->sign = sign;
     d->updateTopLabelText();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setEncrypt(bool encrypt)
 {
     if (encrypt == d->encrypt) {
         return;
     }
     d->encrypt = encrypt;
     d->updateTopLabelText();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setSenders(const std::vector<Sender> &senders)
 {
     if (senders == d->senders) {
         return;
     }
     d->senders = senders;
     d->createSendersAndRecipients();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::setRecipients(const std::vector<Recipient> &recipients)
 {
     if (d->recipients == recipients) {
         return;
     }
     d->recipients = recipients;
     d->createSendersAndRecipients();
     d->showHideWidgets();
     d->updateDialogStatus();
 }
 
 void SignEncryptEMailConflictDialog::pickProtocol()
 {
 
     if (selectedProtocol() != UnknownProtocol) {
         return;    // already picked
     }
 
     const bool pgp = d->isComplete(OpenPGP);
     const bool cms = d->isComplete(CMS);
 
     if (pgp && !cms) {
         d->ui.pgpRB.setChecked(true);
     } else if (cms && !pgp) {
         d->ui.cmsRB.setChecked(true);
     }
 }
 
 bool SignEncryptEMailConflictDialog::isComplete() const
 {
     const Protocol proto = selectedProtocol();
     return proto != UnknownProtocol && d->isComplete(proto);
 }
 
 bool SignEncryptEMailConflictDialog::Private::isComplete(Protocol proto) const
 {
     return (!sign || std::none_of(ui.signers.cbegin(), ui.signers.cend(),
                                   [proto](const CertificateSelectionLine &l) {
                                       return l.isStillAmbiguous(proto);
                                   }))
            && (!encrypt || std::none_of(ui.recipients.cbegin(), ui.recipients.cend(),
                                         [proto](const CertificateSelectionLine &l) {
                                             return l.isStillAmbiguous(proto);
                                         }));
 }
 
 static std::vector<Key> get_keys(const std::vector<CertificateSelectionLine> &lines, Protocol proto)
 {
     if (proto == UnknownProtocol) {
         return std::vector<Key>();
     }
     Q_ASSERT(proto == OpenPGP || proto == CMS);
 
     std::vector<Key> keys;
     keys.reserve(lines.size());
     std::transform(lines.cbegin(), lines.cend(), std::back_inserter(keys),
                    [proto](const CertificateSelectionLine &l) {
                        return l.key(proto);
                    });
     return keys;
 }
 
 std::vector<Key> SignEncryptEMailConflictDialog::resolvedSigningKeys() const
 {
     return d->sign    ? get_keys(d->ui.signers,    selectedProtocol()) : std::vector<Key>();
 }
 
 std::vector<Key> SignEncryptEMailConflictDialog::resolvedEncryptionKeys() const
 {
     return d->encrypt ? get_keys(d->ui.recipients, selectedProtocol()) : std::vector<Key>();
 }
 
 void SignEncryptEMailConflictDialog::setQuickMode(bool on)
 {
     d->ui.quickModeCB.setChecked(on);
 }
 
 bool SignEncryptEMailConflictDialog::isQuickMode() const
 {
     return d->ui.quickModeCB.isChecked();
 }
 
 void SignEncryptEMailConflictDialog::setConflict(bool conflict)
 {
     d->ui.conflictTopLB.setVisible(conflict);
     d->ui.quickModeTopLB.setVisible(!conflict);
 }
 
 #include "moc_signencryptemailconflictdialog.cpp"
diff --git a/src/crypto/gui/signencryptfileswizard.cpp b/src/crypto/gui/signencryptfileswizard.cpp
index 80d1042ba..31d87b968 100644
--- a/src/crypto/gui/signencryptfileswizard.cpp
+++ b/src/crypto/gui/signencryptfileswizard.cpp
@@ -1,517 +1,518 @@
 /*  crypto/gui/signencryptfileswizard.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2009 Klarälvdalens Datakonsult AB
 
     SPDX-FileCopyrightText: 2016 Bundesamt für Sicherheit in der Informationstechnik
     SPDX-FileContributor: Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "signencryptfileswizard.h"
 #include "signencryptwidget.h"
 
 #include "newresultpage.h"
 
 #include <KLocalizedString>
 #include <KSharedConfig>
 #include <KColorScheme>
 #include <KConfigGroup>
 #include <KWindowConfig>
 
 #include <KMessageBox>
 
 #include "kleopatra_debug.h"
 #include <Libkleo/GnuPG>
+#include <Libkleo/Formatting>
 
 #include <Libkleo/FileNameRequester>
 #include <QWindow>
 #include <QVBoxLayout>
 #include <QWizardPage>
 #include <QGroupBox>
 #include <QLabel>
 #include <QIcon>
 #include <QCheckBox>
 
 
 #include <gpgme++/key.h>
 
 
 using namespace GpgME;
 using namespace Kleo;
 using namespace Kleo::Crypto::Gui;
 
 enum Page {
     SigEncPageId,
     ResultPageId,
 
     NumPages
 };
 
 class SigEncPage: public QWizardPage
 {
     Q_OBJECT
 
 public:
     explicit SigEncPage(QWidget *parent = nullptr)
         : QWizardPage(parent),
           mParent((SignEncryptFilesWizard *) parent),
           mWidget(new SignEncryptWidget),
           mOutLayout(new QVBoxLayout),
           mArchive(false),
           mUseOutputDir(false)
     {
         setTitle(i18nc("@title", "Sign / Encrypt Files"));
         auto vLay = new QVBoxLayout(this);
         vLay->setContentsMargins(0, 0, 0, 0);
         vLay->addWidget(mWidget);
         connect(mWidget, &SignEncryptWidget::operationChanged, this,
                 &SigEncPage::updateCommitButton);
         connect(mWidget, &SignEncryptWidget::keysChanged, this,
                 &SigEncPage::updateFileWidgets);
         updateCommitButton(mWidget->currentOp());
 
         auto outputGrp = new QGroupBox(i18n("Output"));
         outputGrp->setLayout(mOutLayout);
 
         mPlaceholderWidget = new QLabel(i18n("Please select an action."));
         mOutLayout->addWidget(mPlaceholderWidget);
 
         mUseOutputDirChk = new QCheckBox(i18n("Encrypt / Sign each file separately."));
         mUseOutputDirChk->setToolTip(i18nc("@info",
                                             "Keep each file separate instead of creating an archive for all."));
 
         mOutLayout->addWidget(mUseOutputDirChk);
         connect (mUseOutputDirChk, &QCheckBox::toggled, this, [this] (bool state) {
                     mUseOutputDir = state;
                     mArchive = !mUseOutputDir;
                     updateFileWidgets();
                 });
 
         vLay->addWidget(outputGrp);
         setMinimumHeight(300);
     }
 
     void setEncryptionPreset(bool value)
     {
         mWidget->setEncryptionChecked(value);
     }
 
     void setSigningPreset(bool value)
     {
         mWidget->setSigningChecked(value);
     }
 
     bool isComplete() const override
     {
         return !mWidget->currentOp().isNull();
     }
 
     int nextId() const override
     {
         return ResultPageId;
     }
 
     void initializePage() override
     {
         setCommitPage(true);
     }
 
     void setArchiveForced(bool archive)
     {
         mArchive = archive;
         setArchiveMutable(!archive);
     }
 
     void setArchiveMutable(bool archive)
     {
         mUseOutputDirChk->setVisible(archive);
         if (archive) {
             const KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             mUseOutputDirChk->setChecked(archCfg.readEntry("LastUseOutputDir", false));
         } else {
             mUseOutputDirChk->setChecked(false);
         }
     }
 
     bool validatePage() override
     {
         bool sign = !mWidget->signKey().isNull();
         bool encrypt = !mWidget->selfKey().isNull() || !mWidget->recipients().empty();
         if (!mWidget->validate()) {
             return false;
         }
         mWidget->saveOwnKeys();
         if (mUseOutputDirChk->isVisible()) {
             KConfigGroup archCfg(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
             archCfg.writeEntry("LastUseOutputDir", mUseOutputDir);
         }
 
         if (sign && !encrypt && mArchive) {
             return KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>Archiving in combination with sign-only currently requires what are known as opaque signatures - "
             "unlike detached ones, these embed the content in the signature.</para>"
             "<para>This format is rather unusual. You might want to archive the files separately, "
             "and then sign the archive as one file with Kleopatra.</para>"
             "<para>Future versions of Kleopatra are expected to also support detached signatures in this case.</para>"),
             i18nc("@title:window", "Unusual Signature Warning"),
             KStandardGuiItem::cont(), KStandardGuiItem::cancel(),
             QStringLiteral("signencryptfileswizard-archive+sign-only-warning"))
             == KMessageBox::Continue;
         } else if (sign && !encrypt) {
             return true;
         }
 
         if (!mWidget->selfKey().isNull()) {
             return true;
         }
         bool hasSecret = false;
         Q_FOREACH (const Key k, mWidget->recipients()) {
             if (k.hasSecret()) {
                 hasSecret = true;
                 break;
             }
         }
         if (!hasSecret && !mWidget->encryptSymmetric()) {
             if (KMessageBox::warningContinueCancel(this,
             xi18nc("@info",
             "<para>None of the recipients you are encrypting to seems to be your own.</para>"
             "<para>This means that you will not be able to decrypt the data anymore, once encrypted.</para>"
             "<para>Do you want to continue, or cancel to change the recipient selection?</para>"),
             i18nc("@title:window", "Encrypt-To-Self Warning"),
             KStandardGuiItem::cont(),
             KStandardGuiItem::cancel(),
             QStringLiteral("warn-encrypt-to-non-self"), KMessageBox::Notify | KMessageBox::Dangerous)
             == KMessageBox::Cancel) {
                 return false;
             }
         }
         return true;
     }
 
     QVector<Key> recipients() const
     {
         return mWidget->recipients();
     }
 
     /* In the future we might find a usecase for multiple
      * signers */
     QVector<Key> signers() const
     {
         QVector<Key> ret;
         const Key k = mWidget->signKey();
         if (!k.isNull()) {
             ret << k;
         }
         return ret;
     }
 
 private:
     QWidget *createRequester(int forKind, QBoxLayout *lay) {
         static const QMap <int, QString> icons = {
             { SignEncryptFilesWizard::SignatureCMS, QStringLiteral("document-sign") },
             { SignEncryptFilesWizard::SignaturePGP, QStringLiteral("document-sign") },
             { SignEncryptFilesWizard::CombinedPGP,  QStringLiteral("document-edit-sign-encrypt") },
             { SignEncryptFilesWizard::EncryptedPGP, QStringLiteral("document-encrypt") },
             { SignEncryptFilesWizard::EncryptedCMS, QStringLiteral("document-encrypt") },
             { SignEncryptFilesWizard::Directory,    QStringLiteral("folder") }
         };
         static const QMap <int, QString> toolTips = {
             { SignEncryptFilesWizard::SignatureCMS, i18n("The S/MIME signature.") },
             { SignEncryptFilesWizard::SignaturePGP, i18n("The signature.") },
             { SignEncryptFilesWizard::CombinedPGP,  i18n("The signed and encrypted file.") },
             { SignEncryptFilesWizard::EncryptedPGP, i18n("The encrypted file.") },
             { SignEncryptFilesWizard::EncryptedCMS, i18n("The S/MIME encrypted file.") },
             { SignEncryptFilesWizard::Directory,    i18n("Output directory.") }
         };
 
         FileNameRequester *req = new FileNameRequester(forKind == SignEncryptFilesWizard::Directory ?
                                                        QDir::Dirs : QDir::Files, this);
         req->setFileName(mOutNames[forKind]);
         QHBoxLayout *hLay = new QHBoxLayout;
         QLabel *iconLabel = new QLabel;
         QWidget *ret = new QWidget;
         iconLabel->setPixmap(QIcon::fromTheme(icons[forKind]).pixmap(32,32));
         hLay->addWidget(iconLabel);
         iconLabel->setToolTip(toolTips[forKind]);
         req->setToolTip(toolTips[forKind]);
         hLay->addWidget(req);
         ret->setLayout(hLay);
         lay->addWidget(ret);
 
         connect (req, &FileNameRequester::fileNameChanged, this,
                  [this, forKind](const QString &newName) {
                     mOutNames[forKind] = newName;
                  });
         return ret;
     }
 
 public:
     void setOutputNames(const QMap<int, QString> &names) {
         Q_ASSERT(mOutNames.isEmpty());
         mOutNames = names;
         Q_FOREACH (int i, mOutNames.keys()) {
             mRequester[i] = createRequester(i, mOutLayout);
         }
         updateFileWidgets();
     }
 
     QMap <int, QString> outputNames() const {
         if (!mUseOutputDir) {
             auto ret = mOutNames;
             ret.remove(SignEncryptFilesWizard::Directory);
             return ret;
         }
         return mOutNames;
     }
 
     bool encryptSymmetric() const
     {
         return mWidget->encryptSymmetric();
     }
 
 private Q_SLOTS:
     void updateCommitButton(const QString &label)
     {
         auto btn = mParent->button(QWizard::CommitButton);
         if (!label.isEmpty()) {
             btn->setText(label);
             if (Kleo::gpgComplianceP("de-vs")) {
                 bool de_vs = mWidget->isDeVsAndValid();
                 btn->setIcon(QIcon::fromTheme(de_vs
                                              ? QStringLiteral("security-high")
                                              : QStringLiteral("security-medium")));
                 btn->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                                    ? KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                                    : KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
                 mParent->setLabelText(de_vs
-                                      ? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
-                                              "VS-NfD-compliant communication possible.")
-                                      : i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
-                                              "VS-NfD-compliant communication not possible."));
+                        ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                            "%1 communication possible.", Formatting::deVsString())
+                        : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                            "%1 communication not possible.", Formatting::deVsString()));
             }
         } else {
             btn->setText(i18n("Next"));
             btn->setIcon(QIcon());
             btn->setStyleSheet(QString());
         }
         Q_EMIT completeChanged();
     }
 
     void updateFileWidgets()
     {
         if (mRequester.isEmpty()) {
             return;
         }
         const QVector<Key> recipients = mWidget->recipients();
         const Key sigKey = mWidget->signKey();
         bool pgp = mWidget->encryptSymmetric();
         bool cms = false;
 
         for (const Key &k : recipients) {
             if (pgp && cms) {
                 break;
             }
             if (k.protocol() == Protocol::OpenPGP) {
                 pgp = true;
             } else {
                 cms = true;
             }
         }
         mOutLayout->setEnabled(false);
         mPlaceholderWidget->setVisible(!cms && !pgp && sigKey.isNull());
         mRequester[SignEncryptFilesWizard::SignatureCMS]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::CMS);
         mRequester[SignEncryptFilesWizard::EncryptedCMS]->setVisible(!mUseOutputDir && cms);
         mRequester[SignEncryptFilesWizard::CombinedPGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && pgp);
         mRequester[SignEncryptFilesWizard::EncryptedPGP]->setVisible(!mUseOutputDir && pgp && sigKey.protocol() != Protocol::OpenPGP);
         mRequester[SignEncryptFilesWizard::SignaturePGP]->setVisible(!mUseOutputDir && sigKey.protocol() == Protocol::OpenPGP && !pgp);
         mRequester[SignEncryptFilesWizard::Directory]->setVisible(mUseOutputDir && !mPlaceholderWidget->isVisible());
         mOutLayout->setEnabled(true);
     }
 
 private:
     SignEncryptFilesWizard *mParent;
     SignEncryptWidget *mWidget;
     QMap <int, QString> mOutNames;
     QMap <int, QWidget *> mRequester;
     QVBoxLayout *mOutLayout;
     QWidget *mPlaceholderWidget;
     QCheckBox *mUseOutputDirChk;
     bool mArchive;
     bool mUseOutputDir;
 };
 
 class ResultPage : public NewResultPage
 {
     Q_OBJECT
 
 public:
     explicit ResultPage(QWidget *parent = nullptr)
         : NewResultPage(parent),
           mParent((SignEncryptFilesWizard *) parent)
     {
         setTitle(i18nc("@title", "Results"));
         setSubTitle(i18nc("@title",
                           "Status and progress of the crypto operations is shown here."));
     }
 
     void initializePage() override
     {
         mParent->setLabelText(QString());
     }
 
 private:
     SignEncryptFilesWizard *mParent;
 };
 
 SignEncryptFilesWizard::SignEncryptFilesWizard(QWidget *parent, Qt::WindowFlags f)
     : QWizard(parent, f)
 {
     readConfig();
 
     bool de_vs = Kleo::gpgComplianceP("de-vs");
 #ifdef Q_OS_WIN
     // Enforce modern style to avoid vista style ugliness.
     setWizardStyle(QWizard::ModernStyle);
 #endif
     mSigEncPage = new SigEncPage(this);
     mResultPage = new ResultPage(this);
 
     connect(this, &QWizard::currentIdChanged, this,
             &SignEncryptFilesWizard::slotCurrentIdChanged);
     setPage(SigEncPageId, mSigEncPage);
     setPage(ResultPageId, mResultPage);
     setOptions(QWizard::IndependentPages |
                (de_vs ? QWizard::HaveCustomButton1 : (QWizard::WizardOption) 0) |
                QWizard::NoBackButtonOnLastPage |
                QWizard::NoBackButtonOnStartPage);
 
     if (de_vs) {
         /* We use a custom button to display a label next to the
            buttons.  */
         mLabel = button(QWizard::CustomButton1);
         /* We style the button so that it looks and acts like a
            label.  */
         mLabel->setStyleSheet(QStringLiteral("border: none"));
         mLabel->setFocusPolicy(Qt::NoFocus);
     } else {
         mLabel = nullptr;
     }
 }
 
 void SignEncryptFilesWizard::setLabelText(const QString &label) const
 {
     if (mLabel) {
         mLabel->setText(label);
     }
 }
 
 void SignEncryptFilesWizard::slotCurrentIdChanged(int id)
 {
     if (id == ResultPageId) {
         Q_EMIT operationPrepared();
     }
 }
 
 SignEncryptFilesWizard::~SignEncryptFilesWizard()
 {
     qCDebug(KLEOPATRA_LOG);
     writeConfig();
 }
 
 void SignEncryptFilesWizard::setSigningPreset(bool preset)
 {
     mSigEncPage->setSigningPreset(preset);
 }
 
 void SignEncryptFilesWizard::setSigningUserMutable(bool mut)
 {
     if (mut == mSigningUserMutable) {
         return;
     }
     mSigningUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setEncryptionPreset(bool preset)
 {
     mSigEncPage->setEncryptionPreset(preset);
 }
 
 void SignEncryptFilesWizard::setEncryptionUserMutable(bool mut)
 {
     if (mut == mEncryptionUserMutable) {
         return;
     }
     mEncryptionUserMutable = mut;
 }
 
 void SignEncryptFilesWizard::setArchiveForced(bool archive)
 {
     mSigEncPage->setArchiveForced(archive);
 }
 
 void SignEncryptFilesWizard::setArchiveMutable(bool archive)
 {
     mSigEncPage->setArchiveMutable(archive);
 }
 
 QVector<Key> SignEncryptFilesWizard::resolvedRecipients() const
 {
     return mSigEncPage->recipients();
 }
 
 QVector<Key> SignEncryptFilesWizard::resolvedSigners() const
 {
     return mSigEncPage->signers();
 }
 
 void SignEncryptFilesWizard::setTaskCollection(const std::shared_ptr<Kleo::Crypto::TaskCollection> &coll)
 {
     mResultPage->setTaskCollection(coll);
 }
 
 void SignEncryptFilesWizard::setOutputNames(const QMap<int, QString> &map) const
 {
     mSigEncPage->setOutputNames(map);
 }
 
 QMap<int, QString> SignEncryptFilesWizard::outputNames() const
 {
     return mSigEncPage->outputNames();
 }
 
 bool SignEncryptFilesWizard::encryptSymmetric() const
 {
     return mSigEncPage->encryptSymmetric();
 }
 
 void SignEncryptFilesWizard::readConfig()
 {
     winId(); // ensure there's a window created
 
     // set default window size
     windowHandle()->resize(640, 480);
 
     // restore size from config file
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
     KWindowConfig::restoreWindowSize(windowHandle(), cfgGroup);
 
     // NOTICE: QWindow::setGeometry() does NOT impact the backing QWidget geometry even if the platform
     // window was created -> QTBUG-40584. We therefore copy the size here.
     // TODO: remove once this was resolved in QWidget QPA
     resize(windowHandle()->size());
 }
 
 void SignEncryptFilesWizard::writeConfig()
 {
     KConfigGroup cfgGroup(KSharedConfig::openConfig(), "SignEncryptFilesWizard");
     KWindowConfig::saveWindowSize(windowHandle(), cfgGroup);
     cfgGroup.sync();
 }
 
 
 #include "signencryptfileswizard.moc"
diff --git a/src/mainwindow.cpp b/src/mainwindow.cpp
index 2bb6b5cb8..c00f3cb51 100644
--- a/src/mainwindow.cpp
+++ b/src/mainwindow.cpp
@@ -1,674 +1,672 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     mainwindow.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2007 Klarälvdalens Datakonsult AB
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 
 #include <config-kleopatra.h>
 
 #include "mainwindow.h"
 #include "aboutdata.h"
 
 #include "view/padwidget.h"
 #include "view/searchbar.h"
 #include "view/tabwidget.h"
 #include "view/keylistcontroller.h"
 #include "view/keycacheoverlay.h"
 #include "view/smartcardwidget.h"
 #include "view/welcomewidget.h"
 
 #include "commands/selftestcommand.h"
 #include "commands/importcrlcommand.h"
 #include "commands/importcertificatefromfilecommand.h"
 #include "commands/decryptverifyfilescommand.h"
 #include "commands/signencryptfilescommand.h"
 
 #include "utils/detail_p.h"
 #include <Libkleo/GnuPG>
 #include "utils/action_data.h"
 #include "utils/filedialog.h"
 #include "utils/clipboardmenu.h"
 
 #include "dialogs/updatenotification.h"
 
 #include <KXMLGUIFactory>
 #include <QApplication>
 #include <QSize>
 #include <QLineEdit>
 #include <KActionMenu>
 #include <KActionCollection>
 #include <KLocalizedString>
 #include <KStandardAction>
 #include <QAction>
 #include <KAboutData>
 #include <KMessageBox>
 #include <KStandardGuiItem>
 #include <KShortcutsDialog>
 #include <KEditToolBar>
 #include "kleopatra_debug.h"
 #include <KConfigGroup>
 
 #include <QAbstractItemView>
 #include <QCloseEvent>
 #include <QMenu>
 #include <QTimer>
 #include <QProcess>
 #include <QVBoxLayout>
 #include <QMimeData>
 #include <QDesktopServices>
 #include <QDir>
 #include <QStackedWidget>
 #include <QStatusBar>
 #include <QLabel>
 
 #include <Libkleo/Formatting>
 #include <Libkleo/KeyListModel>
 #include <Libkleo/KeyListSortFilterProxyModel>
 #include <Libkleo/CryptoConfigDialog>
 #include <Libkleo/Stl_Util>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
 #include <QGpgME/CryptoConfig>
 #include <QGpgME/Protocol>
 
 #include <vector>
 #include <KSharedConfig>
 
 using namespace Kleo;
 using namespace Kleo::Commands;
 using namespace GpgME;
 
 static KGuiItem KStandardGuiItem_quit()
 {
     static const QString app = KAboutData::applicationData().componentName();
     KGuiItem item = KStandardGuiItem::quit();
     item.setText(i18nc("Quit [ApplicationName]", "&Quit %1", app));
     return item;
 }
 
 static KGuiItem KStandardGuiItem_close()
 {
     KGuiItem item = KStandardGuiItem::close();
     item.setText(i18n("Only &Close Window"));
     return item;
 }
 
 static bool isQuitting = false;
 
 class MainWindow::Private
 {
     friend class ::MainWindow;
     MainWindow *const q;
 
 public:
     explicit Private(MainWindow *qq);
     ~Private();
 
     template <typename T>
     void createAndStart()
     {
         (new T(this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(QAbstractItemView *view)
     {
         (new T(view, &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a)
     {
         (new T(a, this->currentView(), &this->controller))->start();
     }
     template <typename T>
     void createAndStart(const QStringList &a, QAbstractItemView *view)
     {
         (new T(a, view, &this->controller))->start();
     }
 
     void closeAndQuit()
     {
         const QString app = KAboutData::applicationData().componentName();
         const int rc = KMessageBox::questionYesNoCancel(q,
                        i18n("%1 may be used by other applications as a service.\n"
                             "You may instead want to close this window without exiting %1.", app),
                        i18n("Really Quit?"), KStandardGuiItem_close(), KStandardGuiItem_quit(), KStandardGuiItem::cancel(),
                        QLatin1String("really-quit-") + app.toLower());
         if (rc == KMessageBox::Cancel) {
             return;
         }
         isQuitting = true;
         if (!q->close()) {
             return;
         }
         // WARNING: 'this' might be deleted at this point!
         if (rc == KMessageBox::No) {
             qApp->quit();
         }
     }
     void configureToolbars()
     {
         KEditToolBar dlg(q->factory());
         dlg.exec();
     }
     void editKeybindings()
     {
         KShortcutsDialog::configure(q->actionCollection(), KShortcutsEditor::LetterShortcutsAllowed);
         updateSearchBarClickMessage();
     }
 
     void updateSearchBarClickMessage()
     {
         const QString shortcutStr = focusToClickSearchAction->shortcut().toString();
         ui.searchBar->updateClickMessage(shortcutStr);
     }
 
     void updateStatusBar()
     {
         const auto complianceMode = Formatting::complianceMode();
-        if (!complianceMode.isEmpty()) {
+        if (complianceMode == QStringLiteral("de-vs")) {
             auto statusBar = new QStatusBar;
             q->setStatusBar(statusBar);
-            auto statusLbl = new QLabel(i18nc("Compliance means that GnuPG is running in a more restricted mode e.g. to handle restricted documents.",
-                                        // The germans want some extra sausage
-                                        "Compliance: %1", complianceMode == QLatin1String("de-vs") ? QStringLiteral ("VS-NfD") : complianceMode));
+            auto statusLbl = new QLabel(Formatting::deVsString());
             statusBar->insertPermanentWidget(0, statusLbl);
 
         } else {
             q->setStatusBar(nullptr);
         }
     }
 
     void selfTest()
     {
         createAndStart<SelfTestCommand>();
     }
     void configureBackend();
 
     void showHandbook();
 
     void gnupgLogViewer()
     {
         if (!QProcess::startDetached(QStringLiteral("kwatchgnupg"), QStringList()))
             KMessageBox::error(q, i18n("Could not start the GnuPG Log Viewer (kwatchgnupg). "
                                        "Please check your installation."),
                                i18n("Error Starting KWatchGnuPG"));
     }
 
     void forceUpdateCheck()
     {
         UpdateNotification::forceUpdateCheck(q);
     }
 
     void openCompendium()
     {
         QDir datadir(QCoreApplication::applicationDirPath() + QStringLiteral("/../share/gpg4win"));
         const auto path = datadir.filePath(i18nc("The Gpg4win compendium is only available"
                                                  "at this point (24.7.2017) in german and english."
                                                  "Please check with Gpg4win before translating this filename.",
                                                  "gpg4win-compendium-en.pdf"));
         qCDebug(KLEOPATRA_LOG) << "Opening Compendium at:" << path;
         // The compendium is always installed. So this should work. Otherwise
         // we have debug output.
         QDesktopServices::openUrl(QUrl::fromLocalFile(path));
     }
 
     void slotConfigCommitted();
     void slotContextMenuRequested(QAbstractItemView *, const QPoint &p)
     {
         if (QMenu *const menu = qobject_cast<QMenu *>(q->factory()->container(QStringLiteral("listview_popup"), q))) {
             menu->exec(p);
         } else {
             qCDebug(KLEOPATRA_LOG) << "no \"listview_popup\" <Menu> in kleopatra's ui.rc file";
         }
     }
 
     void slotFocusQuickSearch()
     {
         ui.searchBar->lineEdit()->setFocus();
     }
 
     void toggleSmartcardView()
     {
         const auto coll = q->actionCollection();
         if (coll) {
             auto act = coll->action(QStringLiteral("pad_view"));
             if (act) {
                 act->setChecked(false);
             }
         }
         if (ui.stackWidget->currentWidget() == ui.scWidget) {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
             checkWelcomePage();
             return;
         }
         ui.stackWidget->setCurrentWidget(ui.scWidget);
     }
 
     void togglePadView()
     {
         const auto coll = q->actionCollection();
         if (coll) {
             auto act = coll->action(QStringLiteral("manage_smartcard"));
             if (act) {
                 act->setChecked(false);
             }
         }
         if (ui.stackWidget->currentWidget() == ui.padWidget) {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
             checkWelcomePage();
             return;
         }
         if (!ui.padWidget) {
             ui.padWidget = new PadWidget;
             ui.stackWidget->addWidget(ui.padWidget);
         }
         ui.stackWidget->setCurrentWidget(ui.padWidget);
         ui.stackWidget->resize(ui.padWidget->sizeHint());
     }
 
 private:
     void setupActions();
 
     QAbstractItemView *currentView() const
     {
         return ui.tabWidget.currentView();
     }
 
     void checkWelcomePage()
     {
         const auto curWidget = ui.stackWidget->currentWidget();
         if (curWidget == ui.scWidget || curWidget == ui.padWidget) {
            return;
         }
         if (KeyCache::instance()->keys().empty()) {
             ui.stackWidget->setCurrentWidget(ui.welcomeWidget);
         } else {
             ui.stackWidget->setCurrentWidget(ui.searchTab);
         }
     }
 
 private:
     Kleo::KeyListController controller;
     bool firstShow : 1;
     struct UI {
         QWidget *searchTab;
         TabWidget tabWidget;
         SearchBar *searchBar;
         PadWidget *padWidget;
         SmartCardWidget *scWidget;
         WelcomeWidget *welcomeWidget;
         QStackedWidget *stackWidget;
         explicit UI(MainWindow *q);
     } ui;
     QAction *focusToClickSearchAction;
     ClipboardMenu *clipboadMenu;
 };
 
 MainWindow::Private::UI::UI(MainWindow *q)
     : tabWidget(q), padWidget(nullptr)
 {
     KDAB_SET_OBJECT_NAME(tabWidget);
 
     searchTab = new QWidget;
     QVBoxLayout *vbox = new QVBoxLayout(searchTab);
     vbox->setSpacing(0);
     searchBar = new SearchBar;
     vbox->addWidget(searchBar);
     tabWidget.connectSearchBar(searchBar);
     vbox->addWidget(&tabWidget);
 
     QWidget *mainWidget = new QWidget;
     auto mainLayout = new QVBoxLayout(mainWidget);
     stackWidget = new QStackedWidget;
 
     mainLayout->addWidget(stackWidget);
 
     stackWidget->addWidget(searchTab);
 
     new KeyCacheOverlay(mainWidget, q);
 
     scWidget = new SmartCardWidget();
     stackWidget->addWidget(scWidget);
 
     welcomeWidget = new WelcomeWidget();
     stackWidget->addWidget(welcomeWidget);
 
     q->setCentralWidget(mainWidget);
 }
 
 MainWindow::Private::Private(MainWindow *qq)
     : q(qq),
       controller(q),
       firstShow(true),
       ui(q)
 {
     KDAB_SET_OBJECT_NAME(controller);
 
     AbstractKeyListModel *flatModel = AbstractKeyListModel::createFlatKeyListModel(q);
     AbstractKeyListModel *hierarchicalModel = AbstractKeyListModel::createHierarchicalKeyListModel(q);
 
     KDAB_SET_OBJECT_NAME(flatModel);
     KDAB_SET_OBJECT_NAME(hierarchicalModel);
 
     controller.setFlatModel(flatModel);
     controller.setHierarchicalModel(hierarchicalModel);
     controller.setTabWidget(&ui.tabWidget);
 
     ui.tabWidget.setFlatModel(flatModel);
     ui.tabWidget.setHierarchicalModel(hierarchicalModel);
 
     ui.stackWidget->setCurrentWidget(ui.searchTab);
 
     setupActions();
 
     connect(&controller, SIGNAL(contextMenuRequested(QAbstractItemView*,QPoint)), q, SLOT(slotContextMenuRequested(QAbstractItemView*,QPoint)));
     connect(ui.scWidget, &SmartCardWidget::backRequested, q, [this]() {
             auto action = q->actionCollection()->action(QStringLiteral("manage_smartcard"));
             Q_ASSERT(action);
             action->setChecked(false);
         });
     connect(KeyCache::instance().get(), &KeyCache::keyListingDone, q, [this] () {checkWelcomePage();});
 
     q->createGUI(QStringLiteral("kleopatra.rc"));
 
     q->setAcceptDrops(true);
 
     // set default window size
     q->resize(QSize(1024, 500));
     q->setAutoSaveSettings();
 
     updateSearchBarClickMessage();
     updateStatusBar();
 }
 
 MainWindow::Private::~Private() {}
 
 MainWindow::MainWindow(QWidget *parent, Qt::WindowFlags flags)
     : KXmlGuiWindow(parent, flags), d(new Private(this))
 {}
 
 MainWindow::~MainWindow() {}
 
 void MainWindow::Private::setupActions()
 {
 
     KActionCollection *const coll = q->actionCollection();
 
     const action_data action_data[] = {
         // most have been MOVED TO keylistcontroller.cpp
         // Tools menu
 #ifndef Q_OS_WIN
         {
             "tools_start_kwatchgnupg", i18n("GnuPG Log Viewer"), QString(),
             "kwatchgnupg", q, SLOT(gnupgLogViewer()), QString(), false, true
         },
 #endif
 #ifdef Q_OS_WIN
         {
             "help_check_updates", i18n("Check for updates"), QString(),
             "gpg4win-compact", q, SLOT(forceUpdateCheck()), QString(), false, true
         },
         {
             "help_show_compendium", i18n("Gpg4win Compendium"), QString(),
             "gpg4win-compact", q, SLOT(openCompendium()), QString(), false, true
         },
 #endif
         {
             "pad_view", i18nc("Title for a generic data input / output area supporting text actions.", "Notepad"),
             i18n("Switch to Pad view."), "edittext", q, SLOT(togglePadView()), QString(), true, true
         },
         // most have been MOVED TO keylistcontroller.cpp
 #if 0
         {
             "configure_backend", i18n("Configure GnuPG Backend..."), QString(),
             0, q, SLOT(configureBackend()), QString(), false, true
         },
 #endif
         // Settings menu
         {
             "settings_self_test", i18n("Perform Self-Test"), QString(),
             nullptr, q, SLOT(selfTest()), QString(), false, true
         },
         {
             "manage_smartcard", i18n("Manage Smartcards"),
             i18n("Edit or initialize a crypto hardware token."), "secure-card", q, SLOT(toggleSmartcardView()), QString(), true, true
         }
 
         // most have been MOVED TO keylistcontroller.cpp
     };
 
     make_actions_from_data(action_data, /*sizeof action_data / sizeof *action_data,*/ coll);
 
     if (QAction *action = coll->action(QStringLiteral("configure_backend"))) {
         action->setMenuRole(QAction::NoRole);    //prevent Qt OS X heuristics for config* actions
     }
 
     KStandardAction::close(q, SLOT(close()), coll);
     KStandardAction::quit(q, SLOT(closeAndQuit()), coll);
     KStandardAction::configureToolbars(q, SLOT(configureToolbars()), coll);
     KStandardAction::keyBindings(q, SLOT(editKeybindings()), coll);
     KStandardAction::preferences(qApp, SLOT(openOrRaiseConfigDialog()), coll);
 
     focusToClickSearchAction = new QAction(i18n("Set Focus to Quick Search"), q);
     coll->addAction(QStringLiteral("focus_to_quickseach"), focusToClickSearchAction);
     coll->setDefaultShortcut(focusToClickSearchAction, QKeySequence(Qt::ALT + Qt::Key_Q));
     connect(focusToClickSearchAction, SIGNAL(triggered(bool)), q, SLOT(slotFocusQuickSearch()));
     clipboadMenu = new ClipboardMenu(q);
     clipboadMenu->setMainWindow(q);
     clipboadMenu->clipboardMenu()->setIcon(QIcon::fromTheme(QStringLiteral("edit-paste")));
     clipboadMenu->clipboardMenu()->setDelayed(false);
     coll->addAction(QStringLiteral("clipboard_menu"), clipboadMenu->clipboardMenu());
 
     q->setStandardToolBarMenuEnabled(true);
 
     controller.createActions(coll);
 
     ui.tabWidget.createActions(coll);
 }
 
 void MainWindow::Private::configureBackend()
 {
     QGpgME::CryptoConfig *const config = QGpgME::cryptoConfig();
     if (!config) {
         KMessageBox::error(q, i18n("Could not configure the cryptography backend (gpgconf tool not found)"), i18n("Configuration Error"));
         return;
     }
 
     Kleo::CryptoConfigDialog dlg(config);
 
     const int result = dlg.exec();
 
     // Forget all data parsed from gpgconf, so that we show updated information
     // when reopening the configuration dialog.
     config->clear();
 
     if (result == QDialog::Accepted) {
 #if 0
         // Tell other apps (e.g. kmail) that the gpgconf data might have changed
         QDBusMessage message =
             QDBusMessage::createSignal(QString(), "org.kde.kleo.CryptoConfig", "changed");
         QDBusConnection::sessionBus().send(message);
 #endif
     }
 }
 
 void MainWindow::Private::slotConfigCommitted()
 {
     controller.updateConfig();
     updateStatusBar();
 }
 
 void MainWindow::closeEvent(QCloseEvent *e)
 {
     // KMainWindow::closeEvent() insists on quitting the application,
     // so do not let it touch the event...
     qCDebug(KLEOPATRA_LOG);
     if (d->controller.hasRunningCommands()) {
         if (d->controller.shutdownWarningRequired()) {
             const int ret = KMessageBox::warningContinueCancel(this, i18n("There are still some background operations ongoing. "
                             "These will be terminated when closing the window. "
                             "Proceed?"),
                             i18n("Ongoing Background Tasks"));
             if (ret != KMessageBox::Continue) {
                 e->ignore();
                 return;
             }
         }
         d->controller.cancelCommands();
         if (d->controller.hasRunningCommands()) {
             // wait for them to be finished:
             setEnabled(false);
             QEventLoop ev;
             QTimer::singleShot(100, &ev, &QEventLoop::quit);
             connect(&d->controller, &KeyListController::commandsExecuting, &ev, &QEventLoop::quit);
             ev.exec();
             if (d->controller.hasRunningCommands())
                 qCWarning(KLEOPATRA_LOG)
                         << "controller still has commands running, this may crash now...";
             setEnabled(true);
         }
     }
     if (isQuitting || qApp->isSavingSession()) {
         d->ui.tabWidget.saveViews(KSharedConfig::openConfig().data());
         KConfigGroup grp(KConfigGroup(KSharedConfig::openConfig(), autoSaveGroup()));
         saveMainWindowSettings(grp);
         e->accept();
     } else {
         e->ignore();
         hide();
     }
 }
 
 void MainWindow::showEvent(QShowEvent *e)
 {
     KXmlGuiWindow::showEvent(e);
     if (d->firstShow) {
         d->ui.tabWidget.loadViews(KSharedConfig::openConfig().data());
         d->firstShow = false;
     }
 
     if (!savedGeometry.isEmpty()) {
         restoreGeometry(savedGeometry);
     }
 
 }
 
 void MainWindow::hideEvent(QHideEvent *e)
 {
     savedGeometry = saveGeometry();
     KXmlGuiWindow::hideEvent(e);
 }
 
 void MainWindow::importCertificatesFromFile(const QStringList &files)
 {
     if (!files.empty()) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     }
 }
 
 static QStringList extract_local_files(const QMimeData *data)
 {
     const QList<QUrl> urls = data->urls();
     // begin workaround KDE/Qt misinterpretation of text/uri-list
     QList<QUrl>::const_iterator end = urls.end();
     if (urls.size() > 1 && !urls.back().isValid()) {
         --end;
     }
     // end workaround
     QStringList result;
     std::transform(urls.begin(), end,
                    std::back_inserter(result),
                    std::mem_fn(&QUrl::toLocalFile));
     result.erase(std::remove_if(result.begin(), result.end(),
                                 std::mem_fn(&QString::isEmpty)), result.end());
     return result;
 }
 
 static bool can_decode_local_files(const QMimeData *data)
 {
     if (!data) {
         return false;
     }
     return !extract_local_files(data).empty();
 }
 
 void MainWindow::dragEnterEvent(QDragEnterEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (can_decode_local_files(e->mimeData())) {
         e->acceptProposedAction();
     }
 }
 
 void MainWindow::dropEvent(QDropEvent *e)
 {
     qCDebug(KLEOPATRA_LOG);
 
     if (!can_decode_local_files(e->mimeData())) {
         return;
     }
 
     e->setDropAction(Qt::CopyAction);
 
     const QStringList files = extract_local_files(e->mimeData());
 
     const unsigned int classification = classify(files);
 
     QMenu menu;
 
     QAction *const signEncrypt = menu.addAction(i18n("Sign/Encrypt..."));
     QAction *const decryptVerify = mayBeAnyMessageType(classification) ? menu.addAction(i18n("Decrypt/Verify...")) : nullptr;
     if (signEncrypt || decryptVerify) {
         menu.addSeparator();
     }
 
     QAction *const importCerts = mayBeAnyCertStoreType(classification) ? menu.addAction(i18n("Import Certificates")) : nullptr;
     QAction *const importCRLs  = mayBeCertificateRevocationList(classification) ? menu.addAction(i18n("Import CRLs")) : nullptr;
     if (importCerts || importCRLs) {
         menu.addSeparator();
     }
 
     if (!signEncrypt && !decryptVerify && !importCerts && !importCRLs) {
         return;
     }
 
     menu.addAction(i18n("Cancel"));
 
     const QAction *const chosen = menu.exec(mapToGlobal(e->pos()));
 
     if (!chosen) {
         return;
     }
 
     if (chosen == signEncrypt) {
         d->createAndStart<SignEncryptFilesCommand>(files);
     } else if (chosen == decryptVerify) {
         d->createAndStart<DecryptVerifyFilesCommand>(files);
     } else if (chosen == importCerts) {
         d->createAndStart<ImportCertificateFromFileCommand>(files);
     } else if (chosen == importCRLs) {
         d->createAndStart<ImportCrlCommand>(files);
     }
 
     e->accept();
 }
 
 void MainWindow::readProperties(const KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::readProperties(cg);
     setHidden(cg.readEntry("hidden", false));
 }
 
 void MainWindow::saveProperties(KConfigGroup &cg)
 {
     qCDebug(KLEOPATRA_LOG);
     KXmlGuiWindow::saveProperties(cg);
     cg.writeEntry("hidden", isHidden());
 }
 
 #include "moc_mainwindow.cpp"
diff --git a/src/view/padwidget.cpp b/src/view/padwidget.cpp
index 52eda6cfe..cd192422e 100644
--- a/src/view/padwidget.cpp
+++ b/src/view/padwidget.cpp
@@ -1,506 +1,507 @@
 /* -*- mode: c++; c-basic-offset:4 -*-
     padwidget.cpp
 
     This file is part of Kleopatra, the KDE keymanager
     SPDX-FileCopyrightText: 2018 Intevation GmbH
 
     SPDX-License-Identifier: GPL-2.0-or-later
 */
 #include "padwidget.h"
 
 #include "kleopatra_debug.h"
 
 #include <Libkleo/Exception>
 #include <Libkleo/Classify>
 #include <Libkleo/KeyCache>
+#include <Libkleo/Formatting>
 
 #include "crypto/gui/signencryptwidget.h"
 #include "crypto/gui/resultitemwidget.h"
 
 #include "crypto/signencrypttask.h"
 #include "crypto/decryptverifytask.h"
 #include <Libkleo/GnuPG>
 #include "utils/input.h"
 #include "utils/output.h"
 
 #include "commands/importcertificatefromdatacommand.h"
 
 #include <gpgme++/data.h>
 #include <gpgme++/decryptionresult.h>
 
 #include <QGpgME/DataProvider>
 
 #include <QButtonGroup>
 #include <QFontDatabase>
 #include <QFontMetrics>
 #include <QLabel>
 #include <QProgressBar>
 #include <QPushButton>
 #include <QRadioButton>
 #include <QTabWidget>
 #include <QTextEdit>
 #include <QVBoxLayout>
 
 #include <KLocalizedString>
 #include <KColorScheme>
 #include <KMessageBox>
 
 #include <KSharedConfig>
 #include <KConfigGroup>
 
 using namespace Kleo;
 using namespace Kleo::Crypto;
 using namespace Kleo::Crypto::Gui;
 
 static GpgME::Protocol getProtocol(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result)
 {
     const auto dvResult = dynamic_cast<const Kleo::Crypto::DecryptVerifyResult*>(result.get());
     if (dvResult) {
         for (const auto &key: KeyCache::instance()->findRecipients(dvResult->decryptionResult())) {
             return key.protocol();
         }
         for (const auto &key: KeyCache::instance()->findSigners(dvResult->verificationResult())) {
             return key.protocol();
         }
     }
     return GpgME::UnknownProtocol;
 }
 
 class PadWidget::Private
 {
 public:
     Private(PadWidget *qq):
         q(qq),
         mEdit(new QTextEdit),
         mCryptBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("document-edit-sign-encrypt")), i18n("Sign / Encrypt Notepad"))),
         mDecryptBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("document-edit-decrypt-verify")), i18n("Decrypt / Verify Notepad"))),
         mRevertBtn(new QPushButton(QIcon::fromTheme(QStringLiteral("edit-undo")), i18n("Revert"))),
         mAdditionalInfoLabel(new QLabel),
         mSigEncWidget(new SignEncryptWidget(nullptr, true)),
         mProgressBar(new QProgressBar),
         mProgressLabel(new QLabel),
         mLastResultWidget(nullptr),
         mPGPRB(nullptr),
         mCMSRB(nullptr),
         mImportProto(GpgME::UnknownProtocol)
     {
         auto vLay = new QVBoxLayout(q);
 
         auto btnLay = new QHBoxLayout;
         vLay->addLayout(btnLay);
         btnLay->addWidget(mCryptBtn);
         btnLay->addWidget(mDecryptBtn);
         btnLay->addWidget(mRevertBtn);
 
         mRevertBtn->setVisible(false);
 
         btnLay->addWidget(mAdditionalInfoLabel);
 
         btnLay->addStretch(-1);
 
         mProgressBar->setRange(0, 0);
         mProgressBar->setVisible(false);
         mProgressLabel->setVisible(false);
         auto progLay = new QHBoxLayout;
 
         progLay->addWidget(mProgressLabel);
         progLay->addWidget(mProgressBar);
 
         mStatusLay = new QVBoxLayout;
         mStatusLay->addLayout(progLay);
         vLay->addLayout(mStatusLay, 0);
 
         auto tabWidget = new QTabWidget;
         vLay->addWidget(tabWidget, 1);
 
         tabWidget->addTab(mEdit, QIcon::fromTheme(QStringLiteral("edittext")), i18n("Notepad"));
 
         // The recipients area
         auto recipientsWidget = new QWidget;
         auto recipientsVLay = new QVBoxLayout(recipientsWidget);
         auto protocolSelectionLay = new QHBoxLayout;
 
         bool pgpOnly = KeyCache::instance()->pgpOnly();
         if (!pgpOnly) {
             recipientsVLay->addLayout(protocolSelectionLay);
         }
 
         protocolSelectionLay->addWidget(new QLabel(i18n("<h3>Protocol:</h3>")));
         protocolSelectionLay->addStretch(-1);
         // Once S/MIME is supported add radio for S/MIME here.
 
         recipientsVLay->addWidget(mSigEncWidget);
         tabWidget->addTab(recipientsWidget, QIcon::fromTheme(QStringLiteral("contact-new-symbolic")),
                           i18n("Recipients"));
 
         mEdit->setPlaceholderText(i18n("Enter a message to encrypt or decrypt..."));
 
         auto fixedFont = QFont(QStringLiteral("Monospace"));
         fixedFont.setStyleHint(QFont::TypeWriter);
         // This does not work well
         // QFontDatabase::systemFont(QFontDatabase::FixedFont);
 
         mEdit->setFont(fixedFont);
         mEdit->setAcceptRichText(false);
         mEdit->setMinimumWidth(QFontMetrics(fixedFont).averageCharWidth() * 70);
 
         if (KeyCache::instance()->pgpOnly()) {
             mSigEncWidget->setProtocol(GpgME::OpenPGP);
         } else {
             auto grp = new QButtonGroup(q);
             auto mPGPRB = new QRadioButton(i18n("OpenPGP"));
             auto mCMSRB = new QRadioButton(i18n("S/MIME"));
             grp->addButton(mPGPRB);
             grp->addButton(mCMSRB);
 
             KConfigGroup config(KSharedConfig::openConfig(), "Notepad");
             if (config.readEntry("wasCMS", false)) {
                 mCMSRB->setChecked(true);
                 mSigEncWidget->setProtocol(GpgME::CMS);
             } else {
                 mPGPRB->setChecked(true);
                 mSigEncWidget->setProtocol(GpgME::OpenPGP);
             }
 
             protocolSelectionLay->addWidget(mPGPRB);
             protocolSelectionLay->addWidget(mCMSRB);
             connect(mPGPRB, &QRadioButton::toggled, q, [this] (bool value) {
                     if (value) {
                         mSigEncWidget->setProtocol(GpgME::OpenPGP);
                     }
                 });
             connect(mCMSRB, &QRadioButton::toggled, q, [this] (bool value) {
                     if (value) {
                         mSigEncWidget->setProtocol(GpgME::CMS);
                     }
                 });
         }
 
         updateCommitButton();
 
         connect(mEdit, &QTextEdit::textChanged, q, [this] () {
                 updateCommitButton();
             });
 
         connect(mCryptBtn, &QPushButton::clicked, q, [this] () {
                 if (mImportProto != GpgME::UnknownProtocol) {
                     doImport();
                 } else {
                     doEncryptSign();
                 }
             });
 
         connect(mSigEncWidget, &SignEncryptWidget::operationChanged, q, [this] (const QString &) {
                 updateCommitButton();
             });
 
         connect(mDecryptBtn, &QPushButton::clicked, q, [this] () {
                 doDecryptVerify();
             });
 
         connect(mRevertBtn, &QPushButton::clicked, q, [this] () {
                 revert();
             });
     }
 
     void revert()
     {
         mEdit->setPlainText(QString::fromUtf8(mInputData));
         mRevertBtn->setVisible(false);
     }
 
     void updateRecipientsFromResult(const Kleo::Crypto::DecryptVerifyResult &result)
     {
         const auto decResult = result.decryptionResult();
 
         for (const auto &recipient: decResult.recipients()) {
             if (!recipient.keyID()) {
                 continue;
             }
 
             GpgME::Key key;
             if (strlen(recipient.keyID()) < 16) {
                 key = KeyCache::instance()->findByShortKeyID(recipient.keyID());
             } else {
                 key = KeyCache::instance()->findByKeyIDOrFingerprint(recipient.keyID());
             }
 
             if (key.isNull()) {
                 std::vector<std::string> subids;
                 subids.push_back(std::string(recipient.keyID()));
                 for (const auto &subkey: KeyCache::instance()->findSubkeysByKeyID(subids)) {
                     key = subkey.parent();
                     break;
                 }
             }
 
             if (key.isNull()) {
                 qCDebug(KLEOPATRA_LOG) << "Unknown key" << recipient.keyID();
                 mSigEncWidget->addUnknownRecipient(recipient.keyID());
                 continue;
             }
 
             bool keyFound = false;
             for (const auto &existingKey: mSigEncWidget->recipients()) {
                 if (existingKey.primaryFingerprint() && key.primaryFingerprint() &&
                     !strcmp (existingKey.primaryFingerprint(), key.primaryFingerprint())) {
                     keyFound = true;
                     break;
                 }
             }
             if (!keyFound) {
                 mSigEncWidget->addRecipient(key);
             }
         }
     }
 
     void cryptDone(const std::shared_ptr<const Kleo::Crypto::Task::Result> &result)
     {
         updateCommitButton();
         mDecryptBtn->setEnabled(true);
         mProgressBar->setVisible(false);
         mProgressLabel->setVisible(false);
 
         mLastResultWidget = new ResultItemWidget(result);
         mLastResultWidget->showCloseButton(true);
         mStatusLay->addWidget(mLastResultWidget);
 
         connect(mLastResultWidget, &ResultItemWidget::closeButtonClicked, q, [this] () {
             removeLastResultItem();
         });
 
         // Check result protocol
         if (mPGPRB) {
             auto proto = getProtocol(result);
             if (proto == GpgME::UnknownProtocol) {
                 proto = mPGPRB->isChecked() ? GpgME::OpenPGP : GpgME::CMS;
             } else if (proto == GpgME::OpenPGP) {
                 mPGPRB->setChecked(true);
             } else if (proto == GpgME::CMS) {
                 mCMSRB->setChecked(true);
             }
 
             KConfigGroup config(KSharedConfig::openConfig(), "Notepad");
             config.writeEntry("wasCMS", proto == GpgME::CMS);
         }
 
         if (result->errorCode()) {
             if (!result->errorString().isEmpty()) {
                 KMessageBox::error(q,
                         result->errorString(),
                         i18nc("@title", "Error in crypto action"));
             }
             return;
         }
         mEdit->setPlainText(QString::fromUtf8(mOutputData));
         mOutputData.clear();
         mRevertBtn->setVisible(true);
 
         const auto decryptVerifyResult = dynamic_cast<const Kleo::Crypto::DecryptVerifyResult*>(result.get());
         if (decryptVerifyResult) {
             updateRecipientsFromResult(*decryptVerifyResult);
         }
     }
 
     void doDecryptVerify()
     {
         doCryptoCommon();
         mSigEncWidget->clearAddedRecipients();
         mProgressLabel->setText(i18n("Decrypt / Verify") + QStringLiteral("..."));
         auto input = Input::createFromByteArray(&mInputData,  i18n("Notepad"));
         auto output = Output::createFromByteArray(&mOutputData, i18n("Notepad"));
 
         AbstractDecryptVerifyTask *task;
         auto classification = input->classification();
         if (classification & Class::OpaqueSignature ||
             classification & Class::ClearsignedMessage) {
             auto verifyTask = new VerifyOpaqueTask();
             verifyTask->setInput(input);
             verifyTask->setOutput(output);
             task = verifyTask;
         } else {
             auto decTask = new DecryptVerifyTask();
             decTask->setInput(input);
             decTask->setOutput(output);
             task = decTask;
         }
         try {
             task->autodetectProtocolFromInput();
         } catch (const Kleo::Exception &e) {
             KMessageBox::error(q,
                     e.message(),
                     i18nc("@title", "Error in crypto action"));
             mCryptBtn->setEnabled(true);
             mDecryptBtn->setEnabled(true);
             mProgressBar->setVisible(false);
             mProgressLabel->setVisible(false);
             return;
         }
 
         connect (task, &Task::result, q, [this, task] (const std::shared_ptr<const Kleo::Crypto::Task::Result> &result) {
                 qCDebug(KLEOPATRA_LOG) << "Decrypt / Verify done. Err:" << result->errorCode();
                 task->deleteLater();
                 cryptDone(result);
             });
         task->start();
     }
 
     void removeLastResultItem()
     {
         if (mLastResultWidget) {
             mStatusLay->removeWidget(mLastResultWidget);
             delete mLastResultWidget;
             mLastResultWidget = nullptr;
         }
     }
 
     void doCryptoCommon()
     {
         mCryptBtn->setEnabled(false);
         mDecryptBtn->setEnabled(false);
         mProgressBar->setVisible(true);
         mProgressLabel->setVisible(true);
         mInputData = mEdit->toPlainText().toUtf8();
         removeLastResultItem();
     }
 
     void doEncryptSign()
     {
         doCryptoCommon();
         mProgressLabel->setText(mSigEncWidget->currentOp() + QStringLiteral("..."));
         auto input = Input::createFromByteArray(&mInputData,  i18n("Notepad"));
         auto output = Output::createFromByteArray(&mOutputData, i18n("Notepad"));
 
         auto task = new SignEncryptTask();
         task->setInput(input);
         task->setOutput(output);
 
         const auto sigKey = mSigEncWidget->signKey();
 
         bool encrypt = mSigEncWidget->encryptSymmetric() || !mSigEncWidget->recipients().isEmpty();
         bool sign = !sigKey.isNull();
 
         if (sign) {
             task->setSign(true);
             std::vector<GpgME::Key> signVector;
             signVector.push_back(sigKey);
             task->setSigners(signVector);
         } else {
             task->setSign(false);
         }
         task->setEncrypt(encrypt);
         task->setRecipients(mSigEncWidget->recipients().toStdVector());
         task->setEncryptSymmetric(mSigEncWidget->encryptSymmetric());
         task->setAsciiArmor(true);
 
         if (sign && !encrypt && sigKey.protocol() == GpgME::OpenPGP) {
             task->setClearsign(true);
         }
 
         connect (task, &Task::result, q, [this, task] (const std::shared_ptr<const Kleo::Crypto::Task::Result> &result) {
                 qCDebug(KLEOPATRA_LOG) << "Encrypt / Sign done. Err:" << result->errorCode();
                 task->deleteLater();
                 cryptDone(result);
             });
         task->start();
     }
 
     void doImport()
     {
         doCryptoCommon();
         mProgressLabel->setText(i18n("Importing..."));
         auto cmd = new Kleo::ImportCertificateFromDataCommand(mInputData, mImportProto);
         connect(cmd, &Kleo::ImportCertificatesCommand::finished, q, [this] () {
                 mCryptBtn->setEnabled(true);
                 mDecryptBtn->setEnabled(true);
                 mProgressBar->setVisible(false);
                 mProgressLabel->setVisible(false);
 
                 updateCommitButton();
                 mRevertBtn->setVisible(true);
                 mEdit->setPlainText(QString());
             });
         cmd->start();
     }
 
     void checkImportProtocol()
     {
         QGpgME::QByteArrayDataProvider dp(mEdit->toPlainText().toUtf8());
         GpgME::Data data(&dp);
         auto type = data.type();
         if (type == GpgME::Data::PGPKey) {
             mImportProto = GpgME::OpenPGP;
         } else if (type == GpgME::Data::X509Cert ||
                    type == GpgME::Data::PKCS12) {
             mImportProto = GpgME::CMS;
         } else {
             mImportProto = GpgME::UnknownProtocol;
         }
     }
 
     void updateCommitButton()
     {
         mAdditionalInfoLabel->setVisible(false);
 
         checkImportProtocol();
 
         if (mImportProto != GpgME::UnknownProtocol) {
             mCryptBtn->setText(i18nc("1 is an operation to apply to the notepad. "
                                      "Like Sign/Encrypt or just Encrypt.", "%1 Notepad",
                                      i18n("Import")));
             mCryptBtn->setDisabled(false);
             return;
         }
 
         if (!mSigEncWidget->currentOp().isEmpty()) {
             mCryptBtn->setDisabled(false);
             mCryptBtn->setText(i18nc("1 is an operation to apply to the notepad. "
                                      "Like Sign/Encrypt or just Encrypt.", "%1 Notepad",
                                      mSigEncWidget->currentOp()));
         } else {
             mCryptBtn->setText(i18n("Sign / Encrypt Notepad"));
             mCryptBtn->setDisabled(true);
         }
 
         if (Kleo::gpgComplianceP("de-vs")) {
             bool de_vs = mSigEncWidget->isDeVsAndValid();
             mCryptBtn->setIcon(QIcon::fromTheme(de_vs
                         ? QStringLiteral("security-high")
                         : QStringLiteral("security-medium")));
             mCryptBtn->setStyleSheet(QStringLiteral("background-color: ") + (de_vs
                         ? KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::PositiveBackground).color().name()
                         : KColorScheme(QPalette::Active, KColorScheme::View).background(KColorScheme::NegativeBackground).color().name()));
             mAdditionalInfoLabel->setText(de_vs
-                    ? i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
-                        "VS-NfD-compliant communication possible.")
-                    : i18nc("VS-NfD-conforming is a German standard for restricted documents for which special restrictions about algorithms apply.  The string states that all cryptographic operations necessary for the communication are compliant with that.",
-                        "VS-NfD-compliant communication not possible."));
+                    ? i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                        "%1 communication possible.", Formatting::deVsString())
+                    : i18nc("%1 is a placeholder for the name of a compliance mode. E.g. NATO RESTRICTED compliant or VS-NfD compliant",
+                        "%1 communication not possible.", Formatting::deVsString()));
             mAdditionalInfoLabel->setVisible(true);
         }
     }
 
 private:
     PadWidget *const q;
     QTextEdit *mEdit;
     QPushButton *mCryptBtn;
     QPushButton *mDecryptBtn;
     QPushButton *mRevertBtn;
     QLabel *mAdditionalInfoLabel;
     QByteArray mInputData;
     QByteArray mOutputData;
     SignEncryptWidget *mSigEncWidget;
     QProgressBar *mProgressBar;
     QLabel *mProgressLabel;
     QVBoxLayout *mStatusLay;
     ResultItemWidget *mLastResultWidget;
     QList<GpgME::Key> mAutoAddedKeys;
     QRadioButton *mPGPRB;
     QRadioButton *mCMSRB;
     GpgME::Protocol mImportProto;
 };
 
 PadWidget::PadWidget(QWidget *parent):
     QWidget(parent),
     d(new Private(this))
 {
 }